Editor

use editor::Editor;

editor::init(cx);   // once, at startup

let scroll = ScrollHandle::new();
let editor = cx.new({
    let scroll = scroll.clone();
    |cx| Editor::new("# Notes", cx).with_scroll(scroll)
});
cx.observe(&editor, |_, _, cx| cx.notify()).detach();

let formatting = editor.read(cx).formatting();

let lit = formatting.marks.contains(&mark);          // and cmd-B before typing counts
let label = formatting.block.clone();                // "Heading 2", for a dropdown
let fence = formatting.fenceable;                    // cmd-E would make a fence, not a span
let bar = formatting.mode == editor::Mode::Blocks;   // the source has nothing to light

editor.update(cx, |editor, cx| editor.toggle_mark(mark, cx));

for (label, kind) in editor::turns() {
    let lit = formatting.block.as_ref() == Some(&label);
    // …and on click: editor.update(cx, |editor, cx| editor.set_block(ix, kind.clone(), cx));
}

editor.update(cx, |editor, cx| editor.toggle_source(cx));

use editor::AppExt as _;
cx.set_image_store(editor::ImageStore {
    keep: |source, _editor, _base, _cx| match source {
        editor::Source::File(path) => Some(path.to_string_lossy().into_owned()),
        editor::Source::Bytes(image) => save_somewhere(image),  // your assets, your URL
    },
    ..Default::default()
});

Editor::new(source, cx)
    .with_image_overlay(Rc::new(|block, url, window, cx| {
        Some(open_image_button(block, url, window, cx).into_any_element())
    }))
    .with_image_overlay_corner(markdown::ImageOverlayCorner::TopRight)

use editor::{AppExt as _, PasteContent};

cx.set_paste_handler(|item, _editor, _destination, _cx| {
    item.text().map(PasteContent::Literal)
});

impl Editor {
    pub fn new(source: &str, cx: &mut Context<Self>) -> Self;

    /// The scroll handle of the pane the document sits in, not one of the
    /// editor's own, or the caret cannot follow typing down the page.
    pub fn with_scroll(self, handle: gpui::ScrollHandle) -> Self;

    /// The document written back to markdown, normalized, on every keystroke —
    /// in either mode, so a save needs no branch.
    pub fn source(&self) -> String;

    /// One read rather than four: a bar answering half its questions from this
    /// frame and half from the last lights the wrong button for a frame.
    pub fn formatting(&self) -> Formatting;

    /// The same entry point cmd-B takes, so a button and a chord cannot
    /// disagree.
    pub fn toggle_mark(&mut self, mark: Mark, cx: &mut Context<Self>);

    pub fn set_block(&mut self, ix: usize, kind: BlockKind, cx: &mut Context<Self>);

    /// Check or uncheck a task block. A press on the box already calls this;
    /// the caret does not move, and one toggle is one undo step.
    pub fn toggle_task(&mut self, ix: usize, cx: &mut Context<Self>);

    // The trigger is yours to place, name and bind. `EditorEvent::ModeChanged`
    // hears about a switch you did not make.
    pub fn mode(&self) -> Mode;
    pub fn set_mode(&mut self, mode: Mode, cx: &mut Context<Self>);
    pub fn toggle_source(&mut self, cx: &mut Context<Self>);

    /// Turns the library's own affordances off where an app puts its own in
    /// the same place.
    pub fn with_chrome(self, chrome: Chrome) -> Self;

    /// One editor's own dialect, rather than the one `markdown::AppExt::set_marks`
    /// installed.
    pub fn with_marks(self, marks: markdown::Marks) -> Self;

    /// Default 100, coalesced so a run of typing comes back as a word. Undo
    /// crosses a mode switch and carries the mode with it.
    pub fn with_undo_limit(self, limit: usize) -> Self;

    /// Where everything landed last frame — `block_bounds`, `picture_bounds`,
    /// `language_bounds`, `checkbox_bounds`, `hit`, and `rects(selection)` for
    /// the painted rows of a range.
    pub fn layouts(&self) -> &BlockLayouts;

    // ...
}

// editor

/// The block vocabulary the slash and block menus offer, to pair with
/// `set_block`.
pub fn turns() -> Vec<(SharedString, BlockKind)>;

pub trait AppExt {
    fn set_image_store(&mut self, store: ImageStore);
    fn image_store(&self) -> ImageStore;
    fn set_paste_handler(&mut self, handler: PasteHandler);
}