📝 External Standards Integration¶

# Pango Markup integration in Designer Bot
class PangoTextRenderer:
    def __init__(self):
        self.markup_parser = PangoMarkupParser()
        self.font_manager = FontManager()

    def render_text_with_markup(self, text_content, canvas):
        """Render text using Pango Markup"""

        # Parse markup
        parsed_markup = self.markup_parser.parse(text_content.markup)

        # Create Pango layout
        layout = canvas.create_pango_layout()

        # Apply markup
        layout.set_markup(parsed_markup)

        # Set font
        if text_content.font_family:
            font_desc = Pango.FontDescription.from_string(
                f"{text_content.font_family} {text_content.font_size}pt"
            )
            layout.set_font_description(font_desc)

        # Render to canvas
        canvas.show_layout(layout)

        return layout

    def convert_to_pango_markup(self, designer_bot_text):
        """Convert Designer Bot text to Pango Markup"""
        markup_parts = []

        for segment in designer_bot_text.segments:
            attributes = []

            if segment.bold:
                attributes.append('weight="bold"')
            if segment.italic:
                attributes.append('style="italic"')
            if segment.underline:
                attributes.append('underline="single"')
            if segment.color:
                attributes.append(f'foreground="{segment.color}"')
            if segment.font_size:
                attributes.append(f'size="{segment.font_size}pt"')

            if attributes:
                markup_parts.append(f'<span {" ".join(attributes)}>{segment.text}</span>')
            else:
                markup_parts.append(segment.text)

        return ''.join(markup_parts)

class TextLayoutEngine:
    def __init__(self):
        self.pango_context = None
        self.font_map = None

    def setup_pango_context(self, canvas):
        """Setup Pango context for text rendering"""
        self.pango_context = canvas.get_pango_context()
        self.font_map = self.pango_context.get_font_map()

        # Configure font options
        font_options = cairo.FontOptions()
        font_options.set_antialias(cairo.ANTIALIAS_SUBPIXEL)
        font_options.set_hint_style(cairo.HINT_STYLE_FULL)
        self.pango_context.set_font_options(font_options)

    def measure_text(self, text, font_description):
        """Measure text dimensions"""
        layout = self.pango_context.create_layout()
        layout.set_font_description(font_description)
        layout.set_text(text)

        width, height = layout.get_pixel_size()
        return width, height

    def wrap_text(self, text, width, font_description):
        """Wrap text to fit within specified width"""
        layout = self.pango_context.create_layout()
        layout.set_font_description(font_description)
        layout.set_text(text)
        layout.set_width(width * Pango.SCALE)
        layout.set_wrap(Pango.WrapMode.WORD)

        return layout

class StandardsConverter:
    def __init__(self):
        self.lottie_converter = LottieConverter()
        self.pango_renderer = PangoTextRenderer()
        self.validation_engine = ValidationEngine()

    def convert_to_lottie(self, designer_bot_json):
        """Convert Designer Bot JSON to Lottie format"""
        try:
            # Validate input
            self.validation_engine.validate_designer_bot_json(designer_bot_json)

            # Convert to Lottie
            lottie_json = self.lottie_converter.convert(designer_bot_json)

            # Validate output
            self.validation_engine.validate_lottie_json(lottie_json)

            return lottie_json

        except ValidationError as e:
            raise ConversionError(f"Validation failed: {e}")
        except Exception as e:
            raise ConversionError(f"Conversion failed: {e}")

    def convert_from_lottie(self, lottie_json):
        """Convert Lottie JSON to Designer Bot format"""
        try:
            # Validate input
            self.validation_engine.validate_lottie_json(lottie_json)

            # Convert to Designer Bot
            designer_bot_json = self.lottie_converter.convert_from_lottie(lottie_json)

            # Validate output
            self.validation_engine.validate_designer_bot_json(designer_bot_json)

            return designer_bot_json

        except ValidationError as e:
            raise ConversionError(f"Validation failed: {e}")
        except Exception as e:
            raise ConversionError(f"Conversion failed: {e}")

class ValidationEngine:
    def __init__(self):
        self.lottie_schema = self.load_lottie_schema()
        self.designer_bot_schema = self.load_designer_bot_schema()

    def validate_lottie_json(self, lottie_json):
        """Validate Lottie JSON against schema"""
        try:
            jsonschema.validate(lottie_json, self.lottie_schema)
        except jsonschema.ValidationError as e:
            raise ValidationError(f"Lottie validation failed: {e.message}")

    def validate_designer_bot_json(self, designer_bot_json):
        """Validate Designer Bot JSON against schema"""
        try:
            jsonschema.validate(designer_bot_json, self.designer_bot_schema)
        except jsonschema.ValidationError as e:
            raise ValidationError(f"Designer Bot validation failed: {e.message}")

    def validate_conversion_accuracy(self, original, converted):
        """Validate that conversion preserves essential properties"""
        # Check composition properties
        assert original.composition.width == converted.composition.width
        assert original.composition.height == converted.composition.height
        assert original.composition.frame_rate == converted.composition.frame_rate

        # Check layer count
        assert len(original.layers) == len(converted.layers)

        # Check asset count
        assert len(original.assets) == len(converted.assets)

class PlatformOptimizer:
    def optimize_for_web(self, lottie_data):
        """Optimize Lottie for web performance"""
        # Reduce keyframe density
        optimized_data = self.reduce_keyframes(lottie_data, factor=0.5)

        # Compress assets
        optimized_data = self.compress_assets(optimized_data)

        # Simplify shapes
        optimized_data = self.simplify_shapes(optimized_data)

        return optimized_data

    def optimize_for_mobile(self, lottie_data):
        """Optimize Lottie for mobile performance"""
        # Further reduce complexity
        optimized_data = self.reduce_keyframes(lottie_data, factor=0.3)

        # Use smaller assets
        optimized_data = self.resize_assets(optimized_data, max_size=512)

        # Limit animation duration
        optimized_data = self.limit_duration(optimized_data, max_duration=5.0)

        return optimized_data