IUP

    cdef char *status
    if isinstance(data, str): data = data.encode()
    status = IupLoadBuffer(data)
    if status: raise IupError(ERROR, status.strip().decode())


cdef void __frame_callback(void *data, va_alist frame) with gil:
    (<Callback>data).__call_with_frame__(frame)

cdef class Callback:
    '''Callback invocation wrapper.'''
    
    cdef void *_cb
    cdef readonly object format
    cdef public object target
    
    def __cinit__(self):

    def __init__(self, format):
        if not format:
            format = b'h=i'
        elif len(format) < 2 or format[-2] != ord(b'='):
            format += b'=i'
        self.format = format
    

    def __address__(self):
        '''Returns the memory address of the C callback entry point.'''
        return <unsigned long>self._cb
    
    def __call__(self, *args):
        '''Performs a Python call to the callback.'''
        return self.target(*args)
    
    cdef __call_with_frame__(self, va_alist frame):

        elif ret == ord(b'f'):
            va_return_float(frame, result)
        elif ret == ord(b'd'):
            va_return_double(frame, result)
        elif ret == ord(b'v'):
            va_return_voidp(frame, <void *><unsigned long?>result)
        elif ret == ord(b'h'):
            va_return_voidp(frame, <void *><unsigned long?>result.__address__())


cdef class BaseHandle:
    '''Base class of IUP attribute containers.'''
    
    cdef Ihandle *_ih
    cdef object _registry
    
    def __cinit__(self):
        self._ih = NULL

        cdef unsigned long address
        if isinstance(value, str):
            value = value.encode()
            IupStoreAttribute(self._ih, name, value)
        elif isinstance(value, bytes):
            IupStoreAttribute(self._ih, name, value)
        elif isinstance(value, Handle):
            address = value.__address__()
            IupSetAttributeHandle(self._ih, name, <Ihandle *>address)
        elif isinstance(value, bool) or value is None:
            if value:
                value = b'YES'
            else:
                value = b'NO'
            IupStoreAttribute(self._ih, name, value)
        else:
            value = str(value).encode()
            IupStoreAttribute(self._ih, name, value)
    
    cdef object _get_callback(self, char *name, object table):
        cdef object callback = None
        cdef unsigned long address
        if table:
            address = <unsigned long>IupGetCallback(self._ih, name)
            if address in table: callback = table[address]
        return callback
    
    cdef void _set_callback(self, char *name, object table, object target):
        cdef Callback callback
        cdef unsigned long address = <unsigned long>IupGetCallback(self._ih, name)
        if address in table:
            callback = table[address]
        else:
            callback = Callback(iupClassCallbackGetFormat(self._ih.iclass, name))
            address = callback.__address__()
            table[address] = callback
            IupSetCallback(self._ih, name, <void *>address)
        callback.target = target


@cython.final
cdef class GlobalHandle(BaseHandle):
    '''Class of the global attribute container.'''
    
    def __getattr__(self, name):
        '''Retrieves a callback or attribute.'''
        if isinstance(name, str): name = name.encode()
        return \
            self._get_callback(name, self._registry) or \
            self._get_attribute(name)
    
    def __setattr__(self, name, value):
        '''Sets a callback or attribute.'''
        if isinstance(name, str): name = name.encode()
        if callable(value):
            self._set_callback(name, self._registry, value)
        else:
            self._set_attribute(name, value)

IUP_GLOBAL = GlobalHandle()


CENTER       = 0xFFFF
LEFT         = 0xFFFE
RIGHT        = 0xFFFD
MOUSEPOS     = 0xFFFC
CURRENT      = 0xFFFB
CENTERPARENT = 0xFFFA
TOP          = LEFT
BOTTOM       = RIGHT

cdef class Handle(BaseHandle):
    '''Class of IUP handles.'''
    
    def __init__(self, unsigned long address):
        '''Wraps a memory address into a new handle.'''
        if not address: raise ValueError('Handle may not be NULL')
        self._ih = <Ihandle *>address
        Py_INCREF(self)

    def create(Self, name, **attrs):
        '''Wraps a new instance of an IUP object into a handle.'''
        cdef unsigned long address
        cdef Handle self
        if isinstance(name, str): name = name.encode()
        
        address = <unsigned long>IupCreate(name)
        if not address:
            raise IupError(ERROR, 'Failed to create {}'.format(name))
        self = Self(address)


        
        try:
            for name, value in attrs.items(): self.__setattr__(name, value)
        except:
            self.destroy()
            raise
        
        return self
    
    @classmethod
    def by_name(Self, name):
        '''Retrieves an IUP object instance by name.'''
        if isinstance(name, str): name = name.encode()
        return Self.wrap(<unsigned long>IupGetHandle(name))
    

    def __address__(self):
        '''Returns the memory address of the underlying object.'''
        return <unsigned long>self._ih

    def _check_destroyed(self):
        '''Ensures that the underlying object is still alive.'''
        if not self._ih: raise ReferenceError('Handle is destroyed')
    

    cdef object _get_name(self):


        cdef char *name = IupGetName(self._ih)
        if name:
            return name.decode()
        else:
            return None
    
    cdef _set_name(self, object name):
        cdef char *ptr
        if isinstance(name, str):
            name = name.encode()
            ptr = name
        elif isinstance(name, bytes):
            ptr = name
        else:
            name = str(name).encode()
            ptr = name
        IupSetHandle(ptr, self._ih)
    

    def _class_name(self):


        return IupGetClassName(self._ih).decode()
    

    def _class_type(self):


        return IupGetClassType(self._ih).decode()
    
    def __getattr__(self, name):
        '''Retrieves a name, callback or attribute.'''
        self._check_destroyed()
        if isinstance(name, str): name = name.encode()
        if name == b'name':
            return self._get_name()
        elif name == b'class_name':
            return self._class_name()
        elif name == b'class_type':
            return self._class_type()
        else:
            return \
                self._get_callback(name, self._registry) or \
                self._get_attribute(name)
    
    def __setattr__(self, name, value):
        '''Sets a name, callback or attribute.'''
        self._check_destroyed()
        if isinstance(name, str): name = name.encode()
        if name == b'name':
            self._set_name(value)
        else:
            if callable(value):
                self._set_callback(name, self._registry, value)
            else:
                self._set_attribute(name, value)
    
    def save_attributes(self):
        '''Ensures that attributes stored in native resources are mirrorred.'''
        self._check_destroyed()
        IupSaveClassAttributes(self._ih)
    
    def show(self, modal = False, x = CURRENT, y = CURRENT):