pattypan = { git = "https://git.bendn.org/pattypan" }

implicit-fn = "0.1.0"

ropey = "1.6.1"

winit = "0.31.0-beta.2"

amap = "0.1.4"

run_times = "0.1.0"

array_chunks = "1.0.0"

rust-fsm = { git = "https://git.bendn.org/rust-fsm", features = ["diagram"] }

tree-house = { version = "0.3.0", features = ["fixtures"] }

# for tree house grammar loading

# lsp-server = { path = "../rust-analyzer/lib/lsp-server" }

# rust-analyzer = { path = "../rust-analyzer/crates/rust-analyzer" }

serde = { version = "1.0.228", features = ["unstable"] }

serde_derive = "1.0.228"

crossbeam = { version = "0.8.4", features = ["nightly", "crossbeam-channel"] }

regex-cursor = "0.1.5"

markdown = "1.0.0"

itertools = "0.14.0"

replace_with = "0.1.8"

nucleo = "0.5.0"

scopeguard = "1.2.0"

swizzle = "0.1.0"

walkdir = "2.5.0"

niri = { package = "niri-ipc", version = "25.11.0" }

rustc-hash = "=2.1.1"

bendy = { version = "0.6.1", features = ["serde"] }

git2 = "0.20.4"

};

None

}

cursor_position: (usize, usize),

w: Arc<dyn Window>,

) {

_ = self

.requests

.complete

.consume(CompletionAction::Click)

Some(Do::ClickedHover | Do::MoveCursor) => {

text.cursor.just(

text.mapped_index_at(cursor_position),

w: Arc<dyn Window>,

c: usize,

) {

Some(Do::ExtendSelectionToMouse) => {

let p = self.text.mapped_index_at(cursor_position);

self.text

&& !e.is_whitespace() =>

'out: {

match self

{

Some(Do::SetHovering) => {

let State::Hovering(l) = &mut self.state else {

});

let diags = self.find_diags(cursor_position, &w);

println!("requesting hover");

// self.requests.hovering.request =

// (DropH::new(handle), cursor_position).into();

// requests.hovering.result = None;

window: &mut Arc<dyn Window>,

freq: &mut Freq,

) -> ControlFlow<()> {

match o {

take(&mut self.requests.complete);

take(&mut self.requests.sig_help);

self.text.cursor.alone();

}

ceach!(self.text.cursor, |cursor| {

Some(

if let Some(x) = cursor.sel

self.text.cursor.clear_selections();

change!(self, window.clone());

}

if let Err(e) = trm::toggle(

self.workspace

.as_deref()

log::error!("opening terminal failed {e}");

}

}

if let Some((l, f)) = lsp!(self + p) {

l.matching_brace(f, &mut self.text)

},

if let Some((lsp, o)) = lsp!(self + p)

&& let Ok(syms) = lsp.workspace_symbols("".into())

{

));

self.state = State::Symbols(q);

},

if let Some((lsp, p)) = lsp!(self + p) {

let State::Symbols(Rq { result: Some(x), request }) =

&mut self.state

));

}

},

match Cmds::complete_or_accept(&z) {

crate::menu::generic::CorA::Complete => {

x.tedit.rope =

}

}

},

let State::Command(x) = &self.state else {

unreachable!()

};

self.text.scroll_to_ln_centering(x as _);

}

}

if let Some(lsp) = lsp!(self) {

let State::Symbols(Rq { result: Some(x), request }) =

&mut self.state

}

}

}

let State::Symbols(Rq { result: Some(x), .. }) =

&mut self.state

else {

}

}

}

let State::Symbols(Rq { result: Some(x), .. }) =

&mut self.state

else {

}

}

}

if let Some(Ok(x)) = x.sel(Some(freq))

&& let Err(e) = self.go(x.at, window.clone())

{

log::error!("alas! {e}")

},

let State::CodeAction(Rq { result: Some(c), .. }) =

&mut self.state

else {

};

c.left();

}

let Some(lsp) = lsp!(self) else { unreachable!() };

let State::CodeAction(Rq { result: Some(c), .. }) =

&mut self.state

log::error!("{e}");

}

}

let State::CodeAction(Rq { result: Some(c), .. }) =

&mut self.state

else {

};

c.down();

}

let State::CodeAction(Rq { result: Some(c), .. }) =

&mut self.state

else {

};

c.up();

}

if let Some(x) =

&self.requests.document_highlights.result =>

'out: {

}

}

}

if self.requests.document_highlights.request.is_none() {

self.refresh_document_highlights();

},

Some(_) => {

self.save();

}

None => {

}

},

self.origin = Some(PathBuf::try_from(x).unwrap());

self.save();

}

self.hist.test_push(&mut self.text);

if let Err(e) = self.hist.undo(&mut self.text) {

eprintln!("undo failed: {e}");

change!(self, window.clone());

}

self.hist.test_push(&mut self.text);

self.hist.redo(&mut self.text).unwrap();

self.bar.last_action = "redid".to_string();

change!(self, window.clone());

}

self.text.cursor.each(|c| {

let Some(r) = c.sel else { return };

match x {

});

self.text.cursor.clear_selections();

}

let Key::Named(y) = event.logical_key else { panic!() };

// let mut z = vec![];

self.text.cursor.each(|x| {

});

// *self.state.sel() = z;

}

let Key::Named(y) = event.logical_key else { panic!() };

self.text.cursor.each(|x| {

x.extend_selection(

self.text.scroll_to_cursor();

inlay!(self);

}

// self.text.cursor.inner.clear();

self.hist.push_if_changed(&mut self.text);

ceach!(self.text.cursor, |cursor| {

self.hist.push_if_changed(&mut self.text);

change!(self, window.clone());

}

self.hist.push_if_changed(&mut self.text);

ceach!(self.text.cursor, |cursor| {

let Some(r) = cursor.sel else { return };

change!(self, window.clone());

}

self.hist.push_if_changed(&mut self.text);

unsafe { take(&mut META) };

let mut clip = String::new();

self.hist.push_if_changed(&mut self.text);

change!(self, window.clone());

}

self.hist.push_if_changed(&mut self.text);

unsafe { take(&mut META) };

let mut clip = String::new();

self.hist.push_if_changed(&mut self.text);

change!(self, window.clone());

}

self.hist.push_if_changed(&mut self.text);

ceach!(self.text.cursor, |cursor| {

let Some(r) = cursor.sel else { return };

self.paste();

// self.hist.push_if_changed(&mut self.text);

}

_ = self.open(Path::new(&x), window.clone());

}

let s = Regex::new(&x).unwrap();

let n = s

.find_iter(&self.text.rope.to_string())

self.bar.last_action = "no matches".into()

});

}

let (re, index, _) = self.state.search();

let s = self.text.rope.to_string();

let m = re.find_iter(&s).nth(*index).unwrap();

self.text.scroll_to_cursor_centering();

inlay!(self);

}

self.hist.push_if_changed(&mut self.text);

self.text.rope = Rope::from_str(

&std::fs::read_to_string(

self.bar.last_action = "reloaded".into();

self.hist.push(&mut self.text)

}

let (x, y) = match dir {

Direction::Above => self.text.cursor.min(),

Direction::Below => self.text.cursor.max(),

let position = self.text.line_to_char(y);

self.text.cursor.add(position + x, &self.text.rope);

}

if let Some((l, ws)) =

lsp!(self).zip(self.workspace.as_deref())

{

.block_on(crate::runnables::run(x, ws))

.unwrap();

},

let State::GoToL(x) = &mut self.state else {

unreachable!()

};

)));

}

}

if let Some(Ok((g, _))) = x.sel(None)

&& let Err(e) = self.go(g, window.clone())

{

eprintln!("go-to-list select fail: {e}");

},

let State::GoToL(x) = &mut self.state else {

unreachable!()

};

// self.text.vo = self.text.char_to_line(x.start);

}

}

}

ControlFlow::Continue(())

}

.requests

.complete

.consume(CompletionAction::K(event.logical_key.as_ref()))

{

Some(CDo::Request(ctx)) => {

if let Ok(fut) = lsp.request_complete(

C(_) => _ [Hover],

MovedOut => Default,

Scrolled => Default,

M(MouseButton::Left if ctrl()) => Default [GoToDefinition(x.request.map(|x| x.1.1).or(x.result.and_then(|x| x.of.iter().find_map(|x| x.tdpp()))))],

M(_) => _ [ClickedHover],

ed.scroll(rows);

window.request_redraw();

}

WindowEvent::ModifiersChanged(modifiers) => {

unsafe { MODIFIERS = modifiers.state() };

window.request_redraw();