Changeset 4776 for libcaca


Ignore:
Timestamp:
Mar 5, 2011, 6:26:35 PM (8 years ago)
Author:
Alex Foulon
Message:
  • Handles error messages from libcaca and ctypes with CanvasError? exception.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • libcaca/trunk/python/caca/canvas.py

    r4772 r4776  
    1616
    1717import ctypes
    18 
    19 from caca import _lib, utf8_to_utf32
     18import errno
     19
     20from caca import _lib, utf8_to_utf32, utf32_to_utf8
    2021from caca.font import _Font
    2122
     
    6869
    6970        if pointer is None:
    70             self._cv = _lib.caca_create_canvas(width, height)
    71             if self._cv == 0:
    72                 raise CanvasError, "Failed to create canvas"
     71            try:
     72                self._cv = _lib.caca_create_canvas(width, height)
     73            except ctypes.ArgumentError, e:
     74                self._cv = 0
     75                raise CanvasError("Specified width or height is invalid")
     76            else:
     77                if self._cv == 0:
     78                    err = ctypes.c_int.in_dll(_lib, "errno")
     79                    if err.value == errno.EINVAL:
     80                        raise CanvasError("Specified width or height is"
     81                                          " invalid")
     82                    elif err.value == errno.ENOMEM:
     83                        raise CanvasError("Not enough memory for the requested"
     84                                          " canvas size")
     85                    else:
     86                        raise CanvasError("Unknown error: failed to create"
     87                                          " canvas")
    7388        else:
    7489            self._cv = pointer
     
    91106        """
    92107        _lib.caca_set_canvas_size.argtypes  = [
    93             _Canvas, ctypes.c_int, ctypes.c_int
     108                _Canvas, ctypes.c_int, ctypes.c_int
    94109            ]
    95110        _lib.caca_set_canvas_size.restype   = ctypes.c_int
    96111
    97         return _lib.caca_set_canvas_size(self, width, height)
     112        try:
     113            ret = _lib.caca_set_canvas_size(self, width, height)
     114        except ctypes.ArgumentError, e:
     115            raise CanvasError("Specified width or height is invalid")
     116        else:
     117            if ret == -1:
     118                err = ctypes.c_int.in_dll(_lib, "errno")
     119                if err.value == errno.EINVAL:
     120                    raise CanvasError("Specified width or height is invalid")
     121                elif err.value == errno.EBUSY:
     122                    raise CanvasError("The canvas is in use by a display driver"
     123                                      " and cannot be resized")
     124                elif err.value == errno.ENOMEM:
     125                    raise CanvasError("Not enough memory for the requested"
     126                                      " canvas size")
     127            else:
     128                return ret
    98129
    99130    def get_width(self):
     
    124155
    125156    def gotoxy(self, x, y):
    126         """ Set cursor position.
     157        """ Set cursor position. Setting the cursor position outside the canvas
     158            is legal but the cursor will not be shown.
    127159
    128160            x   -- X cursor coordinate
    129161            y   -- Y cursor coordinate
    130162        """
    131         _lib.caca_gotoxy.argtypes = [_Canvas, ctypes.c_int]
     163        _lib.caca_gotoxy.argtypes = [_Canvas, ctypes.c_int, ctypes.c_int]
    132164        _lib.caca_gotoxy.restyoe  = ctypes.c_int
    133165
    134         return _lib.caca_gotoxy(self, x, y)
     166        try:
     167            ret = _lib.caca_gotoxy(self, x, y)
     168        except ctypes.ArgumentError, e:
     169            raise CanvasError("specified coordinate X or Y is invalid")
     170        else:
     171            return ret
    135172
    136173    def wherex(self):
     
    151188
    152189    def put_char(self, x, y, ch):
    153         """ Print an ASCII or Unicode character.
     190        """ Print an ASCII or Unicode character. Return the width of the
     191            printed character: 2 for a fullwidth character, 1 otherwise.
    154192
    155193            x   -- X coordinate
     
    158196        """
    159197        _lib.caca_put_char.argtypes = [
    160             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_uint32
     198                _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_uint32
    161199            ]
    162200        _lib.caca_put_char.restype  = ctypes.c_int
    163201
    164         try:
    165             ch = ord(ch)
    166         except TypeError:
    167             ch = utf8_to_utf32(ch)
    168 
    169         return _lib.caca_put_char(self, x, y, ch)
     202        if not isinstance(ch, str):
     203            raise CanvasError("Specified character is invalid")
     204        else:
     205            try:
     206                ch = ord(ch)
     207            except TypeError:
     208                ch = utf8_to_utf32(ch)
     209
     210            try:
     211                ret =  _lib.caca_put_char(self, x, y, ch)
     212            except ctypes.ArgumentError, e:
     213                raise CanvasError("specified coordinate X or Y is invalid")
     214            else:
     215                return ret
    170216
    171217    def get_char(self, x, y):
     
    176222        """
    177223        _lib.caca_get_char.argtypes = [
    178             _Canvas, ctypes.c_int, ctypes.c_int
     224                _Canvas, ctypes.c_int, ctypes.c_int
    179225            ]
    180226        _lib.caca_get_char.restype  = ctypes.c_uint32
    181227
    182         return _lib.caca_get_char(self, x, y)
     228        try:
     229            ch = _lib.caca_get_char(self, x, y)
     230        except ctypes.ArgumentError:
     231            raise CanvasError("specified coordinate X or Y is invalid")
     232        else:
     233            try:
     234                ch = ord(ch)
     235            except TypeError:
     236                ch = utf32_to_utf8(ch)
     237
     238            return ch
    183239
    184240    def put_str(self, x, y, s):
     
    190246        """
    191247        _lib.caca_put_str.argtypes = [
    192             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_char_p
     248                _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_char_p
    193249            ]
    194250        _lib.caca_put_str.restype  = ctypes.c_int
    195251
    196         return _lib.caca_put_str(self, x, y, s)
     252        if not isinstance(s, str):
     253            raise CanvasError("Specified string is invalid")
     254        else:
     255            try:
     256                ret = _lib.caca_put_str(self, x, y, s)
     257            except ctypes.ArgumentError:
     258                raise CanvasError("Specified coordinate X or Y is invalid")
     259            else:
     260                return ret
    197261
    198262    def printf(self, x, y, fmt, *args):
     
    205269        """
    206270        _lib.caca_printf.argtypes = [
    207             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_char_p
     271                _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_char_p
    208272            ]
    209273        _lib.caca_printf.restype  = ctypes.c_int
    210274
    211         return _lib.caca_printf(self, x, y, fmt, *args)
     275        if not isinstance(fmt, str):
     276            raise CanvasError("Specified formated string is invalid")
     277        else:
     278            try:
     279                ret = _lib.caca_printf(self, x, y, fmt, *args)
     280            except ctypes.ArgumentError:
     281                raise CanvasError("Specified coordinate X or Y is invalid")
     282            else:
     283                return ret
    212284
    213285    def vprintf(self, *args, **kw):
     
    232304        """
    233305        _lib.caca_set_canvas_handle.argtypes = [
    234             _Canvas, ctypes.c_int, ctypes.c_int
     306                _Canvas, ctypes.c_int, ctypes.c_int
    235307            ]
    236308        _lib.caca_set_canvas_handle.restype  = ctypes.c_int
    237309
    238         return _lib.caca_set_canvas_handle(self, x, y)
     310        try:
     311            ret = _lib.caca_set_canvas_handle(self, x, y)
     312        except ctypes.ArgumentError:
     313            raise CanvasError("Specified coordinate X or Y is invalid")
     314        else:
     315            return ret
    239316
    240317    def get_handle_x(self):
     
    263340        """
    264341        _lib.caca_blit.argtypes = [
    265             _Canvas, ctypes.c_int, ctypes.c_int, _Canvas, _Canvas
     342                _Canvas, ctypes.c_int, ctypes.c_int, _Canvas, _Canvas
    266343            ]
    267344        _lib.caca_blit.restype  = ctypes.c_int
    268345
    269         if mask is None:
    270             mask = NullCanvas()
    271 
    272         return _lib.caca_blit(self, x, y, cv, mask)
     346        if not isinstance(cv, Canvas):
     347            raise CanvasError("Specified mask canvas is invalid")
     348        else:
     349            if mask is None:
     350                mask = NullCanvas()
     351            else:
     352                if not isinstance(mask, _Canvas):
     353                    raise CanvasError("Specified mask canvas is invalid")
     354
     355        try:
     356            ret = _lib.caca_blit(self, x, y, cv, mask)
     357        except ctypes.ArgumentError:
     358            raise CanvasError("Specified coordinate X or Y is invalid")
     359        else:
     360            if ret == -1:
     361                err = ctypes.c_int.in_dll(_lib, "errno")
     362                if err.value == errno.EINVAL:
     363                    raise CanvasError("A mask was specified but the mask size"
     364                                      " and source canvas size do not match")
     365            else:
     366                return ret
    273367
    274368    def set_boundaries(self, x, y, width, height):
     
    281375        """
    282376        _lib.caca_set_canvas_boundaries.argtypes = [
    283             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int
     377              _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int
    284378            ]
    285379        _lib.caca_set_canvas_boundaries.restype  = ctypes.c_int
    286380
    287         return _lib.caca_set_canvas_boundaries(self, x, y, width, height)
     381        try:
     382            ret = _lib.caca_set_canvas_boundaries(self, x, y, width, height)
     383        except ctypes.ArgumentError:
     384            raise CanvasError("Specified coordinate or size is invalid")
     385        else:
     386            if ret == -1:
     387                err = ctypes.c_int.in_dll(_lib, "errno")
     388                if err.value == errno.EINVAL:
     389                    raise CanvasError("Specified width or height is invalid")
     390                elif err.value == errno.EBUSY:
     391                    raise CanvasError("The canvas is in use by a display driver"
     392                                      " and cannot be resized")
     393                elif err.value == errno.ENOMEM:
     394                    raise CanvasError("Not enough memory for the requested"
     395                                      " canvas size")
     396            else:
     397                return ret
    288398
    289399    def disable_dirty_rect(self):
     
    301411        _lib.caca_enable_dirty_rect.restype  = ctypes.c_int
    302412
    303         return _lib.caca_enable_dirty_rect(self)
     413        ret = _lib.caca_enable_dirty_rect(self)
     414        if ret == -1:
     415            err = ctypes.c_int.in_dll(_lib, "errno")
     416            if err.value == errno.EINVAL:
     417                raise CanvasError("Dirty rectangles were not disabled")
     418        else:
     419            return ret
    304420
    305421    def get_dirty_rect_count(self):
     
    317433            idx -- the requested rectangle index
    318434        """
    319         #initialize dictionnary and pointers
    320435        dct = None
    321436        x = ctypes.c_int()
     
    325440
    326441        _lib.caca_get_dirty_rect.argtypes = [
    327             _Canvas, ctypes.c_int,
    328             ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int),
    329             ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)
     442                _Canvas, ctypes.c_int,
     443                ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int),
     444                ctypes.POINTER(ctypes.c_int), ctypes.POINTER(ctypes.c_int)
    330445            ]
    331446        _lib.caca_get_dirty_rect.restype  = ctypes.c_int
    332447
    333         if _lib.caca_get_dirty_rect(self, idx, x, y, width, height) > -1:
    334             dct = {
    335                 'x': x.value, 'y': y.value,
    336                 'width': width.value, 'height': height.value,
    337             }
    338 
    339         return dct
     448        try:
     449            ret = _lib.caca_get_dirty_rect(self, idx, x, y, width, height)
     450        except ctypes.ArgumentError:
     451            raise CanvasError("Specified rectangle index is invalid")
     452        else:
     453            if ret == -1:
     454                err = ctypes.c_int.in_dll(_lib, "errno")
     455                if err.value == errno.EINVAL:
     456                    raise CanvasError("Specified rectangle index is out of"
     457                                      " bounds")
     458            else:
     459                dct = {
     460                    'x': x.value, 'y': y.value,
     461                    'width': width.value, 'height': height.value,
     462                }
     463                return dct
    340464
    341465    def add_dirty_rect(self, x, y, width, height):
     
    348472        """
    349473        _lib.caca_add_dirty_rect.argtypes = [
    350             _Canvas, ctypes.c_int, ctypes.c_int,
    351             ctypes.c_int, ctypes.c_int
    352         ]
     474                _Canvas, ctypes.c_int, ctypes.c_int,
     475                ctypes.c_int, ctypes.c_int
     476            ]
    353477        _lib.caca_add_dirty_rect.restype  = ctypes.c_int
    354478
    355         return _lib.caca_add_dirty_rect(self, x, y, width, height)
     479        try:
     480            ret =_lib.caca_add_dirty_rect(self, x, y, width, height)
     481        except ctypes.ArgumentError:
     482            raise CanvasError("Specified coordinate or size is invalid")
     483        else:
     484            if ret == -1:
     485                err = ctypes.c_int.in_dll(_lib, "errno")
     486                if err.value == errno.EINVAL:
     487                    raise CanvasError("Specified rectangle coordinates are out"
     488                                      " of bounds")
     489            else:
     490                return ret
    356491
    357492    def remove_dirty_rect(self, x, y, width, height):
     
    364499        """
    365500        _lib.caca_remove_dirty_rect.argtypes = [
    366             _Canvas, ctypes.c_int, ctypes.c_int,
    367             ctypes.c_int, ctypes.c_int
    368         ]
     501                _Canvas, ctypes.c_int, ctypes.c_int,
     502                ctypes.c_int, ctypes.c_int
     503            ]
    369504        _lib.caca_remove_dirty_rect.restype  = ctypes.c_int
    370505
    371         return _lib.caca_remove_dirty_rect(self, x, y, height, width)
     506        try:
     507            ret = _lib.caca_remove_dirty_rect(self, x, y, width, height)
     508        except ctypes.ArgumentError:
     509            raise CanvasError("Specified coordinate or size is invalid")
     510        else:
     511            if ret == -1:
     512                err = ctypes.c_int.in_dll(_lib, "errno")
     513                if err.value == errno.EINVAL:
     514                    raise CanvasError("Specified rectangle coordinates are out"
     515                                      " of bounds")
     516            else:
     517                return ret
    372518
    373519    def clear_dirty_rect_list(self):
     
    417563        _lib.caca_rotate_left.restype  = ctypes.c_int
    418564
    419         return _lib.caca_rotate_left(self)
     565        ret = _lib.caca_rotate_left(self)
     566        if ret == -1:
     567            err = ctypes.c_int.in_dll(_lib, "errno")
     568            if err.value == errno.EBUSY:
     569                raise CanvasError("The canvas is in use by a display driver"
     570                                  " and cannot be rotated")
     571            elif err.value == errno.ENOMEM:
     572                raise CanvasError("Not enough memory to allocate the new"
     573                                  " canvas size")
     574        else:
     575            return ret
    420576
    421577    def rotate_right(self):
     
    425581        _lib.caca_rotate_right.restype  = ctypes.c_int
    426582
    427         return _lib.caca_rotate_right(self)
     583        ret = _lib.caca_rotate_right(self)
     584        if ret == -1:
     585            err = ctypes.c_int.in_dll(_lib, "errno")
     586            if err.value == errno.EBUSY:
     587                raise CanvasError("The canvas is in use by a display driver"
     588                                  " and cannot be rotated")
     589            elif err.value == errno.ENOMEM:
     590                raise CanvasError("Not enough memory to allocate the new"
     591                                  " canvas size")
     592        else:
     593            return ret
    428594
    429595    def stretch_left(self):
     
    433599        _lib.caca_stretch_left.restype  = ctypes.c_int
    434600
    435         return _lib.caca_stretch_left(self)
     601        ret = _lib.caca_stretch_left(self)
     602        if ret == -1:
     603            err = ctypes.c_int.in_dll(_lib, "errno")
     604            if err.value == errno.EBUSY:
     605                raise CanvasError("The canvas is in use by a display driver"
     606                                  " and cannot be rotated")
     607            elif err.value == errno.ENOMEM:
     608                raise CanvasError("Not enough memory to allocate the new"
     609                                  " canvas size")
     610        else:
     611            return ret
    436612
    437613    def stretch_right(self):
     
    441617        _lib.caca_stretch_right.restype  = ctypes.c_int
    442618
    443         return _lib.caca_stretch_right(self)
     619        ret = _lib.caca_stretch_right(self)
     620        if ret == -1:
     621            err = ctypes.c_int.in_dll(_lib, "errno")
     622            if err.value == errno.EBUSY:
     623                raise CanvasError("The canvas is in use by a display driver"
     624                                  " and cannot be rotated")
     625            elif err.value == errno.ENOMEM:
     626                raise CanvasError("Not enough memory to allocate the new"
     627                                  " canvas size")
     628        else:
     629            return ret
    444630
    445631    def get_attr(self, x, y):
     
    451637        _lib.caca_get_attr.argtypes = [_Canvas, ctypes.c_int, ctypes.c_int]
    452638        _lib.caca_get_attr.restype  = ctypes.c_uint32
    453         return _lib.caca_get_attr(self, x, y)
     639
     640        try:
     641            ret = _lib.caca_get_attr(self, x, y)
     642        except ctypes.ArgumentError:
     643            raise CanvasError("Specified coordinate X or Y is invalid")
     644        else:
     645            return ret
    454646
    455647    def set_attr(self, attr):
     
    461653        _lib.caca_set_attr.restype  = ctypes.c_int
    462654
    463         return _lib.caca_set_attr(self, attr)
     655        try:
     656            ret = _lib.caca_set_attr(self, attr)
     657        except ctypes.ArgumentError:
     658            raise CanvasError("Specified attribute is invalid")
     659        else:
     660            return ret
     661
     662    def unset_attr(self, attr):
     663        """ Unset the default character attribute.
     664
     665            attr    -- the requested attribute value
     666        """
     667        _lib.caca_unset_attr.argtypes = [_Canvas, ctypes.c_uint32]
     668        _lib.caca_unset_attr.restype  = ctypes.c_int
     669
     670        try:
     671            ret = _lib.caca_unset_attr(self, attr)
     672        except ctypes.ArgumentError:
     673            raise CanvasError("Specified attribute is invalid")
     674        else:
     675            return ret
     676
     677    def toggle_attr(self, attr):
     678        """ Toggle the default character attribute.
     679
     680            attr -- the requested attribute value
     681        """
     682        _lib.caca_toggle_attr.argtypes = [_Canvas, ctypes.c_uint32]
     683        _lib.caca_toggle_attr.restype  = ctypes.c_int
     684
     685        try:
     686            ret = _lib.caca_toggle_attr(self, attr)
     687        except ctypes.ArgumentError:
     688            raise CanvasError("Specified attribute is invalid")
     689        else:
     690            return ret
    464691
    465692    def put_attr(self, x, y, attr):
     
    475702        _lib.caca_put_attr.restype  = ctypes.c_int
    476703
    477         return _lib.caca_put_attr(self, x, y, attr)
     704        try:
     705            ret = _lib.caca_put_attr(self, x, y, attr)
     706        except ctypes.ArgumentError:
     707            raise CanvasError("Specified coordinate or attribute is invalid")
     708        else:
     709            return ret
    478710
    479711    def set_color_ansi(self, fg, bg):
     
    483715            bg  -- the requested ANSI background colour.
    484716        """
    485         _lib.caca_set_color_ansi.argtypes = [_Canvas, ctypes.c_uint8, ctypes.c_uint8]
     717        _lib.caca_set_color_ansi.argtypes = [
     718                _Canvas, ctypes.c_uint8, ctypes.c_uint8
     719            ]
    486720        _lib.caca_set_color_ansi.restype  = ctypes.c_int
    487721
    488         return _lib.caca_set_color_ansi(self, fg, bg)
     722        try:
     723            ret = _lib.caca_set_color_ansi(self, fg, bg)
     724        except ctypes.ArgumentError:
     725            raise CanvasError("At least one of the colour values is invalid")
     726        else:
     727            if ret == -1:
     728                err = ctypes.c_int.in_dll(_lib, "errno")
     729                if err.value == errno.EINVAL:
     730                    raise CanvasError("At least one of the colour values"
     731                                      " is invalid")
     732            else:
     733                return ret
    489734
    490735    def set_color_argb(self, fg, bg):
     
    499744        _lib.caca_set_color_argb.restype  = ctypes.c_int
    500745
    501         return _lib.caca_set_color_argb(self, fg, bg)
     746        try:
     747            ret = _lib.caca_set_color_argb(self, fg, bg)
     748        except ctypes.ArgumentError:
     749            raise CanvasError("At least one of the colour values is invalid")
     750        else:
     751            return ret
    502752
    503753    def draw_line(self, x1, y1, x2, y2, ch):
     
    511761        """
    512762        _lib.caca_draw_line.argtypes = [
    513             _Canvas, ctypes.c_int, ctypes.c_int,
    514             ctypes.c_int, ctypes.c_int, ctypes.c_uint32
    515         ]
     763                _Canvas, ctypes.c_int, ctypes.c_int,
     764                ctypes.c_int, ctypes.c_int, ctypes.c_uint32
     765            ]
    516766        _lib.caca_draw_line.restype  = ctypes.c_int
    517767
    518         try:
    519             ch = ord(ch)
    520         except TypeError:
    521             ch = utf8_to_utf32(ch)
    522 
    523         return _lib.caca_draw_line(self, x1, y1, x2, y2, ch)
    524 
    525     def draw_polyline(self, array_x, array_y, n, ch):
     768        if not isinstance(ch, str):
     769            raise CanvasError("Specified character is invalid")
     770        else:
     771            try:
     772                ch = ord(ch)
     773            except TypeError:
     774                ch = utf8_to_utf32(ch)
     775
     776            try:
     777                ret = _lib.caca_draw_line(self, x1, y1, x2, y2, ch)
     778            except ctypes.ArgumentError:
     779                raise CanvasError("specified coordinate is invalid")
     780            else:
     781                return ret
     782
     783    def draw_polyline(self, array_xy, ch):
    526784        """ Draw a polyline.
    527785
    528             array_x -- Array of X coordinates, must have n+1 elements
    529             array-y -- Array of Y coordinates, must have n+1 elements
    530             n       -- Number of lines to draw
    531             ch      -- character to be used to draw the line
    532         """
     786            array_xy -- List of (X, Y) coordinates
     787            ch       -- character to be used to draw the line
     788        """
     789        if not isinstance(array_xy, list) or len(array_xy) < 2:
     790            raise CanvasError("Specified array of coordinates is invalid")
     791        else:
     792            for item in array_xy:
     793                if not isinstance(item, list) and \
     794                   not isinstance(item, tuple):
     795                    raise CanvasError("Specified array of coordinates"
     796                                      " is invalid")
     797
     798        ax = ctypes.c_int * len(array_xy)
     799        ay = ctypes.c_int * len(array_xy)
     800
    533801        _lib.caca_draw_polyline.argtypes = [
    534             _Canvas, ctypes.c_int * n, ctypes.c_int * n, ctypes.c_int, ctypes.c_uint32
    535         ]
     802                _Canvas, ax, ay, ctypes.c_int, ctypes.c_uint32
     803            ]
    536804        _lib.caca_draw_polyline.restype  = ctypes.c_int
    537805
    538         try:
    539             ch = ord(ch)
    540         except TypeError:
    541             ch = utf8_to_utf32(ch)
    542 
    543         return _lib.caca_draw_polyline(self, array_x, array_y, n, ch)
     806        if not isinstance(ch, str):
     807            raise CanvasError("Specified character is invalid")
     808        else:
     809            try:
     810                ch = ord(ch)
     811            except TypeError:
     812                ch = utf8_to_utf32(ch)
     813
     814            try:
     815                ax = ax(*[x[0] for x in array_xy])
     816                ay = ay(*[y[1] for y in array_xy])
     817            except IndexError:
     818                raise CanvasError("Specified array coordinates is invalid")
     819
     820            try:
     821                ret = _lib.caca_draw_polyline(self, ax, ay,
     822                                              len(array_xy) - 1, ch)
     823            except ctypes.ArgumentError:
     824                raise CanvasError("specified array of coordinates is invalid")
     825            else:
     826                return ret
    544827
    545828    def draw_thin_line(self, x1, y1, x2, y2):
     
    552835        """
    553836        _lib.caca_draw_thin_line.argtypes = [
    554             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int
    555         ]
     837                _Canvas, ctypes.c_int, ctypes.c_int,
     838                ctypes.c_int, ctypes.c_int
     839            ]
    556840        _lib.caca_draw_thin_line.restype  = ctypes.c_int
    557841
    558         return _lib.caca_draw_thin_line(self, x1, y1, x2, y2)
    559 
    560     def draw_thin_polyline(self, array_x, array_y, n):
     842        try:
     843            ret = _lib.caca_draw_thin_line(self, x1, y1, x2, y2)
     844        except ctypes.ArgumentError:
     845            raise CanvasError("specified coordinate is invalid")
     846        else:
     847            return ret
     848
     849    def draw_thin_polyline(self, array_xy):
    561850        """ Draw an ASCII art thin polyline.
    562851
    563             array_x -- Array of X coordinates, must have n+1 elements
    564             array_y -- Array of Y coordinates, must have n+1 elements
    565             n       -- Number of lines to draw
    566         """
     852            array_xy -- Array of (X, Y) coordinates
     853        """
     854        if not isinstance(array_xy, list) or len(array_xy) < 2:
     855            raise CanvasError("Specified array of coordinates is invalid")
     856        else:
     857            for item in array_xy:
     858                if not isinstance(item, list) and \
     859                   not isinstance(item, tuple):
     860                    raise CanvasError("Specified array of coordinates"
     861                                      " is invalid")
     862
     863        ax = ctypes.c_int * len(array_xy)
     864        ay = ctypes.c_int * len(array_xy)
     865
    567866        _lib.caca_draw_thin_polyline.argtypes = [
    568             Canvas, ctypes.c_int * n, ctypes.c_int * n, ctypes.c_int
    569         ]
     867               Canvas, ax, ay, ctypes.c_int
     868            ]
    570869        _lib.caca_draw_thin_polyline.restype  = ctypes.c_int
    571870
    572         return _lib.caca_draw_thin_polyline(self, array_x, array_y, n)
     871        try:
     872            ax = ax(*[x[0] for x in array_xy])
     873            ay = ay(*[y[1] for y in array_xy])
     874        except IndexError:
     875            raise CanvasError("Specified array coordinates is invalid")
     876
     877        try:
     878            ret = _lib.caca_draw_thin_polyline(self, ax, ay, len(array_xy) - 1)
     879        except ctypes.ArgumentError:
     880            raise CanvasError("specified array of coordinates is invalid")
     881        else:
     882            return ret
    573883
    574884    def draw_circle(self, x, y, r, ch):
     
    585895        _lib.caca_draw_circle.restype  = ctypes.c_int
    586896
    587         try:
    588             ch = ord(ch)
    589         except TypeError:
    590             ch = utf8_to_utf32(ch)
    591 
    592         return _lib.caca_draw_circle(self, x, y, r, ch)
     897        if not isinstance(ch, str):
     898            raise CanvasError("Specified character is invalid")
     899        else:
     900            try:
     901                ch = ord(ch)
     902            except TypeError:
     903                ch = utf8_to_utf32(ch)
     904
     905        try:
     906            ret = _lib.caca_draw_circle(self, x, y, r, ch)
     907        except ctypes.ArgumentError:
     908            raise CanvasError("Specified circle coordinate or radius is"
     909                              " invalid")
     910        else:
     911            return ret
    593912
    594913    def draw_ellipse(self, xo, yo, a, b, ch):
     
    602921        """
    603922        _lib.caca_draw_ellipse.argtypes = [
    604             _Canvas, ctypes.c_int, ctypes.c_int,
    605             ctypes.c_int, ctypes.c_int, ctypes.c_uint32
    606         ]
     923                _Canvas, ctypes.c_int, ctypes.c_int,
     924                ctypes.c_int, ctypes.c_int, ctypes.c_uint32
     925            ]
    607926        _lib.caca_draw_ellipse.restype  = ctypes.c_int
    608927
    609         try:
    610             ch = ord(ch)
    611         except TypeError:
    612             ch = utf8_to_utf32(ch)
    613 
    614         return _lib.caca_draw_ellipse(self, xo, yo, a, b, ch)
     928        if not isinstance(ch, str):
     929            raise CanvasError("Specified character is invalid")
     930        else:
     931            try:
     932                ch = ord(ch)
     933            except TypeError:
     934                ch = utf8_to_utf32(ch)
     935
     936        try:
     937            ret = _lib.caca_draw_ellipse(self, xo, yo, a, b, ch)
     938        except ctypes.ArgumentError:
     939            raise CanvasError("Specified ellipse coordinate or radius is"
     940                              " invalid")
     941        else:
     942            return ret
    615943
    616944    def draw_thin_ellipse(self, xo, yo, a, b):
     
    623951        """
    624952        _lib.caca_draw_thin_ellipse.argtypes = [
    625             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int
    626         ]
     953                _Canvas, ctypes.c_int, ctypes.c_int,
     954                ctypes.c_int, ctypes.c_int
     955            ]
    627956        _lib.caca_draw_thin_ellipse.restype  = ctypes.c_int
    628957
    629         return _lib.caca_draw_thin_ellipse(self, xo, yo, a, b)
     958        try:
     959            ret = _lib.caca_draw_thin_ellipse(self, xo, yo, a, b)
     960        except ctypes.ArgumentError:
     961            raise CanvasError("Specified ellipse coordinate or radius is"
     962                              " invalid")
     963        else:
     964            return ret
    630965
    631966    def fill_ellipse(self, xo, yo, a, b, ch):
     
    639974        """
    640975        _lib.caca_fill_ellipse.argtypes = [
    641             _Canvas, ctypes.c_int, ctypes.c_int,
    642             ctypes.c_int, ctypes.c_int, ctypes.c_uint32
    643         ]
     976                _Canvas, ctypes.c_int, ctypes.c_int,
     977                ctypes.c_int, ctypes.c_int, ctypes.c_uint32
     978            ]
    644979        _lib.caca_fill_ellipse.restype  = ctypes.c_int
    645980
    646         try:
    647             ch = ord(ch)
    648         except TypeError:
    649             ch = utf8_to_utf32(ch)
    650 
    651         return _lib.caca_fill_ellipse(self, xo, yo, a, b, ch)
     981        if not isinstance(ch, str):
     982            raise CanvasError("Specified character is invalid")
     983        else:
     984            try:
     985                ch = ord(ch)
     986            except TypeError:
     987                ch = utf8_to_utf32(ch)
     988
     989        try:
     990            ret = _lib.caca_fill_ellipse(self, xo, yo, a, b, ch)
     991        except ctypes.ArgumentError:
     992            raise CanvasError("Specified ellipse coordinate or radius is"
     993                              " invalid")
     994        else:
     995            return ret
    652996
    653997    def draw_box(self, x, y, width, height, ch):
     
    6611005        """
    6621006        _lib.caca_draw_box.argtypes = [
    663             Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_uint32
    664         ]
     1007                Canvas, ctypes.c_int, ctypes.c_int,
     1008                ctypes.c_int, ctypes.c_int, ctypes.c_uint32
     1009            ]
    6651010        _lib.caca_draw_box.restype  = ctypes.c_int
    6661011
    667         try:
    668             ch = ord(ch)
    669         except TypeError:
    670             ch = utf8_to_utf32(ch)
    671 
    672         return _lib.caca_draw_box(self, x, y, width, height, ch)
     1012        if not isinstance(ch, str):
     1013            raise CanvasError("Specified character is invalid")
     1014        else:
     1015            try:
     1016                ch = ord(ch)
     1017            except TypeError:
     1018                ch = utf8_to_utf32(ch)
     1019
     1020        try:
     1021            ret = _lib.caca_draw_box(self, x, y, width, height, ch)
     1022        except ctypes.ArgumentError:
     1023            raise CanvasError("specified box coordinate is invalid")
     1024        else:
     1025            return ret
    6731026
    6741027    def draw_thin_box(self, x, y, width, height):
     
    6811034        """
    6821035        _lib.caca_draw_thin_box.argtypes = [
    683             _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int
    684         ]
     1036                _Canvas, ctypes.c_int, ctypes.c_int,
     1037                ctypes.c_int, ctypes.c_int
     1038            ]
    6851039        _lib.caca_draw_thin_box.restype  = ctypes.c_int
    6861040
    687         return _lib.caca_draw_thin_box(self, x, y, width, height)
     1041        try:
     1042            ret = _lib.caca_draw_thin_box(self, x, y, width, height)
     1043        except ctypes.ArgumentError:
     1044            raise CanvasError("specified box coordinate is invalid")
     1045        else:
     1046            return ret
    6881047
    6891048    def draw_cp437_box(self, x, y, width, height):
     
    6961055        """
    6971056        _lib.caca_draw_cp437_box.argtypes = [
    698             _Canvas, ctypes.c_int, ctypes.c_int,
    699             ctypes.c_int, ctypes.c_int
    700         ]
     1057                _Canvas, ctypes.c_int, ctypes.c_int,
     1058                ctypes.c_int, ctypes.c_int
     1059            ]
    7011060        _lib.caca_draw_cp437_box.restype  = ctypes.c_int
    7021061
    703         return _lib.caca_draw_cp437_box(self, x, y, width, height)
     1062        try:
     1063            ret = _lib.caca_draw_cp437_box(self, x, y, width, height)
     1064        except ctypes.ArgumentError:
     1065            raise CanvasError("specified box coordinate is invalid")
     1066        else:
     1067            return ret
    7041068
    7051069    def fill_box(self, x, y, width, height, ch):
     
    7181082        _lib.caca_fill_box.restype  = ctypes.c_int
    7191083
    720         try:
    721             ch = ord(ch)
    722         except TypeError:
    723             ch = utf8_to_utf32(ch)
    724 
    725         return _lib.caca_fill_box(self, x, y, width, height, ch)
     1084        if not isinstance(ch, str):
     1085            raise CanvasError("Specified character is invalid")
     1086        else:
     1087            try:
     1088                ch = ord(ch)
     1089            except TypeError:
     1090                ch = utf8_to_utf32(ch)
     1091
     1092        try:
     1093            ret = _lib.caca_fill_box(self, x, y, width, height, ch)
     1094        except ctypes.ArgumentError:
     1095            raise CanvasError("specified box coordinate is invalid")
     1096        else:
     1097            return ret
    7261098
    7271099    def draw_triangle(self, x1, y1, x2, y2, x3, y3, ch):
     
    7421114        _lib.caca_draw_triangle.restype  = ctypes.c_int
    7431115
    744         try:
    745             ch = ord(ch)
    746         except TypeError:
    747             ch = utf8_to_utf32(ch)
    748 
    749         return _lib.caca_draw_triangle(self, x1, y1, x2, y2, x3, y3, ch)
     1116        if not isinstance(ch, str):
     1117            raise CanvasError("Specified character is invalid")
     1118        else:
     1119            try:
     1120                ch = ord(ch)
     1121            except TypeError:
     1122                ch = utf8_to_utf32(ch)
     1123
     1124        try:
     1125            ret = _lib.caca_draw_triangle(self, x1, y1, x2, y2, x3, y3, ch)
     1126        except ctypes.ArgumentError:
     1127            raise CanvasError("specified triangle coordinate is invalid")
     1128        else:
     1129            return ret
    7501130
    7511131    def draw_thin_triangle(self, x1, y1, x2, y2, x3, y3):
    7521132        """ Draw a thin triangle on the canvas.
     1133
     1134            x1  -- X coordinate of the first point
     1135            y1  -- Y coordinate of the first point
     1136            x2  -- X coordinate of the second point
     1137            y2  -- Y coordinate of the second point
     1138            x3  -- X coordinate of the third point
     1139            y3  -- Y coordinate of the third point
    7531140        """
    7541141        _lib.caca_draw_thin_triangle.argtypes = [
     
    7581145        _lib.caca_draw_thin_triangle.restype  = ctypes.c_int
    7591146
    760         return _lib.caca_draw_thin_triangle(self, x1, y1, x2, y2, x3, y3)
     1147        try:
     1148            ret = _lib.caca_draw_thin_triangle(self, x1, y1, x2, y2, x3, y3)
     1149        except ctypes.ArgumentError:
     1150            raise CanvasError("specified triangle coordinate is invalid")
     1151        else:
     1152            return ret
    7611153
    7621154    def fill_triangle(self, x1, y1, x2, y2, x3, y3, ch):
     
    7771169        _lib.caca_fill_triangle.restype  = ctypes.c_int
    7781170
    779         try:
    780             ch = ord(ch)
    781         except TypeError:
    782             ch = utf8_to_utf32(ch)
    783 
    784         return _lib.caca_fill_triangle(self, x1, y1, x2, y2, x3, y3, ch)
     1171        if not isinstance(ch, str):
     1172            raise CanvasError("Specified character is invalid")
     1173        else:
     1174            try:
     1175                ch = ord(ch)
     1176            except TypeError:
     1177                ch = utf8_to_utf32(ch)
     1178
     1179        try:
     1180            ret = _lib.caca_fill_triangle(self, x1, y1, x2, y2, x3, y3, ch)
     1181        except ctypes.ArgumentError:
     1182            raise CanvasError("specified triangle coordinate is invalid")
     1183        else:
     1184            return ret
    7851185
    7861186    def fill_triangle_textured(self, coords, tex, uv):
     
    8141214        _lib.caca_set_frame.restype  = ctypes.c_int
    8151215
    816         return _lib.caca_set_frame(self, idx)
     1216        try:
     1217            ret = _lib.caca_set_frame(self, idx)
     1218        except ctypes.ArgumentError:
     1219            raise CanvasError("specified index is invalid")
     1220        else:
     1221            err = ctypes.c_int.in_dll(_lib, "errno")
     1222            if err.value == errno.EINVAL:
     1223                raise CanvasError("Requested frame is out of range")
     1224            else:
     1225                return ret
    8171226
    8181227    def get_frame_name(self):
     
    8321241        _lib.caca_set_frame_name.restype  = ctypes.c_int
    8331242
    834         return _lib.caca_set_frame_name(self, name)
     1243        try:
     1244            ret = _lib.caca_set_frame_name(self, name)
     1245        except ctypes.ArgumentError:
     1246            raise CanvasError("Specified name is invalid")
     1247        else:
     1248            err = ctypes.c_int.in_dll(_lib, "errno")
     1249            if err.value == errno.ENOMEM:
     1250                raise CanvasError("Not enough memory to allocate new frame")
     1251            else:
     1252                return ret
    8351253
    8361254    def create_frame(self, idx):
     
    8421260        _lib.caca_create_frame.restype  = ctypes.c_int
    8431261
    844         return _lib.caca_create_frame(self, idx)
     1262        try:
     1263            ret = _lib.caca_create_frame(self, idx)
     1264        except ctypes.ArgumentError:
     1265            raise CanvasError("specified index is invalid")
     1266        else:
     1267            err = ctypes.c_int.in_dll(_lib, "errno")
     1268            if err.value == errno.ENOMEM:
     1269                raise CanvasError("Not enough memory to allocate new frame")
     1270            else:
     1271                return ret
    8451272
    8461273    def free_frame(self, idx):
     
    8521279        _lib.caca_free_frame.restype  = ctypes.c_int
    8531280
    854         return _lib.caca_free_frame(self, idx)
     1281        try:
     1282            ret = _lib.caca_free_frame(self, idx)
     1283        except ctypes.ArgumentError:
     1284            raise CanvasError("specified index is invalid")
     1285        else:
     1286            err = ctypes.c_int.in_dll(_lib, "errno")
     1287            if err.value == errno.EINVAL:
     1288                raise CanvasError("Requested frame is out of range, or attempt"
     1289                                  " to delete the last frame of the canvas")
     1290            else:
     1291                return ret
    8551292
    8561293    def import_from_memory(self, data, fmt):
    8571294        """ Import a memory buffer into a canvas.
    8581295
    859             data -- a memory area containing the data to be loaded into the canvas
     1296            data -- a memory area containing the data to be loaded into
     1297                    the canvas
    8601298            fmt  -- a string describing the input format
    8611299
     
    8671305              - utf8: import UTF-8 files with ANSI colour codes.
    8681306        """
    869         #set data size
    8701307        length = ctypes.c_size_t(len(data))
     1308
    8711309        _lib.caca_import_canvas_from_memory.argtypes = [
    872             Canvas, ctypes.c_char_p, ctypes.c_size_t, ctypes.c_char_p
    873         ]
     1310                Canvas, ctypes.c_char_p,
     1311                ctypes.c_size_t, ctypes.c_char_p
     1312            ]
    8741313        _lib.caca_import_canvas_from_memory.restype  = ctypes.c_int
    8751314
    876         return _lib.caca_import_canvas_from_memory(self, data, length, fmt)
     1315        if not isinstance(fmt, str):
     1316            raise CanvasError("Invalid format requested")
     1317
     1318        try:
     1319            ret = _lib.caca_import_canvas_from_memory(self, data, length, fmt)
     1320        except ctypes.ArgumentError:
     1321            raise CanvasError("Given data are invalid")
     1322        else:
     1323            err = ctypes.c_int.in_dll(_lib, "errno")
     1324            if ret == -1:
     1325                if err.value == errno.ENOMEM:
     1326                    raise CanvasError("Not enough memory to allocate canvas")
     1327                elif err.value == errno.EINVAL:
     1328                    raise CanvasError("Invalid format requested")
     1329            else:
     1330                return ret
    8771331
    8781332    def import_from_file(self, filename, fmt):
     
    8941348        _lib.caca_import_canvas_from_file.restype  = ctypes.c_int
    8951349
    896         return _lib.caca_import_canvas_from_file(self, filename, fmt)
     1350        if not isinstance(fmt, str):
     1351            raise CanvasError("Invalid format requested")
     1352
     1353        try:
     1354            ret = _lib.caca_import_canvas_from_file(self, filename, fmt)
     1355        except ctypes.ArgumentError:
     1356            raise CanvasError("Specified filename is invalid")
     1357        else:
     1358            err = ctypes.c_int.in_dll(_lib, "errno")
     1359            if ret == -1:
     1360                if err.value == errno.ENOSYS:
     1361                    raise CanvasError("File access is not implemented on this"
     1362                                      " system")
     1363                elif err.value == errno.ENOMEM:
     1364                    raise CanvasError("Not enough memory to allocate canvas")
     1365                elif err.value == errno.EINVAL:
     1366                    raise CanvasError("Invalid format requested")
     1367            else:
     1368                return ret
    8971369
    8981370    def import_area_from_memory(self, x, y, data, fmt):
     
    9011373            x    -- the leftmost coordinate of the area to import to
    9021374            y    -- the topmost coordinate of the area to import to
    903             data -- a memory area containing the data to be loaded into the canvas
     1375            data -- a memory area containing the data to be loaded into
     1376                    the canvas
    9041377            fmt  -- a string describing the input format
    9051378
     
    9111384              - utf8: import UTF-8 files with ANSI colour codes.
    9121385        """
    913         #set data size
    9141386        length = ctypes.c_size_t(len(data))
     1387
    9151388        _lib.caca_import_area_from_memory.argtypes = [
    916             _Canvas, ctypes.c_int, ctypes.c_int,
    917             ctypes.c_char_p, ctypes.c_size_t, ctypes.c_char_p
    918         ]
     1389                _Canvas, ctypes.c_int, ctypes.c_int,
     1390                ctypes.c_char_p, ctypes.c_size_t, ctypes.c_char_p
     1391            ]
    9191392        _lib.caca_import_area_from_memory.restype  = ctypes.c_int
    9201393
    921         return _lib.caca_import_area_from_memory(self, x, y, data, length, fmt)
     1394        if not isinstance(fmt, str):
     1395            raise CanvasError("Invalid format requested")
     1396        elif not isinstance(data, str):
     1397            raise CanvasError("Given data are invalid")
     1398
     1399        try:
     1400            ret = _lib.caca_import_area_from_memory(self, x, y,
     1401                                                    data, length, fmt)
     1402        except ctypes.ArgumentError:
     1403            raise CanvasError("Specified coordinate X or Y is invalid")
     1404        else:
     1405            if ret == -1:
     1406                err = ctypes.c_int.in_dll(_lib, "errno")
     1407                if err.value == errno.EINVAL:
     1408                    raise CanvasError("Unsupported format requested or"
     1409                                      " invalid coordinates")
     1410                elif err.value == errno.ENOMEM:
     1411                    raise CanvasError("Not enough memory to allocate canvas")
     1412            else:
     1413                return ret
    9221414
    9231415    def import_area_from_file(self, x, y, filename, fmt):
     
    9371429        """
    9381430        _lib.caca_import_area_from_file.argtypes = [
    939             _Canvas, ctypes.c_int, ctypes.c_int,
    940             ctypes.c_char_p, ctypes.c_char_p
    941         ]
     1431                _Canvas, ctypes.c_int, ctypes.c_int,
     1432                ctypes.c_char_p, ctypes.c_char_p
     1433            ]
    9421434        _lib.caca_import_area_from_file.restype  = ctypes.c_int
    9431435
    944         return _lib.caca_import_area_from_file(self, x, y, filename, fmt)
     1436        if not isinstance(fmt, str):
     1437            raise CanvasError("Invalid format requested")
     1438        elif not isinstance(filename, str):
     1439            raise CanvasError("Invalid filename requested")
     1440
     1441        try:
     1442            ret = _lib.caca_import_area_from_file(self, x, y, filename, fmt)
     1443        except ctypes.ArgumentError:
     1444            raise CanvasError("Specified coordinate X or Y is invalid")
     1445        else:
     1446            if ret == -1:
     1447                err = ctypes.c_int.in_dll(_lib, "errno")
     1448                if err.value == errno.ENOSYS:
     1449                    raise CanvasError("File access is not implemented on this"
     1450                                      " system")
     1451                elif err.value == errno.ENOMEM:
     1452                    raise CanvasError("Not enough memory to allocate canvas")
     1453                elif err.value == errno.EINVAL:
     1454                    raise CanvasError("Unsupported format requested or"
     1455                                      " invalid coordinates")
     1456            else:
     1457                return ret
    9451458
    9461459    def export_to_memory(self, fmt):
     
    9601473              - tga: export a TGA image.
    9611474        """
    962         #initialize pointer
    9631475        p_size_t = ctypes.POINTER(ctypes.c_size_t)
    9641476        _lib.caca_export_canvas_to_memory.argtypes = [
    9651477                _Canvas, ctypes.c_char_p, p_size_t
    966         ]
     1478            ]
    9671479        _lib.caca_export_canvas_to_memory.restype  = ctypes.POINTER(ctypes.c_char_p)
    9681480
    9691481        p = ctypes.c_size_t()
    970         ret = _lib.caca_export_canvas_to_memory(self, fmt, p)
    971 
    972         return ctypes.string_at(ret, p.value)
     1482
     1483        try:
     1484            ret = _lib.caca_export_canvas_to_memory(self, fmt, p)
     1485        except ctypes.ArgumentError:
     1486            raise CanvasError("Invalid format requested")
     1487        else:
     1488            if not ret:
     1489                err = ctypes.c_int.in_dll(_lib, "errno")
     1490                if err.value == errno.EINVAL:
     1491                    raise CanvasError("Invalid format requested")
     1492                elif err.value == errno.ENOMEM:
     1493                    raise CanvasError("Not enough memory to allocate output"
     1494                                      " buffer")
     1495            else:
     1496                return ctypes.string_at(ret, p.value)
    9731497
    9741498    def export_area_to_memory(self, x, y, width, height, fmt):
     
    9921516              - tga: export a TGA image.
    9931517        """
    994         #initialize pointer
    9951518        p_size_t = ctypes.POINTER(ctypes.c_size_t)
    9961519
    9971520        _lib.caca_export_area_to_memory.argtypes = [
    998                 _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int, ctypes.c_int,
    999                 ctypes.c_char_p, p_size_t
    1000         ]
     1521                _Canvas, ctypes.c_int, ctypes.c_int, ctypes.c_int,
     1522                ctypes.c_int, ctypes.c_char_p, p_size_t
     1523            ]
    10011524        _lib.caca_export_area_to_memory.restype  = ctypes.POINTER(ctypes.c_char_p)
    10021525
    10031526        p = ctypes.c_size_t()
    1004         ret = _lib.caca_export_area_to_memory(self, x, y, width, height, fmt, p)
    1005 
    1006         return ctypes.string_at(ret, p.value)
     1527
     1528        if not isinstance(fmt, str):
     1529            raise CanvasError("Invalid format requested")
     1530
     1531        try:
     1532            ret = _lib.caca_export_area_to_memory(self, x, y, width, height,
     1533                                                  fmt, p)
     1534        except ctypes.ArgumentError:
     1535            raise CanvasError("Requested area coordinate is invalid")
     1536        else:
     1537            if not ret:
     1538                err = ctypes.c_int.in_dll(_lib, "errno")
     1539                if err.value == errno.EINVAL:
     1540                    raise CanvasError("Invalid format requested")
     1541                elif err.value == errno.ENOMEM:
     1542                    raise CanvasError("Not enough memory to allocate output"
     1543                                      " buffer")
     1544            else:
     1545                return ctypes.string_at(ret, p.value)
    10071546
    10081547    def set_figfont(self, filename):
     
    10141553        _lib.caca_canvas_set_figfont.restype  = ctypes.c_int
    10151554
    1016         return _lib.caca_canvas_set_figfont(self, filename)
     1555        if not isinstance(filename, str):
     1556            raise CanvasError("Invalid filename requested")
     1557        else:
     1558            return _lib.caca_canvas_set_figfont(self, filename)
    10171559
    10181560    def put_figchar(self, ch):
     
    10241566        _lib.caca_put_figchar.restype  = ctypes.c_int
    10251567
    1026         try:
    1027             ch = ord(ch)
    1028         except TypeError:
    1029             ch = utf8_to_utf32(ch)
    1030  
     1568        if not isinstance(ch, str):
     1569            raise CanvasError("Specified character is invalid")
     1570        else:
     1571            try:
     1572                ch = ord(ch)
     1573            except TypeError:
     1574                ch = utf8_to_utf32(ch)
     1575
    10311576        return _lib.caca_put_figchar(self, ch)
    10321577
Note: See TracChangeset for help on using the changeset viewer.