You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: welcome_section.rs
    path of file: ./repos/rerun/crates/re_viewer/src/ui/welcome_screen
    
    the code of the file until where you have to start completion: use super::{large_text_button, url_large_text_button};
use egui::{NumExt, Ui};
use re_entity_db::EntityDb;
use re_log_types::{
    DataRow, EntityPath, LogMsg, RowId, StoreId, StoreInfo, StoreKind, StoreSource, Time, TimePoint,
};
use re_smart_channel::ReceiveSet;
use re_ui::UICommandSender;
use re_viewer_context::CommandSender;
use re_viewer_context::{SystemCommand, SystemCommandSender};

const SPACE_VIEWS_HELP: &str = "https://www.rerun.io/docs/getting-started/viewer-walkthrough";

const CPP_CONNECT_MARKDOWN: &str = include_str!("../../../data/quick_start_guides/cpp_connect.md");
const CPP_SPAWN_MARKDOWN: &str = include_str!("../../../data/quick_start_guides/cpp_spawn.md");
const PYTHON_CONNECT_MARKDOWN: &str =
    include_str!("../../../data/quick_start_guides/python_connect.md");
const PYTHON_SPAWN_MARKDOWN: &str =
    include_str!("../../../data/quick_start_guides/python_spawn.md");
const RUST_CONNECT_MARKDOWN: &str =
    include_str!("../../../data/quick_start_guides/rust_connect.md");
const RUST_SPAWN_MARKDOWN: &str = include_str!("../../../data/quick_start_guides/rust_spawn.md");
const HOW_DOES_IT_WORK_MARKDOWN: &str =
    include_str!("../../../data/quick_start_guides/how_does_it_work.md");

const CPP_CONNECT_CODE_EXAMPLE: &str =
    include_str!("../../../data/quick_start_guides/quick_start_connect.cpp");
const CPP_SPAWN_CODE_EXAMPLE: &str =
    include_str!("../../../data/quick_start_guides/quick_start_spawn.cpp");
const PYTHON_CONNECT_CODE_EXAMPLE: &str =
    include_str!("../../../data/quick_start_guides/quick_start_connect.py");
const PYTHON_SPAWN_CODE_EXAMPLE: &str =
    include_str!("../../../data/quick_start_guides/quick_start_spawn.py");
const RUST_CONNECT_CODE_EXAMPLE: &str =
    include_str!("../../../data/quick_start_guides/quick_start_connect.rs");
const RUST_SPAWN_CODE_EXAMPLE: &str =
    include_str!("../../../data/quick_start_guides/quick_start_spawn.rs");

struct Placeholder<'a> {
    key: &'a str,
    value: &'a str,
}

const PLACEHOLDERS: &[Placeholder<'_>] = &[
    Placeholder {
        key: "HOW_DOES_IT_WORK",
        value: HOW_DOES_IT_WORK_MARKDOWN,
    },
    Placeholder {
        key: "EXAMPLE_CODE_CPP_CONNECT",
        value: CPP_CONNECT_CODE_EXAMPLE,
    },
    Placeholder {
        key: "EXAMPLE_CODE_CPP_SPAWN",
        value: CPP_SPAWN_CODE_EXAMPLE,
    },
    Placeholder {
        key: "EXAMPLE_CODE_PYTHON_CONNECT",
        value: PYTHON_CONNECT_CODE_EXAMPLE,
    },
    Placeholder {
        key: "EXAMPLE_CODE_PYTHON_SPAWN",
        value: PYTHON_SPAWN_CODE_EXAMPLE,
    },
    Placeholder {
        key: "EXAMPLE_CODE_RUST_CONNECT",
        value: RUST_CONNECT_CODE_EXAMPLE,
    },
    Placeholder {
        key: "EXAMPLE_CODE_RUST_SPAWN",
        value: RUST_SPAWN_CODE_EXAMPLE,
    },
];

struct QuickStartEntry<'a> {
    entity_path: &'a str,
    markdown: &'a str,
}

const QUICK_START_ENTRIES_CONNECT: &[QuickStartEntry<'_>] = &[
    QuickStartEntry {
        entity_path: "quick_start/cpp",
        markdown: CPP_CONNECT_MARKDOWN,
    },
    QuickStartEntry {
        entity_path: "quick_start/python",
        markdown: PYTHON_CONNECT_MARKDOWN,
    },
    QuickStartEntry {
       
    
fn onboarding_content_ui(ui: &mut Ui, command_sender: &CommandSender, accepts_connections: bool) {
    // The panel data is stored in this ad hoc structure such that it can easily be iterated over
    // in chunks, to make the layout grid code simpler.
    let panels = [
        Panel {
            title: "Connect to live data",
            body: "Use the Rerun SDK to stream data from your code to the Rerun Viewer. \
                Visualize synchronized data from multiple processes, locally or over a network.",
            image: &re_ui::icons::WELCOME_SCREEN_LIVE_DATA,
            add_buttons: Box::new(move |ui, command_sender| {
                if large_text_button(ui, "Quick Start").clicked() {
                    let entries = if accepts_connections {
                        QUICK_START_ENTRIES_CONNECT
                    } else {
                        QUICK_START_ENTRIES_SPAWN
                    };

                    if let Err(err) = open_quick_start(command_sender, entries, PLACEHOLDERS) {
                        re_log::error!("Failed to load quick start: {}", err);
                    }
                }
            }),
        },
        Panel {
            title: "Load recorded data",
            body:
                "Open and visualize recorded data from previous Rerun sessions (.rrd) as well as \
                data in other formats like .gltf and .jpg. Files can be local or remote.",
            image: &re_ui::icons::WELCOME_SCREEN_RECORDED_DATA,
            add_buttons: Box::new(|ui, command_sender| {
                if large_text_button(ui, "Open fileâ€¦").clicked() {
                    command_sender.send_ui(re_ui::UICommand::Open);
                }
            }),
        },
        Panel {
            title: "Build your views",
            body: "Add and rearrange views. Configure what data is shown and how. Design \
                interactively in the viewer or (coming soon) directly from code in the SDK.",
            image: &re_ui::icons::WELCOME_SCREEN_CONFIGURE,
            add_buttons: Box::new(|ui, _| {
                url_large_text_button(ui, "Learn about Views", SPACE_VIEWS_HELP);
            }),
        },
    ];

    // Shrink images if needed so user can see all the content buttons
    let max_image_height = ui.available_height() - 300.0;

    let panel_count = panels.len();

    const MAX_COLUMN_WIDTH: f32 = 280.0;
    const MIN_COLUMN_WIDTH: f32 = 164.0;

    let grid_spacing = egui::vec2(12.0, 16.0);

    let column_count = (((ui.available_width() + grid_spacing.x)
        / (MIN_COLUMN_WIDTH + grid_spacing.x))
        .floor() as usize)
        .clamp(1, panels.len());

    let column_width = ((ui.available_width() + grid_spacing.x) / column_count as f32
        - grid_spacing.x)
        .floor()
        .at_most(MAX_COLUMN_WIDTH);

    ui.horizontal(|ui| {
        ui.vertical_centered(|ui| {
            ui.add(egui::Label::new(
                egui::RichText::new("Welcome")
                    .strong()
                    .line_height(Some(32.0))
                    .text_style(re_ui::ReUi::welcome_screen_h1()),
            ))
        });
    });
    ui.end_row();

    ui.horizontal(|ui| {
        // this space is added on the left so that the grid is centered
        let centering_hspace = (ui.available_width()
            - column_count as f32 * column_width
            - (column_count - 1) as f32 * grid_spacing.x)
            / 2.0;
        ui.add_space(centering_hspace.at_least(0.0));

        ui.vertical(|ui| {
            ui.add_space(32.0);

            let grid = egui::Grid::new("welcome_section_grid")
                .spacing(grid_spacing)
                .min_col_width(column_width)
                .max_col_width(column_width);

            grid.show(ui, |ui| {
                for panels in panels.chunks(column_count) {
                    if column_count == panel_count {
                        for panel in panels {
                            image_banner(ui, panel.image, column_width, max_image_height);
                        }
                    } else {
                        for _ in panels {
                            ui.vertical(|ui| {
                                ui.add_space(20.0);
                            });
                        }
                    }

                    ui.end_row();

                    for panel in panels {
                        ui.vertical(|ui| {
                            // don't let the text get too close to the right-hand content
                            ui.set_max_width(column_width - 8.0);

                            ui.label(
                                egui::RichText::new(panel.title)
                                    .strong()
                                    .text_style(re_ui::ReUi::welcome_screen_h3()),
                            );
                            ui.label(egui::RichText::new(panel.body).line_height(Some(19.0)));
                            ui.horizontal(|ui| {
                                ui.spacing_mut().item_spacing.x = 4.0;
                                (panel.add_buttons)(ui, command_sender);
                            });
                        });
                    }

                    ui.end_row();
                }
            });
        });
    });
}