# Copyright 2004-2026 Tom Rothamel <pytom@bishoujo.us>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associated documentation files
# (the "Software"), to deal in the Software without restriction,
# including without limitation the rights to use, copy, modify, merge,
# publish, distribute, sublicense, and/or sell copies of the Software,
# and to permit persons to whom the Software is furnished to do so,
# subject to the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

# This file is generated by generate_styles.py.

from renpy.style cimport StyleCore

cdef class Style(StyleCore):

    @property
    def activate_sound(self):
        return self._get(0)
    @activate_sound.setter
    def activate_sound(self, value):
        self.properties.append({'activate_sound': value})
    @activate_sound.deleter
    def activate_sound(self):
        self.delattr('activate_sound')

    @property
    def adjust_spacing(self):
        return self._get(1)
    @adjust_spacing.setter
    def adjust_spacing(self, value):
        self.properties.append({'adjust_spacing': value})
    @adjust_spacing.deleter
    def adjust_spacing(self):
        self.delattr('adjust_spacing')

    @property
    def aft_bar(self):
        return self._get(2)
    @aft_bar.setter
    def aft_bar(self, value):
        self.properties.append({'aft_bar': value})
    @aft_bar.deleter
    def aft_bar(self):
        self.delattr('aft_bar')

    @property
    def aft_gutter(self):
        return self._get(3)
    @aft_gutter.setter
    def aft_gutter(self, value):
        self.properties.append({'aft_gutter': value})
    @aft_gutter.deleter
    def aft_gutter(self):
        self.delattr('aft_gutter')

    @property
    def alt(self):
        return self._get(4)
    @alt.setter
    def alt(self, value):
        self.properties.append({'alt': value})
    @alt.deleter
    def alt(self):
        self.delattr('alt')

    @property
    def altruby_style(self):
        return self._get(5)
    @altruby_style.setter
    def altruby_style(self, value):
        self.properties.append({'altruby_style': value})
    @altruby_style.deleter
    def altruby_style(self):
        self.delattr('altruby_style')

    @property
    def antialias(self):
        return self._get(6)
    @antialias.setter
    def antialias(self, value):
        self.properties.append({'antialias': value})
    @antialias.deleter
    def antialias(self):
        self.delattr('antialias')

    @property
    def axis(self):
        return self._get(7)
    @axis.setter
    def axis(self, value):
        self.properties.append({'axis': value})
    @axis.deleter
    def axis(self):
        self.delattr('axis')

    @property
    def background(self):
        return self._get(8)
    @background.setter
    def background(self, value):
        self.properties.append({'background': value})
    @background.deleter
    def background(self):
        self.delattr('background')

    @property
    def bar_invert(self):
        return self._get(9)
    @bar_invert.setter
    def bar_invert(self, value):
        self.properties.append({'bar_invert': value})
    @bar_invert.deleter
    def bar_invert(self):
        self.delattr('bar_invert')

    @property
    def bar_resizing(self):
        return self._get(10)
    @bar_resizing.setter
    def bar_resizing(self, value):
        self.properties.append({'bar_resizing': value})
    @bar_resizing.deleter
    def bar_resizing(self):
        self.delattr('bar_resizing')

    @property
    def bar_vertical(self):
        return self._get(11)
    @bar_vertical.setter
    def bar_vertical(self, value):
        self.properties.append({'bar_vertical': value})
    @bar_vertical.deleter
    def bar_vertical(self):
        self.delattr('bar_vertical')

    @property
    def black_color(self):
        return self._get(12)
    @black_color.setter
    def black_color(self, value):
        self.properties.append({'black_color': value})
    @black_color.deleter
    def black_color(self):
        self.delattr('black_color')

    @property
    def bold(self):
        return self._get(13)
    @bold.setter
    def bold(self, value):
        self.properties.append({'bold': value})
    @bold.deleter
    def bold(self):
        self.delattr('bold')

    @property
    def bottom_margin(self):
        return self._get(14)
    @bottom_margin.setter
    def bottom_margin(self, value):
        self.properties.append({'bottom_margin': value})
    @bottom_margin.deleter
    def bottom_margin(self):
        self.delattr('bottom_margin')

    @property
    def bottom_padding(self):
        return self._get(15)
    @bottom_padding.setter
    def bottom_padding(self, value):
        self.properties.append({'bottom_padding': value})
    @bottom_padding.deleter
    def bottom_padding(self):
        self.delattr('bottom_padding')

    @property
    def box_align(self):
        return self._get(16)
    @box_align.setter
    def box_align(self, value):
        self.properties.append({'box_align': value})
    @box_align.deleter
    def box_align(self):
        self.delattr('box_align')

    @property
    def box_justify(self):
        return self._get(17)
    @box_justify.setter
    def box_justify(self, value):
        self.properties.append({'box_justify': value})
    @box_justify.deleter
    def box_justify(self):
        self.delattr('box_justify')

    @property
    def box_layout(self):
        return self._get(18)
    @box_layout.setter
    def box_layout(self, value):
        self.properties.append({'box_layout': value})
    @box_layout.deleter
    def box_layout(self):
        self.delattr('box_layout')

    @property
    def box_reverse(self):
        return self._get(19)
    @box_reverse.setter
    def box_reverse(self, value):
        self.properties.append({'box_reverse': value})
    @box_reverse.deleter
    def box_reverse(self):
        self.delattr('box_reverse')

    @property
    def box_wrap(self):
        return self._get(20)
    @box_wrap.setter
    def box_wrap(self, value):
        self.properties.append({'box_wrap': value})
    @box_wrap.deleter
    def box_wrap(self):
        self.delattr('box_wrap')

    @property
    def box_wrap_spacing(self):
        return self._get(21)
    @box_wrap_spacing.setter
    def box_wrap_spacing(self, value):
        self.properties.append({'box_wrap_spacing': value})
    @box_wrap_spacing.deleter
    def box_wrap_spacing(self):
        self.delattr('box_wrap_spacing')

    @property
    def caret(self):
        return self._get(22)
    @caret.setter
    def caret(self, value):
        self.properties.append({'caret': value})
    @caret.deleter
    def caret(self):
        self.delattr('caret')

    @property
    def child(self):
        return self._get(23)
    @child.setter
    def child(self, value):
        self.properties.append({'child': value})
    @child.deleter
    def child(self):
        self.delattr('child')

    @property
    def clipping(self):
        return self._get(24)
    @clipping.setter
    def clipping(self, value):
        self.properties.append({'clipping': value})
    @clipping.deleter
    def clipping(self):
        self.delattr('clipping')

    @property
    def color(self):
        return self._get(25)
    @color.setter
    def color(self, value):
        self.properties.append({'color': value})
    @color.deleter
    def color(self):
        self.delattr('color')

    @property
    def debug(self):
        return self._get(26)
    @debug.setter
    def debug(self, value):
        self.properties.append({'debug': value})
    @debug.deleter
    def debug(self):
        self.delattr('debug')

    @property
    def drop_shadow(self):
        return self._get(27)
    @drop_shadow.setter
    def drop_shadow(self, value):
        self.properties.append({'drop_shadow': value})
    @drop_shadow.deleter
    def drop_shadow(self):
        self.delattr('drop_shadow')

    @property
    def drop_shadow_color(self):
        return self._get(28)
    @drop_shadow_color.setter
    def drop_shadow_color(self, value):
        self.properties.append({'drop_shadow_color': value})
    @drop_shadow_color.deleter
    def drop_shadow_color(self):
        self.delattr('drop_shadow_color')

    @property
    def emoji_font(self):
        return self._get(29)
    @emoji_font.setter
    def emoji_font(self, value):
        self.properties.append({'emoji_font': value})
    @emoji_font.deleter
    def emoji_font(self):
        self.delattr('emoji_font')

    @property
    def extra_alt(self):
        return self._get(30)
    @extra_alt.setter
    def extra_alt(self, value):
        self.properties.append({'extra_alt': value})
    @extra_alt.deleter
    def extra_alt(self):
        self.delattr('extra_alt')

    @property
    def first_indent(self):
        return self._get(31)
    @first_indent.setter
    def first_indent(self, value):
        self.properties.append({'first_indent': value})
    @first_indent.deleter
    def first_indent(self):
        self.delattr('first_indent')

    @property
    def first_spacing(self):
        return self._get(32)
    @first_spacing.setter
    def first_spacing(self, value):
        self.properties.append({'first_spacing': value})
    @first_spacing.deleter
    def first_spacing(self):
        self.delattr('first_spacing')

    @property
    def fit_first(self):
        return self._get(33)
    @fit_first.setter
    def fit_first(self, value):
        self.properties.append({'fit_first': value})
    @fit_first.deleter
    def fit_first(self):
        self.delattr('fit_first')

    @property
    def focus_mask(self):
        return self._get(34)
    @focus_mask.setter
    def focus_mask(self, value):
        self.properties.append({'focus_mask': value})
    @focus_mask.deleter
    def focus_mask(self):
        self.delattr('focus_mask')

    @property
    def focus_rect(self):
        return self._get(35)
    @focus_rect.setter
    def focus_rect(self, value):
        self.properties.append({'focus_rect': value})
    @focus_rect.deleter
    def focus_rect(self):
        self.delattr('focus_rect')

    @property
    def font(self):
        return self._get(36)
    @font.setter
    def font(self, value):
        self.properties.append({'font': value})
    @font.deleter
    def font(self):
        self.delattr('font')

    @property
    def font_features(self):
        return self._get(37)
    @font_features.setter
    def font_features(self, value):
        self.properties.append({'font_features': value})
    @font_features.deleter
    def font_features(self):
        self.delattr('font_features')

    @property
    def fore_bar(self):
        return self._get(38)
    @fore_bar.setter
    def fore_bar(self, value):
        self.properties.append({'fore_bar': value})
    @fore_bar.deleter
    def fore_bar(self):
        self.delattr('fore_bar')

    @property
    def fore_gutter(self):
        return self._get(39)
    @fore_gutter.setter
    def fore_gutter(self, value):
        self.properties.append({'fore_gutter': value})
    @fore_gutter.deleter
    def fore_gutter(self):
        self.delattr('fore_gutter')

    @property
    def foreground(self):
        return self._get(40)
    @foreground.setter
    def foreground(self, value):
        self.properties.append({'foreground': value})
    @foreground.deleter
    def foreground(self):
        self.delattr('foreground')

    @property
    def group_alt(self):
        return self._get(41)
    @group_alt.setter
    def group_alt(self, value):
        self.properties.append({'group_alt': value})
    @group_alt.deleter
    def group_alt(self):
        self.delattr('group_alt')

    @property
    def hinting(self):
        return self._get(42)
    @hinting.setter
    def hinting(self, value):
        self.properties.append({'hinting': value})
    @hinting.deleter
    def hinting(self):
        self.delattr('hinting')

    @property
    def hover_sound(self):
        return self._get(43)
    @hover_sound.setter
    def hover_sound(self, value):
        self.properties.append({'hover_sound': value})
    @hover_sound.deleter
    def hover_sound(self):
        self.delattr('hover_sound')

    @property
    def hyperlink_functions(self):
        return self._get(44)
    @hyperlink_functions.setter
    def hyperlink_functions(self, value):
        self.properties.append({'hyperlink_functions': value})
    @hyperlink_functions.deleter
    def hyperlink_functions(self):
        self.delattr('hyperlink_functions')

    @property
    def instance(self):
        return self._get(45)
    @instance.setter
    def instance(self, value):
        self.properties.append({'instance': value})
    @instance.deleter
    def instance(self):
        self.delattr('instance')

    @property
    def italic(self):
        return self._get(46)
    @italic.setter
    def italic(self, value):
        self.properties.append({'italic': value})
    @italic.deleter
    def italic(self):
        self.delattr('italic')

    @property
    def justify(self):
        return self._get(47)
    @justify.setter
    def justify(self, value):
        self.properties.append({'justify': value})
    @justify.deleter
    def justify(self):
        self.delattr('justify')

    @property
    def kerning(self):
        return self._get(48)
    @kerning.setter
    def kerning(self, value):
        self.properties.append({'kerning': value})
    @kerning.deleter
    def kerning(self):
        self.delattr('kerning')

    @property
    def key_events(self):
        return self._get(49)
    @key_events.setter
    def key_events(self, value):
        self.properties.append({'key_events': value})
    @key_events.deleter
    def key_events(self):
        self.delattr('key_events')

    @property
    def keyboard_focus(self):
        return self._get(50)
    @keyboard_focus.setter
    def keyboard_focus(self, value):
        self.properties.append({'keyboard_focus': value})
    @keyboard_focus.deleter
    def keyboard_focus(self):
        self.delattr('keyboard_focus')

    @property
    def keyboard_focus_insets(self):
        return self._get(51)
    @keyboard_focus_insets.setter
    def keyboard_focus_insets(self, value):
        self.properties.append({'keyboard_focus_insets': value})
    @keyboard_focus_insets.deleter
    def keyboard_focus_insets(self):
        self.delattr('keyboard_focus_insets')

    @property
    def language(self):
        return self._get(52)
    @language.setter
    def language(self, value):
        self.properties.append({'language': value})
    @language.deleter
    def language(self):
        self.delattr('language')

    @property
    def layout(self):
        return self._get(53)
    @layout.setter
    def layout(self, value):
        self.properties.append({'layout': value})
    @layout.deleter
    def layout(self):
        self.delattr('layout')

    @property
    def left_margin(self):
        return self._get(54)
    @left_margin.setter
    def left_margin(self, value):
        self.properties.append({'left_margin': value})
    @left_margin.deleter
    def left_margin(self):
        self.delattr('left_margin')

    @property
    def left_padding(self):
        return self._get(55)
    @left_padding.setter
    def left_padding(self, value):
        self.properties.append({'left_padding': value})
    @left_padding.deleter
    def left_padding(self):
        self.delattr('left_padding')

    @property
    def line_leading(self):
        return self._get(56)
    @line_leading.setter
    def line_leading(self, value):
        self.properties.append({'line_leading': value})
    @line_leading.deleter
    def line_leading(self):
        self.delattr('line_leading')

    @property
    def line_overlap_split(self):
        return self._get(57)
    @line_overlap_split.setter
    def line_overlap_split(self, value):
        self.properties.append({'line_overlap_split': value})
    @line_overlap_split.deleter
    def line_overlap_split(self):
        self.delattr('line_overlap_split')

    @property
    def line_spacing(self):
        return self._get(58)
    @line_spacing.setter
    def line_spacing(self, value):
        self.properties.append({'line_spacing': value})
    @line_spacing.deleter
    def line_spacing(self):
        self.delattr('line_spacing')

    @property
    def min_width(self):
        return self._get(59)
    @min_width.setter
    def min_width(self, value):
        self.properties.append({'min_width': value})
    @min_width.deleter
    def min_width(self):
        self.delattr('min_width')

    @property
    def mipmap(self):
        return self._get(60)
    @mipmap.setter
    def mipmap(self, value):
        self.properties.append({'mipmap': value})
    @mipmap.deleter
    def mipmap(self):
        self.delattr('mipmap')

    @property
    def modal(self):
        return self._get(61)
    @modal.setter
    def modal(self, value):
        self.properties.append({'modal': value})
    @modal.deleter
    def modal(self):
        self.delattr('modal')

    @property
    def mouse(self):
        return self._get(62)
    @mouse.setter
    def mouse(self, value):
        self.properties.append({'mouse': value})
    @mouse.deleter
    def mouse(self):
        self.delattr('mouse')

    @property
    def newline_indent(self):
        return self._get(63)
    @newline_indent.setter
    def newline_indent(self, value):
        self.properties.append({'newline_indent': value})
    @newline_indent.deleter
    def newline_indent(self):
        self.delattr('newline_indent')

    @property
    def order_reverse(self):
        return self._get(64)
    @order_reverse.setter
    def order_reverse(self, value):
        self.properties.append({'order_reverse': value})
    @order_reverse.deleter
    def order_reverse(self):
        self.delattr('order_reverse')

    @property
    def outline_scaling(self):
        return self._get(65)
    @outline_scaling.setter
    def outline_scaling(self, value):
        self.properties.append({'outline_scaling': value})
    @outline_scaling.deleter
    def outline_scaling(self):
        self.delattr('outline_scaling')

    @property
    def outlines(self):
        return self._get(66)
    @outlines.setter
    def outlines(self, value):
        self.properties.append({'outlines': value})
    @outlines.deleter
    def outlines(self):
        self.delattr('outlines')

    @property
    def prefer_emoji(self):
        return self._get(67)
    @prefer_emoji.setter
    def prefer_emoji(self, value):
        self.properties.append({'prefer_emoji': value})
    @prefer_emoji.deleter
    def prefer_emoji(self):
        self.delattr('prefer_emoji')

    @property
    def reading_order(self):
        return self._get(68)
    @reading_order.setter
    def reading_order(self, value):
        self.properties.append({'reading_order': value})
    @reading_order.deleter
    def reading_order(self):
        self.delattr('reading_order')

    @property
    def rest_indent(self):
        return self._get(69)
    @rest_indent.setter
    def rest_indent(self, value):
        self.properties.append({'rest_indent': value})
    @rest_indent.deleter
    def rest_indent(self):
        self.delattr('rest_indent')

    @property
    def right_margin(self):
        return self._get(70)
    @right_margin.setter
    def right_margin(self, value):
        self.properties.append({'right_margin': value})
    @right_margin.deleter
    def right_margin(self):
        self.delattr('right_margin')

    @property
    def right_padding(self):
        return self._get(71)
    @right_padding.setter
    def right_padding(self, value):
        self.properties.append({'right_padding': value})
    @right_padding.deleter
    def right_padding(self):
        self.delattr('right_padding')

    @property
    def ruby_line_leading(self):
        return self._get(72)
    @ruby_line_leading.setter
    def ruby_line_leading(self, value):
        self.properties.append({'ruby_line_leading': value})
    @ruby_line_leading.deleter
    def ruby_line_leading(self):
        self.delattr('ruby_line_leading')

    @property
    def ruby_style(self):
        return self._get(73)
    @ruby_style.setter
    def ruby_style(self, value):
        self.properties.append({'ruby_style': value})
    @ruby_style.deleter
    def ruby_style(self):
        self.delattr('ruby_style')

    @property
    def shaper(self):
        return self._get(74)
    @shaper.setter
    def shaper(self, value):
        self.properties.append({'shaper': value})
    @shaper.deleter
    def shaper(self):
        self.delattr('shaper')

    @property
    def size(self):
        return self._get(75)
    @size.setter
    def size(self, value):
        self.properties.append({'size': value})
    @size.deleter
    def size(self):
        self.delattr('size')

    @property
    def size_group(self):
        return self._get(76)
    @size_group.setter
    def size_group(self, value):
        self.properties.append({'size_group': value})
    @size_group.deleter
    def size_group(self):
        self.delattr('size_group')

    @property
    def slow_abortable(self):
        return self._get(77)
    @slow_abortable.setter
    def slow_abortable(self, value):
        self.properties.append({'slow_abortable': value})
    @slow_abortable.deleter
    def slow_abortable(self):
        self.delattr('slow_abortable')

    @property
    def slow_cps(self):
        return self._get(78)
    @slow_cps.setter
    def slow_cps(self, value):
        self.properties.append({'slow_cps': value})
    @slow_cps.deleter
    def slow_cps(self):
        self.delattr('slow_cps')

    @property
    def slow_cps_multiplier(self):
        return self._get(79)
    @slow_cps_multiplier.setter
    def slow_cps_multiplier(self, value):
        self.properties.append({'slow_cps_multiplier': value})
    @slow_cps_multiplier.deleter
    def slow_cps_multiplier(self):
        self.delattr('slow_cps_multiplier')

    @property
    def spacing(self):
        return self._get(80)
    @spacing.setter
    def spacing(self, value):
        self.properties.append({'spacing': value})
    @spacing.deleter
    def spacing(self):
        self.delattr('spacing')

    @property
    def strikethrough(self):
        return self._get(81)
    @strikethrough.setter
    def strikethrough(self, value):
        self.properties.append({'strikethrough': value})
    @strikethrough.deleter
    def strikethrough(self):
        self.delattr('strikethrough')

    @property
    def subpixel(self):
        return self._get(82)
    @subpixel.setter
    def subpixel(self, value):
        self.properties.append({'subpixel': value})
    @subpixel.deleter
    def subpixel(self):
        self.delattr('subpixel')

    @property
    def subtitle_width(self):
        return self._get(83)
    @subtitle_width.setter
    def subtitle_width(self, value):
        self.properties.append({'subtitle_width': value})
    @subtitle_width.deleter
    def subtitle_width(self):
        self.delattr('subtitle_width')

    @property
    def text_align(self):
        return self._get(84)
    @text_align.setter
    def text_align(self, value):
        self.properties.append({'text_align': value})
    @text_align.deleter
    def text_align(self):
        self.delattr('text_align')

    @property
    def text_y_fudge(self):
        return self._get(85)
    @text_y_fudge.setter
    def text_y_fudge(self, value):
        self.properties.append({'text_y_fudge': value})
    @text_y_fudge.deleter
    def text_y_fudge(self):
        self.delattr('text_y_fudge')

    @property
    def textshader(self):
        return self._get(86)
    @textshader.setter
    def textshader(self, value):
        self.properties.append({'textshader': value})
    @textshader.deleter
    def textshader(self):
        self.delattr('textshader')

    @property
    def thumb(self):
        return self._get(87)
    @thumb.setter
    def thumb(self, value):
        self.properties.append({'thumb': value})
    @thumb.deleter
    def thumb(self):
        self.delattr('thumb')

    @property
    def thumb_align(self):
        return self._get(88)
    @thumb_align.setter
    def thumb_align(self, value):
        self.properties.append({'thumb_align': value})
    @thumb_align.deleter
    def thumb_align(self):
        self.delattr('thumb_align')

    @property
    def thumb_offset(self):
        return self._get(89)
    @thumb_offset.setter
    def thumb_offset(self, value):
        self.properties.append({'thumb_offset': value})
    @thumb_offset.deleter
    def thumb_offset(self):
        self.delattr('thumb_offset')

    @property
    def thumb_shadow(self):
        return self._get(90)
    @thumb_shadow.setter
    def thumb_shadow(self, value):
        self.properties.append({'thumb_shadow': value})
    @thumb_shadow.deleter
    def thumb_shadow(self):
        self.delattr('thumb_shadow')

    @property
    def time_policy(self):
        return self._get(91)
    @time_policy.setter
    def time_policy(self, value):
        self.properties.append({'time_policy': value})
    @time_policy.deleter
    def time_policy(self):
        self.delattr('time_policy')

    @property
    def top_margin(self):
        return self._get(92)
    @top_margin.setter
    def top_margin(self, value):
        self.properties.append({'top_margin': value})
    @top_margin.deleter
    def top_margin(self):
        self.delattr('top_margin')

    @property
    def top_padding(self):
        return self._get(93)
    @top_padding.setter
    def top_padding(self, value):
        self.properties.append({'top_padding': value})
    @top_padding.deleter
    def top_padding(self):
        self.delattr('top_padding')

    @property
    def underline(self):
        return self._get(94)
    @underline.setter
    def underline(self, value):
        self.properties.append({'underline': value})
    @underline.deleter
    def underline(self):
        self.delattr('underline')

    @property
    def unscrollable(self):
        return self._get(95)
    @unscrollable.setter
    def unscrollable(self, value):
        self.properties.append({'unscrollable': value})
    @unscrollable.deleter
    def unscrollable(self):
        self.delattr('unscrollable')

    @property
    def vertical(self):
        return self._get(96)
    @vertical.setter
    def vertical(self, value):
        self.properties.append({'vertical': value})
    @vertical.deleter
    def vertical(self):
        self.delattr('vertical')

    @property
    def xanchor(self):
        return self._get(97)
    @xanchor.setter
    def xanchor(self, value):
        self.properties.append({'xanchor': value})
    @xanchor.deleter
    def xanchor(self):
        self.delattr('xanchor')

    @property
    def xfill(self):
        return self._get(98)
    @xfill.setter
    def xfill(self, value):
        self.properties.append({'xfill': value})
    @xfill.deleter
    def xfill(self):
        self.delattr('xfill')

    @property
    def xfit(self):
        return self._get(99)
    @xfit.setter
    def xfit(self, value):
        self.properties.append({'xfit': value})
    @xfit.deleter
    def xfit(self):
        self.delattr('xfit')

    @property
    def xmaximum(self):
        return self._get(100)
    @xmaximum.setter
    def xmaximum(self, value):
        self.properties.append({'xmaximum': value})
    @xmaximum.deleter
    def xmaximum(self):
        self.delattr('xmaximum')

    @property
    def xminimum(self):
        return self._get(101)
    @xminimum.setter
    def xminimum(self, value):
        self.properties.append({'xminimum': value})
    @xminimum.deleter
    def xminimum(self):
        self.delattr('xminimum')

    @property
    def xoffset(self):
        return self._get(102)
    @xoffset.setter
    def xoffset(self, value):
        self.properties.append({'xoffset': value})
    @xoffset.deleter
    def xoffset(self):
        self.delattr('xoffset')

    @property
    def xpos(self):
        return self._get(103)
    @xpos.setter
    def xpos(self, value):
        self.properties.append({'xpos': value})
    @xpos.deleter
    def xpos(self):
        self.delattr('xpos')

    @property
    def xspacing(self):
        return self._get(104)
    @xspacing.setter
    def xspacing(self, value):
        self.properties.append({'xspacing': value})
    @xspacing.deleter
    def xspacing(self):
        self.delattr('xspacing')

    @property
    def yanchor(self):
        return self._get(105)
    @yanchor.setter
    def yanchor(self, value):
        self.properties.append({'yanchor': value})
    @yanchor.deleter
    def yanchor(self):
        self.delattr('yanchor')

    @property
    def yfill(self):
        return self._get(106)
    @yfill.setter
    def yfill(self, value):
        self.properties.append({'yfill': value})
    @yfill.deleter
    def yfill(self):
        self.delattr('yfill')

    @property
    def yfit(self):
        return self._get(107)
    @yfit.setter
    def yfit(self, value):
        self.properties.append({'yfit': value})
    @yfit.deleter
    def yfit(self):
        self.delattr('yfit')

    @property
    def ymaximum(self):
        return self._get(108)
    @ymaximum.setter
    def ymaximum(self, value):
        self.properties.append({'ymaximum': value})
    @ymaximum.deleter
    def ymaximum(self):
        self.delattr('ymaximum')

    @property
    def yminimum(self):
        return self._get(109)
    @yminimum.setter
    def yminimum(self, value):
        self.properties.append({'yminimum': value})
    @yminimum.deleter
    def yminimum(self):
        self.delattr('yminimum')

    @property
    def yoffset(self):
        return self._get(110)
    @yoffset.setter
    def yoffset(self, value):
        self.properties.append({'yoffset': value})
    @yoffset.deleter
    def yoffset(self):
        self.delattr('yoffset')

    @property
    def ypos(self):
        return self._get(111)
    @ypos.setter
    def ypos(self, value):
        self.properties.append({'ypos': value})
    @ypos.deleter
    def ypos(self):
        self.delattr('ypos')

    @property
    def yspacing(self):
        return self._get(112)
    @yspacing.setter
    def yspacing(self, value):
        self.properties.append({'yspacing': value})
    @yspacing.deleter
    def yspacing(self):
        self.delattr('yspacing')

