ada3f92 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

wip: Getting the new prompt to render in a new layer.

ada3f92Blaž Hrastnik6 years ago

helix-term/src/application.rs+56−126

compare with master

unifiedsplit

@@ -42,16 +42,15 @@ type Terminal = tui::Terminal<CrosstermBackend<std::io::Stdout>>;

42const BASE_WIDTH: u16 = 30;

44pub struct Application<'a> {

45− prompt: Option<Prompt>,

46−

47 compositor: Compositor,

45 compositor: Compositor,

46+ editor: Editor,

48 renderer: Renderer,

47 renderer: Renderer,

50 executor: &'a smol::Executor<'a>,

49 executor: &'a smol::Executor<'a>,

51 language_server: helix_lsp::Client,

50 language_server: helix_lsp::Client,

52}

51}

54−pub(crate) struct Renderer {

53+pub struct Renderer {

55 size: (u16, u16),

54 size: (u16, u16),

56 terminal: Terminal,

55 terminal: Terminal,

57 surface: Surface,

56 surface: Surface,

@@ -263,6 +262,11 @@ impl Renderer {

263 self.surface

262 self.surface

264 .set_string(1, self.size.1 - 2, mode, self.text_color);

263 .set_string(1, self.size.1 - 2, mode, self.text_color);

265

264

265+ if let Some(path) = view.doc.path() {

266+ self.surface

267+ .set_string(6, self.size.1 - 2, path.to_string_lossy(), self.text_color);

268+ }

269+

266 self.surface.set_string(

270 self.surface.set_string(

267 self.size.0 - 10,

271 self.size.0 - 10,

268 self.size.1 - 2,

272 self.size.1 - 2,

@@ -271,7 +275,7 @@ impl Renderer {

271 );

275 );

272 }

276 }

273

277

274− pub fn render_prompt(&mut self, view: &View, prompt: &Prompt, theme: &Theme) {

278+ pub fn render_prompt(&mut self, prompt: &Prompt, theme: &Theme) {

275 // completion

279 // completion

276 if !prompt.completion.is_empty() {

280 if !prompt.completion.is_empty() {

277 // TODO: find out better way of clearing individual lines of the screen

281 // TODO: find out better way of clearing individual lines of the screen

@@ -343,15 +347,6 @@ impl Renderer {

343 let pos = if let Some(prompt) = prompt {

347 let pos = if let Some(prompt) = prompt {

344 Position::new(self.size.0 as usize, 2 + prompt.cursor)

348 Position::new(self.size.0 as usize, 2 + prompt.cursor)

345 } else {

349 } else {

346− if let Some(path) = view.doc.path() {

347− self.surface.set_string(

348− 6,

349− self.size.1 - 1,

350− path.to_string_lossy(),

351− self.text_color,

352− );

353− }

354−

355 let cursor = view.doc.state.selection().cursor();

350 let cursor = view.doc.state.selection().cursor();

356

351

357 let mut pos = view

352 let mut pos = view

@@ -367,146 +362,77 @@ impl Renderer {

367}

362}

368

363

369struct EditorView {

364struct EditorView {

370− editor: Editor,

371− prompt: Option<Prompt>, // TODO: this is None for now, make a layer

372 keymap: Keymaps,

365 keymap: Keymaps,

373}

366}

374

367

375impl EditorView {

368impl EditorView {

376− fn new(editor: Editor) -> Self {

369+ fn new() -> Self {

377 Self {

370 Self {

378− editor,

379− prompt: None,

380 keymap: keymap::default(),

371 keymap: keymap::default(),

381 }

372 }

382 }

373 }

383}

374}

384

375

376+use crate::compositor::Context;

377+

385impl Component for EditorView {

378impl Component for EditorView {

386− fn handle_event(&mut self, event: Event, executor: &smol::Executor) -> EventResult {

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

387 match event {

380 match event {

388 Event::Resize(width, height) => {

381 Event::Resize(width, height) => {

389 // TODO: simplistic ensure cursor in view for now

382 // TODO: simplistic ensure cursor in view for now

390 // TODO: loop over views

383 // TODO: loop over views

391− if let Some(view) = self.editor.view_mut() {

384+ if let Some(view) = cx.editor.view_mut() {

392 view.size = (width, height);

385 view.size = (width, height);

393 view.ensure_cursor_in_view()

386 view.ensure_cursor_in_view()

394 };

387 };

395 EventResult::Consumed(None)

388 EventResult::Consumed(None)

396 }

389 }

397 Event::Key(event) => {

390 Event::Key(event) => {

398− if let Some(view) = self.editor.view_mut() {

391+ if let Some(view) = cx.editor.view_mut() {

399 let keys = vec![event];

392 let keys = vec![event];

400 // TODO: sequences (`gg`)

393 // TODO: sequences (`gg`)

394+ let mode = view.doc.mode();

401 // TODO: handle count other than 1

395 // TODO: handle count other than 1

396+ let mut cx = commands::Context {

397+ view,

398+ executor: cx.executor,

399+ count: 1,

400+ callback: None,

401+ };

402+

402− match view.doc.mode() {

403+ match mode {

403 Mode::Insert => {

404 Mode::Insert => {

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

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

405− let mut cx = commands::Context {

406− view,

407− executor,

408− count: 1,

409− };

410−

411 command(&mut cx);

406 command(&mut cx);

412 } else if let KeyEvent {

407 } else if let KeyEvent {

413 code: KeyCode::Char(c),

408 code: KeyCode::Char(c),

414 ..

409 ..

415 } = event

410 } = event

416 {

411 {

417− let mut cx = commands::Context {

418− view,

419− executor,

420− count: 1,

421− };

422 commands::insert::insert_char(&mut cx, c);

412 commands::insert::insert_char(&mut cx, c);

423 }

413 }

424− view.ensure_cursor_in_view();

425 }

414 }

426 Mode::Normal => {

415 Mode::Normal => {

427− if let &[KeyEvent {

428− code: KeyCode::Char(':'),

429− ..

430− }] = keys.as_slice()

431− {

432− let prompt = Prompt::new(

433− ":".to_owned(),

434− |_input: &str| {

435− // TODO: i need this duplicate list right now to avoid borrow checker issues

436− let command_list = vec![

437− String::from("q"),

438− String::from("aaa"),

439− String::from("bbb"),

440− String::from("ccc"),

441− String::from("ddd"),

442− String::from("eee"),

443− String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"),

444− String::from("q"),

445− String::from("aaa"),

446− String::from("bbb"),

447− String::from("ccc"),

448− String::from("ddd"),

449− String::from("eee"),

450− String::from("q"),

451− String::from("aaa"),

452− String::from("bbb"),

453− String::from("ccc"),

454− String::from("ddd"),

455− String::from("eee"),

456− String::from("q"),

457− String::from("aaa"),

458− String::from("bbb"),

459− String::from("ccc"),

460− String::from("ddd"),

461− String::from("eee"),

462− String::from("q"),

463− String::from("aaa"),

464− String::from("bbb"),

465− String::from("ccc"),

466− String::from("ddd"),

467− String::from("eee"),

468− ];

469− command_list

470− .into_iter()

471− .filter(|command| command.contains(_input))

472− .collect()

473− }, // completion

474− |editor: &mut Editor, input: &str| match input {

475− "q" => editor.should_close = true,

476− _ => (),

477− },

478− );

479−

480− self.prompt = Some(prompt);

481−

482− // HAXX: special casing for command mode

483− } else if let Some(command) = self.keymap[&Mode::Normal].get(&keys) {

416+ if let Some(command) = self.keymap[&Mode::Normal].get(&keys) {

484− let mut cx = commands::Context {

485− view,

486− executor,

487− count: 1,

488− };

489 command(&mut cx);

417 command(&mut cx);

490

418

491 // TODO: simplistic ensure cursor in view for now

419 // TODO: simplistic ensure cursor in view for now

492− view.ensure_cursor_in_view();

493 }

420 }

494 }

421 }

495 mode => {

422 mode => {

496 if let Some(command) = self.keymap[&mode].get(&keys) {

423 if let Some(command) = self.keymap[&mode].get(&keys) {

497− let mut cx = commands::Context {

498− view,

499− executor,

500− count: 1,

501− };

502 command(&mut cx);

424 command(&mut cx);

503

425

504 // TODO: simplistic ensure cursor in view for now

426 // TODO: simplistic ensure cursor in view for now

505− view.ensure_cursor_in_view();

506 }

427 }

507 }

428 }

508 }

429 }

430+ // appease borrowck

431+ let callback = cx.callback.take();

432+

433+ view.ensure_cursor_in_view();

434+

509− EventResult::Consumed(None)

435+ EventResult::Consumed(callback)

510 } else {

436 } else {

511 EventResult::Ignored

437 EventResult::Ignored

512 }

438 }

@@ -514,19 +440,19 @@ impl Component for EditorView {

514 Event::Mouse(_) => EventResult::Ignored,

440 Event::Mouse(_) => EventResult::Ignored,

515 }

441 }

516 }

442 }

517− fn render(&mut self, renderer: &mut Renderer) {

443+ fn render(&mut self, renderer: &mut Renderer, cx: &mut Context) {

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

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

519 let viewport = Rect::new(OFFSET, 0, renderer.size.0, renderer.size.1 - 2); // - 2 for statusline and prompt

445 let viewport = Rect::new(OFFSET, 0, renderer.size.0, renderer.size.1 - 2); // - 2 for statusline and prompt

520

446

521 // SAFETY: we cheat around the view_mut() borrow because it doesn't allow us to also borrow

447 // SAFETY: we cheat around the view_mut() borrow because it doesn't allow us to also borrow

522 // theme. Theme is immutable mutating view won't disrupt theme_ref.

448 // theme. Theme is immutable mutating view won't disrupt theme_ref.

523− let theme_ref = unsafe { &*(&self.editor.theme as *const Theme) };

449+ let theme_ref = unsafe { &*(&cx.editor.theme as *const Theme) };

524− if let Some(view) = self.editor.view_mut() {

450+ if let Some(view) = cx.editor.view_mut() {

525 renderer.render_view(view, viewport, theme_ref);

451 renderer.render_view(view, viewport, theme_ref);

526 }

452 }

527

453

528 // TODO: drop unwrap

454 // TODO: drop unwrap

529− renderer.render_cursor(self.editor.view().unwrap(), self.prompt.as_ref(), viewport);

455+ renderer.render_cursor(cx.editor.view().unwrap(), None, viewport);

530 }

456 }

531}

457}

532

458

@@ -540,11 +466,12 @@ impl<'a> Application<'a> {

540 }

466 }

541

467

542 let mut compositor = Compositor::new();

468 let mut compositor = Compositor::new();

543− compositor.push(Box::new(EditorView::new(editor)));

469+ compositor.push(Box::new(EditorView::new()));

544

470

545 let language_server = helix_lsp::Client::start(&executor, "rust-analyzer", &[]);

471 let language_server = helix_lsp::Client::start(&executor, "rust-analyzer", &[]);

546

472

547 let mut app = Self {

473 let mut app = Self {

474+ editor,

548 renderer,

475 renderer,

549 // TODO; move to state

476 // TODO; move to state

550 compositor,

477 compositor,

@@ -558,7 +485,11 @@ impl<'a> Application<'a> {

558

485

559 fn render(&mut self) {

486 fn render(&mut self) {

560 self.renderer.surface.reset(); // reset is faster than allocating new empty surface

487 self.renderer.surface.reset(); // reset is faster than allocating new empty surface

488+ let mut cx = crate::compositor::Context {

489+ editor: &mut self.editor,

490+ executor: &self.executor,

491+ };

561− self.compositor.render(&mut self.renderer); // viewport,

492+ self.compositor.render(&mut self.renderer, &mut cx); // viewport,

562 self.renderer.draw_and_swap();

493 self.renderer.draw_and_swap();

563 }

494 }

564

495

@@ -569,17 +500,16 @@ impl<'a> Application<'a> {

569 self.language_server.initialize().await.unwrap();

500 self.language_server.initialize().await.unwrap();

570 // TODO: temp

501 // TODO: temp

571 // self.language_server

502 // self.language_server

572− // .text_document_did_open(&self.editor.view().unwrap().doc)

503+ // .text_document_did_open(&cx.editor.view().unwrap().doc)

573 // .await

504 // .await

574 // .unwrap();

505 // .unwrap();

575

506

576 self.render();

507 self.render();

577

508

578 loop {

509 loop {

579− // TODO:

580− // if self.editor.should_close {

510+ if self.editor.should_close {

581− // break;

511+ break;

582− // }

512+ }

583

513

584 use futures_util::{select, FutureExt};

514 use futures_util::{select, FutureExt};

585 select! {

515 select! {

@@ -594,26 +524,26 @@ impl<'a> Application<'a> {

594 }

524 }

595

525

596 pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {

526 pub fn handle_terminal_events(&mut self, event: Option<Result<Event, crossterm::ErrorKind>>) {

527+ let mut cx = crate::compositor::Context {

528+ editor: &mut self.editor,

529+ executor: &self.executor,

530+ };

597 // Handle key events

531 // Handle key events

598− match event {

532+ let should_redraw = match event {

599 Some(Ok(Event::Resize(width, height))) => {

533 Some(Ok(Event::Resize(width, height))) => {

600 self.renderer.resize(width, height);

534 self.renderer.resize(width, height);

601

535

602− // TODO: use the response

603 self.compositor

536 self.compositor

604− .handle_event(Event::Resize(width, height), self.executor);

537+ .handle_event(Event::Resize(width, height), &mut cx)

605−

606− self.render();

607− }

608− Some(Ok(event)) => {

609− // TODO: use the response

610− self.compositor.handle_event(event, self.executor);

611−

612− self.render();

613 }

538 }

539+ Some(Ok(event)) => self.compositor.handle_event(event, &mut cx),

614 Some(Err(x)) => panic!(x),

540 Some(Err(x)) => panic!(x),

615 None => panic!(),

541 None => panic!(),

616 };

542 };

543+

544+ if should_redraw {

545+ self.render();

546+ }

617 }

547 }

618

548

619 pub async fn handle_language_server_message(&mut self, call: Option<helix_lsp::Call>) {

549 pub async fn handle_language_server_message(&mut self, call: Option<helix_lsp::Call>) {

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

@@ -9,17 +9,21 @@ use helix_core::{

10use once_cell::sync::Lazy;

12+use crate::compositor::Compositor;

12use crate::prompt::Prompt;

13use crate::prompt::Prompt;

14use helix_view::{

15use helix_view::{

15 document::Mode,

16 document::Mode,

16 view::{View, PADDING},

17 view::{View, PADDING},

18+ Editor,

17};

19};

19pub struct Context<'a, 'b> {

21pub struct Context<'a, 'b> {

20 pub count: usize,

22 pub count: usize,

21 pub view: &'a mut View,

23 pub view: &'a mut View,

22 pub executor: &'a smol::Executor<'b>,

24 pub executor: &'a smol::Executor<'b>,

25+

26+ pub callback: Option<crate::compositor::Callback>,

23}

27}

25/// A command is a function that takes the current state and a count, and does a side-effect on the

29/// A command is a function that takes the current state and a count, and does a side-effect on the

@@ -333,8 +337,57 @@ pub fn append_mode(cx: &mut Context) {

333}

337}

334

338

335// TODO: I, A, o and O can share a lot of the primitives.

339// TODO: I, A, o and O can share a lot of the primitives.

336−pub fn command_mode(_cx: &mut Context) {

340+pub fn command_mode(cx: &mut Context) {

337− unimplemented!()

341+ cx.callback = Some(Box::new(|compositor: &mut Compositor| {

342+ let prompt = Prompt::new(

343+ ":".to_owned(),

344+ |_input: &str| {

345+ // TODO: i need this duplicate list right now to avoid borrow checker issues

346+ let command_list = vec![

347+ String::from("q"),

348+ String::from("aaa"),

349+ String::from("bbb"),

350+ String::from("ccc"),

351+ String::from("ddd"),

352+ String::from("eee"),

353+ String::from("averylongcommandaverylongcommandaverylongcommandaverylongcommandaverylongcommand"),

354+ String::from("q"),

355+ String::from("aaa"),

356+ String::from("bbb"),

357+ String::from("ccc"),

358+ String::from("ddd"),

359+ String::from("eee"),

360+ String::from("q"),

361+ String::from("aaa"),

362+ String::from("bbb"),

363+ String::from("ccc"),

364+ String::from("ddd"),

365+ String::from("eee"),

366+ String::from("q"),

367+ String::from("aaa"),

368+ String::from("bbb"),

369+ String::from("ccc"),

370+ String::from("ddd"),

371+ String::from("eee"),

372+ String::from("q"),

373+ String::from("aaa"),

374+ String::from("bbb"),

375+ String::from("ccc"),

376+ String::from("ddd"),

377+ String::from("eee"),

378+ ];

379+ command_list

380+ .into_iter()

381+ .filter(|command| command.contains(_input))

382+ .collect()

383+ }, // completion

384+ |editor: &mut Editor, input: &str| match input {

385+ "q" => editor.should_close = true,

386+ _ => (),

387+ },

388+ );

389+ compositor.push(Box::new(prompt));

390+ }));

338}

391}

339

392

340// calculate line numbers for each selection range

393// calculate line numbers for each selection range

helix-term/src/compositor.rs+25−11

@@ -18,7 +18,7 @@ use crossterm::event::Event;

18use smol::Executor;

19use tui::buffer::Buffer as Surface;

21−pub(crate) type Callback = Box<dyn Fn(&mut Compositor)>;

21+pub type Callback = Box<dyn Fn(&mut Compositor)>;

23// --> EventResult should have a callback that takes a context with methods like .popup(),

24// .prompt() etc. That way we can abstract it from the renderer.

@@ -29,14 +29,21 @@ pub(crate) type Callback = Box<dyn Fn(&mut Compositor)>;

29// If Compositor was specified in the callback that's then problematic because of

31// Cursive-inspired

32−pub(crate) enum EventResult {

32+pub enum EventResult {

33 Ignored,

34 Consumed(Option<Callback>),

35}

37+use helix_view::{Editor, View};

38+// shared with commands.rs

39+pub struct Context<'a, 'b> {

40+ pub editor: &'a mut Editor,

41+ pub executor: &'a smol::Executor<'b>,

42+}

43+

37−pub(crate) trait Component {

44+pub trait Component {

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

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

39− fn handle_event(&mut self, event: Event, executor: &Executor) -> EventResult;

46+ fn handle_event(&mut self, event: Event, ctx: &mut Context) -> EventResult;

40 // , args: ()

47 // , args: ()

42 /// Should redraw? Useful for saving redraw cycles if we know component didn't change.

49 /// Should redraw? Useful for saving redraw cycles if we know component didn't change.

@@ -44,7 +51,7 @@ pub(crate) trait Component {

44 true

51 true

45 }

52 }

47− fn render(&mut self, renderer: &mut Renderer);

54+ fn render(&mut self, renderer: &mut Renderer, ctx: &mut Context);

48}

55}

50// struct Editor { };

57// struct Editor { };

@@ -94,7 +101,7 @@ pub(crate) trait Component {

94// // 2) Alternatively,

101// // 2) Alternatively,

95//}

102//}

103

97−pub(crate) struct Compositor {

104+pub struct Compositor {

98 layers: Vec<Box<dyn Component>>,

105 layers: Vec<Box<dyn Component>>,

99}

106}

100

107

@@ -111,17 +118,24 @@ impl Compositor {

111 self.layers.pop();

118 self.layers.pop();

112 }

119 }

113

120

114− pub fn handle_event(&mut self, event: Event, executor: &Executor) -> () {

121+ pub fn handle_event(&mut self, event: Event, cx: &mut Context) -> bool {

115 // TODO: custom focus

122 // TODO: custom focus

116 if let Some(layer) = self.layers.last_mut() {

123 if let Some(layer) = self.layers.last_mut() {

117− layer.handle_event(event, executor);

124+ return match layer.handle_event(event, cx) {

118− // return should_update

125+ EventResult::Consumed(Some(callback)) => {

126+ callback(self);

127+ true

128+ }

129+ EventResult::Consumed(None) => true,

130+ EventResult::Ignored => false,

131+ };

119 }

132 }

133+ false

120 }

134 }

121

135

122− pub fn render(&mut self, renderer: &mut Renderer) {

136+ pub fn render(&mut self, renderer: &mut Renderer, cx: &mut Context) {

123 for layer in &mut self.layers {

137 for layer in &mut self.layers {

124− layer.render(renderer)

138+ layer.render(renderer, cx)

125 }

139 }

126 }

140 }

127}

141}

helix-term/src/prompt.rs+23−6

@@ -1,5 +1,9 @@

1−use crate::Editor;

1+use crate::{

2+ application::Renderer,

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

4+};

2−use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};

5+use crossterm::event::{Event, KeyCode, KeyEvent, KeyModifiers};

6+use helix_view::Editor;

3use std::string::String;

7use std::string::String;

5pub struct Prompt {

9pub struct Prompt {

@@ -79,9 +83,16 @@ impl Prompt {

79 pub fn exit_selection(&mut self) {

83 pub fn exit_selection(&mut self) {

80 self.completion_selection_index = None;

84 self.completion_selection_index = None;

81 }

85 }

86+}

87+

88+impl Component for Prompt {

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

90+ let event = match event {

91+ Event::Key(event) => event,

92+ _ => return EventResult::Ignored,

93+ };

83− pub fn handle_event(&mut self, key_event: KeyEvent, editor: &mut Editor) {

84− match key_event {

95+ match event {

85 KeyEvent {

96 KeyEvent {

86 code: KeyCode::Char(c),

97 code: KeyCode::Char(c),

87 modifiers: KeyModifiers::NONE,

98 modifiers: KeyModifiers::NONE,

@@ -112,7 +123,7 @@ impl Prompt {

112 KeyEvent {

123 KeyEvent {

113 code: KeyCode::Enter,

124 code: KeyCode::Enter,

114 ..

125 ..

115− } => (self.callback_fn)(editor, &self.line),

126+ } => (self.callback_fn)(cx.editor, &self.line),

116 KeyEvent {

127 KeyEvent {

117 code: KeyCode::Tab, ..

128 code: KeyCode::Tab, ..

118 } => self.change_completion_selection(),

129 } => self.change_completion_selection(),

@@ -121,6 +132,12 @@ impl Prompt {

121 modifiers: KeyModifiers::CONTROL,

132 modifiers: KeyModifiers::CONTROL,

122 } => self.exit_selection(),

133 } => self.exit_selection(),

123 _ => (),

134 _ => (),

124− }

135+ };

136+

137+ EventResult::Consumed(None)

138+ }

139+

140+ fn render(&mut self, renderer: &mut Renderer, cx: &mut Context) {

141+ renderer.render_prompt(self, &cx.editor.theme)

125 }

142 }

126}

143}