def __init__(self, display=True):
self.app = QApplication([])
QWebView.__init__(self)
if display:
self.show() # show the browser
def main():
app = QApplication(sys.argv)
mainwindow = MainWindow()
mainwindow.show()
app.exec_()
def main():
app = QApplication(sys.argv)
opc = opcda.start()
main_window = MainWindow(opc)
main_window.show()
app.exec_()
def gui():
appg = QApplication(argv)
window = CC_window()
QCoreApplication.processEvents()
appg.exec_()
exit(0)
def testQPushButton(self):
#QApplication deleted before QPushButton
a = QApplication([])
b = QPushButton('aaaa')
del a
url = item.text()
if url.startswith('http://'):
webbrowser.open(url)
if column == 0:
for (user, url, _, _) in VIDEO:
if (self.item(row, column).text() == user):
webbrowser.open(url)
# def closeEvent(self, event):
# event.accept()
# self.thread.terminate()
# sys.exit()
class VideoThread(QThread):
dataReady = Signal(object)
def run(self):
print time.ctime(time.time()), u' - 检查视频更新'
Updater().getLatest()
self.dataReady.emit('')
if __name__ == '__main__':
app = QApplication(sys.argv)
table = MyTable(0, 4)
table.thread.start()
app.exec_()
sys.exit()
def main():
app = QApplication(sys.argv)
signal(SIGINT, quit_handler)
mainwindow = MainWindow()
app.setActiveWindow(mainwindow)
sys.exit(app.exec_())
def main():
app = QApplication(sys.argv)
splitterWidget = SplitterWidget()
splitterWidget.show()
app.exec_()
def main():
app = QApplication(argv)
game = TicTacToe(3)
gui = GameGui(game)
app.exec_()
def main():
app = QApplication(sys.argv)
view = FremantleView()
view.showFullScreen()
sys.exit(app.exec_())
def run():
app = QApplication(sys.argv)
editor = EditorMainWindow()
editor.show()
sys.exit(app.exec_())
triggered=self.exitFile )
self.copyAction=QAction( QIcon(), '&Copy',
self,
shortcut="Ctrl+C",
statusTip="Copy",
triggered=self.textEdit.copy )
self.pasteAction=QAction( QIcon(), '&Paste',
self,
shortcut="Ctrl+V",
triggered=self.textEdit.paste)
self.aboutAction=QAction( QIcon(), '&About',
self,
statusTip="Displays info",
triggered=self.aboutHelp )
# Actual menu bar item creation
def createMenus(self):
""" Function to create actual menu bar
"""
self.fileMenu = self.menuBar().addMenu("&File")
self.editMenu = self.menuBar().addMenu("&Edit")
self.helpMenu = self.menuBar().addMenu("&Help")
if __name__=='__main__':
try:
Aeneid_app=QApplication(sys.argv)
Aeneid_win=MainWindow()
sys.exit( Aeneid_app.exec_() )
except NameError: print("Name Error: ", sys.exc_info()[1])
except SystemExit: print("Closing Window...")
except Exception: print (sys.exc_info()[1])
""" When the start button is pressed, start the main program loop """
if Main.selectedProgram:
if not Main.running:
self.start_btn.setText('Stop')
Main.running = True
try:
pythoncom.CoInitializeEx(pythoncom.COINIT_MULTITHREADED)
except pythoncom.com_error:
# already initialized.
pass
thread = Thread(
target=Main.enumWindows, name='enumWindows')
thread.run()
else:
self.start_btn.setText('Start')
Main.running = False
self.set_playing(Misc.noSongPlaying)
Wr.write('')
def set_playing(self, title=''):
""" Sets the text of the label of what song is playing """
# print 'setting title: ', title
self.current_playing.setText(title)
if __name__ == '__main__':
initialize()
pythoncom.CoInitialize()
APP = QApplication(sys.argv)
Constants.UI = UiMain()
sys.exit(APP.exec_())
def setUpClass(cls):
super(TestDeliverySlipGUI, cls).setUpClass()
app = QApplication.instance()
if app is None:
app = QApplication(sys.argv)
cls.app = app
def main():
app = QApplication(sys.argv)
ex_start = Start()
ex_start.show()
sys.exit(app.exec_())
from PIL import Image
from PySide.QtGui import QImage, QImageReader, QLabel, QPixmap, QApplication
im = Image.open("centroid_diff_x.png")
data = im.convert('RGBA').tostring()
app = QApplication([])
image = QImage(data, im.size[0], im.size[1], QImage.Format_ARGB32)
pix = QPixmap.fromImage(image)
lbl = QLabel()
lbl.setPixmap(pix)
lbl.show()
app.exec_()
if __name__ == '__main__':
#get our context for communicating through ZeroMQ
with zmq.Context() as ctx:
#set up a socket to send and receive messages
with ctx.socket(zmq.REQ) as sock:
#connect to the socket (TCP, port 5556 default)
port = 5556
sock.connect('tcp://%s:%d' % ('localhost', port))
time.sleep(1)
#create a QApplication if one doesn't already exist
app = QApplication.instance()
if app == None:
app = QApplication([
'/Users/Patrick/anaconda/lib/python2.7/site-packages/spyderlib/widgets/externalshell/start_ipython_kernel.py'
])
#create and show the main window
mwind = MainWindow()
mwind.show()
mwind.sock = sock
#set up stream for stdout and stderr based on outputStream class
outputStream = outputStream()
#when outputStream sends messages, connect to appropriate function for
#writing to terminal window
outputStream.message.connect(mwind.print_message)
#connect stdout and stderr to outputStream
layout.addWidget(self._make_dec_arrow())
layout.addWidget(self._make_push_button())
layout.addWidget(self._make_inc_arrow())
layout.addStretch()
def _make_page_label(self):
label = QLabel('Page')
label.setStyleSheet(_PAGE_LABEL_CSS)
return label
def _make_dec_arrow(self):
label = QLabel(u'\u2222')
label.setStyleSheet(_ARROW_CSS)
return label
# ----------------------------------------------------------------------------
# __main__ test entry point
# ----------------------------------------------------------------------------
def _print_it(it):
print it
if __name__ == '__main__':
app = QApplication(())
lbl = HexPageNavigator(0xF100)
lbl.show()
app.exec_()
__author__ = 'waterstrider.vin'
from sys import argv
from PySide.QtGui import QApplication
from uTextWatermark.uTextWatermarkWidget import UTextWatermarkWidget
if __name__ == "__main__":
app = QApplication(argv)
uTextWatermarkWidget = UTextWatermarkWidget()
uTextWatermarkWidget.show()
app.exec_()
def main():
app = QApplication(sys.argv)
# app.setStyle('plastique')
win = BaseMplCanvas()
win.show()
sys.exit(app.exec_())
def testConnectSignal(self):
app = QApplication([])
m2 = M2()
# Test if the aboutToShow signal was translated to correct type
m2.aboutToShow.connect(self.aboutToShowHandler)
def main(argv=None):
app = QApplication(sys.argv)
loader = QUiLoader()
# loader del mainwindows y todos los dialogs
ui = loader.load(':/mainwindow')
d_agregado = loader.load(':/agregado_dialog')
d_segmentado = loader.load(':/segmentado_dialog')
d_crearVar_0 = loader.load(':/crear_variable_existente')
d_crearVar_1 = loader.load(':/crear_variable_funcion')
d_crearVar_2 = loader.load(':/crear_variable_algoritmo')
d_multiselector = loader.load(':/multiselect_column')
d_multiselector_2 = loader.load(':/multiselect_column')
d_discretizar = loader.load(':/discretizar_dialog')
d_tipificar = loader.load(':/tipificar_dialog')
d_recodificar = loader.load(':/recodificar_dialog')
d_muestra = loader.load(':/muestra_dialog')
d_transformar = loader.load(':/transformar_dialog')
d_cajas = loader.load(':/cajas_dialog')
d_frec = loader.load(':/frecuencias_dialog')
d_dispersion = loader.load(':/dispersion_dialog')
d_percentiles = loader.load(':/percentiles_dialog')
d_histogramas = loader.load(':/histograma_dialog')
d_descr_univar = loader.load(':/descr_univar_dialog')
d_descr_multiple = loader.load(':/descr_multiple_dialog')
d_correlacion = loader.load(':/correlacion_dialog')
d_contr_inter = loader.load(':/contr_inter_dialog')
d_contr_intra = loader.load(':/contr_intra_dialog')
d_anova_inter = loader.load(':/anova_inter_dialog')
d_anova_intra = loader.load(':/anova_intra_dialog')
d_anova_split = loader.load(':/anova_split_dialog')
d_regr_multiple = loader.load(':/regr_multiple_dialog')
d_regr_mediacion = loader.load(':/regr_mediacion_dialog')
d_sobre = loader.load(':/sobre_nosotros_dialog')
# instancio el mainwindow
mWindow = MainWindow(ui, d_sobre)
fncArchivo = FncArchivo(ui)
fndDatosAgregado = FncDatosAgregado(ui, d_agregado)
fncDatosSegmentado = FncDatosSegmentado(ui, d_segmentado)
fncDatosCrear = FncDatosCrear(ui, d_multiselector, d_crearVar_0,
d_crearVar_1, d_crearVar_2)
fncDatosDiscretizar = FncDatosDiscretizar(ui, d_discretizar)
fncDatosTipificar = FncDatosTipificar(ui, d_tipificar, d_multiselector)
fncDatosRecodificar = FncDatosRecodificar(ui, d_recodificar)
fncDatosMuesTra = FncDatosMuestraTransformar(ui, d_muestra, d_transformar)
fncGrafCajasFrec = FncGrafCajasFrec(ui, d_cajas, d_frec, d_multiselector)
fncGrafDispersion = FncGrafDispersion(ui, d_dispersion, d_multiselector)
fncGrafPercenHisto = FncGrafPercenHisto(ui, d_percentiles, d_histogramas,
d_multiselector)
fncAnlsDescriptivos = FncAnlsDescriptivos(ui, d_descr_univar,
d_descr_multiple,
d_multiselector)
fncAnlsCorrelacion = FncAnlsCorrelacion(ui, d_correlacion, d_multiselector,
d_multiselector_2)
fncAnlsContraste = FncAnlsContraste(ui, d_contr_inter, d_contr_intra,
d_multiselector)
fncAnlsAnova = FncAnlsAnova(ui, d_anova_inter, d_anova_intra,
d_anova_split, d_multiselector)
fncAnlsRegresion = FncAnlsRegresion(ui, d_regr_multiple, d_regr_mediacion,
d_multiselector)
# inicio el programa
ui.setWindowTitle("ULLRToolbox")
ui.setWindowIcon(QtGui.QIcon(':/logo64'))
ui.showMaximized()
return app.exec_()
def __init__(self,
user_agent=default_user_agent,
wait_timeout=8,
wait_callback=None,
log_level=logging.WARNING,
display=False,
viewport_size=(800, 600),
ignore_ssl_errors=True,
cache_dir=os.path.join(tempfile.gettempdir(), "ghost.py"),
plugins_enabled=False,
java_enabled=False,
plugin_path=[
'/usr/lib/mozilla/plugins',
],
download_images=True,
qt_debug=False,
no_sslv3=True,
show_scroolbars=True):
self.http_resources = []
self.user_agent = user_agent
self.wait_timeout = wait_timeout
self.wait_callback = wait_callback
self.ignore_ssl_errors = ignore_ssl_errors
self.loaded = True
if not sys.platform.startswith('win') and not 'DISPLAY' in os.environ\
and not hasattr(Ghost, 'xvfb'):
try:
os.environ['DISPLAY'] = ':99'
Ghost.xvfb = subprocess.Popen(['Xvfb', ':99'])
except OSError:
raise Error('Xvfb is required to a ghost run outside ' +
'an X instance')
self.display = display
if not Ghost._app:
Ghost._app = QApplication.instance() or QApplication(['ghost'])
qInstallMsgHandler(QTMessageProxy(qt_debug))
if plugin_path:
for p in plugin_path:
Ghost._app.addLibraryPath(p)
if no_sslv3:
# enable tls1 only
old = QSslConfiguration.defaultConfiguration()
old.setProtocol(QSsl.TlsV1)
QSslConfiguration.setDefaultConfiguration(old)
self.popup_messages = []
self.page = GhostWebPage(Ghost._app, self)
QtWebKit.QWebSettings.setMaximumPagesInCache(0)
QtWebKit.QWebSettings.setObjectCacheCapacities(0, 0, 0)
QtWebKit.QWebSettings.globalSettings().setAttribute(
QtWebKit.QWebSettings.LocalStorageEnabled, True)
self.page.setForwardUnsupportedContent(True)
self.page.settings().setAttribute(QtWebKit.QWebSettings.AutoLoadImages,
download_images)
self.page.settings().setAttribute(QtWebKit.QWebSettings.PluginsEnabled,
plugins_enabled)
self.page.settings().setAttribute(QtWebKit.QWebSettings.JavaEnabled,
java_enabled)
if not show_scroolbars:
self.page.mainFrame().setScrollBarPolicy(
QtCore.Qt.Vertical, QtCore.Qt.ScrollBarAlwaysOff)
self.page.mainFrame().setScrollBarPolicy(
QtCore.Qt.Horizontal, QtCore.Qt.ScrollBarAlwaysOff)
self.set_viewport_size(*viewport_size)
# Page signals
self.page.loadFinished.connect(self._page_loaded)
self.page.loadStarted.connect(self._page_load_started)
self.page.unsupportedContent.connect(self._unsupported_content)
self.manager = self.page.networkAccessManager()
self.manager.finished.connect(self._request_ended)
self.manager.sslErrors.connect(self._on_manager_ssl_errors)
# Cache
self.cache = QNetworkDiskCache()
self.cache.setCacheDirectory(cache_dir)
self.manager.setCache(self.cache)
# Cookie jar
self.cookie_jar = QNetworkCookieJar()
self.manager.setCookieJar(self.cookie_jar)
# User Agent
self.page.setUserAgent(self.user_agent)
self.page.networkAccessManager().authenticationRequired\
.connect(self._authenticate)
self.page.networkAccessManager().proxyAuthenticationRequired\
.connect(self._authenticate)
self.main_frame = self.page.mainFrame()
logger.setLevel(log_level)
if self.display:
class MyQWebView(QtWebKit.QWebView):
def sizeHint(self):
return QSize(*viewport_size)
self.webview = MyQWebView()
if plugins_enabled:
self.webview.settings().setAttribute(
QtWebKit.QWebSettings.PluginsEnabled, True)
if java_enabled:
self.webview.settings().setAttribute(
QtWebKit.QWebSettings.JavaEnabled, True)
self.webview.setPage(self.page)
self.webview.show()
else:
self.webview = None
