def test_thumbnailer(self):
return
try:
app = QApplication([])
thumbnailer = Thumbnailer()
button = QPushButton()
button.resize(256, 256)
button.show()
def quit():
thumbnailer.close()
app.quit()
button.clicked.connect(quit)
def cb(filename, flavor, pixmap):
icon = QIcon(pixmap)
button.setIcon(icon)
button.setIconSize(pixmap.rect().size())
button.repaint()
thumbnailer.request_thumbnail("/tmp/test2.png", "large", cb)
app.exec()
except Exception as err:
print(err)
def main():
app = QApplication(sys.argv)
form = Form()
form.show()
app.exec()
def test_collector(self):
app = QApplication([])
try:
vfs = StdioFilesystem("/tmp")
metadata_collector = MetaDataCollector(vfs)
def on_metadata(filename, metadata):
print(filename)
print(metadata)
print()
metadata_collector.sig_metadata_ready.connect(on_metadata)
metadata_collector.request_metadata(Location.from_path("dirtools/fileview/icons/noun_409399_cc.png"))
QTimer.singleShot(500, metadata_collector.close)
QTimer.singleShot(1500, app.quit)
app.exec()
except Exception as err:
print(err)
finally:
metadata_collector.close()
vfs.close()
def user_interface():
"""
THe user interace 'app'
:return:
"""
app = QApplication([])
ui = UIWindow()
app.exec()
def call_sutdyPlan_interface(system):
import sys
app = QApplication(sys.argv)
window = MainWindow(system)
window.show()
#sys.exit(app.exec_())
app.exec()
def ShowUi():
app = QApplication(argv)
c = UiController()
v = IDEView()
c.connectView(v)
c.mainWindow.show()
app.exec()
def run_browser(url):
app = QApplication(['info-display'])
browser = QWebView()
page = WebPage()
browser.setPage(page)
browser.load(QUrl(url))
browser.show()
app.exec()
def main():
# Create the application object
app = QApplication(sys.argv)
# Create the main window
mainWindow = MainWindow(app)
# Show and run the application
mainWindow.show()
app.exec()
def main(argv):
signal.signal(signal.SIGINT, signal.SIG_DFL)
app = QApplication([])
scene = QGraphicsScene()
view = QGraphicsView()
thumbnails = []
for filename in os.listdir(argv[1]):
filename = os.path.join(argv[1], filename)
print(filename)
thumbnails.append(DBusThumbnailer.thumbnail_from_filename(filename, "large"))
count = 0
items = []
for y in range(0, 100000, 150):
for x in range(0, 2500, 150):
scene.addRect(x, y, 128, 128)
# image = QImage(128, 128, QImage.Format_RGB32)
if count < len(thumbnails):
print(thumbnails[count])
image = QImage(thumbnails[count])
else:
arr = numpy.random.randint(0, 2**32, (128, 128), dtype=numpy.uint32)
image = QImage(arr, 128, 128, 128 * 4, QImage.Format_ARGB32)
pixmap = QPixmap.fromImage(image)
item = QGraphicsPixmapItem(pixmap)
scene.addItem(item)
text = scene.addText("Test Textual: {}".format(count))
item.setPos(x, y)
text.setPos(x, y + 128)
count += 1
item.setFlags(QGraphicsItem.ItemIsSelectable)
item.setAcceptHoverEvents(True)
items.append([item, text])
print(count)
if False:
random.shuffle(items)
i = 0
for y in range(0, 100000, 150):
for x in range(0, 2500, 150):
for item in items[i]:
item.setPos(x, y)
i += 1
view.setScene(scene)
view.resize(800, 600)
view.show()
app.exec()
def testui():
"""
@return: None
@rtype: None
"""
app = QApplication(argv)
c = UiController(app)
v = IDEView()
c.connectView(v)
c.mainWindow.show()
app.exec()
class Interface(object):
"""The Gui for the AI
Attributes:
app: An object representing a Q application
"""
def __init__(self):
self.app = QApplication(sys.argv)
def run(self):
view = QWebEngineView()
view.show()
view.setUrl(QUrl("https://google.com"))
self.app.exec()
def main():
parser = argparse.ArgumentParser(description='A prototype of BitTorrent client (GUI)')
parser.add_argument('--debug', action='store_true', help='Show debug messages')
parser.add_argument('filenames', nargs='*', help='Torrent file names')
args = parser.parse_args()
if not args.debug:
logging.disable(logging.INFO)
app = QApplication(sys.argv)
app.setWindowIcon(load_icon('logo'))
with closing(asyncio.get_event_loop()) as loop:
if loop.run_until_complete(find_another_daemon(args.filenames)):
if not args.filenames:
QMessageBox.critical(None, 'Failed to start', 'Another program instance is already running')
return
control_thread = ControlManagerThread()
main_window = MainWindow(control_thread)
control_thread.start()
app.lastWindowClosed.connect(control_thread.stop)
main_window.add_torrent_files(args.filenames)
return app.exec()
def main():
""" The entry point for the setuptools generated GUI wrapper. """
# Parse the command line.
parser = argparse.ArgumentParser()
parser.add_argument('project', help="the project to edit", nargs='?')
args = parser.parse_args()
from PyQt5.QtWidgets import QApplication
from . import Project
from .gui import ProjectGUI
app = QApplication(sys.argv, applicationName='pyqtdeploy',
organizationDomain='riverbankcomputing.com',
organizationName='Riverbank Computing')
if args.project is None:
project = Project()
else:
project = ProjectGUI.load(args.project)
if project is None:
return 1
gui = ProjectGUI(project)
gui.show()
return app.exec()
def main():
app = QApplication(sys.argv)
QCoreApplication.setOrganizationName('Hardcoded Software')
QCoreApplication.setApplicationName(__appname__)
QCoreApplication.setApplicationVersion(__version__)
setupQtLogging()
settings = QSettings()
lang = settings.value('Language')
locale_folder = op.join(BASE_PATH, 'locale')
install_gettext_trans_under_qt(locale_folder, lang)
# Handle OS signals
setUpSignals()
# Let the Python interpreter runs every 500ms to handle signals. This is
# required because Python cannot handle signals while the Qt event loop is
# running.
from PyQt5.QtCore import QTimer
timer = QTimer()
timer.start(500)
timer.timeout.connect(lambda: None)
# Many strings are translated at import time, so this is why we only import after the translator
# has been installed
from qt.app import DupeGuru
app.setWindowIcon(QIcon(QPixmap(":/{0}".format(DupeGuru.LOGO_NAME))))
global dgapp
dgapp = DupeGuru()
install_excepthook('https://github.com/hsoft/dupeguru/issues')
result = app.exec()
# I was getting weird crashes when quitting under Windows, and manually deleting main app
# references with gc.collect() in between seems to fix the problem.
del dgapp
gc.collect()
del app
gc.collect()
return result
def main():
loggingIni = pkg_resources.resource_stream(data.__name__, 'logging.ini')
loggingIni = io.TextIOWrapper(loggingIni, encoding='utf-8')
print("LOGGING ini file: {}".format(loggingIni))
logging.config.fileConfig(loggingIni)
# Create the application object
app = QApplication(sys.argv)
# Create the main window
mainWindow = MainWindow(app)
# Show and run the application
mainWindow.show()
app.exec()
def run(image_path = None):
# Global exceptions
sys.excepthook = excepthook
app = QApplication(sys.argv)
# Splash screen
splash_pix = QPixmap('resources/splash.jpg')
splash = QSplashScreen(splash_pix)
splash.setMask(splash_pix.mask())
splash.show()
app.processEvents()
# Load translation
locale_code = SettingsModel().get('Language', 'code')
if locale_code != "en_US": # Standard language
# Standard translator for the generated GUI
translator = QTranslator()
translator.load('localization/' + locale_code + '.qm')
app.installTranslator(translator)
# Translator for various GUI elements
translator_2 = QTranslator()
translator_2.load('localization/' + locale_code + '_2.qm')
app.installTranslator(translator_2)
# Start
m = Hitagi(image_path) # Pass image path
splash.finish(m)
sys.exit(app.exec())
def main():
initialize_logger(
os.path.join(os.path.dirname(__file__), 'LOG'), "MAIN")
app = QApplication(sys.argv)
model = MainModel(app_folder=os.path.dirname(__file__),
developing=False)
MainController(model)
sys.exit(app.exec())
def main():
app = QApplication(sys.argv)
main_window = MainWindow()
main_window.show()
app.setApplicationName("Whatsdesk")
app.setApplicationDisplayName("Whatsdesk")
print("App Started")
sys.exit(app.exec())
class Main(QWidget,Ui_Dialog):
def __init__(self):
self.app=QApplication(sys.argv)
super(Main, self).__init__()
self.setupUi(self)
self.load_default()
def exec(self):
self.show()
self.app.exec()
def run(self):
self.show()
self.app.exec()
def load_default(self):
pass
def main(argv):
signal.signal(signal.SIGINT, signal.SIG_DFL)
app = QApplication([])
combo = LineThing()
# combo.setEditable(True)
combo.show()
sys.exit(app.exec())
def main(argv):
app = QApplication(argv)
title = ''
if len(argv) > 1:
title = sys.argv[1]
window = MainWindow(title)
window.show()
return app.exec()
def main():
if markups.__version_tuple__ < (2, ):
sys.exit('Error: ReText needs PyMarkups 2.0 or newer to run.')
# If we're running on Windows without a console, then discard stdout
# and save stderr to a file to facilitate debugging in case of crashes.
if sys.executable.endswith('pythonw.exe'):
sys.stdout = open(devnull, 'w')
sys.stderr = open('stderr.log', 'w')
app = QApplication(sys.argv)
app.setOrganizationName("ReText project")
app.setApplicationName("ReText")
app.setApplicationDisplayName("ReText")
app.setApplicationVersion(app_version)
app.setOrganizationDomain('mitya57.me')
if hasattr(app, 'setDesktopFileName'): # available since Qt 5.7
app.setDesktopFileName('me.mitya57.ReText.desktop')
QNetworkProxyFactory.setUseSystemConfiguration(True)
RtTranslator = QTranslator()
for path in datadirs:
if RtTranslator.load('retext_' + globalSettings.uiLanguage,
join(path, 'locale')):
break
QtTranslator = QTranslator()
QtTranslator.load("qt_" + globalSettings.uiLanguage,
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
app.installTranslator(RtTranslator)
app.installTranslator(QtTranslator)
print('Using configuration file:', settings.fileName())
if globalSettings.appStyleSheet:
sheetfile = QFile(globalSettings.appStyleSheet)
sheetfile.open(QIODevice.ReadOnly)
app.setStyleSheet(QTextStream(sheetfile).readAll())
sheetfile.close()
window = ReTextWindow()
window.show()
# ReText can change directory when loading files, so we
# need to have a list of canonical names before loading
fileNames = list(map(canonicalize, sys.argv[1:]))
previewMode = False
for fileName in fileNames:
if QFile.exists(fileName):
window.openFileWrapper(fileName)
if previewMode:
window.actionPreview.setChecked(True)
window.preview(True)
elif fileName == '--preview':
previewMode = True
inputData = '' if (sys.stdin is None or sys.stdin.isatty()) else sys.stdin.read()
if inputData or not window.tabWidget.count():
window.createNew(inputData)
signal.signal(signal.SIGINT, lambda sig, frame: window.close())
sys.exit(app.exec())
def gui_main():
init()
global config, root_folder, settings, main_window
root_folder = os.path.expanduser(config.get("root_folder"))
if root_folder[-1] != '/':
root_folder += '/'
settings = QSettings("org", "edocuments")
app = QApplication(sys.argv)
main_window = MainWindow()
if settings.value("geometry") is not None:
main_window.restoreGeometry(settings.value("geometry"))
if settings.value("state") is not None:
main_window.restoreState(settings.value("state"))
main_window.show()
app.exec()
settings.setValue("geometry", main_window.saveGeometry())
settings.setValue("state", main_window.saveState())
settings.sync()
def test_qml():
# qmlpath = os.path.abspath(os.path.join(os.path.dirname(PyQt5.__file__), 'Qt', 'qml'))
# pluginpath = os.path.abspath(os.path.join(os.path.dirname(PyQt5.__file__), 'Qt', 'plugin'))
# os.environ['QML2_IMPORT_PATH'] = qmlpath
# os.environ['QT_PLUGIN_PATH'] = pluginpath
app = QApplication(sys.argv)
window = QMainWindow()
window.setWindowTitle('PyQt Demo')
engine = QQmlApplicationEngine('demo.qml')
engine.quit.connect(app.quit)
sys.exit(app.exec())
def main():
print(__name__)
lx = ListCommand()
lx.main(args=None)
# Note: Need a TextIOWrapper since streams are essentially byte-based since Python 3
# See also http://bugs.python.org/issue13518
loggingIni = pkg_resources.resource_stream(data.__name__, "logging.ini")
loggingIni = io.TextIOWrapper(loggingIni, encoding="utf-8")
print("LOGGING ini file: {}".format(loggingIni))
logging.config.fileConfig(loggingIni)
# Create the application object
app = QApplication(sys.argv)
# Create the main window
mainWindow = MainWindow(app)
# Show and run the application
mainWindow.show()
app.exec()
def main():
app = QApplication(sys.argv)
socket = QUdpSocket(app)
def lambdatimeout():
socket.writeDatagram(QByteArray(b""), QHostAddress("127.0.0.1"), 14555)
timer = QTimer(app)
timer.timeout.connect(lambdatimeout)
timer.setSingleShot(False)
timer.start(1000)
# socket.connectToHost(QHostAddress('127.0.0.1'), 14550)
sys.exit(app.exec())
def main(argv):
"""Main function running dotplot application.
Args:
argv:
list of (command-line like) arguments to be parsed by
ArgumentParser and used in the program's run. The first
argument in the list should be the name of the script.
"""
args = ArgumentParser().parse(argv)
if args.gui:
if not is_pyqt5_available():
print('You need to install PyQt5 to use GUI.')
else:
from PyQt5.QtWidgets import QApplication
from .gui import MainWindow
global application
# register application
application = QApplication(sys.argv)
# create main window; henceforth this class takes all control
main_window = MainWindow(args)
# after releasing lock by MainWindow, quit gracefully
return application.exec()
else:
dotplot = Dotplot(args.parsed_sequences, args.plotter, args.drawer)
dotplot.make_plot()
if args.drawer.method == 'matplotlib':
if not is_matplotlib_available():
print('You need to install matplotlib to use it.')
return False
else:
# ORDER MATTERS here. And one cannot just merge these imports.
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as pyplot
figure = pyplot.figure()
main_plot = figure.add_subplot(111)
dotplot.draw(main_plot, args.parsed_sequences)
pyplot.show()
else:
drawings = dotplot.draw()
print(drawings)
return True
def main():
app = QApplication(sys.argv)
app.setOrganizationName("ReText project")
app.setApplicationName("ReText")
app.setApplicationDisplayName("ReText")
app.setApplicationVersion(app_version)
app.setOrganizationDomain('mitya57.me')
if hasattr(app, 'setDesktopFileName'): # available since Qt 5.7
app.setDesktopFileName('me.mitya57.ReText.desktop')
QNetworkProxyFactory.setUseSystemConfiguration(True)
RtTranslator = QTranslator()
for path in datadirs:
if RtTranslator.load('retext_' + globalSettings.uiLanguage,
join(path, 'locale')):
break
QtTranslator = QTranslator()
QtTranslator.load("qt_" + globalSettings.uiLanguage,
QLibraryInfo.location(QLibraryInfo.TranslationsPath))
app.installTranslator(RtTranslator)
app.installTranslator(QtTranslator)
if globalSettings.appStyleSheet:
sheetfile = QFile(globalSettings.appStyleSheet)
sheetfile.open(QIODevice.ReadOnly)
app.setStyleSheet(QTextStream(sheetfile).readAll())
sheetfile.close()
window = ReTextWindow()
window.show()
# ReText can change directory when loading files, so we
# need to have a list of canonical names before loading
fileNames = list(map(canonicalize, sys.argv[1:]))
previewMode = False
for fileName in fileNames:
if QFile.exists(fileName):
window.openFileWrapper(fileName)
if previewMode:
window.actionPreview.trigger()
elif fileName == '--preview':
previewMode = True
if sys.stdin:
inputData = '' if sys.stdin.isatty() else sys.stdin.read()
if inputData or not window.tabWidget.count():
window.createNew(inputData)
signal.signal(signal.SIGINT, lambda sig, frame: window.close())
sys.exit(app.exec())
def main(args=sys.argv):
make_logger("unicodemoticon", emoji=True)
lock = set_single_instance("unicodemoticon")
check_encoding()
set_process_name("unicodemoticon")
set_process_priority()
app = QApplication(args)
app.setApplicationName("unicodemoticon")
app.setOrganizationName("unicodemoticon")
app.setOrganizationDomain("unicodemoticon")
app.instance().setQuitOnLastWindowClosed(False) # no quit on dialog quit
if qdarkstyle:
app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())
icon = QIcon(app.style().standardPixmap(QStyle.SP_FileIcon))
app.setWindowIcon(icon)
mainwindow = MainWidget()
mainwindow.show()
mainwindow.hide()
make_post_exec_msg(start_time)
sys.exit(app.exec())
def main(d):
"""Main Loop."""
make_root_check_and_encoding_debug()
set_process_name_and_cpu_priority("websktop")
set_single_instance("websktop")
signal.signal(signal.SIGINT, signal.SIG_DFL) # CTRL+C work to quit app
app = QApplication(sys.argv)
app.setApplicationName("websktop")
app.setOrganizationName("websktop")
app.setOrganizationDomain("websktop")
# app.instance().setQuitOnLastWindowClosed(False) # no quit on dialog quit
icon = QIcon(app.style().standardPixmap(QStyle.SP_FileIcon))
app.setWindowIcon(icon)
window = MainWindow()
window.show()
importd_thread = DThread(app, d)
importd_thread.finished.connect(app.exit) # if ImportD Quits then Quit GUI
app.aboutToQuit.connect(importd_thread.exit) # UI Quits then Quit ImportD
importd_thread.start()
make_post_execution_message()
sys.exit(app.exec())
else:
print("ERROR: network not available!")
sys.exit()
else:
ip_port = ("webserver disabled", "")
app = QApplication(sys.argv)
if settings.get("touchOptimize"):
app.setStyle("bb10dark")
else:
app.setStyle("kvantum-dark")
#print(app.style().metaObject().className()) # returns QBB10DarkStyle or bb10dark
#print("available styles: ", QStyleFactory.keys())
window = Player()
window.show()
# set autoTimer
if settings.get("autotimer"):
window.setAutoTimer(bool(settings["autotimer"]))
# handle exit
exitcode = app.exec()
if webserver != None:
print("stopping webserver...")
webserver.terminate()
sys.exit(exitcode)
# Inititiating spin! ~Cooper, Interstellar, 2014
import sys
from PyQt5.QtWidgets import QApplication
from src.gui.dialogs.create_email import CreateEmailDialog
APP = QApplication(sys.argv)
if __name__ == '__main__':
dialog = CreateEmailDialog()
dialog.show()
APP.exec()
def main():
App = QApplication(sys.argv)
window = Splash()
window.timer.start(100, window)
sys.exit(App.exec())
def main():
app = QApplication([])
window = Window()
app.exec()
self.show()
def CreateButton(self):
button = QPushButton("Click to Quit", self)
button.setGeometry(QRect(100, 100, 125, 28))
button.setIcon(QtGui.QIcon("CPS.jpg"))
button.setIconSize(QtCore.QSize(40, 40))
button.setToolTip("This will close the application")
button.clicked.connect(self.clickme)
def CreateButton2(self):
button = QPushButton("Click to Halt", self)
button.setGeometry(QRect(200, 200, 120, 28))
button.setIcon(QtGui.QIcon("kali.jpg"))
button.setIconSize(QtCore.QSize(40, 40))
button.setToolTip("This will halt the application")
button.clicked.connect(self.HardQuit)
def clickme(self):
print("System Quiting")
sys.exit(0)
def HardQuit(self):
print("System HALT", file=sys.stderr)
sys.exit(1)
App = QApplication(sys.argv)
window = Window()
sys.exit(App.exec())
def fn_iniciar(self):
self.boton_parar.setEnabled(True)
self.boton_iniciar.setEnabled(False)
t = threading.Thread(name="fn_inicio_supervision",
target=self.fn_inicio_supervision)
t.start()
def fn_parar(self):
self.fn_parar_supervision()
self.boton_iniciar.setEnabled(True)
self.boton_parar.setEnabled(False)
print(self.t)
self.t.stop()
msgBox = QMessageBox()
msgBox.setIcon(QMessageBox.Information)
msgBox.setWindowTitle("Información")
msgBox.setText(
"Se ha detenido correctamente la supervicion de la carpeta")
msgBox.exec()
def cerrar_aplicacion(self):
sys.exit()
if __name__ == "__main__":
app = QApplication(sys.argv)
GUI = UsuarioUI()
GUI.show()
sys.exit(app.exec())
def test_window():
app=QApplication([])
ex=MainWindow()
app.exec()
def janela_principal(self):
self.principal = Principal()
self.principal.show()
self.close()
class Gerador(QMainWindow, Ui_Gerador):
def __init__(self, parent=None):
super().__init__(parent=None)
super().setupUi(self)
self.btn_Voltar.clicked.connect(self.janela_principal)
self.btn_Gerar.clicked.connect(self.gerar)
def janela_principal(self):
self.principal = Principal()
self.principal.show()
self.close()
def gerar(self):
cpf_gerado = gerar()
self.cpf_gerado.setText(
f'{cpf_gerado[0:3]}.{cpf_gerado[3:6]}.{cpf_gerado[6:9]}-{cpf_gerado[9:]}'
)
if __name__ == '__main__':
qt = QApplication(sys.argv)
principal = Principal()
principal.show()
qt.exec()
def run_game():
count1 = 0
pygame.init()
size = 600, 400
screen = pygame.display.set_mode(size)
clock = pygame.time.Clock()
running = True
SPAWNTARGET = 30
pygame.time.set_timer(SPAWNTARGET, 500)
all_sprites = pygame.sprite.Group()
backround = pygame.sprite.Sprite(all_sprites)
backround.image = load_image("space.png")
backround.rect = backround.image.get_rect()
backround.rect.x = 0
backround.rect.y = 0
player = pygame.sprite.Sprite()
player.image = load_image("astrominer.png")
player.rect = player.image.get_rect()
all_sprites.add(player)
player.mask = pygame.mask.from_surface(player.image)
WHITE = (0, 255, 255)
x_min, x_max = 0, 600
circles = []
targets = []
pygame.mouse.set_visible(False)
sc = pygame.display.set_mode((400, 300))
sc.fill(WHITE)
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.MOUSEBUTTONDOWN:
bullet = pygame.sprite.Sprite(all_sprites)
bullet.image = load_image("bullet.jpg")
bullet.rect = bullet.image.get_rect()
bullet.rect.x = event.pos[0]
bullet.rect.y = event.pos[1]
circles.append(bullet)
bullet.mask = pygame.mask.from_surface(bullet.image)
if event.type == SPAWNTARGET:
meteor = pygame.sprite.Sprite(all_sprites)
meteor.image = load_image("aster.jpg")
meteor.rect = meteor.image.get_rect()
meteor.rect.x = random.randint(x_min, x_max)
meteor.rect.y = 0
targets.append(meteor)
meteor.mask = pygame.mask.from_surface(meteor.image)
meteor_delete = []
bullet_delete = []
for i, target in enumerate(targets):
if pygame.sprite.collide_mask(player, target):
running = False
hit = False
for bullet in circles:
if pygame.sprite.collide_mask(bullet, target):
hit = True
if hit:
target.kill()
meteor_delete.append(i)
count1 += 1
screen.fill((0, 0, 0))
if pygame.mouse.get_focused():
pos = pygame.mouse.get_pos()
player.rect.x = pos[0] - 20
player.rect.y = pos[1] - 35
for i, circle_center in enumerate(circles):
circle_center.rect.y -= 15
if circle_center.rect.y < -50:
bullet_delete.append(i)
for i, target_pos in enumerate(targets):
target_pos.rect.y += 3
if target_pos.rect.y > 400:
meteor_delete.append(i)
for i, j in enumerate(list(set(meteor_delete))):
targets.pop(j - i)
for i, j in enumerate(bullet_delete):
circles.pop(j - i)
all_sprites.draw(screen)
pygame.display.update()
clock.tick(60)
app = QApplication([])
end_menu = menu2.MainWindow(count1)
end_menu.show()
app.exec()
pygame.quit()
return count1
def main():
app = QApplication(sys.argv)
main = MainWindow()
main.show()
app.exec()
def main():
app = QApplication(sys.argv)
window = Sniffer()
window.show()
app.exec()
from PyQt5 import QtGui, QtCore, QtWidgets
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout
from PyQt5.QtCore import Qt
import sys
from tabwidget import TabWidget
from widget import Widget1, Widget2, Widget3
class Main(QWidget):
def __init__(self):
super().__init__()
wd1 = Widget1("Button 1")
wd2 = Widget2("Button 2")
wd3 = Widget3("Button 3")
self.tw = TabWidget()
self.tw.tabEmptySignal.connect(self.tabIsEmpty)
self.tw.attachWidget(wd1, "WD1")
self.tw.attachWidget(wd2, "WD2")
self.tw.attachWidget(wd3, "WD3")
self.tw.show()
def tabIsEmpty(self):
wd1 = Widget1("Button 111")
self.tw.attachWidget(wd1, "New")
if __name__ == "__main__":
qapp = QApplication(sys.argv)
app = Main()
qapp.exec()
class Window(QWidget):
def __init__(self):
super().__init__()
self.InitUi()
def InitUi(self):
self.listwidget = QListWidget()
li = ['java', 'c++', 'c#']
self.listwidget.insertItem(0, 'C++')
self.listwidget.insertItem(1, 'PYthon')
self.listwidget.insertItem(2, 'C#')
self.listwidget.clicked.connect(self.list_clicked)
self.vbox = QVBoxLayout()
self.label = QLabel("Language you selected")
self.label.setFont(QtGui.QFont("sanserif", 15))
self.vbox.addWidget(self.label)
self.vbox.addWidget(self.listwidget)
self.setLayout(self.vbox)
def list_clicked(self):
item = self.listwidget.currentItem()
self.label.setText(str(item.text()))
App = QApplication(sys.argv)
win = Window()
win.show()
App.exec()
{detalle_tiempo(self.total_duracion)}'
self.datos.setText(reproduccion)
self.tiempo.blockSignals(True)
self.tiempo.setValue(posicion)
self.tiempo.blockSignals(False)
# Metodo que detecta la posiscion establecida del modulo QMediaPlayer
def posicion_establecida(self, position):
self.media.setPosition(position)
def errores(self):
self.reproducir.setEnabled(False)
# self.lbl.setText("Error: " + self.media.errorString())
# Metodo para centrar la ventana principal
def centrar(self):
ventana = self.frameGeometry()
centro = QDesktopWidget().availableGeometry().center()
# print(centro)
ventana.moveCenter(centro)
self.move(ventana.topLeft())
if __name__ == '__main__':
reproductor = QApplication(sys.argv)
player = Reproductor()
reproductor.setStyle('Fusion')
sys.exit(reproductor.exec())
o_score = self.score(o_tile)
if o_score is not None:
return +o_score
x_tile = self.x.play()
assert x_tile in self.choices()
self.set(x_tile, notify)
x_score = self.score(x_tile)
if x_score is not None:
return -x_score
return None
def reset(self, notify: bool = False):
for tile in self:
tile.player = None
if notify is True:
tile.notify()
self.o.reset()
self.x.reset()
self.next = self.o
if __name__ == "__main__":
from PyQt5.QtWidgets import QApplication
import sys
import ui
application = QApplication(sys.argv)
qTicTacToe = ui.QTicTacToe()
sys.exit(application.exec())
def main():
app = QApplication(sys.argv)
appWindow = AppWindow()
controller = Controller(appWindow.gui)
appWindow.show()
sys.exit(app.exec())
root = QApplication([])
window = QMainWindow()
bg_new = 'background-color: rgb(%d,%d,%d);' % (random.randint(
1, 255), random.randint(1, 255), random.randint(1, 255))
window.setStyleSheet(bg_new)
window.resize(900, 600)
#
# quit = QAction("Quit", window)
# quit.triggered.connect(lambda: make_w())
clock = QtWidgets.QLabel(window)
clock.setFont(QFont("setItalic", 20))
clock.setText('Label Example')
bg_new = 'background-color: rgb(%d,%d,%d);' % (random.randint(
1, 255), random.randint(1, 255), random.randint(1, 255))
clock.setStyleSheet(bg_new)
clock.move(0, 0)
window.layout().addWidget(clock)
window.clock = clock
clock.timer = QTimer()
timer = window.clock.timer
starting_cordinate_hero = [window.clock.y(), window.clock.x()]
timer.timeout.connect(
lambda: jump_to_down(starting_cordinate_hero, window.clock))
timer.start(30)
window.show()
root.exec()
form_layout = QFormLayout()
group_box = QGroupBox("This is group box")
label_list = []
button_list = []
for i in range(self.val):
label_list.append((QLabel(f"Label {i}")))
button_list.append(QPushButton(f"Click me {i}"))
form_layout.addRow(label_list[i], button_list[i])
group_box.setLayout(form_layout)
scroll = QScrollArea()
scroll.setWidget(group_box)
scroll.setWidgetResizable(True)
scroll.setFixedHeight(300)
layout = QVBoxLayout()
layout.addWidget(scroll)
self.setLayout(layout)
self.show()
if __name__ == "__main__":
myapp = QApplication(sys.argv)
window = Window(20)
sys.exit(myapp.exec())
import sys
from PyQt5.QtWidgets import QApplication
from texteditorWindow import EditorWindow
from PyQt5.QtWidgets import QStyleFactory
from PyQt5.QtGui import QPalette
from PyQt5.QtGui import QColor
qApp = QApplication(sys.argv)
#qApp.setStyle(QStyleFactory.create("Fusion"))
#pal = QPalette()
#pal.setColor(QPalette.Window, QColor(53,53,53))
#pal.setColor(QPalette.Button, QColor(53,53,53))
#pal.setColor(QPalette.Highlight, QColor(142,45,197))
#pal.setColor(QPalette.ButtonText, QColor(255,255,255))
#pal.setColor(QPalette.WindowText, QColor(255,255,255))
#qApp.setPalette(pal)
textEditor = EditorWindow()
qApp.exec()
class MainWindown(QMainWindow):
load_data_ready = pyqtSignal(object)
def __init__(self):
self.PosData = None
self.Clusterer = None
self.show_visual = False
self.show_bg = False
self.pos_vis = None
self.clustering_vis = None
self.point_size = None
self.pool = Pool(processes=1) # experimenting
self.app = QApplication([])
QMainWindow.__init__(self)
ui_fname = 'main_window.ui'
self.ui = uic.loadUi(ui_fname)
self.ui.button_data_fname.clicked.connect(self.button_open_data_file)
self.ui.button_range_fname.clicked.connect(self.button_open_range_file)
self.ui.button_load_data.clicked.connect(self.button_load_data_click)
self.ui.button_show_ion_map.clicked.connect(
self.button_show_ion_map_click)
self.ui.button_run.clicked.connect(self.button_run_click)
self.ui.button_terminate.clicked.connect(self.button_terminate_click)
self.ui.button_show_visual.clicked.connect(
self.button_show_visual_click)
self.ui.button_show_visual.setEnabled(False)
self.ui.button_save_output.clicked.connect(self.button_save_click)
self.ui.groupBox_expert.hide()
self.ui.checkBox_show_bg.stateChanged.connect(self.checked_bg)
self.ui.checkBox_show_expert.stateChanged.connect(self.checked_expert)
# self.my_stream = MyStream()
# self.my_stream.message.connect(self.on_my_stream_message)
# sys.stdout = self.my_stream # basically overide the stdout method with my_stream, and output it to the text box.
self.ui.show()
sys.exit(self.app.exec())
@pyqtSlot(int, name='checked_bg')
def checked_bg(self, state):
if state == Qt.Checked:
self.show_bg = True
else:
self.show_bg = False
@pyqtSlot(int, name='checked_expert')
def checked_expert(self, state):
if state == Qt.Checked:
self.ui.groupBox_expert.show()
else:
self.ui.groupBox_expert.hide()
@pyqtSlot(str, name='on_myStream_message')
def on_my_stream_message(self, message):
self.ui.textBrowser.append(message)
@pyqtSlot(name='button_open_data_file')
def button_open_data_file(self):
fname = QFileDialog.getOpenFileName(self, 'Open Pos File', os.getcwd(),
"Pos files (*.pos)")
self.ui.le_data_fname.setText(fname[0])
@pyqtSlot(name='button_open_range_file')
def button_open_range_file(self):
fname = QFileDialog.getOpenFileName(self, 'Open Range File',
os.getcwd(),
"Range files (*.rrng, *.RRNG)")
self.ui.le_rrng_fname.setText(fname[0])
@pyqtSlot(name='button_load_data_click')
def button_load_data_click(self):
data_fname = self.ui.le_data_fname.text()
rrng_fname = self.ui.le_rrng_fname.text()
self.point_size = int(self.ui.le_point_size.text())
self.ui.textBrowser.setText('Data file loaded: ' + data_fname + '\n' +
'Range file loaded: ' + rrng_fname + '\n')
self.ui.textBrowser.append('Loadeding...')
self.DataLoader = APTDataLoader(data_fname, rrng_fname)
self.thread_data_loader = QThread()
self.DataLoader.data_ready.connect(self.get_load_data)
self.DataLoader.finished.connect(self.thread_data_loader.quit)
self.DataLoader.moveToThread(self.thread_data_loader)
self.thread_data_loader.started.connect(self.DataLoader.load_APT_data)
self.thread_data_loader.start()
@pyqtSlot(object, name='get_load_data')
def get_load_data(self, data):
if data == None:
self.ui.textBrowser.append(
'Invalid filenames. Please make sure filenames are correct and files located in current folder.'
)
else:
self.PosData = data
self.ui.textBrowser.append('Loaded Success.\n')
@pyqtSlot(name='button_show_ion_map_click')
def button_show_ion_map_click(self):
self.ui.textBrowser.append('Processing...\n')
self.pos_vis = APTDataViewer(self.PosData,
point_size=self.point_size,
max_ion=2000)
@pyqtSlot(name='button_run_click')
def button_run_click(self):
ion_types = self.ui.le_ion_types.text()
ion_types = ion_types.split(', ')
method = self.ui.le_method.text()
eps = float(self.ui.le_eps.text())
minpts = int(self.ui.le_minpts.text())
min_cluster_size = int(self.ui.le_min_cluster_size.text(
)) if self.ui.le_min_cluster_size.text() != 'None' else minpts
rho = float(self.ui.le_density.text())
det_eff = float(self.ui.le_det_eff.text())
con = float(self.ui.le_solute_con.text())
k = int(
self.ui.le_k.text()) if self.ui.le_k.text() != 'None' else minpts
significant_separation = float(
self.ui.le_significant_separation.text())
cluster_member_prob = float(self.ui.le_cluster_member_prob.text())
min_node_size = int(self.ui.le_min_node_size.text(
)) if self.ui.le_min_node_size.text() != 'None' else minpts
est_bg = float(self.ui.le_est_bg.text()
) if self.ui.le_est_bg.text() != 'None' else np.inf
node_similarity = float(self.ui.le_similarity.text())
if self.PosData == None:
self.ui.textBrowser.append('Please Load Data First!\n')
else:
self.ui.textBrowser.append('Clustering started...')
try:
clustering_parameters = {
'ion_types': ion_types,
'method': method,
'eps': eps,
'minpts': minpts,
'min_node_size': min_node_size,
'significant_separation': significant_separation,
'k': k,
'node_similarity': node_similarity,
'cluster_member_prob': cluster_member_prob,
'est_bg': est_bg,
'min_cluster_size': min_cluster_size
}
self.DoClustering = DoClustering(self.PosData,
clustering_parameters)
self.thread_do_clustering = QThread()
self.DoClustering.cluster_ready.connect(
self.get_clustering_result)
self.DoClustering.finished.connect(
self.thread_do_clustering.quit)
self.DoClustering.moveToThread(self.thread_do_clustering)
self.thread_do_clustering.started.connect(
self.DoClustering.cluster_analysis)
self.thread_do_clustering.start()
except:
self.ui.textBrowser.append(
'Something is wrong in cluster analysis setting, please check again...'
)
@pyqtSlot(object, name='get_clustering_result')
def get_clustering_result(self, data):
self.Clusterer = data
self.ui.textBrowser.append('Clustering finished.\n')
self.ui.button_show_visual.setEnabled(True)
@pyqtSlot(name='button_terminate_click')
def button_terminate_click(self):
self.thread_do_clustering.quit()
self.ui.textBrowser.append('Cluster analysis terminated!\n')
@pyqtSlot(name='button_show_visual_click')
def button_show_visual_click(self):
self.clustering_vis = ClusteringView(self.Clusterer, self.show_bg,
self.point_size)
@pyqtSlot(name='button_save_click')
def button_save_click(self):
output_filename = self.ui.le_output_fname.text()
try:
if self.Clusterer.RD is not None:
self.Clusterer.write_RD_to_file(output_filename + '_ol_RD_CD')
self.Clusterer.cluster_stats(output_filename + '_cluster_stats')
self.Clusterer.write_cluster_to_file(output_filename + '_clusters')
self.Clusterer.write_indexed_cluster_rrng(output_filename +
'_clusters')
self.Clusterer.write_log(output_filename + '_log')
except:
self.ui.textBrowser.append('Invalid output filename. Try again.')
#python用户图形界面编程实现
import sys #简单用户图形界面实现
from PyQt5.QtWidgets import QApplication,QWidget,QPushButton
from PyQt5.QtGui import QIcon
import sys
app=QApplication(sys.argv) #sys.argv是一组命令行参数的列表
w=QWidget() #QWidget控件是一个用户界面的基本控件，这里是一个窗口（window）
w.resize(500,800) #窗口的大小设置，宽和高
w.move(900,300) #修改控件位置的方法
w.setWindowTitle("大数据与数据挖掘") #窗口添加标题
w.setWindowIcon(QIcon("rose-1.jpg")) #设置标题图标
w.show()
sys.exit(app.exec()) #关闭界面窗口
def run():
# create QApplication
app = QApplication(sys.argv)
Window = MainWindow()
Window.show()
sys.exit(app.exec())
def main():
global app
app = QApplication(sys.argv)
w = MyMainWindow()
w.show()
app.exec()
def run():
App = QApplication(sys.argv)
window = Window()
sys.exit(App.exec())
def main():
app = QApplication([])
app.setStyle('Fusion')
_window = MyForm()
app.exec()
def main():
app = QApplication(sys.argv)
window = MainPage()
window.show()
sys.exit(app.exec())
bottom_line_height = 2
bottom_lr_height = 4
bottom_line_y = inner_height - 2
bottom_line_width = inner_width - margin_left * 2
bottom_line_rect = QRect(margin_left, bottom_line_y,
bottom_line_width, bottom_line_height)
bottom_lr_y = bottom_line_y - bottom_lr_height + bottom_line_height
bottom_left_rect = QRect(margin_left, bottom_lr_y,
line_width, bottom_lr_height)
bottom_right_rect = QRect(margin_left+bottom_line_width-line_width, bottom_lr_y,
line_width, bottom_lr_height)
painter.drawRoundedRect(bottom_line_rect, 2, 2)
painter.drawRoundedRect(bottom_left_rect, 2, 2)
painter.drawRoundedRect(bottom_right_rect, 2, 2)
def drawStatus(self, painter):
if self._downloading:
super().drawStatus(painter)
if __name__ == '__main__':
from unittest.mock import MagicMock
from PyQt5.QtWidgets import QApplication
app = QApplication([])
widget = DownloadLabel(MagicMock(), MagicMock())
widget.show()
widget.resize(30, 30)
app.exec()
def main():
app = QApplication(sys.argv)
mw = MainWindow()
mw.show()
sys.exit(app.exec())
#!/usr/bin/env python3
import sys
from PyQt5.QtWidgets import QApplication
from vgrabber.qtgui.guimodel import GuiModel
from vgrabber.qtgui.mainwindow import MainWindow
app = QApplication(sys.argv)
app.setOrganizationName("Jan Janech")
app.setApplicationName("vzdelavanieGui")
model = GuiModel()
main_window = MainWindow(model)
main_window.show()
ret = app.exec()
model.quit()
sys.exit(ret)
def main():
app = QApplication(sys.argv)
canv = PixmapCanvas(init_func=init, update_func=update, anim_period=1000)
canv.show()
sys.exit(app.exec())