def testIt(self):
app = QGuiApplication([])
qmlRegisterType(MyClass,'Example',1,0,'MyClass')
view = QQuickView()
view.setSource(QUrl.fromLocalFile(adjust_filename('bug_926.qml', __file__)))
self.assertEqual(len(view.errors()), 0)
view.show()
QTimer.singleShot(0, app.quit)
app.exec_()
def testIt(self):
app = QGuiApplication([])
qmlRegisterType(PieChart, 'Charts', 1, 0, 'PieChart');
qmlRegisterType(PieSlice, "Charts", 1, 0, "PieSlice");
view = QQuickView()
view.setSource(QUrl.fromLocalFile(helper.adjust_filename('registertype.qml', __file__)))
view.show()
QTimer.singleShot(250, view.close)
app.exec_()
self.assertTrue(appendCalled)
self.assertTrue(paintCalled)
c0, r0 = cell
c = self.curCR[0] + c0
r = self.curCR[1] + r0
self.setShapeAt((c, r), self.curPiece.shape)
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
# Expose the list to the Qml code
random.seed(None)
tetrix = TetrixBoard()
context = view.rootContext()
context.setContextProperty("tetrix", tetrix)
# Load the QML file
qml_file = os.path.join(os.path.dirname(__file__), "view.qml")
view.setSource(QUrl.fromLocalFile(os.path.abspath(qml_file)))
# Show the window
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
# execute and cleanup
app.exec_()
del view
#testing purpose
def call(self):
print("timer call")
#menu
def controls(self):
if QKeySequence(Qt.CTRL + Qt.Key_A):
self.showAll()
elif QKeySequence(Qt.CTRL + Qt.Key_B):
self.showOne()
elif QKeySequence(Qt.CTRL + Qt.Key_C):
self.changeAttributes()
#testing purpose
def longer(self):
self.squareMesh.setXExtent(self.squareMesh.xExtent() + 1)
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
view = Window()
view.show()
(app.exec_())
while True:
view.show()
view.squareMesh.setXExtent(view.squareMesh.xExtent() + 1)
(app.exec_())
# sys.exit(app.exec_())
self._name = value
colorChanged = Signal()
color = Property(QColor, getColor, setColor, notify=colorChanged)
name = Property(text_type, getName, setName)
chartCleared = Signal()
@Slot() # This should be something like @Invokable
def clearChart(self):
self.setColor(Qt.transparent)
self.update()
self.chartCleared.emit()
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
qmlRegisterType(PieChart, 'Charts', 1, 0, 'PieChart');
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
qmlFile = os.path.join(os.path.dirname(__file__), 'app.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
res = app.exec_()
# Deleting the view before it goes out of scope is required to make sure all child QML instances
# are destroyed in the correct order.
del view
sys.exit(res)
return d['name']
elif role == Qt.DecorationRole:
return Qt.black
elif role == PersonModel.MyRole:
return d['myrole']
return None
def populate(self):
self._data.append({'name':'Qt', 'myrole':'role1'})
self._data.append({'name':'PySide', 'myrole':'role2'})
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
view = QQuickView()
view.setResizeMode(QQuickView.SizeRootObjectToView)
myModel = PersonModel()
myModel.populate()
view.rootContext().setContextProperty("myModel", myModel)
qmlFile = os.path.join(os.path.dirname(__file__), 'view.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
view.show()
app.exec_()
# Deleting the view before it goes out of scope is required to make sure all child QML instances
# are destroyed in the correct order.
del view
roleId = int(data[1])
logging.info(f'[ROLES] update role of user {userId} to {roleId}')
cursor = self.db.cursor()
cursor.execute("""
UPDATE users SET role = ? WHERE id = ?""", [roleId, userId])
self.db.commit()
if __name__ == '__main__':
qt = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# Instance of the Python object
app = App()
# Expose the Python object to QML
context = engine.rootContext()
context.setContextProperty("app", app)
# Get the path of the current directory, and then add the name
# of the QML file, to load it.
qmlFile = join(dirname(__file__), 'app.qml')
engine.load(abspath(qmlFile))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(qt.exec_())
QFile.remove(fileName)
if __name__ == "__main__":
logging.info('Started')
app = QGuiApplication()
connectToDatabase()
inference_thread = InferenceThread()
# Start inference thread
inference_thread.start()
sql_conversation_model = SqlConversationModel()
dialog = Dialog(sql_conversation_model)
audio_recorder = AudioRecorder(dialog, inference_thread)
engine = QQmlApplicationEngine()
# Export pertinent objects to QML
engine.rootContext().setContextProperty("chat_model", sql_conversation_model)
engine.rootContext().setContextProperty("audio_recorder", audio_recorder)
QtWebEngine.initialize();
qmlFile = os.path.join(os.path.dirname(__file__), "chat.qml")
engine.load(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
ret = app.exec_()
# Signal to inference thread that the application is quitting
inference_thread.setQuit()
logging.info('Finished')
sys.exit(ret)
import sys
import os
from PySide2.QtGui import QGuiApplication
from PySide2.QtQml import QQmlApplicationEngine
from view_model import ViewModel
if __name__ == '__main__':
myApp = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
context = engine.rootContext()
# import the path for the Qt Application Manager
engine.addImportPath("/home/bob/Qt/5.11.2/Automotive/sources/qtapplicationmanager/dummyimports/")
# create a view model
view_model = ViewModel()
# bind the view model to the context
context.setContextProperty('view_model', view_model)
# load the main QML window
engine.load('mainwindow.qml')
if not engine.rootObjects():
sys.exit(-1)
sys.exit(myApp.exec_())
else:
value = values.values()[0]
sensorObj.stop()
return sensorValue
try:
sensorObj = SensorReader((shtObj, ), 1, reportSensorValues('shtObj'))
sensorObj.start()
finally:
sensorObj.join()
return 0
if __name__ == '__main__':
appObj = QGuiApplication(sys.argv)
engineObj = QQmlApplicationEngine()
eventObj = EventGenerator()
engineObj.rootContext().setContextProperty("pythonObj", eventObj)
qmlFile = join(dirname(__file__), 'usr_interface.qml')
engineObj.load(QUrl(qmlFile))
if not engineObj.rootObjects():
sys.exit(-1)
sys.exit(appObj.exec_())
class SystemWindow(QObject):
def __init__(self):
QObject.__init__(self)
self.app = QGuiApplication()
# AUTO REFRESH / DYNAMIC INFOS
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(lambda: self.setDynamicInfo())
# AUTO DISPLAY
self.show_UI()
# SHOW PERCENTAGE
showPercentage = False
# PERCENTAGE / DYNAMIC
percentageCPU = Signal(float)
percentageRAM = Signal(float)
percentageGPU = Signal(float)
cpuFrequencyCurrentInfo = Signal(str)
ramAvailableInfo = Signal(str)
ramUsedInfo = Signal(str)
vramFreeInfo = Signal(str)
vramUsedInfo = Signal(str)
gpuTempInfo = Signal(str)
# STATIC INFO
cpuInfo = Signal(str)
cpuPhysicalCoresInfo = Signal(str)
cpuTotalCoresInfo = Signal(str)
cpuFrequencyMaxInfo = Signal(str)
cpuFrequencyMinInfo = Signal(str)
ramTotalInfo = Signal(str)
gpuModelInfo = Signal(str)
vramTotalInfo = Signal(str)
# SET DYNAMIC INFO
def setDynamicInfo(self):
# FORMAT SIZES
def get_size(bytes, suffix="B"):
factor = 1024
for unit in ["", "M", "G", "T", "P"]:
if bytes < factor:
return f"{bytes:.2f}{unit}{suffix}"
bytes /= factor
if self.showPercentage:
# SYSTEM VARS
svmen = psutil.virtual_memory()
gpus = GPUtil.getGPUs()
cpufreq = psutil.cpu_freq()
# CIRCULAR PROGRESS BAR
self.percentageCPU.emit(psutil.cpu_percent())
self.percentageRAM.emit(svmen.percent)
self.percentageGPU.emit(float(gpus[0].load * 100))
# CPU FREQUENCY
self.cpuFrequencyCurrentInfo.emit(f"{cpufreq.current:.2f}Mhz")
# RAM USAGE
self.ramAvailableInfo.emit(get_size(svmen.available))
self.ramUsedInfo.emit(get_size(svmen.used))
# GPU INFO
self.vramFreeInfo.emit(f"{gpus[0].memoryFree}MB")
self.vramUsedInfo.emit(f"{gpus[0].memoryUsed}MB")
self.gpuTempInfo.emit(f"{gpus[0].temperature} ºC")
# SET STATIC INFO
@Slot()
def setStaticInfo(self):
# FORMAT SIZES
def get_size(bytes, suffix="B"):
factor = 1024
for unit in ["", "M", "G", "T", "P"]:
if bytes < factor:
return f"{bytes:.2f}{unit}{suffix}"
bytes /= factor
# SYSTEM VARS
svmen = psutil.virtual_memory()
gpus = GPUtil.getGPUs()
cpufreq = psutil.cpu_freq()
# CPU INFO
self.cpuInfo.emit(cpuinfo.get_cpu_info()['brand_raw'])
self.cpuPhysicalCoresInfo.emit(str(psutil.cpu_count(logical=False)))
self.cpuTotalCoresInfo.emit(str(psutil.cpu_count(logical=True)))
self.cpuFrequencyMaxInfo.emit(f"{cpufreq.max:.2f}Mhz")
self.cpuFrequencyMinInfo.emit(f"{cpufreq.min:.2f}Mhz")
# RAM INFO
self.ramTotalInfo.emit(get_size(svmen.total))
# GPU INFO
self.gpuModelInfo.emit(gpus[0].name)
self.vramTotalInfo.emit(f"{gpus[0].memoryTotal}MB")
# SHOW PERCENTAGE
def showValues():
self.showPercentage = True
QTimer.singleShot(2000, showValues)
def show_UI(self):
# app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# GET CONTEXT
engine.rootContext().setContextProperty("backend", self)
# LOAD QML
engine.load(os.path.join(os.path.dirname(__file__), "qml/system.qml"))
# AUTO CLOSE
timer2 = QTimer(self)
timer2.start(10000)
timer2.timeout.connect(lambda: sys.exit())
if not engine.rootObjects():
sys.exit(-1)
sys.exit(self.app.exec_())
class WeatherWindow(QObject):
def __init__(self, city):
QObject.__init__(self)
self.app = QGuiApplication()
self.city = city
# GET RESULTS FROM API
self.results_weather = weather.Current_Weather(
self.city).display_weather_results()
# AUTO REFRESH / DYNAMIC INFOS
timer = QTimer(self)
timer.start(1000)
timer.timeout.connect(lambda: self.setDynamicInfo())
self.show_UI()
# SHOW PERCENTAGE
showPercentage = False
# PERCENTAGE / DYNAMIC
percentageCPU = Signal(float)
percentageRAM = Signal(float)
percentageGPU = Signal(float)
cpuFrequencyCurrentInfo = Signal(float)
ramAvailableInfo = Signal(str)
ramUsedInfo = Signal(str)
# vramFreeInfo = Signal(str)
# vramUsedInfo = Signal(str)
gpuTempInfo = Signal(str)
# STATIC INFO
cpuInfo = Signal(str)
cpuPhysicalCoresInfo = Signal(str)
cpuTotalCoresInfo = Signal(str)
cpuFrequencyMaxInfo = Signal(float)
cpuFrequencyMinInfo = Signal(float)
ramTotalInfo = Signal(str)
gpuModelInfo = Signal(str)
vramTotalInfo = Signal(str)
# SET DYNAMIC INFO
def setDynamicInfo(self):
# FORMAT SIZES
def get_size(bytes, suffix="B"):
factor = 1024
for unit in ["", "M", "G", "T", "P"]:
if bytes < factor:
return f"{bytes:.2f}{unit}{suffix}"
bytes /= factor
if self.showPercentage:
# CIRCULAR PROGRESS BAR
self.percentageCPU.emit(int(self.results_weather[0]))
self.percentageRAM.emit(int(self.results_weather[1]))
self.percentageGPU.emit(self.results_weather[2])
# CPU FREQUENCY
self.cpuFrequencyCurrentInfo.emit(self.results_weather[0])
# RAM USAGE
self.ramAvailableInfo.emit(str(self.results_weather[5]))
self.ramUsedInfo.emit(str(self.results_weather[6]))
# GPU INFO
self.gpuTempInfo.emit(self.results_weather[11])
# SET STATIC INFO
@Slot()
def setStaticInfo(self):
# FORMAT SIZES
def get_size(bytes, suffix="B"):
factor = 1024
for unit in ["", "M", "G", "T", "P"]:
if bytes < factor:
return f"{bytes:.2f}{unit}{suffix}"
bytes /= factor
# CPU INFO
self.cpuInfo.emit(str(self.results_weather[3]))
self.cpuPhysicalCoresInfo.emit(str(self.results_weather[2]))
self.cpuTotalCoresInfo.emit(str(self.results_weather[1]))
self.cpuFrequencyMaxInfo.emit(self.results_weather[5])
self.cpuFrequencyMinInfo.emit(self.results_weather[6])
# RAM INFO
self.ramTotalInfo.emit(str(self.results_weather[7]) + "m/s")
# GPU INFO
self.gpuModelInfo.emit(self.results_weather[3])
self.vramTotalInfo.emit(self.results_weather[10])
# SHOW PERCENTAGE
def showValues():
self.showPercentage = True
QTimer.singleShot(2000, showValues)
def show_UI(self):
# app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# GET CONTEXT
engine.rootContext().setContextProperty("backend", self)
# LOAD QML
engine.load(
os.path.join(os.path.dirname(__file__), "qml/pages/weather.qml"))
# AUTO CLOSE
timer2 = QTimer(self)
timer2.start(10000)
timer2.timeout.connect(lambda: sys.exit())
if not engine.rootObjects():
sys.exit(-1)
sys.exit(self.app.exec_())
# Iniciar Loop em segundo plano para ler os dados da GPIO
gpioThread = Thread(target=loopGPIO)
gpioThread.daemon = True
gpioThread.start()
# Iniciar Servidor para interface Web
serverThread = Thread(target=server)
serverThread.daemon = True
serverThread.start()
# Iniciar interface Qt
if __name__ == "__main__":
# Apply Material Style
sys_argv = sys.argv
sys_argv += ["--style", "material"]
qtApp = QGuiApplication(sys_argv)
qmlFile = path.join(path.dirname(__file__), "interface/main.qml")
# deixa a Classe Bridge disponível para os aquivos .qml
engine = QQmlApplicationEngine()
context = engine.rootContext()
context.setContextProperty("Py", ponte)
engine.load(path.abspath(qmlFile))
if not engine.rootObjects():
sys.exit(-1)
# initServer()
sys.exit(qtApp.exec_())
worker_interface.moveToThread(worker_interface_thread)
worker_interface_thread.start()
viewer = Viewer()
translator = Translator()
translator.updateAppLanguage.connect(update_app_language)
qml_file = os.path.abspath(
os.path.join(os.path.dirname(__file__), 'main.qml'))
engine = QQmlApplicationEngine()
engine.rootContext().setContextProperty("worker_manager", worker_manager)
engine.rootContext().setContextProperty("translator", translator)
engine.rootContext().setContextProperty("viewer", viewer)
engine.load(qml_file)
if not engine.rootObjects():
sys.exit(-1)
root = engine.rootObjects()[0]
rc = app.exec_()
if worker_manager.running:
worker_manager.stop_worker()
worker_interface_thread.quit()
worker_interface_thread.wait()
sys.exit(rc)
import os
import sys
from PySide2.QtCore import QObject, QUrl
from PySide2.QtGui import QGuiApplication
from PySide2.QtQuick import QQuickView
def sayThis(s):
print(s)
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
view = QQuickView()
qmlFile = os.path.join(os.path.dirname(__file__), 'view.qml')
view.setSource(QUrl.fromLocalFile(os.path.abspath(qmlFile)))
if view.status() == QQuickView.Error:
sys.exit(-1)
root = view.rootObject()
button = root.findChild(QObject, "buttonMouseArea")
button.clicked.connect(
lambda: sayThis("clicked button (signal directly connected)"))
view.show()
res = app.exec_()
# Deleting the view before it goes out of scope is required to make sure all child QML instances
# are destroyed in the correct order.
del view
sys.exit(res)
numberChanged = Signal(int)
def __set_number(self, val):
if self.__number != val:
self.__number = val;
self.numberChanged.emit(self.__number)
def get_number(self):
return self.__number
number = Property(int, get_number, notify=numberChanged)
if __name__ == '__main__':
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
number_generator = NumberGenerator()
engine.rootContext().setContextProperty("numberGenerator", number_generator)
engine.load(QUrl("main.qml"))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
# ...
def setTime(self):
now = datetime.datetime.now()
formatDate = now.strftime("Now is %H:%M:%S %p of %Y/%m/%d")
print(formatDate)
self.printTime.emit(formatDate)
# Function Set Name To Label
@Slot(str)
def welcomeText(self, name):
self.setName.emit("Welcome, " + name)
if __name__ == "__main__":
app = QGuiApplication(sys.argv)
engine = QQmlApplicationEngine()
# Get Context
main = MainWindow()
engine.rootContext().setContextProperty("backend", main)
# Set App Extra Info
app.setOrganizationName("Wanderson M. Pimenta")
app.setOrganizationDomain("N/A")
# Load QML File
engine.load(os.path.join(os.path.dirname(__file__), "qml/main.qml"))
if not engine.rootObjects():
sys.exit(-1)
sys.exit(app.exec_())
class QTUI(UIBase):
def xyToIndex(self, x, y):
return y * 8 + x
def indexToXY(self, index):
return (index % 8, index // 8)
def ioThread(self, inputQueue, emitter):
while True:
io = inputQueue.get()
if (io["type"] == UIMessageType.SETUP):
player = io["data"]["player_name"]
emitter.sendName(player[WHITE], player[BLACK])
elif (io["type"] == UIMessageType.BOARD):
for index in range(0, 64):
col, row = self.indexToXY(index)
item = io["data"][row][col]
if (item == BLACK):
emitter.send(index, True)
elif (item == WHITE):
emitter.send(index, False)
time.sleep(0.2)
elif (io["type"] == UIMessageType.SCORE):
emitter.sendScore(io["data"]["o"], io["data"]["x"])
elif (io["type"] == UIMessageType.TURN):
turn = io["data"]
if turn == "x":
emitter.sendMark(True)
else:
emitter.sendMark(False)
elif (io["type"] == UIMessageType.FORFEIT):
print("Tidak ada langkah mungkin, skip")
elif (io["type"] == UIMessageType.DOTURN):
pass
elif (io["type"] == UIMessageType.QUIT):
break
self.inputQueue.task_done()
def threadWorker(self):
self.app = QGuiApplication()
self.view = QQuickView()
self.view.setResizeMode(QQuickView.SizeRootObjectToView)
#Load the QML file
qml_file = os.path.join(os.path.dirname(__file__), "view.qml")
self.view.setSource(QUrl.fromLocalFile(os.path.abspath(qml_file)))
root = self.view.rootObject()
ioHandler = Handler(self.moveQueue)
context = self.view.rootContext()
context.setContextProperty("handler", ioHandler)
#Show the window
if self.view.status() == QQuickView.Error:
sys.exit(-1)
ioSignaler = ioObject(root)
input_thread = threading.Thread(target=self.ioThread,
args=(self.inputQueue, ioSignaler))
input_thread.start()
self.view.show()
self.app.exec_()
self.inputQueue.put({"type": UIMessageType.QUIT})
input_thread.join()
self.outputQueue.put({"type": UICommandType.QUIT})
self.moveQueue.put({"x": -1, "y": -1})
