Python _error.SDLError类代码示例

def new_surface_from_surface(c_surface, w, h):
    if 4 < c_surface.format.BytesPerPixel <= 0:
        raise ValueError("unsupported Surface bit depth for transform")

    format = c_surface.format
    newsurf = sdl.SDL_CreateRGBSurface(c_surface.flags, w, h,
                                       format.BitsPerPixel,
                                       format.Rmask, format.Gmask,
                                       format.Bmask, format.Amask)
    if not newsurf:
        SDLError.from_sdl_error()

    if format.BytesPerPixel == 1 and format.palette:
        sdl.SDL_SetColors(newsurf, format.palette.colors, 0,
                          format.palette.ncolors)

    if c_surface.flags & sdl.SDL_SRCCOLORKEY:
        sdl.SDL_SetColorKey(newsurf, (c_surface.flags & sdl.SDL_RLEACCEL) |
                            sdl.SDL_SRCCOLORKEY, format.colorkey)

    if c_surface.flags & sdl.SDL_SRCALPHA:
        result = sdl.SDL_SetAlpha(newsurf, c_surface.flags, format.alpha)
        if result == -1:
            raise SDLError.from_sdl_error()

    return newsurf

def save(surface, filename):
    """ save(Surface, filename) -> None
    save an image to disk
    """
    surf = surface._c_surface
    if surf.flags & sdl.SDL_OPENGL:
        raise NotImplementedError()
    if not isinstance(filename, string_types):
        raise TypeError("Expected a string for the file arugment: got %s"
                        % type(filename).__name__)

    filename = rwops_encode_file_path(filename)
    fn_normalized = filename.lower()
    result = 0
    # TODO: prep/unprep surface
    if fn_normalized.endswith(b'bmp'):
        # save as BMP
        result = sdl.SDL_SaveBMP(surf, filename)
    elif (fn_normalized.endswith(b'jpg')
          or fn_normalized.endswith(b'jpeg')):
        # save as JPEG
        result = save_jpg(surf, filename)
    elif fn_normalized.endswith(b'png'):
        # save as PNG
        result = save_png(surf, filename)
    else:
        # save as TGA
        result = save_tga(surf, filename, True)
    if result == -1:
        raise SDLError.from_sdl_error()

def set_cursor(size, hotspot, xormasks, andmasks):
    """ set_cursor(size, hotspot, xormasks, andmasks) -> None
    set the image for the system mouse cursor
    """
    check_video()

    spotx, spoty = int(hotspot[0]), int(hotspot[1])
    w, h = int(size[0]), int(size[1])
    if w % 8 != 0:
        raise ValueError("Cursor width must be divisible by 8")

    if not hasattr(xormasks, '__iter__') or not hasattr(andmasks, '__iter__'):
        raise TypeError("xormask and andmask must be sequences")
    if len(xormasks) != w * h / 8.0 or len(andmasks) != w * h / 8.0:
        raise ValueError("bitmasks must be sized width*height/8")
    try:
        xordata = ffi.new('uint8_t[]', [int(m) for m in xormasks])
        anddata = ffi.new('uint8_t[]', [int(andmasks[i]) for i
                                        in range(len(xormasks))])
    except (ValueError, TypeError):
        raise TypeError("Invalid number in mask array")
    except OverflowError:
        raise TypeError("Number in mask array is larger than 8 bits")

    cursor = sdl.SDL_CreateCursor(xordata, anddata, w, h, spotx, spoty)
    if not cursor:
        raise SDLError.from_sdl_error()
    lastcursor = sdl.SDL_GetCursor()
    sdl.SDL_SetCursor(cursor)
    sdl.SDL_FreeCursor(lastcursor)

    def fill(self, color, rect=None, special_flags=0):
        """ fill(color, rect=None, special_flags=0) -> Rect
        fill Surface with a solid color
        """
        self.check_opengl()

        c_color = create_color(color, self._format)
        sdlrect = ffi.new('SDL_Rect*')
        if rect is not None:
            sdlrect.x, sdlrect.y, sdlrect.w, sdlrect.h = rect_vals_from_obj(rect)
        else:
            sdlrect.w = self._w
            sdlrect.h = self._h

        if self.crop_to_surface(sdlrect):
            if special_flags:
                res = sdl.surface_fill_blend(self._c_surface, sdlrect,
                                             c_color, special_flags)
            else:
                with locked(self._c_surface):
                    # TODO: prep/unprep
                    res = sdl.SDL_FillRect(self._c_surface, sdlrect, c_color)

            if res == -1:
                raise SDLError.from_sdl_error()

        return Rect._from4(sdlrect.x, sdlrect.y, sdlrect.w, sdlrect.h)

def wait():
    """ wait() -> EventType instance
    wait for a single event from the queue
    """
    event = ffi.new('SDL_Event*')
    if not sdl.SDL_WaitEvent(event):
        raise SDLError.from_sdl_error()
    return EventType(event[0])

def _win_rwops_from_file(fileobj):
    """Windows compatible implementation of rwops_from_file."""
    # sdl.SDL_RWFromFP doesn't setup the correct handlers on
    # windows, so we fall back to our helpers
    rwops = _lib_rwops_from_file(fileobj)
    if not rwops:
        raise SDLError.from_sdl_error()
    return rwops

def init():
    """ init() -> None
    Initialize the display module
    """
    if not video_autoinit():
        raise SDLError.from_sdl_error()
    if not autoinit():
        raise RuntimeError("autoinit failed")

def set_repeat(delay=0, interval=0):
    """ set_repeat() -> None
    control how held keys are repeated
    """
    check_video()
    if delay and not interval:
        interval = delay
    if sdl.SDL_EnableKeyRepeat(delay, interval) == -1:
        raise SDLError.from_sdl_error()

 def init(self):
     """ init() -> None
     initialize the Joystick
     """
     if self._id not in self._OPEN_JOYSTICKS:
         joydata = sdl.SDL_JoystickOpen(self._id)
         if not joydata:
             raise SDLError.from_sdl_error()
         self._OPEN_JOYSTICKS[self._id] = joydata

    def set_colorkey(self, color=None, flags=0):
        self.check_opengl()
        c_color = 0
        if color is not None:
            c_color = create_color(color, self._format)
            flags |= sdl.SDL_SRCCOLORKEY

        with locked(self._c_surface):
            if sdl.SDL_SetColorKey(self._c_surface, flags, c_color) == -1:
                raise SDLError.from_sdl_error()

def gl_set_attribute(flag, value):
    """ gl_set_attribute(flag, value) -> None
    Request an OpenGL display attribute for the display mode
    """
    check_video()
    # check_opengl()

    if flag == -1:
        return None
    if sdl.SDL_GL_SetAttribute(flag, value) == -1:
        raise SDLError.from_sdl_error()

def gl_get_attribute(flag):
    """ gl_get_attribute(flag) -> value
    Get the value for an OpenGL flag for the current display
    """
    check_video()
    # pygame seg faults instead of doing this
    # check_opengl()

    value = ffi.new('int *')
    if sdl.SDL_GL_GetAttribute(flag, value) == -1:
        raise SDLError.from_sdl_error()
    return value[0]

def _unix_rwops_from_file(fileobj):
    """Non-windows implementation of rwops_from_file."""
    try:
        # We try use the SDL helper first, since
        # it's the simplest code path
        rwops = sdl.SDL_RWFromFP(fileobj, 0)
    except (TypeError, IOError):
        # Construct a suitable rwops object
        rwops = _lib_rwops_from_file(fileobj)
    if not rwops:
        raise SDLError.from_sdl_error()
    return rwops

def set_timer(eventid, milliseconds):
    """set_timer(eventid, milliseconds) -> None
    repeatedly create an event on the event queue"
    """
    if eventid <= sdl.SDL_NOEVENT or eventid >= sdl.SDL_NUMEVENTS:
        raise ValueError("Event id must be between NOEVENT(0) and" " NUMEVENTS(32)")

    old_event = _event_timers.pop(eventid, None)
    if old_event:
        sdl.SDL_RemoveTimer(old_event)

    if milliseconds <= 0:
        return

    _try_init()

    handle = ffi.cast("void *", eventid)
    newtimer = sdl.SDL_AddTimer(milliseconds, _timer_callback, handle)
    if not newtimer:
        SDLError.from_sdl_error()

    _event_timers[eventid] = newtimer

 def set_clip(self, rect):
     """ set_clip(rect) -> None
     set the current clipping area of the Surface
     """
     self.check_surface()
     if rect:
         sdlrect = ffi.new('SDL_Rect*')
         sdlrect.x, sdlrect.y, sdlrect.w, sdlrect.h = \
                 rect_vals_from_obj(rect)
         res = sdl.SDL_SetClipRect(self._c_surface, sdlrect)
     else:
         res = sdl.SDL_SetClipRect(self._c_surface, ffi.NULL)
     if res == -1:
         raise SDLError.from_sdl_error()