Delete pygwin directory
This commit is contained in:
themixray
GitHub
parent
d498edaa32
commit
258295e671
12 changed files with 0 additions and 764 deletions
|
|
@ -1,13 +0,0 @@
|
|||
from pygwin.surface import surface
|
||||
import pygwin.keyboard as keyboard
|
||||
import pygwin.gamepad as _gp
|
||||
import pygwin.mouse as mouse
|
||||
from pygwin.rect import rect
|
||||
import pygwin.image as image
|
||||
import pygwin.mixer as mixer
|
||||
from pygwin.events import *
|
||||
from pygame.locals import *
|
||||
from pygwin.font import *
|
||||
from pygwin._win import *
|
||||
from pygwin._pg import pg
|
||||
gamepad = _gp.gamepad(pg)
|
||||
|
|
@ -1,16 +0,0 @@
|
|||
from contextlib import contextmanager as _cm
|
||||
import os as _os
|
||||
import sys as _sys
|
||||
|
||||
@_cm
|
||||
def _suppress_stdout():
|
||||
with open(_os.devnull, "w") as devnull:
|
||||
old_stdout = _sys.stdout
|
||||
_sys.stdout = devnull
|
||||
try:
|
||||
yield
|
||||
finally:
|
||||
_sys.stdout = old_stdout
|
||||
with _suppress_stdout():
|
||||
import pygame as pg
|
||||
pg.init()
|
||||
|
|
@ -1,91 +0,0 @@
|
|||
from pygwin.surface import surface as _surface
|
||||
from datetime import datetime as _dt
|
||||
from pygwin._pg import pg as _pg
|
||||
import win32job as _w32j
|
||||
import win32api as _w32a
|
||||
|
||||
class win(_surface):
|
||||
def __init__(self):
|
||||
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
|
||||
def update(self, fps=-1):
|
||||
if fps != -1:
|
||||
self._clock.tick(fps)
|
||||
self._withfps = True
|
||||
_pg.display.update()
|
||||
def title(self, title):
|
||||
_pg.display.set_caption(title)
|
||||
def icon(self, path):
|
||||
_pg.display.set_icon(_pg.image.load(path))
|
||||
def resize(self, size):
|
||||
_pg.display.set_mode(size)
|
||||
def fullscreen(self):
|
||||
_pg.display.toogle_fullscreen()
|
||||
def close(self):
|
||||
_pg.display.quit()
|
||||
@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']
|
||||
|
||||
def create(title=None, size=(0,0), icon=None):
|
||||
screen = _pg.display.set_mode(size)
|
||||
if title != None: _pg.display.set_caption(title)
|
||||
if icon != None: _pg.display.set_icon(_pg.image.load(icon))
|
||||
return win()
|
||||
|
||||
def ramLimit(bytes):
|
||||
def create_job(job_name='', breakaway='silent'):
|
||||
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)
|
||||
return hjob
|
||||
def assign_job(hjob):
|
||||
global g_hjob
|
||||
hprocess = _w32a.GetCurrentProcess()
|
||||
try:
|
||||
_w32j.AssignProcessToJobObject(hjob, hprocess)
|
||||
g_hjob = hjob
|
||||
except _w32j.error as e:
|
||||
if (e.winerror != winerror.ERROR_ACCESS_DENIED or
|
||||
sys.getwindowsversion() >= (6, 2) or
|
||||
not _w32j.IsProcessInJob(hprocess, None)):
|
||||
raise
|
||||
warnings.warn('The process is already in a job. Nested jobs are not '
|
||||
'supported prior to Windows 8.')
|
||||
def limit_memory(memory_limit):
|
||||
if g_hjob is None:
|
||||
return
|
||||
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)
|
||||
assign_job(create_job())
|
||||
limit_memory(bytes)
|
||||
|
||||
def close():
|
||||
_pg.quit()
|
||||
quit()
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
from pygwin._pg import pg as _pg
|
||||
|
||||
def getEvents():
|
||||
return _pg.event.get()
|
||||
|
|
@ -1,45 +0,0 @@
|
|||
from pygwin.surface import surface as _surface
|
||||
from pygwin._pg import pg as _pg
|
||||
|
||||
class font:
|
||||
def __init__(self, path):
|
||||
self._path = path
|
||||
def _font(self, size):
|
||||
return _pg.font.Font(self._path,size)
|
||||
def render(self, text, size, color, newLineSpace=5,
|
||||
italic=False, bold=False, underline=False):
|
||||
text = str(text)
|
||||
font = self._font(size)
|
||||
font.set_italic(italic)
|
||||
font.set_bold(bold)
|
||||
font.set_underline(underline)
|
||||
if text.replace('\n', '') != text:
|
||||
text = text.split('\n')
|
||||
surf = _pg.Surface([
|
||||
font.size(max(text, key=len))[0],
|
||||
(font.size('123')[1]+newLineSpace)*len(text)],
|
||||
pygame.SRCALPHA)
|
||||
y = 0
|
||||
for i in text:
|
||||
r = font.render(i, True, color)
|
||||
surf.blit(r, (r.get_rect(center=(int(surf.get_width()/2),y)).x, y))
|
||||
y += font.size(i)[1]
|
||||
if i != text[-1]:
|
||||
y += newLineSpace
|
||||
else:
|
||||
surf = font.render(text, True, color)
|
||||
surface = _surface(surf.get_size())
|
||||
surface._surface_orig = surf
|
||||
return surface
|
||||
def size(self, text, size, newLineSpace=5,
|
||||
italic=False, bold=False, underline=False):
|
||||
return self.render(text, size, (255,255,255),
|
||||
newLineSpace=newLineSpace,
|
||||
italic=italic, bold=bold,
|
||||
underline=underline).size
|
||||
|
||||
class sysFont(font):
|
||||
def __init__(self, name):
|
||||
self._path = _pg.font.match_font(name)
|
||||
|
||||
defaultFont = font(_pg.font.get_default_font())
|
||||
|
|
@ -1,260 +0,0 @@
|
|||
import inputs as _inputs
|
||||
import threading as _threading
|
||||
import time as _time
|
||||
|
||||
class gamepad:
|
||||
def __init__(self, pygame):
|
||||
self._lasty = ''
|
||||
self._lastx = ''
|
||||
self.founded = False
|
||||
self.buttons = []
|
||||
self.leftJoystick = [0, 0]
|
||||
self.rightJoystick = [0, 0]
|
||||
self._pygame = pygame
|
||||
self.start()
|
||||
def _tick(self):
|
||||
events = _inputs.get_gamepad()
|
||||
if not self._pygame.display.get_active():return
|
||||
self.founded = True
|
||||
temp = []
|
||||
for x in self.buttons:
|
||||
if x not in temp:
|
||||
temp.append(x)
|
||||
self.buttons = temp
|
||||
if events:
|
||||
for event in events:
|
||||
if event.code == 'ABS_X':
|
||||
self.leftJoystickCallback(x=event.state)
|
||||
self.leftJoystick[0] = event.state
|
||||
elif event.code == 'ABS_Y':
|
||||
self.leftJoystickCallback(y=event.state)
|
||||
self.leftJoystick[1] = event.state
|
||||
elif event.code == 'ABS_RY':
|
||||
self.rightJoystickCallback(y=event.state)
|
||||
self.rightJoystick[1] = event.state
|
||||
elif event.code == 'ABS_RX':
|
||||
self.rightJoystickCallback(x=event.state)
|
||||
self.rightJoystick[0] = event.state
|
||||
elif event.code == 'BTN_THUMBL':
|
||||
if event.state:
|
||||
self.leftJoystickPressCallback()
|
||||
self.buttons.append('left-joystick')
|
||||
else:
|
||||
self.leftJoystickReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('left-joystick')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_THUMBR':
|
||||
if event.state:
|
||||
self.rightJoystickPressCallback()
|
||||
self.buttons.append('right-joystick')
|
||||
else:
|
||||
self.rightJoystickReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('right-joystick')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_TL':
|
||||
if event.state:
|
||||
self.L1PressCallback()
|
||||
self.buttons.append('l1')
|
||||
else:
|
||||
self.L1ReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('l1')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_TR':
|
||||
if event.state:
|
||||
self.R1PressCallback()
|
||||
self.buttons.append('r1')
|
||||
else:
|
||||
self.R1ReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('r1')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'ABS_Z':
|
||||
if event.state == 255:
|
||||
self.L2PressCallback()
|
||||
self.buttons.append('l2')
|
||||
elif event.state == 0:
|
||||
self.L2ReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('l2')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'ABS_RZ':
|
||||
if event.state == 255:
|
||||
self.R2PressCallback()
|
||||
self.buttons.append('r2')
|
||||
elif event.state == 0:
|
||||
self.R2ReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('r2')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_WEST':
|
||||
if event.state:
|
||||
self.westPressCallback()
|
||||
self.buttons.append('west')
|
||||
else:
|
||||
self.westReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('west')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_NORTH':
|
||||
if event.state:
|
||||
self.northPressCallback()
|
||||
self.buttons.append('north')
|
||||
else:
|
||||
self.northReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('north')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_EAST':
|
||||
if event.state:
|
||||
self.eastPressCallback()
|
||||
self.buttons.append('east')
|
||||
else:
|
||||
self.eastReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('east')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_SOUTH':
|
||||
if event.state:
|
||||
self.southPressCallback()
|
||||
self.buttons.append('south')
|
||||
else:
|
||||
self.southReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('south')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'ABS_HAT0Y':
|
||||
if event.state == 1:
|
||||
self.downPressCallback()
|
||||
self.buttons.append('down')
|
||||
self._lasty = 'down'
|
||||
elif event.state == -1:
|
||||
self.upPressCallback()
|
||||
self.buttons.append('up')
|
||||
self._lasty = 'up'
|
||||
else:
|
||||
if self._lasty == 'up':
|
||||
self.upReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('up')
|
||||
except:
|
||||
pass
|
||||
elif self._lasty == 'down':
|
||||
self.downReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('down')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'ABS_HAT0X':
|
||||
if event.state == 1:
|
||||
self.rightPressCallback()
|
||||
self.buttons.append('right')
|
||||
self._lastx = 'right'
|
||||
elif event.state == -1:
|
||||
self.leftPressCallback()
|
||||
self.buttons.append('left')
|
||||
self._lastx = 'left'
|
||||
else:
|
||||
if self._lastx == 'right':
|
||||
self.rightReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('right')
|
||||
except:
|
||||
pass
|
||||
elif self._lastx == 'left':
|
||||
self.leftReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('left')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_START':
|
||||
if event.state:
|
||||
self.selectPressCallback()
|
||||
self.buttons.append('select')
|
||||
else:
|
||||
self.selectReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('select')
|
||||
except:
|
||||
pass
|
||||
elif event.code == 'BTN_SELECT':
|
||||
if event.state:
|
||||
self.startPressCallback()
|
||||
self.buttons.append('start')
|
||||
else:
|
||||
self.startReleaseCallback()
|
||||
try:
|
||||
self.buttons.remove('start')
|
||||
except:
|
||||
pass
|
||||
def start(self):
|
||||
# def exc(self):
|
||||
# if self.founded == False:
|
||||
# raise Exception('Gamepad not found!')
|
||||
# _threading._timer(10, lambda: exc(self)).start()
|
||||
self.founded = False
|
||||
self._started = True
|
||||
def ttcb(self):
|
||||
while self._started:
|
||||
self._tick()
|
||||
_threading.Thread(target=lambda:ttcb(self),
|
||||
daemon=True).start()
|
||||
def _stop(self):
|
||||
self._started = False
|
||||
def isPressed(self, btn):
|
||||
return btn in self.buttons
|
||||
def reset(self):
|
||||
self._lasty = ''
|
||||
self._lastx = ''
|
||||
self.buttons = []
|
||||
self.leftJoystick = [0, 0]
|
||||
self.rightJoystick = [0, 0]
|
||||
def getPressed(self):
|
||||
return self.buttons
|
||||
# def leftJoystickCallback(self, x=None, y=None): pass
|
||||
# def rightJoystickCallback(self, x=None, y=None): pass
|
||||
# def leftJoystickPressCallback(self): pass
|
||||
# def leftJoystickReleaseCallback(self): pass
|
||||
# def rightJoystickPressCallback(self): pass
|
||||
# def rightJoystickReleaseCallback(self): pass
|
||||
# def L1PressCallback(self): pass
|
||||
# def L1ReleaseCallback(self): pass
|
||||
# def R1PressCallback(self): pass
|
||||
# def R1ReleaseCallback(self): pass
|
||||
# def R2PressCallback(self): pass
|
||||
# def R2ReleaseCallback(self): pass
|
||||
# def L2PressCallback(self): pass
|
||||
# def L2ReleaseCallback(self): pass
|
||||
# def westPressCallback(self): pass
|
||||
# def westReleaseCallback(self): pass
|
||||
# def northPressCallback(self): pass
|
||||
# def northReleaseCallback(self): pass
|
||||
# def eastPressCallback(self): pass
|
||||
# def eastReleaseCallback(self): pass
|
||||
# def southPressCallback(self): pass
|
||||
# def southReleaseCallback(self): pass
|
||||
# def southReleaseCallback(self): pass
|
||||
# def selectPressCallback(self): pass
|
||||
# def selectReleaseCallback(self): pass
|
||||
# def startPressCallback(self): pass
|
||||
# def startReleaseCallback(self): pass
|
||||
# def upPressCallback(self): pass
|
||||
# def upReleaseCallback(self): pass
|
||||
# def downPressCallback(self): pass
|
||||
# def downReleaseCallback(self): pass
|
||||
# def leftPressCallback(self): pass
|
||||
# def leftReleaseCallback(self): pass
|
||||
# def rightPressCallback(self): pass
|
||||
# def rightReleaseCallback(self): pass
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
from pygwin._pg import pg as _pg
|
||||
from pygwin.surface import surface as _surface
|
||||
from PIL import Image as _image
|
||||
import pickle as _p
|
||||
|
||||
def load(path):
|
||||
if path.endswith('.gif'):
|
||||
im = Image.open(path)
|
||||
surfs = []
|
||||
for i in range(im.n_frames):
|
||||
im.seek(i)
|
||||
image = _pg.image.fromstring(im.tobytes(),im.size,im.mode)
|
||||
surf = _surface(image.get_size())
|
||||
surf._surface_orig = image
|
||||
surfs.append(surf)
|
||||
return surfs
|
||||
else:
|
||||
image = _pg.image.load(path)
|
||||
surf = _surface(image.get_size())
|
||||
surf._surface_orig = image
|
||||
return surf
|
||||
|
||||
def save(surface, path):
|
||||
if type(surface) == _surface:
|
||||
orig = surface._surface_orig
|
||||
else:
|
||||
orig = surface._orig
|
||||
_pg.image.save_extended(orig, path)
|
||||
|
||||
def toString(surface):
|
||||
if type(surface) == _surface:
|
||||
orig = surface._surface_orig
|
||||
else:
|
||||
orig = surface._orig
|
||||
return _p.dumps([_pg.image.tostring(orig, "RGBA"), list(surface.size)])
|
||||
|
||||
def fromString(string):
|
||||
string = _p.loads(string)
|
||||
surf = _pg.image.fromstring(string[0], tuple(string[1]), "RGBA")
|
||||
surface = _surface(tuple(string[1]))
|
||||
surface._surface_orig = surf
|
||||
return surface
|
||||
|
|
@ -1,10 +0,0 @@
|
|||
from pygwin._pg import pg as _pg
|
||||
|
||||
def getPressed():
|
||||
fkeys = {}
|
||||
keys = _pg.key.get_pressed()
|
||||
for i in range(len(keys)):
|
||||
fkeys.update({_pg.key.name(i):keys[i]})
|
||||
return fkeys
|
||||
def isPressed(key):
|
||||
return getPressed()[key]
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
from pygwin._pg import pg as _pg
|
||||
import os as _os
|
||||
import tempfile as _tf
|
||||
|
||||
ffmpeg = None
|
||||
|
||||
class sound:
|
||||
def __init__(self, path):
|
||||
if not (path.endswith('.wav') or path.endswith('.ogg')):
|
||||
try:
|
||||
from pydub import AudioSegment as _as
|
||||
if ffmpeg != None:
|
||||
_as.ffmpeg = ffmpeg
|
||||
_as.converter = ffmpeg
|
||||
sound = _as.from_file(path, _os.path.splitext(path)[1])
|
||||
path = _tf.mkstemp('.wav')
|
||||
sound.export(path, format="wav")
|
||||
except:
|
||||
print('Set ffmpeg to path so that you don'+\
|
||||
"'t have to convert the file to "+\
|
||||
'".wav". If you have installed, but the error still appears, write down the path to ffmpeg.exe in plugin.ffmpeg.')
|
||||
self._sound = _pg.mixer.Sound(path)
|
||||
def play(self):
|
||||
self._sound.play()
|
||||
def stop(self):
|
||||
self._sound.stop()
|
||||
def volume():
|
||||
def fget(self):
|
||||
return self._sound.get_volume()
|
||||
def fset(self, value):
|
||||
if type(value) == int:
|
||||
self._sound.set_volume(value)
|
||||
def fdel(self):
|
||||
pass
|
||||
return locals()
|
||||
volume = property(**volume())
|
||||
@property
|
||||
def length(self):
|
||||
return self._sound.get_length()
|
||||
|
||||
class music:
|
||||
def __init__(self, path):
|
||||
if path.endswith('.wav') or path.endswith('.ogg'):
|
||||
self._path = path
|
||||
else:
|
||||
try:
|
||||
from pydub import AudioSegment as _as
|
||||
if ffmpeg != None:
|
||||
_as.ffmpeg = ffmpeg
|
||||
_as.converter = ffmpeg
|
||||
sound = _as.from_file(path, _os.path.splitext(path)[1])
|
||||
path = _tf.mkstemp('.wav')
|
||||
sound.export(path, format="wav")
|
||||
except:
|
||||
print('Set ffmpeg to path so that you don'+\
|
||||
"'t have to convert the file to "+\
|
||||
'".wav". If you have installed, but the error still appears, write down the path to ffmpeg.exe in plugin.ffmpeg.')
|
||||
_pg.mixer.music.load(path)
|
||||
def play(self, loops=0):
|
||||
_pg.mixer.music.play(loops)
|
||||
def stop(self):
|
||||
_pg.mixer.music.stop()
|
||||
def restart(self):
|
||||
_pg.mixer.music.rewind()
|
||||
def pause(self):
|
||||
_pg.mixer.music.pause()
|
||||
def release(self):
|
||||
_pg.mixer.music.unpause()
|
||||
def queue(self):
|
||||
_pg.mixer.music.queue(self._path)
|
||||
|
||||
def volume():
|
||||
def fget(self):
|
||||
return _pg.mixer.music.get_volume()
|
||||
def fset(self, value):
|
||||
if type(value) == int:
|
||||
_pg.mixer.music.set_volume(value)
|
||||
def fdel(self):
|
||||
pass
|
||||
return locals()
|
||||
volume = property(**volume())
|
||||
|
||||
def pos():
|
||||
def fget(self):
|
||||
return _pg.mixer.music.get_pos()
|
||||
def fset(self, value):
|
||||
if type(value) == int:
|
||||
_pg.mixer.music.set_pos(value)
|
||||
def fdel(self):
|
||||
pass
|
||||
return locals()
|
||||
pos = property(**pos())
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
from pygwin._pg import pg as _pg
|
||||
|
||||
def isPressed(x):
|
||||
return _pg.mouse.get_pressed()[x]
|
||||
def getPressed():
|
||||
return _pg.mouse.get_pressed()
|
||||
def setPosition(x):
|
||||
_pg.mouse.set_pos(x)
|
||||
def getPosition():
|
||||
return _pg.mouse.get_pos()
|
||||
def setVisible(x):
|
||||
_pg.mouse.set_visible(x)
|
||||
def getVisible():
|
||||
return _pg.mouse.get_visible()
|
||||
def getCursor():
|
||||
return _pg.mouse.get_cursor()
|
||||
def setCursor(size, hotspot=None, xormasks=None, andmasks=None):
|
||||
if hotspot == None and xormasks == None and andmasks == None:
|
||||
_pg.mouse.set_system_cursor(size)
|
||||
else:
|
||||
_pg.mouse.set_cursor(size, hotspot, xormasks, andmasks)
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
from pygwin._pg import pg
|
||||
|
||||
class rect:
|
||||
def __init__(self,x,y,w,h):
|
||||
self.x = x
|
||||
self.y = y
|
||||
self.w = w
|
||||
self.h = h
|
||||
def width():
|
||||
def fget(self):
|
||||
return self.w
|
||||
def fset(self, value):
|
||||
self.w = value
|
||||
def fdel(self):
|
||||
pass
|
||||
return locals()
|
||||
width = property(**width())
|
||||
def height():
|
||||
def fget(self):
|
||||
return self.h
|
||||
def fset(self, value):
|
||||
self.h = value
|
||||
def fdel(self):
|
||||
pass
|
||||
return locals()
|
||||
height = property(**height())
|
||||
def contains(self, xorect, y=None):
|
||||
if type(xorect) == rect and y == None:
|
||||
return pg.Rect(self.x,self.y,
|
||||
self.w,self.h).contains(pg.Rect(
|
||||
xorect.x,xorect.y,xorect.w,xorect.h))
|
||||
elif type(xorect) != rect and y != None:
|
||||
return pg.Rect(self.x,self.y,self.w,
|
||||
self.h).collidepoint((xorect,y))
|
||||
|
|
@ -1,136 +0,0 @@
|
|||
from pygwin._pg import pg as _pg
|
||||
|
||||
class surface:
|
||||
def __init__(self, size):
|
||||
self._size = size
|
||||
self._orig = _pg.Surface(size, _pg.SRCALPHA)
|
||||
self._pixels = []
|
||||
# self._pixels = []
|
||||
# pxls = _pg.PixelArray(self._orig)
|
||||
# for x in range(self.size[0]):
|
||||
# self._pixels.append([])
|
||||
# for y in range(self.size[1]):
|
||||
# self._pixels[x].append(pxls[x, y])
|
||||
@property
|
||||
def pixels(self):
|
||||
pixels = []
|
||||
pxls = _pg.PixelArray(self._orig)
|
||||
for x in range(self.size[0]):
|
||||
pixels.append([])
|
||||
for y in range(self.size[1]):
|
||||
pixels[x].append(pxls[x, y])
|
||||
return pixels
|
||||
@property
|
||||
def size(self):
|
||||
return self._size
|
||||
def copy(self):
|
||||
surf = surface(self.size)
|
||||
surf._surface_orig = self._orig
|
||||
return surf
|
||||
def getPixel(self, x, y):
|
||||
# return self._pixels[x][y]
|
||||
return self._orig.get_at((x,y))
|
||||
def setPixel(self, x, y, color):
|
||||
self._orig.set_at((x,y),color)
|
||||
return self.copy()
|
||||
def blit(self, surf, xy):
|
||||
if type(surf) != surface:
|
||||
from pygwin.font import defaultFont as _df
|
||||
surf = _df.render(surf, 25, (0,0,0))
|
||||
self._orig.blit(surf._surface_orig, xy)
|
||||
return self.copy()
|
||||
def fill(self, color):
|
||||
self._orig.fill(color)
|
||||
# self._pixels = []
|
||||
# for x in range(self.size[0]):
|
||||
# self._pixels.append([])
|
||||
# for y in range(self.size[1]):
|
||||
# self._pixels[x].append(color)
|
||||
return self.copy()
|
||||
def crop(self, rect):
|
||||
self._orig = self._orig.subsurface((rect.x,rect.y,rect.w,rect.h))
|
||||
self._size = self._orig.get_size()
|
||||
return self.copy()
|
||||
def scale(self, rect):
|
||||
self._orig = _pg.transform.scale(self._orig, (rect.w, rect.h))
|
||||
self._size = self._orig.get_size()
|
||||
return self.copy()
|
||||
def rotate(self, angle):
|
||||
self._orig = _pg.transform.rotate(self._orig, angle)
|
||||
self._size = self._orig.get_size()
|
||||
return self.copy()
|
||||
def flip(self, x, y):
|
||||
self._orig = _pg.transform.flip(self._orig, x, y)
|
||||
return self.copy()
|
||||
def blur(self, amt):
|
||||
if amt < 0:
|
||||
return self.copy()
|
||||
scale = (int(self._orig.get_width()*(amt+1)),int(self._orig.get_height()[1]*(amt+1)))
|
||||
self._orig = _pg.transform.smoothscale(self._orig,scale)
|
||||
self._orig = _pg.transform.smoothscale(self._orig,self._orig.get_size())
|
||||
return self.copy()
|
||||
class _draw:
|
||||
def __init__(self,surface):
|
||||
self._surf = surface
|
||||
def rect(self,color,rect,
|
||||
width=0,borderRadius=0,
|
||||
borderTopLeftRadius=-1,
|
||||
borderTopRightRadius=-1,
|
||||
borderBottomLeftRadius=-1,
|
||||
borderBottomRightRadius=-1):
|
||||
if type(self._surf) == surface:
|
||||
orig = self._surf._surface_orig
|
||||
else:
|
||||
orig = self._surf._orig
|
||||
_pg.draw.rect(orig,color,_pg.Rect(rect.x,rect.y,rect.w,rect.h),
|
||||
width,borderRadius,borderTopLeftRadius,
|
||||
borderTopRightRadius,borderBottomLeftRadius,
|
||||
borderBottomRightRadius)
|
||||
return self._surf.copy()
|
||||
def polygon(self, color, points, width=0):
|
||||
if type(self._surf) == surface:
|
||||
orig = self._surf._surface_orig
|
||||
else:
|
||||
orig = self._surf._orig
|
||||
_pg.draw.polygon(orig,color,points,width)
|
||||
return self._surf.copy()
|
||||
def circle(self,color,center,
|
||||
radius,width=0,
|
||||
drawTopLeft=None,
|
||||
drawTopRight=None,
|
||||
drawBottomLeft=None,
|
||||
drawBottomRight=None):
|
||||
if type(self._surf) == surface:
|
||||
orig = self._surf._surface_orig
|
||||
else:
|
||||
orig = self._surf._orig
|
||||
_pg.draw.circle(orig,color,center,radius,
|
||||
width,drawTopRight,drawTopLeft,
|
||||
drawBottomLeft,drawBottomRight)
|
||||
return self._surf.copy()
|
||||
def ellipse(self,color,rect,width=0):
|
||||
if type(self._surf) == surface:
|
||||
orig = self._surf._surface_orig
|
||||
else:
|
||||
orig = self._surf._orig
|
||||
_pg.draw.ellipse(orig,color,_pg.Rect(rect.x,rect.y,rect.w,rect.h),width)
|
||||
return self._surf.copy()
|
||||
def line(self,color,start,end,width=1):
|
||||
if type(self._surf) == surface:
|
||||
orig = self._surf._surface_orig
|
||||
else:
|
||||
orig = self._surf._orig
|
||||
_pg.draw.line(orig,color,start,end,width)
|
||||
return self._surf.copy()
|
||||
def arc(self,color,rect,startAngle,stopAngle,width=1):
|
||||
if type(self._surf) == surface:
|
||||
orig = self._surf._surface_orig
|
||||
else:
|
||||
orig = self._surf._orig
|
||||
_pg.draw.arc(orig,color,
|
||||
_pg.Rect(rect.x,rect.y,rect.w,rect.h),
|
||||
startAngle,stopAngle,width)
|
||||
return self._surf.copy()
|
||||
@property
|
||||
def draw(self):
|
||||
return self._draw(self)
|
||||
Loading…
Add table
Add a link
Reference in a new issue