Skip to main content

​
Overview

ZepMode_Standard implements a standard, non-modal text editing experience similar to most modern text editors. Unlike Vim mode, this mode stays in Insert mode by default, allowing immediate text entry without mode switching.

​
Class Definition

class ZepMode_Standard : public ZepMode
Inherits from ZepMode and provides straightforward text editing without modal behavior.

​
Constructor

ZepMode_Standard(ZepEditor& editor)
Creates a new Standard mode instance.
​
editor
ZepEditor&
required
Reference to the parent ZepEditor instance

​
Core Methods

​
Init

virtual void Init() override
Initializes Standard mode and sets up key mappings for common editing operations.
Standard mode sets up conventional key bindings like Ctrl+C for copy, Ctrl+V for paste, etc.

​
Begin

virtual void Begin(ZepWindow* pWindow) override
Activates Standard mode for the specified window.
​
pWindow
ZepWindow*
required
The window to activate Standard mode in

​
Name

virtual const char* Name() const override
static const char* StaticName()
Returns the mode name “Standard”. Returns: "Standard"

​
DefaultMode

virtual EditorMode DefaultMode() const override
Returns the default editor mode for Standard mode (Insert mode). Returns: EditorMode::Insert
Unlike Vim mode which starts in Normal mode, Standard mode starts in Insert mode, allowing immediate text entry.

​
Key Characteristics

​
Always Insert Mode

Standard mode operates primarily in EditorMode::Insert, meaning:
  • Keys immediately insert text into the buffer
  • No need to press ‘i’ or ‘a’ to start typing
  • All editing operations use modifier keys (Ctrl, Alt, Shift)

​
Standard Key Bindings

Standard mode typically supports familiar key combinations:
  • Navigation: Arrow keys, Home, End, Page Up, Page Down
  • Editing: Backspace, Delete, Enter
  • Selection: Shift + Arrow keys
  • Clipboard: Ctrl+C (copy), Ctrl+X (cut), Ctrl+V (paste)
  • Undo/Redo: Ctrl+Z (undo), Ctrl+Y or Ctrl+Shift+Z (redo)
  • File Operations: Ctrl+S (save), Ctrl+O (open)
  • Search: Ctrl+F (find)

​
No Relative Line Numbers

Unlike Vim mode, Standard mode uses absolute line numbering, which is more conventional for non-modal editors.

​
Usage Example

#include <zep/mode_standard.h>
#include <zep/editor.h>

// Create editor
auto editor = std::make_unique<ZepEditor>(display);

// Create and register Standard mode
auto standardMode = std::make_shared<ZepMode_Standard>(*editor);
standardMode->Init();
editor->RegisterMode(standardMode);

// Set Standard as the active mode
editor->SetMode(ZepMode_Standard::StaticName());

// Get current window and start using Standard mode
auto window = editor->GetActiveWindow();
standardMode->Begin(window);

// User can immediately start typing
standardMode->AddKeyPress('H');
standardMode->AddKeyPress('e');
standardMode->AddKeyPress('l');
standardMode->AddKeyPress('l');
standardMode->AddKeyPress('o');

// Use modifier keys for operations
standardMode->AddKeyPress('z', ModifierKey::Ctrl);  // Undo
standardMode->AddKeyPress('s', ModifierKey::Ctrl);  // Save

​
Comparison with Vim Mode

FeatureStandard ModeVim Mode
Default modeInsertNormal
Text entryImmediateRequires ‘i’, ‘a’, etc.
NavigationArrow keys + modifiersh, j, k, l, w, b, etc.
Line numbersAbsoluteRelative
Command modeNoYes (Ex mode)
Visual selectionShift + arrowsv, V
Copy/PasteCtrl+C/Vy, p
Standard mode is ideal for users who prefer conventional text editor behavior or are integrating Zep into applications where Vim keybindings might be unexpected.

​
Integration Example

// Application with mode selection
class MyApplication
{
public:
    void SetupEditor()
    {
        m_editor = std::make_unique<ZepEditor>(m_display);
        
        // Register both modes
        auto vimMode = std::make_shared<ZepMode_Vim>(*m_editor);
        auto standardMode = std::make_shared<ZepMode_Standard>(*m_editor);
        
        vimMode->Init();
        standardMode->Init();
        
        m_editor->RegisterMode(vimMode);
        m_editor->RegisterMode(standardMode);
        
        // Let user choose mode
        if (m_userPreference == "vim") {
            m_editor->SetMode(ZepMode_Vim::StaticName());
        } else {
            m_editor->SetMode(ZepMode_Standard::StaticName());
        }
    }
    
    void ToggleMode()
    {
        auto currentMode = m_editor->GetCurrentMode();
        if (currentMode->Name() == ZepMode_Vim::StaticName()) {
            m_editor->SetMode(ZepMode_Standard::StaticName());
        } else {
            m_editor->SetMode(ZepMode_Vim::StaticName());
        }
    }
    
private:
    std::unique_ptr<ZepEditor> m_editor;
    ZepDisplay& m_display;
    std::string m_userPreference;
};

​
Custom Key Bindings

// Extend Standard mode with custom bindings
class MyStandardMode : public ZepMode_Standard
{
public:
    MyStandardMode(ZepEditor& editor) : ZepMode_Standard(editor) {}
    
    void Init() override
    {
        // Initialize base mappings
        ZepMode_Standard::Init();
        
        // Add custom key binding: Ctrl+Shift+D to duplicate line
        m_insertMap.AddKeyMap(
            'd',
            ModifierKey::Ctrl | ModifierKey::Shift,
            StringId("DuplicateLine")
        );
    }
    
    void AddKeyPress(uint32_t key, uint32_t modifiers) override
    {
        // Handle custom commands
        if (key == 'd' && 
            (modifiers & (ModifierKey::Ctrl | ModifierKey::Shift))) {
            DuplicateCurrentLine();
            return;
        }
        
        // Fall back to base handling
        ZepMode_Standard::AddKeyPress(key, modifiers);
    }
    
private:
    void DuplicateCurrentLine()
    {
        // Implementation
    }
};

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us