95d0bba · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

ui: Improve completion state handling.

95d0bbaBlaž Hrastnik6 years ago

helix-term/src/commands.rs+6−2

compare with master

unifiedsplit

@@ -1691,8 +1691,12 @@ pub fn completion(cx: &mut Context) {

1691

1692 // TODO: if no completion, show some message or something

1693 if !items.is_empty() {

1694+ use crate::compositor::AnyComponent;

1695+ let size = compositor.size();

1696+ let ui = compositor.find("hx::ui::editor::EditorView").unwrap();

1697+ if let Some(ui) = ui.as_any_mut().downcast_mut::<ui::EditorView>() {

1694− let completion = Completion::new(items, trigger_offset);

1698+ ui.set_completion(items, trigger_offset, size);

1695− compositor.push(Box::new(completion));

1699+ };

1696 }

1700 }

1697 },

1701 },

1698 );

1702 );

helix-term/src/compositor.rs+85−1

@@ -34,7 +34,7 @@ pub struct Context<'a> {

34 pub callbacks: &'a mut LspCallbacks,

35}

37−pub trait Component {

37+pub trait Component: Any + AnyComponent {

38 /// Process input events, return true if handled.

39 fn handle_event(&mut self, event: Event, ctx: &mut Context) -> EventResult {

40 EventResult::Ignored

@@ -60,6 +60,10 @@ pub trait Component {

60 // that way render can use it

61 None

62 }

63+

64+ fn type_name(&self) -> &'static str {

65+ std::any::type_name::<Self>()

66+ }

63}

67}

65use anyhow::Error;

69use anyhow::Error;

@@ -142,4 +146,84 @@ impl Compositor {

142 }

146 }

143 None

147 None

144 }

148 }

149+

150+ pub fn find(&mut self, type_name: &str) -> Option<&mut dyn Component> {

151+ self.layers

152+ .iter_mut()

153+ .find(|component| component.type_name() == type_name)

154+ .map(|component| component.as_mut())

155+ }

156+}

157+

158+// View casting, taken straight from Cursive

159+

160+use std::any::Any;

161+

162+/// A view that can be downcasted to its concrete type.

163+///

164+/// This trait is automatically implemented for any `T: Component`.

165+pub trait AnyComponent {

166+ /// Downcast self to a `Any`.

167+ fn as_any(&self) -> &dyn Any;

168+

169+ /// Downcast self to a mutable `Any`.

170+ fn as_any_mut(&mut self) -> &mut dyn Any;

171+

172+ /// Returns a boxed any from a boxed self.

173+ ///

174+ /// Can be used before `Box::downcast()`.

175+ ///

176+ /// # Examples

177+ ///

178+ /// ```rust

179+ /// # use cursive_core::views::TextComponent;

180+ /// # use cursive_core::view::Component;

181+ /// let boxed: Box<Component> = Box::new(TextComponent::new("text"));

182+ /// let text: Box<TextComponent> = boxed.as_boxed_any().downcast().unwrap();

183+ /// ```

184+ fn as_boxed_any(self: Box<Self>) -> Box<dyn Any>;

185+}

186+

187+impl<T: Component> AnyComponent for T {

188+ /// Downcast self to a `Any`.

189+ fn as_any(&self) -> &dyn Any {

190+ self

191+ }

192+

193+ /// Downcast self to a mutable `Any`.

194+ fn as_any_mut(&mut self) -> &mut dyn Any {

195+ self

196+ }

197+

198+ fn as_boxed_any(self: Box<Self>) -> Box<dyn Any> {

199+ self

200+ }

201+}

202+

203+impl dyn AnyComponent {

204+ /// Attempts to downcast `self` to a concrete type.

205+ pub fn downcast_ref<T: Any>(&self) -> Option<&T> {

206+ self.as_any().downcast_ref()

207+ }

208+

209+ /// Attempts to downcast `self` to a concrete type.

210+ pub fn downcast_mut<T: Any>(&mut self) -> Option<&mut T> {

211+ self.as_any_mut().downcast_mut()

212+ }

213+

214+ /// Attempts to downcast `Box<Self>` to a concrete type.

215+ pub fn downcast<T: Any>(self: Box<Self>) -> Result<Box<T>, Box<Self>> {

216+ // Do the check here + unwrap, so the error

217+ // value is `Self` and not `dyn Any`.

218+ if self.as_any().is::<T>() {

219+ Ok(self.as_boxed_any().downcast().unwrap())

220+ } else {

221+ Err(self)

222+ }

223+ }

224+

225+ /// Checks if this view is of type `T`.

226+ pub fn is<T: Any>(&mut self) -> bool {

227+ self.as_any().is::<T>()

228+ }

145}

229}

helix-term/src/ui/completion.rs+41−34

@@ -12,6 +12,7 @@ use std::borrow::Cow;

12use helix_core::{Position, Transaction};

13use helix_view::Editor;

15+use crate::commands;

15use crate::ui::{Menu, Popup, PromptEvent};

16use crate::ui::{Menu, Popup, PromptEvent};

17use helix_lsp::lsp;

18use helix_lsp::lsp;

@@ -112,44 +113,50 @@ impl Completion {

112 trigger_offset,

113 trigger_offset,

113 }

114 }

115 }

116+

117+ pub fn update(&mut self, cx: &mut commands::Context) {

118+ // recompute menu based on matches

119+ let menu = self.popup.contents_mut();

120+ let (view, doc) = cx.editor.current();

121+

122+ // cx.hooks()

123+ // cx.add_hook(enum type, ||)

124+ // cx.trigger_hook(enum type, &str, ...) <-- there has to be enough to identify doc/view

125+ // callback with editor & compositor

126+ //

127+ // trigger_hook sends event into channel, that's consumed in the global loop and

128+ // triggers all registered callbacks

129+ // TODO: hooks should get processed immediately so maybe do it after select!(), before

130+ // looping?

131+

132+ let cursor = doc.selection(view.id).cursor();

133+ if self.trigger_offset <= cursor {

134+ let fragment = doc.text().slice(self.trigger_offset..=cursor);

135+ let text = Cow::from(fragment);

136+ // TODO: logic is same as ui/picker

137+ menu.score(&text);

138+ }

139+ }

140+

141+ pub fn is_empty(&self) -> bool {

142+ self.popup.contents().is_empty()

143+ }

115}

144}

116

145

146+// need to:

147+// - trigger on the right trigger char

148+// - detect previous open instance and recycle

149+// - update after input, but AFTER the document has changed

150+// - if no more matches, need to auto close

151+//

152+// missing bits:

153+// - a more robust hook system: emit to a channel, process in main loop

154+// - a way to find specific layers in compositor

155+// - components register for hooks, then unregister when terminated

156+// ... since completion is a special case, maybe just build it into doc/render?

157+

117impl Component for Completion {

158impl Component for Completion {

118 fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {

159 fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {

119− // input

120− if let Event::Key(KeyEvent {

121− code: KeyCode::Char(ch),

122− ..

123− }) = event

124− {

125− // recompute menu based on matches

126− let menu = self.popup.contents();

127− let (view, doc) = cx.editor.current();

128−

129− // cx.hooks()

130− // cx.add_hook(enum type, ||)

131− // cx.trigger_hook(enum type, &str, ...) <-- there has to be enough to identify doc/view

132− // callback with editor & compositor

133− //

134− // trigger_hook sends event into channel, that's consumed in the global loop and

135− // triggers all registered callbacks

136− // TODO: hooks should get processed immediately so maybe do it after select!(), before

137− // looping?

138−

139− let cursor = doc.selection(view.id).cursor();

140− if self.trigger_offset <= cursor {

141− let fragment = doc.text().slice(self.trigger_offset..cursor);

142− // ^ problem seems to be that we handle events here before the editor layer, so the

143− // keypress isn't included in the editor layer yet...

144− // so we can't use ..= for now.

145− let text = Cow::from(fragment);

146− // TODO: logic is same as ui/picker

147− menu.score(&text);

148−

149− // TODO: if after scoring the selection is 0 items, remove popup

150− }

151− }

152−

153 self.popup.handle_event(event, cx)

160 self.popup.handle_event(event, cx)

154 }

161 }

155

162

helix-term/src/ui/editor.rs+32−5

@@ -3,7 +3,7 @@ use crate::{

3 compositor::{Component, Compositor, Context, EventResult},

4 key,

5 keymap::{self, Keymaps},

6− ui::text_color,

6+ ui::{text_color, Completion},

7};

9use helix_core::{

@@ -29,6 +29,7 @@ pub struct EditorView {

29 on_next_key: Option<Box<dyn FnOnce(&mut commands::Context, KeyEvent)>>,

30 status_msg: Option<String>,

31 last_insert: (commands::Command, Vec<KeyEvent>),

32+ completion: Option<Completion>,

32}

33}

34const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter

35const OFFSET: u16 = 7; // 1 diagnostic + 5 linenr + 1 gutter

@@ -40,6 +41,7 @@ impl EditorView {

40 on_next_key: None,

41 on_next_key: None,

41 status_msg: None,

42 status_msg: None,

42 last_insert: (commands::normal_mode, Vec::new()),

43 last_insert: (commands::normal_mode, Vec::new()),

44+ completion: None,

43 }

45 }

44 }

46 }

@@ -435,15 +437,15 @@ impl EditorView {

435 );

437 );

436 }

438 }

437

439

438− fn insert_mode(&self, cxt: &mut commands::Context, event: KeyEvent) {

440+ fn insert_mode(&self, cx: &mut commands::Context, event: KeyEvent) {

439 if let Some(command) = self.keymap[&Mode::Insert].get(&event) {

441 if let Some(command) = self.keymap[&Mode::Insert].get(&event) {

440− command(cxt);

442+ command(cx);

441 } else if let KeyEvent {

443 } else if let KeyEvent {

442 code: KeyCode::Char(ch),

444 code: KeyCode::Char(ch),

443 ..

445 ..

444 } = event

446 } = event

445 {

447 {

446− commands::insert::insert_char(cxt, ch);

448+ commands::insert::insert_char(cx, ch);

447 }

449 }

448 }

450 }

449

451

@@ -476,6 +478,18 @@ impl EditorView {

476 }

478 }

477 }

479 }

478 }

480 }

481+

482+ pub fn set_completion(

483+ &mut self,

484+ items: Vec<helix_lsp::lsp::CompletionItem>,

485+ trigger_offset: usize,

486+ size: Rect,

487+ ) {

488+ let mut completion = Completion::new(items, trigger_offset);

489+ // TODO : propagate required size on resize to completion too

490+ completion.required_size((size.width, size.height));

491+ self.completion = Some(completion);

492+ }

479}

493}

480

494

481impl Component for EditorView {

495impl Component for EditorView {

@@ -512,7 +526,15 @@ impl Component for EditorView {

512 // record last_insert key

526 // record last_insert key

513 self.last_insert.1.push(event);

527 self.last_insert.1.push(event);

514

528

515− self.insert_mode(&mut cxt, event)

529+ self.insert_mode(&mut cxt, event);

530+

531+ if let Some(completion) = &mut self.completion {

532+ completion.update(&mut cxt);

533+ if completion.is_empty() {

534+ self.completion = None;

535+ }

536+ // TODO: if exiting InsertMode, remove completion

537+ }

516 }

538 }

517 mode => self.command_mode(mode, &mut cxt, event),

539 mode => self.command_mode(mode, &mut cxt, event),

518 }

540 }

@@ -547,6 +569,11 @@ impl Component for EditorView {

547 let doc = cx.editor.document(view.doc).unwrap();

569 let doc = cx.editor.document(view.doc).unwrap();

548 self.render_view(doc, view, view.area, surface, &cx.editor.theme, is_focused);

570 self.render_view(doc, view, view.area, surface, &cx.editor.theme, is_focused);

549 }

571 }

572+

573+ if let Some(completion) = &self.completion {

574+ completion.render(area, surface, cx)

575+ // render completion here

576+ }

550 }

577 }

551

578

552 fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {

579 fn cursor_position(&self, area: Rect, editor: &Editor) -> Option<Position> {

helix-term/src/ui/menu.rs+9−1

@@ -123,11 +123,19 @@ impl<T> Menu<T> {

123 .map(|(index, _score)| &self.options[*index])

124 })

125 }

126+

127+ pub fn is_empty(&self) -> bool {

128+ self.matches.is_empty()

129+ }

130+

131+ pub fn len(&self) -> usize {

132+ self.matches.len()

133+ }

126}

134}

127

135

128use super::PromptEvent as MenuEvent;

136use super::PromptEvent as MenuEvent;

129

137

130−impl<T> Component for Menu<T> {

138+impl<T: 'static> Component for Menu<T> {

131 fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {

139 fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {

132 let event = match event {

140 let event = match event {

133 Event::Key(event) => event,

141 Event::Key(event) => event,

helix-term/src/ui/picker.rs+1−1

@@ -118,7 +118,7 @@ impl<T> Picker<T> {

118// - on input change:

119// - score all the names in relation to input

120

121−impl<T> Component for Picker<T> {

121+impl<T: 'static> Component for Picker<T> {

122 fn handle_event(&mut self, event: Event, cx: &mut Context) -> EventResult {

123 let key_event = match event {

124 Event::Key(event) => event,

helix-term/src/ui/popup.rs+5−1

@@ -46,7 +46,11 @@ impl<T: Component> Popup<T> {

46 }

47 }

49− pub fn contents(&mut self) -> &mut T {

49+ pub fn contents(&self) -> &T {

50+ &self.contents

51+ }

52+

53+ pub fn contents_mut(&mut self) -> &mut T {

50 &mut self.contents

54 &mut self.contents

51 }

55 }

52}

56}