def __init__(self, seq):

self.idx = 0

self.seq = seq

def __iter__(self):

return self

def __next__(self):

if self.idx < len(self.seq):

self.idx += 1

return self.seq[self.idx - 1]

else:

self.idx = 0

_fields_ = [

("x", c_float),

("y", c_float)

]

def __init__(self, x, y):

self.x = x

self.y = y

def __eq__(self, obj):

_fields_ = [

("values", c_float * 9)

]

def __init__(self):

tmp = dll.pixie_matrix3()

self.values = tmp.values

def __eq__(self, obj):

return self.values[0] == obj.values[0] and self.values[1] == obj.values[1] and self.values[2] == obj.values[2] and self.values[3] == obj.values[3] and self.values[4] == obj.values[4] and self.values[5] == obj.values[5] and self.values[6] == obj.values[6] and self.values[7] == obj.values[7] and self.values[8] == obj.values[8]

def __mul__(self, b):

result = dll.pixie_matrix3_mul(self, b)

_fields_ = [

("x", c_float),

("y", c_float),

("w", c_float),

("h", c_float)

]

def __init__(self, x, y, w, h):

self.x = x

self.y = y

self.w = w

self.h = h

def __eq__(self, obj):

_fields_ = [

("r", c_float),

("g", c_float),

("b", c_float),

("a", c_float)

]

def __init__(self, r, g, b, a):

self.r = r

self.g = g

self.b = b

self.a = a

def __eq__(self, obj):

_fields_ = [

("color", Color),

("position", c_float)

]

def __init__(self, color, position):

self.color = color

self.position = position

def __eq__(self, obj):

_fields_ = [

("width", c_float)

]

def __init__(self, width):

self.width = width

def __eq__(self, obj):

_fields_ = [("ref", c_ulonglong)]

def __bool__(self):

return self.ref != None

def __eq__(self, obj):

return self.ref == obj.ref

def __del__(self):

dll.pixie_seq_float32_unref(self)

def __init__(self):

self.ref = dll.pixie_new_seq_float32()

def __len__(self):

return dll.pixie_seq_float32_len(self)

def __getitem__(self, index):

return dll.pixie_seq_float32_get(self, index)

def __setitem__(self, index, value):

dll.pixie_seq_float32_set(self, index, value)

def __delitem__(self, index):

dll.pixie_seq_float32_delete(self, index)

def append(self, value):

dll.pixie_seq_float32_add(self, value)

def clear(self):

dll.pixie_seq_float32_clear(self)

def __iter__(self):

_fields_ = [("ref", c_ulonglong)]

def __bool__(self):

return self.ref != None

def __eq__(self, obj):

return self.ref == obj.ref

def __del__(self):

dll.pixie_seq_span_unref(self)

def __init__(self):

self.ref = dll.pixie_new_seq_span()

def __len__(self):

return dll.pixie_seq_span_len(self)

def __getitem__(self, index):

return dll.pixie_seq_span_get(self, index)

def __setitem__(self, index, value):

dll.pixie_seq_span_set(self, index, value)

def __delitem__(self, index):

dll.pixie_seq_span_delete(self, index)

def append(self, value):

dll.pixie_seq_span_add(self, value)

def clear(self):

dll.pixie_seq_span_clear(self)

def __iter__(self):

return SeqIterator(self)

def typeset(self, bounds = None, h_align = LEFT_ALIGN, v_align = TOP_ALIGN, wrap = True):

"""

if bounds is None:

bounds = Vector2(0, 0)

result = dll.pixie_seq_span_typeset(self, bounds, h_align, v_align, wrap)

return result

def layout_bounds(self):

"""

result = dll.pixie_seq_span_layout_bounds(self)

_fields_ = [("ref", c_ulonglong)]

def __bool__(self):

return self.ref != None

def __eq__(self, obj):

return self.ref == obj.ref

def __del__(self):

dll.pixie_image_unref(self)

def __init__(self, width, height):

result = dll.pixie_new_image(width, height)

if check_error():

raise PixieError(take_error())

self.ref = result

@property

def width(self):

return dll.pixie_image_get_width(self)

@width.setter

def width(self, width):

dll.pixie_image_set_width(self, width)

@property

def height(self):

return dll.pixie_image_get_height(self)

@height.setter

def height(self, height):

dll.pixie_image_set_height(self, height)

def write_file(self, file_path):

"""

dll.pixie_image_write_file(self, file_path.encode("utf8"))

if check_error():

raise PixieError(take_error())

def copy(self):

"""

result = dll.pixie_image_copy(self)

if check_error():

raise PixieError(take_error())

return result

def get_color(self, x, y):

"""

result = dll.pixie_image_get_color(self, x, y)

return result

def set_color(self, x, y, color):

"""

dll.pixie_image_set_color(self, x, y, color)

def fill(self, color):

"""

dll.pixie_image_fill(self, color)

def flip_horizontal(self):

"""

dll.pixie_image_flip_horizontal(self)

def flip_vertical(self):

"""

dll.pixie_image_flip_vertical(self)

def sub_image(self, x, y, w, h):

"""

result = dll.pixie_image_sub_image(self, x, y, w, h)

if check_error():

raise PixieError(take_error())

return result

def minify_by2(self, power = 1):

"""

result = dll.pixie_image_minify_by2(self, power)

if check_error():

raise PixieError(take_error())

return result

def magnify_by2(self, power = 1):

"""

result = dll.pixie_image_magnify_by2(self, power)

if check_error():

raise PixieError(take_error())

return result

def apply_opacity(self, opacity):

"""

dll.pixie_image_apply_opacity(self, opacity)

def invert(self):

"""

dll.pixie_image_invert(self)

def blur(self, radius, out_of_bounds = None):

"""

if out_of_bounds is None:

out_of_bounds = Color(0, 0, 0, 0)

dll.pixie_image_blur(self, radius, out_of_bounds)

if check_error():

raise PixieError(take_error())

def new_mask(self):

"""

result = dll.pixie_image_new_mask(self)

if check_error():

raise PixieError(take_error())

return result

def resize(self, width, height):

"""

result = dll.pixie_image_resize(self, width, height)

if check_error():

raise PixieError(take_error())

return result

def shadow(self, offset, spread, blur, color):

"""

result = dll.pixie_image_shadow(self, offset, spread, blur, color)

if check_error():

raise PixieError(take_error())

return result

def super_image(self, x, y, w, h):

"""

result = dll.pixie_image_super_image(self, x, y, w, h)

if check_error():

raise PixieError(take_error())

return result

def draw(self, b, transform = None, blend_mode = NORMAL_BLEND):

"""

if transform is None:

transform = Matrix3()

dll.pixie_image_draw(self, b, transform, blend_mode)

if check_error():

raise PixieError(take_error())

def mask_draw(self, mask, transform = None, blend_mode = MASK_BLEND):

"""

if transform is None:

transform = Matrix3()

dll.pixie_image_mask_draw(self, mask, transform, blend_mode)

if check_error():

raise PixieError(take_error())

def fill_gradient(self, paint):

"""

dll.pixie_image_fill_gradient(self, paint)

if check_error():

raise PixieError(take_error())

def fill_text(self, font, text, transform = None, bounds = None, h_align = LEFT_ALIGN, v_align = TOP_ALIGN):

"""

if transform is None:

transform = Matrix3()

if bounds is None:

bounds = Vector2(0, 0)

dll.pixie_image_fill_text(self, font, text.encode("utf8"), transform, bounds, h_align, v_align)

if check_error():

raise PixieError(take_error())

def arrangement_fill_text(self, arrangement, transform = None):

"""

if transform is None:

transform = Matrix3()

dll.pixie_image_arrangement_fill_text(self, arrangement, transform)

if check_error():

raise PixieError(take_error())

def stroke_text(self, font, text, transform = None, stroke_width = 1.0, bounds = None, h_align = LEFT_ALIGN, v_align = TOP_ALIGN, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None):

"""

if transform is None:

transform = Matrix3()

if bounds is None:

bounds = Vector2(0, 0)

if dashes is None:

dashes = SeqFloat32()

dll.pixie_image_stroke_text(self, font, text.encode("utf8"), transform, stroke_width, bounds, h_align, v_align, line_cap, line_join, miter_limit, dashes)

if check_error():

raise PixieError(take_error())

def arrangement_stroke_text(self, arrangement, transform = None, stroke_width = 1.0, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None):

"""

if transform is None:

transform = Matrix3()

if dashes is None:

dashes = SeqFloat32()

dll.pixie_image_arrangement_stroke_text(self, arrangement, transform, stroke_width, line_cap, line_join, miter_limit, dashes)

if check_error():

raise PixieError(take_error())

def fill_path(self, path, paint, transform = None, winding_rule = NON_ZERO):

"""

if transform is None:

transform = Matrix3()

dll.pixie_image_fill_path(self, path, paint, transform, winding_rule)

if check_error():

raise PixieError(take_error())

def stroke_path(self, path, paint, transform = None, stroke_width = 1.0, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None):

"""

if transform is None:

transform = Matrix3()

if dashes is None:

dashes = SeqFloat32()

dll.pixie_image_stroke_path(self, path, paint, transform, stroke_width, line_cap, line_join, miter_limit, dashes)

if check_error():

raise PixieError(take_error())

def new_context(self):

"""

result = dll.pixie_image_new_context(self)

_fields_ = [("ref", c_ulonglong)]

def __bool__(self):

return self.ref != None

def __eq__(self, obj):

return self.ref == obj.ref

def __del__(self):

dll.pixie_mask_unref(self)

def __init__(self, width, height):

result = dll.pixie_new_mask(width, height)

if check_error():

raise PixieError(take_error())

self.ref = result

@property

def width(self):

return dll.pixie_mask_get_width(self)

@width.setter

def width(self, width):

dll.pixie_mask_set_width(self, width)

@property

def height(self):

return dll.pixie_mask_get_height(self)

@height.setter

def height(self, height):

dll.pixie_mask_set_height(self, height)

def write_file(self, file_path):

"""

dll.pixie_mask_write_file(self, file_path.encode("utf8"))

if check_error():

raise PixieError(take_error())

def copy(self):

"""

result = dll.pixie_mask_copy(self)

if check_error():

raise PixieError(take_error())

return result

def get_value(self, x, y):

"""

result = dll.pixie_mask_get_value(self, x, y)

return result

def set_value(self, x, y, value):

"""

dll.pixie_mask_set_value(self, x, y, value)

def fill(self, value):

"""

dll.pixie_mask_fill(self, value)

def minify_by2(self, power = 1):

"""

result = dll.pixie_mask_minify_by2(self, power)

if check_error():

raise PixieError(take_error())

return result

def magnify_by2(self, power = 1):

"""

result = dll.pixie_mask_magnify_by2(self, power)

if check_error():

raise PixieError(take_error())

return result

def spread(self, spread):

"""

dll.pixie_mask_spread(self, spread)

if check_error():

raise PixieError(take_error())

def ceil(self):

"""

dll.pixie_mask_ceil(self)

def new_image(self):

result = dll.pixie_mask_new_image(self)

if check_error():

raise PixieError(take_error())

return result

def apply_opacity(self, opacity):

"""

dll.pixie_mask_apply_opacity(self, opacity)

def invert(self):

"""

dll.pixie_mask_invert(self)

def blur(self, radius, out_of_bounds = 0):

"""

dll.pixie_mask_blur(self, radius, out_of_bounds)

if check_error():

raise PixieError(take_error())

def draw(self, b, transform = None, blend_mode = MASK_BLEND):

"""

if transform is None:

transform = Matrix3()

dll.pixie_mask_draw(self, b, transform, blend_mode)

if check_error():

raise PixieError(take_error())

def image_draw(self, image, transform = None, blend_mode = MASK_BLEND):

"""

if transform is None:

transform = Matrix3()

dll.pixie_mask_image_draw(self, image, transform, blend_mode)

if check_error():

raise PixieError(take_error())

def fill_text(self, font, text, transform = None, bounds = None, h_align = LEFT_ALIGN, v_align = TOP_ALIGN):

"""

if transform is None:

transform = Matrix3()

if bounds is None:

bounds = Vector2(0, 0)

dll.pixie_mask_fill_text(self, font, text.encode("utf8"), transform, bounds, h_align, v_align)

if check_error():

raise PixieError(take_error())

def arrangement_fill_text(self, arrangement, transform = None):

"""

if transform is None:

transform = Matrix3()

dll.pixie_mask_arrangement_fill_text(self, arrangement, transform)

if check_error():

raise PixieError(take_error())

def stroke_text(self, font, text, transform = None, stroke_width = 1.0, bounds = None, h_align = LEFT_ALIGN, v_align = TOP_ALIGN, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None):

"""

if transform is None:

transform = Matrix3()

if bounds is None:

bounds = Vector2(0, 0)

if dashes is None:

dashes = SeqFloat32()

dll.pixie_mask_stroke_text(self, font, text.encode("utf8"), transform, stroke_width, bounds, h_align, v_align, line_cap, line_join, miter_limit, dashes)

if check_error():

raise PixieError(take_error())

def arrangement_stroke_text(self, arrangement, transform = None, stroke_width = 1.0, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None):

"""

if transform is None:

transform = Matrix3()

if dashes is None:

dashes = SeqFloat32()

dll.pixie_mask_arrangement_stroke_text(self, arrangement, transform, stroke_width, line_cap, line_join, miter_limit, dashes)

if check_error():

raise PixieError(take_error())

def fill_path(self, path, transform = None, winding_rule = NON_ZERO, blend_mode = NORMAL_BLEND):

"""

if transform is None:

transform = Matrix3()

dll.pixie_mask_fill_path(self, path, transform, winding_rule, blend_mode)

if check_error():

raise PixieError(take_error())

def stroke_path(self, path, transform = None, stroke_width = 1.0, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None, blend_mode = NORMAL_BLEND):

"""

if transform is None:

transform = Matrix3()

if dashes is None:

dashes = SeqFloat32()

dll.pixie_mask_stroke_path(self, path, transform, stroke_width, line_cap, line_join, miter_limit, dashes, blend_mode)

if check_error():

_fields_ = [("ref", c_ulonglong)]

def __bool__(self):

return self.ref != None

def __eq__(self, obj):

return self.ref == obj.ref

def __del__(self):

dll.pixie_paint_unref(self)

def __init__(self, kind):

result = dll.pixie_new_paint(kind)

self.ref = result

@property

def kind(self):

return dll.pixie_paint_get_kind(self)

@kind.setter

def kind(self, kind):

dll.pixie_paint_set_kind(self, kind)

@property

def blend_mode(self):

return dll.pixie_paint_get_blend_mode(self)

@blend_mode.setter

def blend_mode(self, blend_mode):

dll.pixie_paint_set_blend_mode(self, blend_mode)

@property

def opacity(self):

return dll.pixie_paint_get_opacity(self)

@opacity.setter

def opacity(self, opacity):

dll.pixie_paint_set_opacity(self, opacity)

@property

def color(self):

return dll.pixie_paint_get_color(self)

@color.setter

def color(self, color):

dll.pixie_paint_set_color(self, color)

@property

def image(self):

return dll.pixie_paint_get_image(self)

@image.setter

def image(self, image):

dll.pixie_paint_set_image(self, image)

@property

def image_mat(self):

return dll.pixie_paint_get_image_mat(self)

@image_mat.setter

def image_mat(self, image_mat):

dll.pixie_paint_set_image_mat(self, image_mat)

class PaintGradientHandlePositions:

def __init__(self, paint):

self.paint = paint

def __len__(self):

return dll.pixie_paint_gradient_handle_positions_len(self.paint)

def __getitem__(self, index):

return dll.pixie_paint_gradient_handle_positions_get(self.paint, index)

def __setitem__(self, index, value):

dll.pixie_paint_gradient_handle_positions_set(self.paint, index, value)

def __delitem__(self, index):

dll.pixie_paint_gradient_handle_positions_delete(self.paint, index)

def append(self, value):

dll.pixie_paint_gradient_handle_positions_add(self.paint, value)

def clear(self):

dll.pixie_paint_gradient_handle_positions_clear(self.paint)

def __iter__(self):

return SeqIterator(self)

@property

def gradient_handle_positions(self):

return self.PaintGradientHandlePositions(self)

class PaintGradientStops:

def __init__(self, paint):

self.paint = paint

def __len__(self):

return dll.pixie_paint_gradient_stops_len(self.paint)

def __getitem__(self, index):

return dll.pixie_paint_gradient_stops_get(self.paint, index)

def __setitem__(self, index, value):

dll.pixie_paint_gradient_stops_set(self.paint, index, value)

def __delitem__(self, index):

dll.pixie_paint_gradient_stops_delete(self.paint, index)

def append(self, value):

dll.pixie_paint_gradient_stops_add(self.paint, value)

def clear(self):

dll.pixie_paint_gradient_stops_clear(self.paint)

def __iter__(self):

return SeqIterator(self)

@property

def gradient_stops(self):

return self.PaintGradientStops(self)

def new_paint(self):

"""

result = dll.pixie_paint_new_paint(self)

_fields_ = [("ref", c_ulonglong)]

def __bool__(self):

return self.ref != None

def __eq__(self, obj):

return self.ref == obj.ref

def __del__(self):

dll.pixie_path_unref(self)

def __init__(self):

result = dll.pixie_new_path()

self.ref = result

def transform(self, mat):

"""

dll.pixie_path_transform(self, mat)

def add_path(self, other):

"""

dll.pixie_path_add_path(self, other)

def close_path(self):

"""

dll.pixie_path_close_path(self)

def compute_bounds(self, transform = None):

"""

if transform is None:

transform = Matrix3()

result = dll.pixie_path_compute_bounds(self, transform)

if check_error():

raise PixieError(take_error())

return result

def fill_overlaps(self, test, transform = None, winding_rule = NON_ZERO):

"""

if transform is None:

transform = Matrix3()

result = dll.pixie_path_fill_overlaps(self, test, transform, winding_rule)

if check_error():

raise PixieError(take_error())

return result

def stroke_overlaps(self, test, transform = None, stroke_width = 1.0, line_cap = BUTT_CAP, line_join = MITER_JOIN, miter_limit = DEFAULT_MITER_LIMIT, dashes = None):

"""

if transform is None:

transform = Matrix3()

if dashes is None:

dashes = SeqFloat32()

result = dll.pixie_path_stroke_overlaps(self, test, transform, stroke_width, line_cap, line_join, miter_limit, dashes)

if check_error():

raise PixieError(take_error())