MeexReay/pygwin2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add files via upload

Browse source
This commit is contained in:
themixray 2021-11-02 19:52:29 +03:00 • committed by GitHub
parent cdadd9af36
commit 0b94717fb9
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
6 changed files with 88 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

1
pygwin/__init__.py
View file

@ -5,7 +5,6 @@ import pygwin.mouse as mouse
from pygwin.rect import rect from pygwin.rect import rect
import pygwin.image as image import pygwin.image as image
import pygwin.mixer as mixer import pygwin.mixer as mixer
from pygwin.events import *
from pygame.locals import * from pygame.locals import *
from pygwin.font import * from pygwin.font import *
from pygwin._win import * from pygwin._win import *

33
pygwin/_win.py
View file

@ -16,12 +16,30 @@ class win(_surface):
self._clock.tick(fps) self._clock.tick(fps)
self._withfps = True self._withfps = True
_pg.display.update() _pg.display.update()
def title(self, title): def title():
_pg.display.set_caption(title) def fget(self):
def icon(self, path): return _pg.display.get_caption()
_pg.display.set_icon(_pg.image.load(path)) def fset(self, value):
def resize(self, size): if type(value) != str:
_pg.display.set_mode(size) 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))
def size():
def fget(self):
return _pg.display.get_window_size()
def fset(self, value):
if type(value) != tuple or type(value) != list:
return
_pg.display.set_mode(value)
def fdel(self):
pass
return locals()
size = property(**size())
def fullscreen(self): def fullscreen(self):
_pg.display.toogle_fullscreen() _pg.display.toogle_fullscreen()
def close(self): def close(self):
@ -89,3 +107,6 @@ def ramLimit(bytes):
def close(): def close():
_pg.quit() _pg.quit()
quit() quit()
def getEvents():
return _pg.event.get()

236
pygwin/gamepad.py
View file

@ -7,254 +7,104 @@ class gamepad:
self._lasty = '' self._lasty = ''
self._lastx = '' self._lastx = ''
self.founded = False self.founded = False
self.buttons = [] self._buttons = {'left-joystick': False,
'right-joystick': False,
'north': False,
'south': False,
'west': False,
'east': False,
'l1': False,
'l2': False,
'r1': False,
'r2': False,
'up': False,
'down': False,
'left': False,
'right': False,
'start': False,
'select': False}
self.leftJoystick = [0, 0] self.leftJoystick = [0, 0]
self.rightJoystick = [0, 0] self.rightJoystick = [0, 0]
self._pygame = pygame self._pygame = pygame
self.start() self._start()
def _tick(self): def _tick(self):
events = _inputs.get_gamepad() events = _inputs.get_gamepad()
if not self._pygame.display.get_active():return if not self._pygame.display.get_active():return
self.founded = True self.founded = True
temp = []
for x in self.buttons:
if x not in temp:
temp.append(x)
self.buttons = temp
if events: if events:
for event in events: for event in events:
if event.code == 'ABS_X': if event.code == 'ABS_X':
self.leftJoystickCallback(x=event.state)
self.leftJoystick[0] = event.state self.leftJoystick[0] = event.state
elif event.code == 'ABS_Y': elif event.code == 'ABS_Y':
self.leftJoystickCallback(y=event.state)
self.leftJoystick[1] = event.state self.leftJoystick[1] = event.state
elif event.code == 'ABS_RY': elif event.code == 'ABS_RY':
self.rightJoystickCallback(y=event.state)
self.rightJoystick[1] = event.state self.rightJoystick[1] = event.state
elif event.code == 'ABS_RX': elif event.code == 'ABS_RX':
self.rightJoystickCallback(x=event.state)
self.rightJoystick[0] = event.state self.rightJoystick[0] = event.state
elif event.code == 'BTN_THUMBL': elif event.code == 'BTN_THUMBL':
if event.state: self._buttons['left-joystick'] = 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': elif event.code == 'BTN_THUMBR':
if event.state: self._buttons['right-joystick'] = 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': elif event.code == 'BTN_TL':
if event.state: self._buttons['l1'] = event.state
self.L1PressCallback()
self.buttons.append('l1')
else:
self.L1ReleaseCallback()
try:
self.buttons.remove('l1')
except:
pass
elif event.code == 'BTN_TR': elif event.code == 'BTN_TR':
if event.state: self._buttons['r1'] = event.state
self.R1PressCallback()
self.buttons.append('r1')
else:
self.R1ReleaseCallback()
try:
self.buttons.remove('r1')
except:
pass
elif event.code == 'ABS_Z': elif event.code == 'ABS_Z':
if event.state == 255: if event.state == 255:
self.L2PressCallback() self._buttons['l2'] = 1
self.buttons.append('l2')
elif event.state == 0: elif event.state == 0:
self.L2ReleaseCallback() self._buttons['l2'] = 0
try:
self.buttons.remove('l2')
except:
pass
elif event.code == 'ABS_RZ': elif event.code == 'ABS_RZ':
if event.state == 255: if event.state == 255:
self.R2PressCallback() self._buttons['r2'] = 1
self.buttons.append('r2')
elif event.state == 0: elif event.state == 0:
self.R2ReleaseCallback() self._buttons['r2'] = 0
try:
self.buttons.remove('r2')
except:
pass
elif event.code == 'BTN_WEST': elif event.code == 'BTN_WEST':
if event.state: self._buttons['west'] = event.state
self.westPressCallback()
self.buttons.append('west')
else:
self.westReleaseCallback()
try:
self.buttons.remove('west')
except:
pass
elif event.code == 'BTN_NORTH': elif event.code == 'BTN_NORTH':
if event.state: self._buttons['north'] = event.state
self.northPressCallback()
self.buttons.append('north')
else:
self.northReleaseCallback()
try:
self.buttons.remove('north')
except:
pass
elif event.code == 'BTN_EAST': elif event.code == 'BTN_EAST':
if event.state: self._buttons['east'] = event.state
self.eastPressCallback()
self.buttons.append('east')
else:
self.eastReleaseCallback()
try:
self.buttons.remove('east')
except:
pass
elif event.code == 'BTN_SOUTH': elif event.code == 'BTN_SOUTH':
if event.state: self._buttons['south'] = event.state
self.southPressCallback()
self.buttons.append('south')
else:
self.southReleaseCallback()
try:
self.buttons.remove('south')
except:
pass
elif event.code == 'ABS_HAT0Y': elif event.code == 'ABS_HAT0Y':
if event.state == 1: if event.state == 1:
self.downPressCallback() self._buttons['down'] = True
self.buttons.append('down')
self._lasty = 'down' self._lasty = 'down'
elif event.state == -1: elif event.state == -1:
self.upPressCallback() self._buttons['up'] = True
self.buttons.append('up')
self._lasty = 'up' self._lasty = 'up'
else: else:
if self._lasty == 'up': self._buttons[self._lasty] = False
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': elif event.code == 'ABS_HAT0X':
if event.state == 1: if event.state == 1:
self.rightPressCallback() self._buttons['right'] = True
self.buttons.append('right')
self._lastx = 'right' self._lastx = 'right'
elif event.state == -1: elif event.state == -1:
self.leftPressCallback() self._buttons['left'] = True
self.buttons.append('left')
self._lastx = 'left' self._lastx = 'left'
else: else:
if self._lastx == 'right': self._buttons[self._lastx] = False
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': elif event.code == 'BTN_START':
if event.state: self._buttons['select'] = event.state
self.selectPressCallback()
self.buttons.append('select')
else:
self.selectReleaseCallback()
try:
self.buttons.remove('select')
except:
pass
elif event.code == 'BTN_SELECT': elif event.code == 'BTN_SELECT':
if event.state: self._buttons['start'] = event.state
self.startPressCallback() def _start(self):
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.founded = False
self._started = True self._started = True
def ttcb(self): def ttcb(self):
while self._started: while self._started:
self._tick() self._tick()
_threading.Thread(target=lambda:ttcb(self), _threading.Thread(target=lambda:ttcb(self),daemon=True).start()
daemon=True).start() def close(self):
def _stop(self):
self._started = False self._started = False
def isPressed(self, btn): def isPressed(self, btn):
return btn in self.buttons return btn in self._buttons
def reset(self): def reset(self):
self._lasty = '' self._lasty = ''
self._lastx = '' self._lastx = ''
self.buttons = [] self._buttons = []
self.leftJoystick = [0, 0] self.leftJoystick = [0, 0]
self.rightJoystick = [0, 0] self.rightJoystick = [0, 0]
def getPressed(self): def getPressed(self):
return self.buttons 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

8
pygwin/image.py
View file

@ -20,22 +20,22 @@ def load(path):
surf._surface_orig = image surf._surface_orig = image
return surf return surf
def save(surface, path): def save(surface, dest):
if type(surface) == _surface: if type(surface) == _surface:
orig = surface._surface_orig orig = surface._surface_orig
else: else:
orig = surface._orig orig = surface._orig
_pg.image.save_extended(orig, path) _pg.image.save_extended(orig, dest)
def toString(surface): def toString(surface):
if type(surface) == _surface: if type(surface) == _surface:
orig = surface._surface_orig orig = surface._surface_orig
else: else:
orig = surface._orig orig = surface._orig
return _p.dumps([_pg.image.tostring(orig, "RGBA"), list(surface.size)]) return _p.dumps([_pg.image.tostring(orig,"RGBA"),list(surface.size)],0)
def fromString(string): def fromString(string):
string = _p.loads(string) string = _p.loads(string, encoding='latin1')
surf = _pg.image.fromstring(string[0],tuple(string[1]),"RGBA") surf = _pg.image.fromstring(string[0],tuple(string[1]),"RGBA")
surface = _surface(tuple(string[1])) surface = _surface(tuple(string[1]))
surface._surface_orig = surf surface._surface_orig = surf

7
pygwin/mouse.py
View file

@ -1,9 +1,10 @@
from pygwin._pg import pg as _pg from pygwin._pg import pg as _pg
def isPressed(x):
return _pg.mouse.get_pressed()[x]
def getPressed(): def getPressed():
return _pg.mouse.get_pressed() orig = _pg.mouse.get_pressed(3)
return {'left':orig[0],'middle':orig[1],'right':orig[2]}
def isPressed(x):
return getPressed()[x]
def setPosition(x): def setPosition(x):
_pg.mouse.set_pos(x) _pg.mouse.set_pos(x)
def getPosition(): def getPosition():

29
pygwin/surface.py
View file

@ -6,12 +6,6 @@ class surface:
self._size = size self._size = size
self._orig = _pg.Surface(size, _pg.SRCALPHA) self._orig = _pg.Surface(size, _pg.SRCALPHA)
self._pixels = [] 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 @property
def pixels(self): def pixels(self):
pixels = [] pixels = []
@ -24,12 +18,18 @@ class surface:
@property @property
def size(self): def size(self):
return self._size return self._size
def rect(self, x=0, y=0, center=[]):
if center == []:
return _r(x, y, self.size[0], self.size[1])
else:
return _r(center[0]-(self.size[0]/2),
center[1]-(self.size[1]/2),
self.size[0], self.size[1])
def copy(self): def copy(self):
surf = surface(self.size) surf = surface(self.size)
surf._surface_orig = self._orig surf._surface_orig = self._orig
return surf return surf
def getPixel(self, x, y): def getPixel(self, x, y):
# return self._pixels[x][y]
return self._orig.get_at((x,y)) return self._orig.get_at((x,y))
def setPixel(self, x, y, color): def setPixel(self, x, y, color):
self._orig.set_at((x,y),color) self._orig.set_at((x,y),color)
@ -42,11 +42,6 @@ class surface:
return self.copy() return self.copy()
def fill(self, color): def fill(self, color):
self._orig.fill(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() return self.copy()
def crop(self, rect): def crop(self, rect):
self._orig = self._orig.subsurface((rect.x,rect.y,rect.w,rect.h)) self._orig = self._orig.subsurface((rect.x,rect.y,rect.w,rect.h))
@ -67,16 +62,10 @@ class surface:
if amt < 0: if amt < 0:
return self.copy() return self.copy()
scale = (int(self._orig.get_width()*(amt+1)),int(self._orig.get_height()[1]*(amt+1))) scale = (int(self._orig.get_width()*(amt+1)),int(self._orig.get_height()[1]*(amt+1)))
size = self._orig.get_size()
self._orig = _pg.transform.smoothscale(self._orig,scale) self._orig = _pg.transform.smoothscale(self._orig,scale)
self._orig = _pg.transform.smoothscale(self._orig,self._orig.get_size()) self._orig = _pg.transform.smoothscale(self._orig,size)
return self.copy() return self.copy()
def rect(self, x=0, y=0, center=None):
if center == None:
return _r(x, y, self.size[0], self.size[1])
else:
return _r(center[0]-(self.size[0]/2),
center[1]-(self.size[1]/2),
self.size[0], self.size[1])
class _draw: class _draw:
def __init__(self,surface): def __init__(self,surface):
self._surf = surface self._surf = surface