188 lines
6.9 KiB
Python
188 lines
6.9 KiB
Python
from pygwin.surface import surface as _surface
|
|
from pygwin.tray import tray as _tray
|
|
from datetime import datetime as _dt
|
|
from pygwin.image import save as _s
|
|
from pygwin._pg import pg as _pg
|
|
import pygwin.image as _img
|
|
import win32job as _w32j
|
|
import win32api as _w32a
|
|
import win32con as _w32c
|
|
import win32gui as _w32g
|
|
import requests as _req
|
|
import tempfile as _tf
|
|
import threading as _t
|
|
import pickle as _p
|
|
import mouse as _m
|
|
import time as _ti
|
|
|
|
class _win(_surface):
|
|
def __init__(self, iconpath=None):
|
|
self._orig = _pg.display.get_surface()
|
|
super().__init__(self._orig.get_size())
|
|
self._orig = _pg.display.get_surface()
|
|
self._clock = _pg.time.Clock()
|
|
self._withfps = False
|
|
self._iconpath = iconpath
|
|
self._isallowdrag = False
|
|
# self._issmartdrag = False
|
|
if iconpath != None:
|
|
self.tray = _tray(self.title,iconpath)
|
|
def update(self, fps=-1):
|
|
if fps != -1:
|
|
self._clock.tick(fps)
|
|
self._withfps = True
|
|
_pg.display.update()
|
|
def resize(self, size=None):
|
|
if size == None:
|
|
return self.size
|
|
else:
|
|
self._orig = _pg.display.set_mode(value)
|
|
def title():
|
|
def fget(self):
|
|
return _pg.display.get_caption()[0]
|
|
def fset(self, value):
|
|
if type(value) != str:
|
|
return
|
|
_pg.display.set_caption(value)
|
|
def fdel(self):
|
|
pass
|
|
return locals()
|
|
title = property(**title())
|
|
def icon(value):
|
|
_pg.display.set_icon(_pg.image.load(value))
|
|
self._iconpath = iconpath
|
|
def size():
|
|
def fget(self):
|
|
return _pg.display.get_window_size()
|
|
def fset(self, value):
|
|
if type(value) in [list,tuple]:
|
|
return
|
|
_pg.display.set_mode(value)
|
|
def fdel(self):
|
|
pass
|
|
return locals()
|
|
size = property(**size())
|
|
def fullscreen(self):
|
|
_pg.display.toogle_fullscreen()
|
|
def close(self):
|
|
# _w32g.PostMessage(self.hwnd, _w32c.WM_CLOSE, 0, 0)
|
|
_pg.display.quit()
|
|
try:self.tray.stop()
|
|
except:pass
|
|
def focus(self):
|
|
self.hide()
|
|
self.show()
|
|
_w32g.BringWindowToTop(self.hwnd)
|
|
_w32g.ShowWindow(self.hwnd, _w32c.SW_SHOWNORMAL)
|
|
_w32g.SetForegroundWindow(self.hwnd)
|
|
def hide(self):
|
|
_w32g.ShowWindow(self.hwnd, _w32c.SW_HIDE)
|
|
def show(self):
|
|
_w32g.ShowWindow(self.hwnd, _w32c.SW_SHOW)
|
|
def move(self, x, y):
|
|
rect = _w32g.GetWindowRect(self.hwnd)
|
|
_w32g.MoveWindow(self.hwnd, int(x), int(y),
|
|
rect[2]-x, rect[3]-y, 0)
|
|
def screenshot(self, path):
|
|
_s(self._orig, path)
|
|
return path
|
|
def center(self,x=_w32a.GetSystemMetrics(0)/2,
|
|
y=_w32a.GetSystemMetrics(1)/2):
|
|
self.move(x-self.size[0]/2,y-self.size[1]/2)
|
|
def denyDrag(self):
|
|
self._isallowdrag = True
|
|
def loop(self):
|
|
while self._isallowdrag:
|
|
pos = _m.get_position()
|
|
pos = [pos[i]-self.position[i] for i in range(2)]
|
|
if pos[0] < _w32g.GetWindowRect(self.hwnd)[2]-137:
|
|
if pos[1] < 30:
|
|
_m.release('left')
|
|
_t.Thread(target=lambda:loop(self),daemon=1).start()
|
|
def allowDrag(self):
|
|
self._isallowdrag = False
|
|
# def smartDrag(self, x):
|
|
# self.allowDrag()
|
|
# self._issmartdrag = x
|
|
# if x:
|
|
# self._isallowdrag = True
|
|
# def loop(self):
|
|
# wsd = None
|
|
# while self._issmartdrag:
|
|
# self.update()
|
|
# pos = _m.get_position()
|
|
# pos = [pos[i]-self.position[i] for i in range(2)]
|
|
# if pos[0] < _w32g.GetWindowRect(self.hwnd)[2]-137:
|
|
# if pos[1] < 30:
|
|
# if _m.is_pressed('left'):
|
|
# _m.release('left')
|
|
# if wsd == None:
|
|
# wsd = pos+list(self.position)
|
|
# else:
|
|
# if wsd != pos+list(self.position):
|
|
# self.move(wsd[2]+(pos[0]-wsd[0]),
|
|
# wsd[3]+(pos[1]-wsd[1]))
|
|
# else:
|
|
# wsd = None
|
|
# _ti.sleep(0.5)
|
|
# _t.Thread(target=lambda:loop(self),daemon=1).start()
|
|
@property
|
|
def position(self):
|
|
rect = _w32g.GetWindowRect(self.hwnd)
|
|
x = rect[0]
|
|
y = rect[1]
|
|
return (x, y)
|
|
@property
|
|
def rawFps(self):
|
|
if self._withfps:
|
|
return self._clock.get_fps()
|
|
else:
|
|
return float(f'2010.{_dt.now().year}')
|
|
@property
|
|
def fps(self):
|
|
return int(self.rawFps)
|
|
@property
|
|
def hwnd(self):
|
|
return _pg.display.get_wm_info()['window']
|
|
@property
|
|
def visible(self):
|
|
return _w32g.IsWindowVisible(self._win)
|
|
|
|
def create(title=None, size=(0,0), icon=None, resizable=False, noframe=False):
|
|
screen = _pg.display.set_mode(size)
|
|
if resizable:
|
|
screen = _pg.display.set_mode(size,_pg.RESIZABLE)
|
|
if noframe:
|
|
screen = _pg.display.set_mode(size,_pg.NOFRAME)
|
|
else:
|
|
if title != None:
|
|
_pg.display.set_caption(title)
|
|
if icon != None:
|
|
_pg.display.set_icon(_pg.image.load(icon))
|
|
return _win(icon)
|
|
|
|
def ramLimit(memory_limit):
|
|
hjob = _w32j.CreateJobObject(None,job_name)
|
|
if breakaway:
|
|
info = _w32j.QueryInformationJobObject(hjob,_w32j.JobObjectExtendedLimitInformation)
|
|
if breakaway=='silent':info['BasicLimitInformation']['LimitFlags']|=(_w32j.JOB_OBJECT_LIMIT_SILENT_BREAKAWAY_OK)
|
|
else:info['BasicLimitInformation']['LimitFlags']|=(_w32j.JOB_OBJECT_LIMIT_BREAKAWAY_OK)
|
|
_w32j.SetInformationJobObject(hjob,_w32j.JobObjectExtendedLimitInformation,info)
|
|
hprocess = _w32a.GetCurrentProcess()
|
|
try:_w32j.AssignProcessToJobObject(hjob, hprocess);g_hjob=hjob
|
|
except _w32j.error as e:
|
|
if e.winerror!=winerror.ERROR_ACCESS_DENIED:raise
|
|
elif sys.getwindowsversion()>=(6,2):raise
|
|
elif _w32j.IsProcessInJob(hprocess,None):raise
|
|
warnings.warn('The process is already in a job. Nested jobs are not supported prior to Windows 8.')
|
|
info=_w32j.QueryInformationJobObject(g_hjob,_w32j.JobObjectExtendedLimitInformation)
|
|
info['ProcessMemoryLimit']=memory_limit
|
|
info['BasicLimitInformation']['LimitFlags']|=(_w32j.JOB_OBJECT_LIMIT_PROCESS_MEMORY)
|
|
_w32j.SetInformationJobObject(g_hjob,_w32j.JobObjectExtendedLimitInformation,info)
|
|
|
|
def close():
|
|
_pg.quit()
|
|
quit()
|
|
|
|
def getEvents():
|
|
return _pg.event.get()
|