commit via ctrl+o

fix command stack
add to changelog

CHANGELOG.md

@@ -7,6 +7,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+<<<<<<< HEAD
 **submodules view**
 
 ![submodules](assets/submodules.gif)
@@ -161,6 +162,10 @@ The way this works got changed and simplified ([See docs](https://github.com/ext
 - visualize progress during async syntax highlighting ([#889](https://github.com/extrawurst/gitui/issues/889))
 - added support for markdown emoji's in commits [[@andrewpollack](https://github.com/andrewpollack)] ([#768](https://github.com/extrawurst/gitui/issues/768))
 - added scrollbar to revlog [[@ashvin021](https://github.com/ashvin021)] ([#868](https://github.com/extrawurst/gitui/issues/868))
+=======
+### Changed
+- `enter` adds *newline* to commit msg (*commit* via `ctrl+o` now) [[@WizardOhio24](https://github.com/WizardOhio24)] ([#509](https://github.com/extrawurst/gitui/issues/509))
+>>>>>>> commit via ctrl+o
 
 ### Fixed
 - fix build when system level libgit2 version was used ([#883](https://github.com/extrawurst/gitui/issues/883))

src/components/commit.rs

@@ -42,6 +42,7 @@ enum Mode {
 	Revert,
 }
 
+<<<<<<< HEAD
 pub struct CommitComponent {
 	repo: RepoPathRef,
 	input: TextInputComponent,
@@ -51,6 +52,86 @@ pub struct CommitComponent {
 	git_branch_name: cached::BranchName,
 	commit_template: Option<String>,
 	theme: SharedTheme,
+=======
+impl Component for CommitComponent {
+    fn commands(
+        &self,
+        out: &mut Vec<CommandInfo>,
+        force_all: bool,
+    ) -> CommandBlocking {
+        self.input.commands(out, force_all);
+
+        if self.is_visible() || force_all {
+            out.push(CommandInfo::new(
+                strings::commands::commit(&self.key_config),
+                self.can_commit(),
+                true,
+            ));
+
+            out.push(CommandInfo::new(
+                strings::commands::commit_amend(&self.key_config),
+                self.can_amend(),
+                true,
+            ));
+
+            out.push(CommandInfo::new(
+                strings::commands::commit_open_editor(
+                    &self.key_config,
+                ),
+                true,
+                true,
+            ));
+        }
+
+        visibility_blocking(self)
+    }
+
+    fn event(&mut self, ev: Event) -> Result<bool> {
+        if self.is_visible() {
+            if let Event::Key(e) = ev {
+                if e == self.key_config.commit && self.can_commit() {
+                    self.commit()?;
+                } else if e == self.key_config.commit_amend
+                    && self.can_amend()
+                {
+                    self.amend()?;
+                } else if e == self.key_config.open_commit_editor {
+                    self.queue.borrow_mut().push_back(
+                        InternalEvent::OpenExternalEditor(None),
+                    );
+                    self.hide();
+                } else if self.input.event(ev)? {
+                    return Ok(true);
+                }
+                // stop key event propagation
+                return Ok(true);
+            }
+        }
+
+        Ok(false)
+    }
+
+    fn is_visible(&self) -> bool {
+        self.input.is_visible()
+    }
+
+    fn hide(&mut self) {
+        self.input.hide()
+    }
+
+    fn show(&mut self) -> Result<()> {
+        if self.amend.is_some() {
+            self.input.clear();
+        }
+        self.amend = None;
+
+        self.input
+            .set_title(strings::commit_title(&self.key_config));
+        self.input.show()?;
+
+        Ok(())
+    }
+>>>>>>> commit via ctrl+o
 }
 
 const FIRST_LINE_LIMIT: usize = 50;

src/components/textinput.rs

@@ -571,6 +571,7 @@ impl DrawableComponent for TextInputComponent {
 }
 
 impl Component for TextInputComponent {
+<<<<<<< HEAD
 	fn commands(
 		&self,
 		out: &mut Vec<CommandInfo>,
@@ -678,6 +679,100 @@ impl Component for TextInputComponent {
 
 		Ok(())
 	}
+=======
+    fn commands(
+        &self,
+        out: &mut Vec<CommandInfo>,
+        _force_all: bool,
+    ) -> CommandBlocking {
+        out.push(
+            CommandInfo::new(
+                strings::commands::close_popup(&self.key_config),
+                true,
+                self.visible,
+            )
+            .order(1),
+        );
+
+        out.push(CommandInfo::new(
+            strings::commands::commit_new_line(&self.key_config),
+            true,
+            self.visible,
+        ));
+
+        visibility_blocking(self)
+    }
+
+    fn event(&mut self, ev: Event) -> Result<bool> {
+        if self.visible {
+            if let Event::Key(e) = ev {
+                if e == self.key_config.exit_popup {
+                    self.hide();
+                    return Ok(true);
+                } else if e == self.key_config.enter
+                    && self.input_type == InputType::Multiline
+                {
+                    self.msg.insert(self.cursor_position, '\n');
+                    self.incr_cursor();
+                    return Ok(true);
+                }
+
+                let is_ctrl =
+                    e.modifiers.contains(KeyModifiers::CONTROL);
+
+                match e.code {
+                    KeyCode::Char(c) if !is_ctrl => {
+                        self.msg.insert(self.cursor_position, c);
+                        self.incr_cursor();
+                        return Ok(true);
+                    }
+                    KeyCode::Delete => {
+                        if self.cursor_position < self.msg.len() {
+                            self.msg.remove(self.cursor_position);
+                        }
+                        return Ok(true);
+                    }
+                    KeyCode::Backspace => {
+                        self.backspace();
+                        return Ok(true);
+                    }
+                    KeyCode::Left => {
+                        self.decr_cursor();
+                        return Ok(true);
+                    }
+                    KeyCode::Right => {
+                        self.incr_cursor();
+                        return Ok(true);
+                    }
+                    KeyCode::Home => {
+                        self.cursor_position = 0;
+                        return Ok(true);
+                    }
+                    KeyCode::End => {
+                        self.cursor_position = self.msg.len();
+                        return Ok(true);
+                    }
+                    _ => (),
+                };
+            }
+        }
+        Ok(false)
+    }
+
+    fn is_visible(&self) -> bool {
+        self.visible
+    }
+
+    fn hide(&mut self) {
+        self.visible = false
+    }
+
+    fn show(&mut self) -> Result<()> {
+        self.visible = true;
+
+        Ok(())
+    }
+>>>>>>> commit via ctrl+o
 }
 
 #[cfg(test)]