Method wrap_text

src/engine.rs:3400–3515

(&mut self)

    }

    fn wrap_text(&mut self) {
        for text_idx in 0..self.text_element_data.len() {
            let elem_index = self.text_element_data[text_idx].element_index as usize;
            let text = self.text_element_data[text_idx].text.clone();
            let preferred_dims = self.text_element_data[text_idx].preferred_dimensions;

            self.text_element_data[text_idx].wrapped_lines_start = self.wrapped_text_lines.len();
            self.text_element_data[text_idx].wrapped_lines_length = 0;

            let container_width = self.layout_elements[elem_index].dimensions.width;

            // Find text config
            let text_config_idx = self
                .find_element_config_index(elem_index, ElementConfigType::Text)
                .unwrap_or(0);
            let text_config = self.text_element_configs[text_config_idx].clone();

            let measured = self.measure_text_cached(&text, &text_config);

            let line_height = if text_config.line_height > 0 {
                text_config.line_height as f32
            } else {
                preferred_dims.height
            };

            if !measured.contains_newlines && preferred_dims.width <= container_width {
                // Single line
                self.wrapped_text_lines.push(WrappedTextLine {
                    dimensions: self.layout_elements[elem_index].dimensions,
                    start: 0,
                    length: text.len(),
                });
                self.text_element_data[text_idx].wrapped_lines_length = 1;
                continue;
            }

            // Multi-line wrapping
            let measure_fn = self.measure_text_fn.as_ref().unwrap();
            let space_width = {
                let space_config = text_config.clone();
                measure_fn(" ", &space_config).width
            };

            let mut word_index = measured.measured_words_start_index;
            let mut line_width: f32 = 0.0;
            let mut line_length_chars: i32 = 0;
            let mut line_start_offset: i32 = 0;

            while word_index != -1 {
                let measured_word = self.measured_words[word_index as usize];

                // Word doesn't fit but it's the only word on the line
                if line_length_chars == 0 && line_width + measured_word.width > container_width {
                    self.wrapped_text_lines.push(WrappedTextLine {
                        dimensions: Dimensions::new(measured_word.width, line_height),
                        start: measured_word.start_offset as usize,
                        length: measured_word.length as usize,
                    });