def moveByName(self, name):
dic = {
'left': 0,
'right': QApplication.screens()[0].size().width(),
'center': QApplication.screens()[0].size().width()/2-self.width()/2,
}
self.move(dic[name], self.y())
def __performGrab(self, mode):
"""
Private method to perform a screen grab other than a selected region.
@param mode screenshot mode
@type SnapshotModes
"""
self.__grabberWidget.releaseMouse()
self.__grabberWidget.hide()
self.__grabTimer.stop()
if mode == SnapshotModes.Fullscreen:
desktop = QApplication.desktop()
snapshot = QApplication.screens()[0].grabWindow(
desktop.winId(), desktop.x(), desktop.y(), desktop.width(),
desktop.height())
elif mode == SnapshotModes.SelectedScreen:
desktop = QApplication.desktop()
if Globals.qVersionTuple() >= (5, 10, 0):
screen = QApplication.screenAt(QCursor.pos())
geom = screen.geometry()
else:
screenId = desktop.screenNumber(QCursor.pos())
geom = desktop.screenGeometry(screenId)
x = geom.x()
y = geom.y()
snapshot = QApplication.screens()[0].grabWindow(
desktop.winId(), x, y, geom.width(), geom.height())
else:
snapshot = QPixmap()
self.grabbed.emit(snapshot)
def main():
app = QApplication(sys.argv)
mainWindow = MainWindow()
mainWindow.move(app.screens()[0].geometry().topLeft())
mainWindow.showMaximized()
mainWindow.dataWindow.move(app.screens()[-1].geometry().topLeft())
mainWindow.dataWindow.showMaximized()
sys.exit(app.exec())
def _getPixelRatio():
if PyQtImpl == "PyQt5":
# Source: https://stackoverflow.com/a/40053864/3388962
pos = QCursor.pos()
for screen in QApplication.screens():
rect = screen.geometry()
if rect.contains(pos):
return screen.devicePixelRatio()
# Should never happen, but try to find a good fallback.
return QApplication.screens()[0].devicePixelRatio()
else:
# Qt4 seems not to provide any cross-platform means to get the
# pixel ratio.
return 1.
def captureScreen():
''' Captures the screen the mouse is currently on '''
num = QApplication.desktop().screenNumber(QCursor.pos())
geo = QApplication.screens()[num].geometry()
return _captureRegion(geo.x(), geo.y(), geo.width(), geo.height(),
0).toImage()
def captureRegion():
screens = [(g.x(), g.y(), g.width(), g.height())
for g in (s.geometry() for s in QApplication.screens())]
log.debug('Screens: {}', screens)
x, y, w, h = _getDesktopBounds()
pixmap = _captureRegion(x, y, w, h, 0)
log.debug('Opening region select window at {x}, {y} with dims {w}, {h}',
x=x,
y=y,
w=w,
h=h)
sel = RegionSelector(x, y, w, h, pixmap)
sel.exec_()
toCopy = sel.selection
if toCopy is None: return None
return pixmap.copy(toCopy.toRect()).toImage()
#enddef
def __init__(self, parent=None):
super(MainWindow, self).__init__()
self.preview_screen = QApplication.primaryScreen().grabWindow(0)
print(QApplication.screens())
self.settings()
self.create_widgets()
self.set_layout()
def main():
import argparse
parser = argparse.ArgumentParser(description='Process some integers.')
parser.add_argument('-1', nargs='?', type=int, dest='screen', const='0')
parser.add_argument('-2', nargs='?', type=int, dest='screen', const='1')
parser.add_argument('-3', nargs='?', type=int, dest='screen', const='2')
args = parser.parse_args()
app = QApplication(sys.argv)
_setPalette(app)
number_of_screens = len(app.screens())
screens = _get_screens(app)
if number_of_screens > 1 and args.screen is None:
args.screen = show_screen_selection(screens)
if args.screen == 0 or args.screen is None:
print('No screen chosen, exiting.')
sys.exit(0)
else:
args.screen -= 1
elif args.screen is None:
args.screen = 0
screen, screen_geom, pixmap = screens[args.screen]
window = ScreenPenWindow(screen, screen_geom, pixmap)
sys.exit(app.exec_())
def captureRegion(x, y, width, height, winId = 0): ''' Captures a region ''' region = QRect(x, y, width, height) screens = [s for s in QApplication.screens() if s.geometry().intersects(region)] # How much to reposition each image so the whole thing is based at 0, 0 offsetX, offsetY = -x, -y final = QImage(width, height, QImage.Format_ARGB32) final.fill(QColor(0, 0, 0, 255)) painter = QPainter() painter.begin(final) painter.setCompositionMode(QPainter.CompositionMode_Source) for screen in screens: geo = screen.geometry() shot = screen.grabWindow(winId, geo.x(), geo.y(), geo.width(), geo.height()) # determine the area to copy toCopy = geo.intersected(region) # Composite it onto the final painter.drawPixmap(toCopy.x() + offsetX, toCopy.y() + offsetY, shot.copy(toCopy)) #end for painter.end() return final
def position_menu(self):
"""Set menu position from tray icon."""
menu = self.trayicon.contextMenu()
desktop = QApplication.desktop()
screen = QApplication.screens()[desktop.screenNumber(menu)]
screen_geom = screen.availableGeometry()
menu_size = menu.sizeHint()
icon_geom = self.trayicon.geometry()
if icon_geom.left() + menu_size.width() <= screen_geom.right():
left = icon_geom.left()
elif icon_geom.right() - menu_size.width() >= screen_geom.left():
left = icon_geom.right() - menu_size.width()
else:
return
if icon_geom.bottom() + menu_size.height() <= screen_geom.bottom():
top = icon_geom.bottom()
elif icon_geom.top() - menu_size.height() >= screen_geom.top():
top = icon_geom.top() - menu_size.height()
else:
return
menu.move(left, top)
def _getPixelRatio():
pos = QCursor.pos()
for screen in QApplication.screens():
rect = screen.geometry()
if rect.contains(pos):
return screen.devicePixelRatio()
return 1
def visualize(self):
app = QApplication(sys.argv)
screen = app.screens()[0]
dpi = screen.physicalDotsPerInch()
app.quit()
xx = np.linspace(self.xlim[0], self.xlim[1], visualizer.dense)
yy = np.linspace(self.ylim[0], self.ylim[1], visualizer.dense)
xx, yy = np.meshgrid(xx, yy)
X = np.array([[p[0], p[1]] for p in zip(xx.flatten(), yy.flatten())])
zz = self.model.inference(X).reshape(xx.shape)
fig = plt.figure(figsize=(self.figure_size[0] / dpi,
self.figure_size[1] / dpi))
# ax = plt.gca()
# fig = Figure(figsize = self.figure_size)
# canvas = FigureCanvas(fig)
ax = fig.gca()
ax.pcolor(xx, yy, zz, cmap='RdBu_r')
sns.scatterplot(self.model._X[:, 0],
self.model._X[:, 1],
hue=self.model._y,
ax=ax)
ax.set_xlim(self.xlim)
ax.set_ylim(self.ylim)
ax.axis('off')
ax.legend().remove()
plt.savefig("tmp.png", dpi=dpi)
image = Image.open("tmp.png")
return image
def __init__(self, parent=None):
super(MainWindow, self).__init__()
self.preview_screen = QApplication.primaryScreen().grabWindow(0)
print(QApplication.screens())
self.ayarlar()
self.mainEmsal()
self.set_layout()
def __findScreen(self,name):
# app = QApplication(sys.argv)
if name == "all":
print("Not implemented yet")
sys.exit(1)
screens = QApplication.screens()
for scr in screens:
if scr.name() == name:
return scr
def fill_screen_list(self):
# TODO: SCREEN settings value gets overwritten
self.ui.cb_screen.clear()
for i in range(len(QApplication.screens())):
self.ui.cb_screen.addItem("Screen %d" % (i+1))
screen = Settings().get_value(Settings.SCREEN)
if screen is not None:
self.ui.cb_screen.setCurrentIndex(int(screen))
def get_screen_dpi():
import sys
from PyQt5.QtWidgets import QApplication
app = QApplication(sys.argv)
screen = app.screens()[0]
dpi = screen.physicalDotsPerInch()
app.quit()
return dpi
def newBalloonPoint(self):
screen = QApplication.screens()[0].size()
headradius = min(self.width(), self.height()) / 2
pos = self.pos() + QPoint(headradius, headradius)
tocenter = QVector2D(screen.width()/2-pos.x(), screen.height()/2-pos.y())
radorig = math.atan2(tocenter.y(), tocenter.x())
raddiff = random.gauss(0, 0.5**2)*math.pi
radius = headradius * random.uniform(1.6,2.2)
diff = QPoint(radius*math.cos(radorig+raddiff), radius*math.sin(radorig+raddiff))
return pos + diff
def screenshot(self):
self._screenImg = QPixmap(self._screenSize)
self._screenImg.fill(Qt.black)
painter = QPainter(self._screenImg)
for index, screen in enumerate(QApplication.screens()):
p = screen.grabWindow(0)
offx = QApplication.desktop().pos().x()
offy = QApplication.desktop().pos().y()
x, y, w, h = screen.geometry().getRect()
painter.drawPixmap(QPoint(x - offx, y - offy), p)
def _getDesktopBounds():
screens = QApplication.screens()
# Calculate the bounds of the final image
geos = [s.geometry() for s in screens]
minX, minY = min(g.x() for g in geos), min(g.y() for g in geos)
maxX, maxY = max(g.x() + g.width() for g in geos), max(g.y() + g.height()
for g in geos)
return minX, minY, maxX - minX, maxY - minY
def captureDesktop(): ''' Captures the whole desktop ''' screens = QApplication.screens() # Calculate the bounds of the final image geos = [s.geometry() for s in screens] minX, minY = min(g.x() for g in geos), min(g.y() for g in geos) maxX, maxY = max(g.x() + g.width() for g in geos), max(g.y() + g.height() for g in geos) return captureRegion(minX, minY, maxX - minX, maxY - minY)
class Application:
app: QApplication = None
window: MainWindow = None
joystick: xbox.Joystick = None
timer: QTimer = None
def __init__(self):
self.refresh_rate = 30
self.view_model = ViewModel()
self.debouncer: JoystickDebouncer = None
def start(self):
if self.app is not None:
return
self.app = QApplication(sys.argv)
dpi.DPI = self.app.screens()[0].physicalDotsPerInch()
self.init_window()
self.joystick = xbox.Joystick(self.refresh_rate)
# Init timer
# TODO init debouncer
self.debouncer = JoystickDebouncer(self.app, 60, 250)
self.debouncer.trigger = self.get_joystick_state
self.debouncer.notify = self.draw
self.debouncer.start()
sys.exit(self.app.exec_())
def get_joystick_state(self) -> JoystickState:
joystick_state = JoystickState()
joystick_state.green_pressed = self.joystick.A() == 1
joystick_state.red_pressed = self.joystick.B() == 1
joystick_state.yellow_pressed = self.joystick.Y() == 1
joystick_state.blue_pressed = self.joystick.X() == 1
joystick_state.orange_pressed = self.joystick.leftBumper() == 1
return joystick_state
def draw(self, view_model: ViewModel):
if view_model is None:
return
self.view_model = view_model
self.window.update()
def init_window(self):
self.window = MainWindow(self)
self.window.load_dictionary()
self.window.show()
def __performGrab(self):
"""
Private method to perform a screen grab other than a selected region.
"""
self.__grabberWidget.releaseMouse()
self.__grabberWidget.hide()
self.__grabTimer.stop()
if self.__mode == SnapWidget.ModeFullscreen:
desktop = QApplication.desktop()
if qVersion() >= "5.0.0":
self.__snapshot = QApplication.screens()[0].grabWindow(
desktop.winId(), desktop.x(), desktop.y(), desktop.width(),
desktop.height())
else:
self.__snapshot = QPixmap.grabWindow(desktop.winId(),
desktop.x(), desktop.y(),
desktop.width(),
desktop.height())
elif self.__mode == SnapWidget.ModeScreen:
desktop = QApplication.desktop()
screenId = desktop.screenNumber(QCursor.pos())
geom = desktop.screenGeometry(screenId)
x = geom.x()
y = geom.y()
if qVersion() >= "5.0.0":
self.__snapshot = QApplication.screens()[0].grabWindow(
desktop.winId(), x, y, geom.width(), geom.height())
else:
self.__snapshot = QPixmap.grabWindow(desktop.winId(), x, y,
geom.width(),
geom.height())
else:
self.__snapshot = QPixmap()
self.__redisplay()
self.__modified = True
self.__updateCaption()
def _getPixelRatio():
if PyQtImpl in ["PyQt5", "PySide2"]:
# Source: https://stackoverflow.com/a/40053864/3388962
pos = QCursor.pos()
for screen in QApplication.screens():
rect = screen.geometry()
if rect.contains(pos):
return screen.devicePixelRatio()
# Should never happen, but try to find a good fallback.
return QApplication.devicePixelRatio()
else:
# Qt4 seems not to provide any cross-platform means to get the
# pixel ratio.
return 1.
def initConfigParams():
global configParams
configParams = {}
screen = QApplication.screens()[0]
display_width_px = screen.size().width()
display_height_px = screen.size().height()
update(
square_field=False,
monitorIndex=len(QApplication.screens()) - 1,
deviceFrameRate=screen.refreshRate(),
frameRateDivisor=1,
field_width_um=display_width_px * 2,
field_height_um=display_height_px * 2,
field_width_px=display_width_px,
field_height_px=display_height_px,
field_left_px=0,
field_top_px=0,
electrodeDistance_um_X=100,
electrodeDistance_um_Y=100,
electrodeOffset_um_X=-750,
electrodeOffset_um_Y=-750,
electrodeZone1_left=1,
electrodeZone1_top=0,
electrodeZone1_right=14,
electrodeZone1_bottom=15,
electrodeZone2_left=0,
electrodeZone2_top=1,
electrodeZone2_right=15,
electrodeZone2_bottom=14,
fft_width_px=1024,
fft_height_px=1024,
msr_stop_port=('COM5', 'RTS'),
exp_sync_port=('COM5', 'BREAK'),
stim_sync_port=('COM3', 'RTS'),
tick_port=('COM3', 'BREAK'),
)
def __performGrab(self):
"""
Private method to perform a screen grab other than a selected region.
"""
self.__grabberWidget.releaseMouse()
self.__grabberWidget.hide()
self.__grabTimer.stop()
if self.__mode == SnapWidget.ModeFullscreen:
desktop = QApplication.desktop()
if qVersion() >= "5.0.0":
self.__snapshot = QApplication.screens()[0].grabWindow(
desktop.winId(), desktop.x(), desktop.y(),
desktop.width(), desktop.height())
else:
self.__snapshot = QPixmap.grabWindow(
desktop.winId(), desktop.x(), desktop.y(),
desktop.width(), desktop.height())
elif self.__mode == SnapWidget.ModeScreen:
desktop = QApplication.desktop()
screenId = desktop.screenNumber(QCursor.pos())
geom = desktop.screenGeometry(screenId)
x = geom.x()
y = geom.y()
if qVersion() >= "5.0.0":
self.__snapshot = QApplication.screens()[0].grabWindow(
desktop.winId(), x, y, geom.width(), geom.height())
else:
self.__snapshot = QPixmap.grabWindow(
desktop.winId(), x, y, geom.width(), geom.height())
else:
self.__snapshot = QPixmap()
self.__redisplay()
self.__modified = True
self.__updateCaption()
def start(self, seconds):
"""
Public method to start the timer.
@param seconds timeout value (integer)
"""
if qVersionTuple() >= (5, 10, 0):
screenGeom = QApplication.screens()[0].geometry()
else:
screenGeom = QApplication.desktop().screenGeometry()
self.move(screenGeom.width() // 2 - self.size().width() // 2,
screenGeom.top())
self.__toggle = True
self.__time = 0
self.__length = seconds
self.__timer.start(1000)
self.show()
def enterEvent(self, evt):
"""
Protected method handling the mouse cursor entering the widget.
@param evt enter event (QEvent)
"""
if qVersionTuple() >= (5, 10, 0):
screenGeom = QApplication.screens()[0].geometry()
else:
screenGeom = QApplication.desktop().screenGeometry()
if self.x() == screenGeom.left():
self.move(
screenGeom.x() +
(screenGeom.width() // 2 - self.size().width() // 2),
screenGeom.top())
else:
self.move(screenGeom.topLeft())
def speak(self, text):
balloon = Balloon(text, point=self.newBalloonPoint(), parent=self)
def closure(ev):
try:
self.balloons.remove(balloon)
except ValueError:
pass
balloon.destroyed.connect(closure)
self.balloons.append(balloon)
balloon.show()
# before show(), the size() have not calculated yet
pos = balloon.pos() - QPoint(balloon.width()/2, balloon.height()/2)
if pos.x() < 0: pos.setX(0)
if pos.y() < 0: pos.setY(0)
screen = QApplication.screens()[0].size() - balloon.size()
if screen.width() < pos.x(): pos.setX(screen.width())
if screen.height() < pos.y(): pos.setY(screen.height())
balloon.move(pos)
def __initialize(self):
"""
Private slot to initialize the rest of the widget.
"""
self.__desktop = QApplication.desktop()
x = self.__desktop.x()
y = self.__desktop.y()
self.__pixmap = QApplication.screens()[0].grabWindow(
self.__desktop.winId(), x, y, self.__desktop.width(),
self.__desktop.height())
self.resize(self.__pixmap.size())
self.move(x, y)
self.setCursor(Qt.CrossCursor)
self.show()
self.grabMouse()
self.grabKeyboard()
self.activateWindow()
def load_settings(self) -> None:
self.settings.beginGroup('location')
self._opened_file_name = self.settings.value('open', str(Path.cwd()),
str)
self._exported_file_name = self.settings.value('export',
str(Path.cwd()), str)
self.settings.endGroup()
self.settings.beginGroup('window')
# Fallback: Center the window
desktop: QScreen = QApplication.screens()[0]
window_frame: QRect = self.frameGeometry()
desktop_center: QPoint = desktop.availableGeometry().center()
window_frame.moveCenter(desktop_center)
self.move(window_frame.topLeft())
self.restoreGeometry(self.settings.value('geometry', QByteArray()))
self.restoreState(self.settings.value('state', QByteArray()))
self.settings.endGroup()
def grab_entire_desktop_qt() -> QPixmap:
"""
Grab the entire desktop screenshot to QPixmap (Qt default implementation)
:return: QPixmap instance or None
:rtype: QPixmap
"""
geo = QRect()
for screen in QGuiApplication.screens():
src_rect = screen.geometry()
src_rect.moveTo(int(src_rect.x() / screen.devicePixelRatio()),
int(src_rect.y() / screen.devicePixelRatio()))
geo = geo.united(src_rect)
pixmap = QApplication.primaryScreen().grabWindow(
QApplication.desktop().winId(), geo.x(), geo.y(), geo.width(),
geo.height())
screen_no = QApplication.desktop().screenNumber()
screen = QApplication.screens()[screen_no]
pixmap.setDevicePixelRatio(screen.devicePixelRatio())
return pixmap
def __initialize(self):
"""
Private slot to initialize the rest of the widget.
"""
self.__desktop = QApplication.desktop()
x = self.__desktop.x()
y = self.__desktop.y()
if qVersion() >= "5.0.0":
self.__pixmap = QApplication.screens()[0].grabWindow(
self.__desktop.winId(), x, y,
self.__desktop.width(), self.__desktop.height())
else:
self.__pixmap = QPixmap.grabWindow(
self.__desktop.winId(), x, y,
self.__desktop.width(), self.__desktop.height())
self.resize(self.__pixmap.size())
self.move(x, y)
self.setCursor(Qt.CrossCursor)
self.show()
self.grabMouse()
self.grabKeyboard()
def grab_screens() -> QPixmap:
"""Return a screenshot of all screens."""
# grab all screens
screens = QApplication.screens()
pixmaps = []
w = 0
h = 0
for screen in screens:
pix = screen.grabWindow(0)
w += pix.width()
h = max(h, pix.height())
pixmaps.append(pix)
# merge all pixmaps
final = QPixmap(w, h)
painter = QPainter(final)
final.fill(Qt.white)
p = 0
for pixmap in pixmaps:
painter.drawPixmap(QPoint(p, 0), pixmap)
p += pixmap.width()
return final
def __init__(self):
"""
Constructor
"""
super(NotificationsPage, self).__init__()
self.setupUi(self)
self.setObjectName("NotificationsPage")
minX, maxX = self.xSpinBox.maximum(), self.xSpinBox.minimum()
minY, maxY = self.ySpinBox.maximum(), self.ySpinBox.minimum()
if qVersionTuple() >= (5, 10, 0):
for screen in QApplication.screens():
geom = screen.availableGeometry()
minX = min(minX, geom.x())
maxX = max(maxX, geom.x() + geom.width())
minY = min(minY, geom.y())
maxY = max(maxY, geom.y() + geom.height())
else:
desk = QApplication.desktop()
for screen in range(desk.screenCount()):
geom = desk.availableGeometry(screen)
minX = min(minX, geom.x())
maxX = max(maxX, geom.x() + geom.width())
minY = min(minY, geom.y())
maxY = max(maxY, geom.y() + geom.height())
self.xSpinBox.setMinimum(minX)
self.xSpinBox.setMaximum(maxX)
self.ySpinBox.setMinimum(minY)
self.ySpinBox.setMaximum(maxY)
self.__notification = None
# set initial values
self.enableCheckBox.setChecked(
Preferences.getUI("NotificationsEnabled"))
self.timeoutSpinBox.setValue(Preferences.getUI("NotificationTimeout"))
point = Preferences.getUI("NotificationPosition")
self.xSpinBox.setValue(point.x())
self.ySpinBox.setValue(point.y())
def save_image(self):
# Change filename to match needed format
self.filename = self.filename[:-3] + "eps"
self.canvas.postscript(file=self.filename,
height=self.height,
width=self.width)
img = Image.open(self.filename)
ps = self.canvas.postscript(colormode='color',
x=0,
y=0,
height=self.height,
width=self.width)
app = QApplication(sys.argv)
screen = app.screens()[0]
dpi = screen.physicalDotsPerInch()
app.quit()
def open_eps(ps, dpi=300.0):
img = Image.open(io.BytesIO(ps.encode('utf-8')))
original = [float(d) for d in img.size]
scale = dpi / 72.0
if dpi is not 0:
img.load(scale=math.ceil(scale))
if scale != 1:
img.thumbnail([round(scale * d) for d in original],
Image.ANTIALIAS)
return img
# im = Image.open('test.ps')
img = open_eps(ps, dpi=dpi)
img.save("victory.png", dpi=(dpi, dpi))
tkinter.messagebox.askokcancel(
'!',
'You are now exiting the GUI. Your updated image has been saved as "victory.png" on your device.'
)
def get_frame(self):
time_mill = time.time() * 1000
if time_mill - self.pre_time < 800:
return [None, 1]
else:
self.pre_time = time_mill
app = QApplication(sys.argv)
screens = app.screens()
if len(screens) == 0:
logger.info("screen :0")
return [None, -1]
window = screens[0].grabWindow(self.hwnd)
if win32gui.IsWindow(self.hwnd) == 1:
window_rect = win32gui.GetWindowRect(self.hwnd)
img = window.toImage()
img_np = self.convertQImageToMat(img)
self.update_locate(window_rect, img_np.shape)
img_np = img_np[-2 - 960:-2, 2:-2, 0:3].copy()
if img_np.shape[0] != 960:
raise Exception("错误的分辨率")
return [img_np, 1]
else:
return [None, -1]
def main():
# get screen DPI
app = QApplication(sys.argv)
screen = app.screens()[0]
dpi = screen.physicalDotsPerInch()
print('DPI : ', dpi)
app.quit()
# read data
objTX_Data = TX_Data()
objTX_Data.ReadData("./source/AI_Log_15n_50.csv")
objTX_Data.CalculateTech()
objDraw_Data = Draw_Data(dpi, 100)
# prepare wxPython framework
app = wx.App(False)
frame = MainFrame(None, objTX_Data, objDraw_Data)
frame.SetScrollBarRange(objTX_Data.m_iTotalRecords)
frame.Show(True)
# start the applications
app.MainLoop()
def landOnScreen(self):
screen = QApplication.screens()[0].size()
self.move(self.x(), screen.height() - self.height()
+ self.y() - self.geometry().y())
