Add files via upload

pygwin/__init__.py

@@ -0,0 +1,13 @@
+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)

pygwin/_pg.py

@@ -0,0 +1,16 @@
+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()

pygwin/_win.py

@@ -0,0 +1,91 @@
+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()

pygwin/events.py

@@ -0,0 +1,4 @@
+from pygwin._pg import pg as _pg
+
+def getEvents():
+    return _pg.event.get()

pygwin/font.py

@@ -0,0 +1,45 @@
+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())

pygwin/gamepad.py

@@ -0,0 +1,260 @@
+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

pygwin/image.py

@@ -0,0 +1,42 @@
+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

pygwin/keyboard.py

@@ -0,0 +1,10 @@
+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]

pygwin/mixer.py

@@ -0,0 +1,92 @@
+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())

pygwin/mouse.py

@@ -0,0 +1,21 @@
+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)

pygwin/rect.py

@@ -0,0 +1,34 @@
+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))

pygwin/surface.py

@@ -0,0 +1,136 @@
+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)