def inputhook(context):
global _appref
app = QtCore.QCoreApplication.instance()
if not app:
_appref = app = QtGui.QApplication([" "])
event_loop = QtCore.QEventLoop(app)
if sys.platform == 'win32':
# The QSocketNotifier method doesn't appear to work on Windows.
# Use polling instead.
timer = QtCore.QTimer()
timer.timeout.connect(event_loop.quit)
while not context.input_is_ready():
timer.start(50) # 50 ms
event_loop.exec_()
timer.stop()
else:
# On POSIX platforms, we can use a file descriptor to quit the event
# loop when there is input ready to read.
notifier = QtCore.QSocketNotifier(context.fileno(),
QtCore.QSocketNotifier.Read)
# connect the callback we care about before we turn it on
notifier.activated.connect(event_loop.exit)
notifier.setEnabled(True)
# only start the event loop we are not already flipped
if not context.input_is_ready():
event_loop.exec_()
def _notify_stream_qt(kernel, stream):
from IPython.external.qt_for_kernel import QtCore
def process_stream_events():
"""fall back to main loop when there's a socket event"""
# call flush to ensure that the stream doesn't lose events
# due to our consuming of the edge-triggered FD
# flush returns the number of events consumed.
# if there were any, wake it up
if stream.flush(limit=1):
notifier.setEnabled(False)
kernel.app.quit()
fd = stream.getsockopt(zmq.FD)
notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read, kernel.app)
notifier.activated.connect(process_stream_events)
# there may already be unprocessed events waiting.
# these events will not wake zmq's edge-triggered FD
# since edge-triggered notification only occurs on new i/o activity.
# process all the waiting events immediately
# so we start in a clean state ensuring that any new i/o events will notify.
# schedule first call on the eventloop as soon as it's running,
# so we don't block here processing events
timer = QtCore.QTimer(kernel.app)
timer.setSingleShot(True)
timer.timeout.connect(process_stream_events)
timer.start(0)
def _notify_stream_qt(kernel, stream):
from IPython.external.qt_for_kernel import QtCore
if _use_appnope() and kernel._darwin_app_nap:
from appnope import nope_scope as context
else:
from contextlib import contextmanager
@contextmanager
def context():
yield
def process_stream_events():
while stream.getsockopt(zmq.EVENTS) & zmq.POLLIN:
with context():
kernel.do_one_iteration()
fd = stream.getsockopt(zmq.FD)
notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read,
kernel.app)
notifier.activated.connect(process_stream_events)
# there may already be unprocessed events waiting.
# these events will not wake zmq's edge-triggered FD
# since edge-triggered notification only occurs on new i/o activity.
# process all the waiting events immediately
# so we start in a clean state ensuring that any new i/o events will notify.
# schedule first call on the eventloop as soon as it's running,
# so we don't block here processing events
timer = QtCore.QTimer(kernel.app)
timer.setSingleShot(True)
timer.timeout.connect(process_stream_events)
timer.start(0)
def inputhook(context):
global _appref
app = QtCore.QCoreApplication.instance()
if not app:
if sys.platform == 'linux':
if not os.environ.get('DISPLAY') \
and not os.environ.get('WAYLAND_DISPLAY'):
import warnings
global _already_warned
if not _already_warned:
_already_warned = True
warnings.warn(
'The DISPLAY or WAYLAND_DISPLAY environment variable is '
'not set or empty and Qt5 requires this environment '
'variable. Deactivate Qt5 code.')
return
try:
QtCore.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
except AttributeError: # Only for Qt>=5.6, <6.
pass
try:
QtCore.QApplication.setHighDpiScaleFactorRoundingPolicy(
QtCore.Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
except AttributeError: # Only for Qt>=5.14.
pass
_appref = app = QtGui.QApplication([" "])
# "reclaim" IPython sys.excepthook after event loop starts
# without this, it defaults back to BaseIPythonApplication.excepthook
# and exceptions in the Qt event loop are rendered without traceback
# formatting and look like "bug in IPython".
QtCore.QTimer.singleShot(0, _reclaim_excepthook)
event_loop = QtCore.QEventLoop(app)
if sys.platform == 'win32':
# The QSocketNotifier method doesn't appear to work on Windows.
# Use polling instead.
timer = QtCore.QTimer()
timer.timeout.connect(event_loop.quit)
while not context.input_is_ready():
timer.start(50) # 50 ms
_exec(event_loop)
timer.stop()
else:
# On POSIX platforms, we can use a file descriptor to quit the event
# loop when there is input ready to read.
notifier = QtCore.QSocketNotifier(
context.fileno(),
enum_helper("QtCore.QSocketNotifier.Type").Read)
try:
# connect the callback we care about before we turn it on
notifier.activated.connect(lambda: event_loop.exit())
notifier.setEnabled(True)
# only start the event loop we are not already flipped
if not context.input_is_ready():
_exec(event_loop)
finally:
notifier.setEnabled(False)
def inputhook(context):
app = QtCore.QCoreApplication.instance()
if not app:
return
event_loop = QtCore.QEventLoop(app)
notifier = QtCore.QSocketNotifier(context.fileno(),
QtCore.QSocketNotifier.Read)
notifier.setEnabled(True)
notifier.activated.connect(event_loop.exit)
event_loop.exec_()
def enable_qt4(self, app=None):
"""Enable event loop integration with PyQt4.
Parameters
----------
app : Qt Application, optional.
Running application to use. If not given, we probe Qt for an
existing application object, and create a new one if none is found.
Notes
-----
This methods sets the PyOS_InputHook for PyQt4, which allows
the PyQt4 to integrate with terminal based applications like
IPython.
If ``app`` is not given we probe for an existing one, and return it if
found. If no existing app is found, we create an :class:`QApplication`
as follows::
from PyQt4 import QtCore
app = QtGui.QApplication(sys.argv)
"""
from IPython.external.qt_for_kernel import QtCore, QtGui
if "pyreadline" in sys.modules:
# see IPython GitHub Issue #281 for more info on this issue
# Similar intermittent behavior has been reported on OSX,
# but not consistently reproducible
warnings.warn(
"""PyReadline's inputhook can conflict with Qt, causing delays
in interactive input. If you do see this issue, we recommend using another GUI
toolkit if you can, or disable readline with the configuration option
'TerminalInteractiveShell.readline_use=False', specified in a config file or
at the command-line""",
RuntimeWarning,
)
# PyQt4 has had this since 4.3.1. In version 4.2, PyOS_InputHook
# was set when QtCore was imported, but if it ever got removed,
# you couldn't reset it. For earlier versions we can
# probably implement a ctypes version.
try:
QtCore.pyqtRestoreInputHook()
except AttributeError:
pass
self._current_gui = GUI_QT4
if app is None:
app = QtCore.QCoreApplication.instance()
if app is None:
app = QtGui.QApplication([" "])
app._in_event_loop = True
self._apps[GUI_QT4] = app
return app
def inputhook(context):
global _appref
app = QtCore.QCoreApplication.instance()
if not app:
if sys.platform == 'linux':
if not os.environ.get('DISPLAY') \
and not os.environ.get('WAYLAND_DISPLAY'):
import warnings
global _already_warned
if not _already_warned:
_already_warned = True
warnings.warn(
'The DISPLAY or WAYLAND_DISPLAY environment variable is '
'not set or empty and Qt5 requires this environment '
'variable. Deactivate Qt5 code.')
return
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
_appref = app = QtGui.QApplication([" "])
# "reclaim" IPython sys.excepthook after event loop starts
# without this, it defaults back to BaseIPythonApplication.excepthook
# and exceptions in the Qt event loop are rendered without traceback
# formatting and look like "bug in IPython".
QtCore.QTimer.singleShot(0, _reclaim_excepthook)
event_loop = QtCore.QEventLoop(app)
if sys.platform == 'win32':
# The QSocketNotifier method doesn't appear to work on Windows.
# Use polling instead.
timer = QtCore.QTimer()
timer.timeout.connect(event_loop.quit)
while not context.input_is_ready():
timer.start(50) # 50 ms
event_loop.exec_()
timer.stop()
else:
# On POSIX platforms, we can use a file descriptor to quit the event
# loop when there is input ready to read.
notifier = QtCore.QSocketNotifier(context.fileno(),
QtCore.QSocketNotifier.Read)
try:
# connect the callback we care about before we turn it on
# lambda is necessary as PyQT inspect the function signature to know
# what arguments to pass to. See https://github.com/ipython/ipython/pull/12355
notifier.activated.connect(lambda: event_loop.exit())
notifier.setEnabled(True)
# only start the event loop we are not already flipped
if not context.input_is_ready():
event_loop.exec_()
finally:
notifier.setEnabled(False)
def enable_qt4(self, app=None):
"""Enable event loop integration with PyQt4.
Parameters
----------
app : Qt Application, optional.
Running application to use. If not given, we probe Qt for an
existing application object, and create a new one if none is found.
Notes
-----
This methods sets the PyOS_InputHook for PyQt4, which allows
the PyQt4 to integrate with terminal based applications like
IPython.
If ``app`` is not given we probe for an existing one, and return it if
found. If no existing app is found, we create an :class:`QApplication`
as follows::
from PyQt4 import QtCore
app = QtGui.QApplication(sys.argv)
"""
from IPython.external.qt_for_kernel import QtCore, QtGui
if 'pyreadline' in sys.modules:
# see IPython GitHub Issue #281 for more info on this issue
# Similar intermittent behavior has been reported on OSX,
# but not consistently reproducible
warnings.warn(
"""PyReadline's inputhook can conflict with Qt, causing delays
in interactive input. If you do see this issue, we recommend using another GUI
toolkit if you can, or disable readline with the configuration option
'TerminalInteractiveShell.readline_use=False', specified in a config file or
at the command-line""", RuntimeWarning)
# PyQt4 has had this since 4.3.1. In version 4.2, PyOS_InputHook
# was set when QtCore was imported, but if it ever got removed,
# you couldn't reset it. For earlier versions we can
# probably implement a ctypes version.
try:
QtCore.pyqtRestoreInputHook()
except AttributeError:
pass
self._current_gui = GUI_QT4
if app is None:
app = QtCore.QCoreApplication.instance()
if app is None:
app = QtGui.QApplication([" "])
app._in_event_loop = True
self._apps[GUI_QT4] = app
return app
def inputhook(context):
global _appref
app = QtCore.QCoreApplication.instance()
if not app:
if sys.platform == 'linux':
if not os.environ.get('DISPLAY') \
and not os.environ.get('WAYLAND_DISPLAY'):
import warnings
global _already_warned
if not _already_warned:
_already_warned = True
warnings.warn(
'The DISPLAY or WAYLAND_DISPLAY environment variable is '
'not set or empty and Qt5 requires this environment '
'variable. Deactivate Qt5 code.'
)
return
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling)
_appref = app = QtGui.QApplication([" "])
event_loop = QtCore.QEventLoop(app)
if sys.platform == 'win32':
# The QSocketNotifier method doesn't appear to work on Windows.
# Use polling instead.
timer = QtCore.QTimer()
timer.timeout.connect(event_loop.quit)
while not context.input_is_ready():
timer.start(50) # 50 ms
event_loop.exec_()
timer.stop()
else:
# On POSIX platforms, we can use a file descriptor to quit the event
# loop when there is input ready to read.
notifier = QtCore.QSocketNotifier(context.fileno(),
QtCore.QSocketNotifier.Read)
try:
# connect the callback we care about before we turn it on
notifier.activated.connect(event_loop.exit)
notifier.setEnabled(True)
# only start the event loop we are not already flipped
if not context.input_is_ready():
event_loop.exec_()
finally:
notifier.setEnabled(False)
def on_figure_window_close(figure, function):
"""Connects a close figure signal to a given function.
Parameters
----------
figure : mpl figure instance
function : function
"""
backend = plt.get_backend()
if backend not in ("GTKAgg", "WXAgg", "TkAgg", "Qt4Agg"):
return
window = figure.canvas.manager.window
if not hasattr(figure, '_on_window_close'):
figure._on_window_close = list()
if function not in figure._on_window_close:
figure._on_window_close.append(function)
if backend == 'GTKAgg':
def function_wrapper(*args):
function()
window.connect('destroy', function_wrapper)
elif backend == 'WXAgg':
# In linux the following code produces a segmentation fault
# so it is enabled only for Windows
import wx
def function_wrapper(event):
# When using WX window.connect does not supports multiple functions
for f in figure._on_window_close:
f()
plt.close(figure)
window.Bind(wx.EVT_CLOSE, function_wrapper)
elif backend == 'TkAgg':
def function_wrapper(*args):
# When using TK window.connect does not supports multiple functions
for f in figure._on_window_close:
f()
figure.canvas.manager.window.bind("<Destroy>", function_wrapper)
elif backend == 'Qt4Agg':
# PyQt
# In PyQt window.connect supports multiple functions
from IPython.external.qt_for_kernel import QtCore
window.connect(window, QtCore.SIGNAL('closing()'), function)
else:
raise AttributeError("The %s backend is not supported. " % backend)
def loop_qt4(kernel):
"""Start a kernel with PyQt4 event loop integration."""
from IPython.external.qt_for_kernel import QtCore
from IPython.lib.guisupport import get_app_qt4, start_event_loop_qt4
kernel.app = get_app_qt4([" "])
kernel.app.setQuitOnLastWindowClosed(False)
kernel.timer = QtCore.QTimer()
kernel.timer.timeout.connect(kernel.do_one_iteration)
# Units for the timer are in milliseconds
kernel.timer.start(1000 * kernel._poll_interval)
start_event_loop_qt4(kernel.app)
def inputhook(context):
app = QtCore.QCoreApplication.instance()
if not app:
return
event_loop = QtCore.QEventLoop(app)
if sys.platform == 'win32':
# The QSocketNotifier method doesn't appear to work on Windows.
# Use polling instead.
timer = QtCore.QTimer()
timer.timeout.connect(event_loop.quit)
while not context.input_is_ready():
timer.start(50) # 50 ms
event_loop.exec_()
timer.stop()
else:
# On POSIX platforms, we can use a file descriptor to quit the event
# loop when there is input ready to read.
notifier = QtCore.QSocketNotifier(context.fileno(), QtCore.QSocketNotifier.Read)
notifier.setEnabled(True)
notifier.activated.connect(event_loop.exit)
event_loop.exec_()
def _notify_stream_qt(kernel, stream):
from IPython.external.qt_for_kernel import QtCore
if _on_os_x_10_9() and kernel._darwin_app_nap:
from IPython.external.appnope import nope_scope as context
else:
from IPython.core.interactiveshell import NoOpContext as context
def process_stream_events():
while stream.getsockopt(zmq.EVENTS) & zmq.POLLIN:
with context():
kernel.do_one_iteration()
fd = stream.getsockopt(zmq.FD)
notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read, kernel.app)
notifier.activated.connect(process_stream_events)
def _notify_stream_qt(kernel, stream):
from IPython.external.qt_for_kernel import QtCore
if _use_appnope() and kernel._darwin_app_nap:
from appnope import nope_scope as context
else:
from contextlib import contextmanager
@contextmanager
def context():
yield
def process_stream_events():
while stream.getsockopt(zmq.EVENTS) & zmq.POLLIN:
with context():
kernel.do_one_iteration()
fd = stream.getsockopt(zmq.FD)
notifier = QtCore.QSocketNotifier(fd, QtCore.QSocketNotifier.Read, kernel.app)
notifier.activated.connect(process_stream_events)
def inputhook_qt4():
"""PyOS_InputHook python hook for Qt4.
Process pending Qt events and if there's no pending keyboard
input, spend a short slice of time (50ms) running the Qt event
loop.
As a Python ctypes callback can't raise an exception, we catch
the KeyboardInterrupt and temporarily deactivate the hook,
which will let a *second* CTRL+C be processed normally and go
back to a clean prompt line.
"""
try:
allow_CTRL_C()
app = QtCore.QCoreApplication.instance()
if not app: # shouldn't happen, but safer if it happens anyway...
return 0
app.processEvents(QtCore.QEventLoop.AllEvents, 300)
if not stdin_ready():
timer = QtCore.QTimer()
timer.timeout.connect(app.quit)
while not stdin_ready():
timer.start(50)
app.exec_()
timer.stop()
ignore_CTRL_C()
except KeyboardInterrupt:
ignore_CTRL_C()
got_kbdint[0] = True
print("\nKeyboardInterrupt - qt4 event loop interrupted!"
"\n * hit CTRL+C again to clear the prompt"
"\n * use '%gui none' to disable the event loop"
" permanently"
"\n and '%gui qt4' to re-enable it later")
mgr.clear_inputhook()
except: # NO exceptions are allowed to escape from a ctypes callback
mgr.clear_inputhook()
from traceback import print_exc
print_exc()
print("Got exception from inputhook_qt4, unregistering.")
return 0
def inputhook_qt4():
"""PyOS_InputHook python hook for Qt4.
Process pending Qt events and if there's no pending keyboard
input, spend a short slice of time (50ms) running the Qt event
loop.
As a Python ctypes callback can't raise an exception, we catch
the KeyboardInterrupt and temporarily deactivate the hook,
which will let a *second* CTRL+C be processed normally and go
back to a clean prompt line.
"""
try:
allow_CTRL_C()
app = QtCore.QCoreApplication.instance()
if not app: # shouldn't happen, but safer if it happens anyway...
return 0
app.processEvents(QtCore.QEventLoop.AllEvents, 300)
if not stdin_ready():
# Generally a program would run QCoreApplication::exec()
# from main() to enter and process the Qt event loop until
# quit() or exit() is called and the program terminates.
#
# For our input hook integration, we need to repeatedly
# enter and process the Qt event loop for only a short
# amount of time (say 50ms) to ensure that Python stays
# responsive to other user inputs.
#
# A naive approach would be to repeatedly call
# QCoreApplication::exec(), using a timer to quit after a
# short amount of time. Unfortunately, QCoreApplication
# emits an aboutToQuit signal before stopping, which has
# the undesirable effect of closing all modal windows.
#
# To work around this problem, we instead create a
# QEventLoop and call QEventLoop::exec(). Other than
# setting some state variables which do not seem to be
# used anywhere, the only thing QCoreApplication adds is
# the aboutToQuit signal which is precisely what we are
# trying to avoid.
timer = QtCore.QTimer()
event_loop = QtCore.QEventLoop()
timer.timeout.connect(event_loop.quit)
while not stdin_ready():
timer.start(50)
event_loop.exec_()
timer.stop()
except KeyboardInterrupt:
global got_kbdint, sigint_timer
ignore_CTRL_C()
got_kbdint = True
mgr.clear_inputhook()
# This generates a second SIGINT so the user doesn't have to
# press CTRL+C twice to get a clean prompt.
#
# Since we can't catch the resulting KeyboardInterrupt here
# (because this is a ctypes callback), we use a timer to
# generate the SIGINT after we leave this callback.
#
# Unfortunately this doesn't work on Windows (SIGINT kills
# Python and CTRL_C_EVENT doesn't work).
if os.name == "posix":
pid = os.getpid()
if not sigint_timer:
sigint_timer = threading.Timer(
0.01, os.kill, args=[pid, signal.SIGINT]
)
sigint_timer.start()
else:
print("\nKeyboardInterrupt - Ctrl-C again for new prompt")
except: # NO exceptions are allowed to escape from a ctypes callback
ignore_CTRL_C()
from traceback import print_exc
print_exc()
print("Got exception from inputhook_qt4, unregistering.")
mgr.clear_inputhook()
finally:
allow_CTRL_C()
return 0
def paintEvent(self, e):
painter = QPainter(self)
# painter.setPen(QPen(Qt.black, 5, Qt.SolidLine))
boardSize = int(self.h * 0.6)
sizeSquare = boardSize // 4
centerW = self.w // 2
centerH = self.h // 2
# draw tabuleiro
for i in range(4):
for u in range(4):
tab = State.tabuleiro
positionW = (i - 2) * sizeSquare + centerW
positionH = (u - 2) * sizeSquare + centerH
painter.setBrush(
QBrush(QColor(115, 65, 29) if (u + i) % 2 == 0 else QColor(232, 193, 119), Qt.SolidPattern))
painter.drawRect(positionW, positionH, sizeSquare, sizeSquare)
# draw piece
posicaoTabuleiro = tab[i][3 - u]
peca = posicaoTabuleiro.peca
if peca:
label = QLabel(self)
label.setAlignment(Qt.AlignCenter)
label.setGeometry(QtCore.QRect(positionW, positionH, sizeSquare, sizeSquare))
label.setText('')
cor = peca.cor
piece = peca.tipo
label.setPixmap(QtGui.QPixmap("images_tic-tac-chec/{}-{}.png".format(cor, piece)))
label.setObjectName(cor + piece)
self.widgets.append(label)
label.show()
letterW = 2 * sizeSquare + centerW
letterH = 2 * sizeSquare + centerH
painter.setPen(Qt.white)
# draw coordenas
letters = ['A', 'B', 'C', 'D']
numbers = range(4)
for index in range(4):
positionW = (index - 2) * sizeSquare + centerW
positionH = (index - 2) * sizeSquare + centerH
# do lado
painter.drawText(letterW + 5, positionH + sizeSquare // 2, str(numbers[-index - 1] + 1))
# em baixo
painter.drawText(positionW + sizeSquare // 2, letterH + 17, letters[index])
for index, player in enumerate(State.jogadores):
# draw player names
maxSize = (self.w - boardSize) // 2
title = QLabel(player.name.title(), self)
title.setStyleSheet("color: white;")
font = QtGui.QFont("Helvetica", 18)
title.setFont(font)
w = title.size().width()
# h = title.size().height()
if index == 0:
x = maxSize // 2 - w // 2
else:
x = self.w - (maxSize // 2) - w // 4
title.move(x, self.h // 20)
title.show()
# draw pecas
for indexPiece, peca in enumerate(player.inventarioPecas):
size = int(maxSize * 0.6)
pieceSize = int(maxSize * 0.4)
border = (size - pieceSize) // 2
label = QLabel(self)
label.setAlignment(Qt.AlignCenter)
if index == 0:
label.setGeometry(QtCore.QRect(border, (indexPiece) * size + border + 50, pieceSize, pieceSize))
else:
label.setGeometry(
QtCore.QRect(self.w - border - pieceSize, (indexPiece) * size + border + 50, pieceSize,
pieceSize))
label.setText('')
cor = peca.cor
piece = peca.tipo
label.setPixmap(QtGui.QPixmap("../src/images_tic-tac-chec/{}-{}.png".format(cor, piece)))
label.setObjectName(cor + piece)
self.widgets.append(label)
label.show()
# label jogador que tem que jogar
currentPlayer = State.jogadores[State.jogadorAtual]
title = QLabel('Jogador atual: ' + currentPlayer.name.title(), self)
title.setStyleSheet("color: white;")
font = QtGui.QFont("Helvetica", 18, QtGui.QFont.Bold)
title.setFont(font)
w = title.size().width()
title.move(self.w // 2 - w, self.h // 20)
self.widgets.append(title)
title.show()
# button jogar
inicioBtn = QPushButton(self)
inicioBtn.setGeometry(QtCore.QRect(self.w // 2 - 55, int(self.h * 0.9), 110, 30))
inicioBtn.setStyleSheet("background-color: rgb(204, 204, 204);")
inicioBtn.setObjectName("jogar")
_translate = QtCore.QCoreApplication.translate
inicioBtn.setText('Jogar')
inicioBtn.clicked.connect(self.choosePiece)
inicioBtn.show()
