Vendor selectionhighlight, bracketmatch, colorpreview, navigate, editorconfig (2.1.8-7)

Five more plugins from lite-xl-plugins @ 31eef29, all default VSCode
behaviors:

- selectionhighlight: highlights other occurrences of the selected word
- bracketmatch: highlights the bracket matching the one under the cursor
- colorpreview: inline swatches for #hex/rgb()/hsl() color literals
- navigate: Go Back / Go Forward cursor history (alt+left/right)
- editorconfig: applies .editorconfig files; vendored as the whole
  upstream directory (parser + test harness, lite-xl test editorconfig);
  builds on the bundled trimwhitespace plugin

All depend on core only (editorconfig additionally on trimwhitespace,
already shipped). Verified against the built package: all plugins load,
navigate registers its commands, and an .editorconfig with
indent_size = 2 is applied to an opened file.

Pinned to lite-xl-plugins @ 31eef29 (see debian/extra/README.source).

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+charset = utf-8
+indent_size = 2
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[meson.build]
+indent_size = 4

.gitattributes

@@ -1,3 +1,11 @@
+# Set the default behavior, in case people don't have core.autocrlf set.
+# See https://help.github.com/en/articles/dealing-with-line-endings
+* text=auto
+
 winlib/*  linguist-vendored
 src/lib/* linguist-vendored
-icon.inl  linguist-vendored
+resources/icons/icon.inl linguist-vendored
+
+# Vendored test fixtures must keep their original bytes (crlf.in tests
+# CRLF handling; normalizing it would corrupt the fixture).
+debian/extra/plugins/editorconfig/tests/** -text

.github/FUNDING.yml

@@ -1,3 +0,0 @@
-# These are supported funding model platforms
-
-github: rxi

.github/labeler.yml

@@ -0,0 +1,60 @@
+"Category: CI":
+- changed-files:
+  - any-glob-to-any-file:
+    - .github/workflows/*
+
+"Category: Meta":
+- changed-files:
+  - any-glob-to-any-file:
+    - ./*
+    - .github/*
+    - .github/ISSUE_TEMPLATE/*
+    - .github/PULL_REQUEST_TEMPLATE/*
+    - .gitignore
+
+"Category: Build System":
+- changed-files:
+  - any-glob-to-any-file:
+    - meson.build
+    - meson_options.txt
+    - subprojects/*
+
+"Category: Documentation":
+- changed-files:
+  - any-glob-to-any-file:
+    - docs/**/*
+
+"Category: Resources":
+- changed-files:
+  - any-glob-to-any-file:
+    - resources/**/*
+
+"Category: Themes":
+- changed-files:
+  - any-glob-to-any-file:
+    - data/colors/*
+
+"Category: Lua Core":
+- changed-files:
+  - any-glob-to-any-file:
+    - data/core/**/*
+
+"Category: Fonts":
+- changed-files:
+  - any-glob-to-any-file:
+    - data/fonts/*
+
+"Category: Plugins":
+- changed-files:
+  - any-glob-to-any-file:
+    - data/plugins/*
+
+"Category: C Core":
+- changed-files:
+  - any-glob-to-any-file:
+    - src/**/*
+
+"Category: Libraries":
+- changed-files:
+  - any-glob-to-any-file:
+    - lib/**/*

.github/workflows/auto_labeler_pr.yml

@@ -0,0 +1,16 @@
+name: "Pull Request Labeler"
+on:
+- pull_request_target
+
+permissions:
+  pull-requests: write
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Apply Type Label
+        uses: actions/labeler@v5
+        with:
+          repo-token: "${{ secrets.GITHUB_TOKEN }}"
+          sync-labels: false

.github/workflows/build.yml

@@ -0,0 +1,300 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - "*"
+
+  pull_request:
+    branches:
+      - "*"
+
+  workflow_dispatch:
+
+jobs:
+  build_linux:
+    name: Linux
+    runs-on: ubuntu-22.04
+    strategy:
+      matrix:
+        config:
+          - { name: "GCC", cc: gcc, cxx: g++ }
+          # disable this until we have clang in the build box
+          # - { name: "clang", cc: clang, cxx: clang++ }
+    env:
+      CC: ${{ matrix.config.cc }}
+      CXX: ${{ matrix.config.cxx }}
+
+    steps:
+      - name: Set Environment Variables
+        if: ${{ matrix.config.cc == 'gcc' }}
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_REF=${GITHUB_REF##*/}" >> "$GITHUB_ENV"
+          echo "INSTALL_NAME=lite-xl-${GITHUB_REF##*/}-linux-$(uname -m)-portable" >> "$GITHUB_ENV"
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      # disabled because this will break our own Python install
+      - name: Python Setup
+        if: false
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      # disabled because the container has up-to-date packages
+      - name: Update Packages
+        if: false
+        run: sudo apt-get update
+
+      # disabled as the dependencies are already installed
+      - name: Install Dependencies
+        if: false
+        run: bash scripts/install-dependencies.sh --debug
+
+      - name: Build
+        uses: docker://ghcr.io/lite-xl/lite-xl-build-box-manylinux:v4
+        with:
+          entrypoint: /entrypoint.sh
+          args: |
+            bash --version
+            bash scripts/build.sh --debug --forcefallback --portable
+
+      - name: Package
+        if: ${{ matrix.config.cc == 'gcc' }}
+        run: bash scripts/package.sh --version ${INSTALL_REF} --debug --binary
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        if: ${{ matrix.config.cc == 'gcc' }}
+        with:
+          name: Linux Artifacts
+          path: ${{ env.INSTALL_NAME }}.tar.gz
+          compression-level: 0
+
+  build_macos:
+    name: macOS
+    strategy:
+      matrix:
+        config:
+          - { arch: x86_64, runner: macos-13 } # macos-13 uses x86_64
+          - { arch: arm64, runner: macos-14 } # macos-14 / latest uses M1
+
+    runs-on: ${{ matrix.config.runner }}
+    env:
+      CC: clang
+      CXX: clang++
+
+    steps:
+      - name: System Information
+        run: |
+          system_profiler SPSoftwareDataType
+          bash --version
+          gcc -v
+          xcodebuild -version
+
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_REF=${GITHUB_REF##*/}" >> "$GITHUB_ENV"
+          echo "INSTALL_NAME=lite-xl-${GITHUB_REF##*/}-macos-${{ matrix.config.arch }}" >> "$GITHUB_ENV"
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Python Setup
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      # installing md5sha1sum will eliminate a warning with arm64 and libusb
+      - name: Install Dependencies
+        run: |
+          brew install bash md5sha1sum
+          pip install meson ninja dmgbuild
+
+      - name: Build
+        run: |
+          bash --version
+          bash scripts/build.sh --bundle --debug --forcefallback
+
+      - name: Create DMG Image
+        run: bash scripts/package.sh --version ${INSTALL_REF} --debug --dmg
+
+      - name: Upload DMG Image
+        uses: actions/upload-artifact@v4
+        with:
+          name: macOS DMG Images (${{ matrix.config.arch }})
+          path: ${{ env.INSTALL_NAME }}.dmg
+          compression-level: 0
+
+  build_macos_universal:
+    name: macOS (Universal)
+    runs-on: macos-14
+    needs: build_macos
+
+    steps:
+      - name: System Information
+        run: |
+          system_profiler SPSoftwareDataType
+          bash --version
+          gcc -v
+          xcodebuild -version
+
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_NAME=lite-xl-${GITHUB_REF##*/}-macos-universal" >> "$GITHUB_ENV"
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dmgbuild
+        run: pip install dmgbuild
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
+        id: download
+        with:
+          pattern: macOS DMG Images *
+          merge-multiple: true
+          path: dmgs-original
+
+      - name: Make universal bundles
+        run: |
+          bash --version
+          bash scripts/make-universal-binaries.sh ${{ steps.download.outputs.download-path }} "${INSTALL_NAME}"
+
+      - name: Upload DMG Image
+        uses: actions/upload-artifact@v4
+        with:
+          name: macOS DMG Images (Universal)
+          path: ${{ env.INSTALL_NAME }}.dmg
+          compression-level: 0
+
+  build_windows_msys2:
+    name: Windows
+    runs-on: windows-2019
+    strategy:
+      matrix:
+        config:
+          - { msystem: MINGW32, arch: i686 }
+          - { msystem: MINGW64, arch: x86_64 }
+    defaults:
+      run:
+        shell: msys2 {0}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.config.msystem }}
+          install: >-
+            base-devel
+            git
+            zip
+            patch
+          pacboy: >-
+            gcc:p
+            meson:p
+            cmake:p
+            ninja:p
+            pkg-config:p
+            ca-certificates:p
+
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_REF=${GITHUB_REF##*/}" >> "$GITHUB_ENV"
+          if [[ "${MSYSTEM}" == "MINGW64" ]]; then
+            echo "INSTALL_NAME=lite-xl-${GITHUB_REF##*/}-windows-x86_64" >> "$GITHUB_ENV"
+          else
+            echo "INSTALL_NAME=lite-xl-${GITHUB_REF##*/}-windows-i686" >> "$GITHUB_ENV"
+          fi
+
+      - name: Install Dependencies
+        if: false
+        run: bash scripts/install-dependencies.sh --debug
+
+      - name: Build
+        run: |
+          bash --version
+          bash scripts/build.sh -U --debug --forcefallback
+
+      - name: Package
+        run: bash scripts/package.sh --version ${INSTALL_REF} --debug --binary
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Windows Artifacts (${{ matrix.config.msystem }})
+          path: ${{ env.INSTALL_NAME }}.zip
+          compression-level: 0
+
+  build_windows_msvc:
+    name: Windows (MSVC)
+    runs-on: windows-2019
+    strategy:
+      matrix:
+        arch:
+          - { target: x86, name: i686 }
+          - { target: x64, name: x86_64 }
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup MSVC
+        id: msvc-dev-cmd
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.arch.target }}
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install meson and ninja
+        run: pip install --no-cache-dir meson ninja
+
+      - name: Export GitHub Actions cache environment variables
+        uses: actions/github-script@v7
+        with:
+          script: |
+            core.exportVariable('ACTIONS_CACHE_URL', process.env.ACTIONS_CACHE_URL || '');
+            core.exportVariable('ACTIONS_RUNTIME_TOKEN', process.env.ACTIONS_RUNTIME_TOKEN || '');
+              
+      - name: Install pkgconf
+        env: { VCPKG_BINARY_SOURCES: "clear;x-gha,readwrite" }
+        run: vcpkg install pkgconf:x64-windows-release
+
+      # https://github.com/ilammy/msvc-dev-cmd?tab=readme-ov-file#name-conflicts-with-shell-bash
+      - name: Set environment variables
+        run: |
+          echo "PKG_CONFIG=C:\vcpkg\installed\x64-windows-release\tools\pkgconf\pkgconf.exe" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+          echo "CC_LD=$((Get-Command link.exe).Source)" | Out-File -FilePath $env:GITHUB_ENV -Encoding utf8 -Append
+
+      - name: Build
+        run: bash scripts/build.sh --addons --debug --forcefallback --lto --portable --mode ${{ needs.version.outputs.buildtype }} -b build
+
+      - name: Package
+        run: |
+          Remove-Item -Recurse -Force -Path "lite-xl/lib","lite-xl/include"
+          7z a -mx=9 "$env:INSTALL_NAME.zip" lite-xl
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Windows Artifacts (MSVC ${{ matrix.arch.target }})
+          path: ${{ env.INSTALL_NAME }}.zip
+          compression-level: 0

.github/workflows/postrelease.yml

@@ -0,0 +1,25 @@
+name: Postrelease
+on:
+  release:
+    types: [released]
+
+jobs:
+  postrelease:
+    if: ${{ github.repository == 'lite-xl/lite-xl' && startsWith(github.ref, 'refs/tags/v') && !contains(github.ref, 'rc') }}
+    runs-on: windows-latest
+    steps:
+      - name: Update winget-pkgs repository
+        env: { GH_TOKEN: "${{ secrets.WINGET_TOKEN }}" }
+        run: gh repo sync lite-xl/winget-pkgs
+
+      - name: Release to winget
+        uses: vedantmgoyal9/winget-releaser@main
+        with:
+          identifier: LiteXLTeam.LiteXL
+          installers-regex: '^LiteXL-v[0-9\.]+-x86_64-setup\.exe$'
+          fork-user: 'lite-xl'
+          token: ${{ secrets.WINGET_TOKEN }}
+
+      - name: Update documentation link
+        env: { GH_TOKEN: "${{ secrets.DOCS_TOKEN }}" }
+        run: gh -R lite-xl/docs workflow run deploy.yml

.github/workflows/release.yml

@@ -0,0 +1,347 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - v[0-9]+.*
+
+  workflow_dispatch:
+    inputs:
+      version:
+        description: Release Version
+        default: v2.1.8
+        required: true
+
+jobs:
+  release:
+    name: Create Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    outputs:
+      upload_url: ${{ steps.create_release.outputs.upload_url }}
+      version: ${{ steps.tag.outputs.version }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Fetch Version
+        id: tag
+        run: |
+          if [[ "${{ github.event.inputs.version }}" != "" ]]; then
+            echo "version=${{ github.event.inputs.version }}" >> $GITHUB_OUTPUT
+          else
+            echo "version=${GITHUB_REF/refs\/tags\//}" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Update Tag
+        uses: richardsimko/update-tag@v1
+        with:
+          tag_name: ${{ steps.tag.outputs.version }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate Release Notes
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: bash scripts/generate-release-notes.sh --debug --version ${{ steps.tag.outputs.version }}
+
+      - name: Create Release
+        id: create_release
+        uses: ncipollo/release-action@v1
+        with:
+          name: Lite XL ${{ steps.tag.outputs.version }}
+          tag: ${{ steps.tag.outputs.version }}
+          draft: true
+          bodyFile: release-notes.md
+          allowUpdates: true
+
+  build_linux:
+    name: Linux
+    needs: release
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_REF=${{ needs.release.outputs.version }}" >> "$GITHUB_ENV"
+          echo "CCACHE_DIR=$PWD/.ccache" >> $GITHUB_ENV
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      # disabled because this will break our own Python install
+      - name: Python Setup
+        if: false
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      # disabled because the container has up-to-date packages
+      - name: Update Packages
+        if: false
+        run: sudo apt-get update
+
+      # disabled as the dependencies are already installed
+      - name: Install Dependencies
+        if: false
+        run: |
+          bash scripts/install-dependencies.sh --debug
+          sudo apt-get install -y ccache
+
+      - name: Build Portable
+        uses: docker://ghcr.io/lite-xl/lite-xl-build-box-manylinux:v4
+        with:
+          entrypoint: /entrypoint.sh
+          args: |
+            bash --version
+            bash scripts/build.sh --debug --forcefallback --portable --release --lto
+
+      - name: Package Portables
+        uses: docker://ghcr.io/lite-xl/lite-xl-build-box-manylinux:v4
+        with:
+          entrypoint: /entrypoint.sh
+          args: |
+            bash scripts/package.sh --version ${INSTALL_REF} --debug --binary --release
+            bash scripts/package.sh --version ${INSTALL_REF} --debug --addons --binary --release
+
+      - name: Build AppImages
+        uses: docker://ghcr.io/lite-xl/lite-xl-build-box-manylinux:v4
+        with:
+          entrypoint: /entrypoint.sh
+          args: |
+            bash scripts/appimage.sh --debug --static --version ${INSTALL_REF} --release
+            bash scripts/appimage.sh --debug --nobuild --addons --version ${INSTALL_REF}
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Linux Artifacts
+          path: |
+            lite-xl-${{ env.INSTALL_REF }}-linux-x86_64-portable.tar.gz
+            lite-xl-${{ env.INSTALL_REF }}-addons-linux-x86_64-portable.tar.gz
+            LiteXL-${{ env.INSTALL_REF }}-x86_64.AppImage
+            LiteXL-${{ env.INSTALL_REF }}-addons-x86_64.AppImage
+
+  build_macos:
+    name: macOS
+    needs: release
+    strategy:
+      matrix:
+        config:
+          - { arch: x86_64, runner: macos-13 } # macos-13 uses x86_64
+          - { arch: arm64, runner: macos-14 } # macos-14 / latest uses M1
+
+    runs-on: ${{ matrix.config.runner }}
+    env:
+      CC: clang
+      CXX: clang++
+
+    steps:
+      - name: System Information
+        run: |
+          system_profiler SPSoftwareDataType
+          bash --version
+          gcc -v
+          xcodebuild -version
+
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_REF=${{ needs.release.outputs.version }}" >> "$GITHUB_ENV"
+          echo "INSTALL_NAME=lite-xl-${{ needs.release.outputs.version }}-macos-${{ matrix.config.arch }}" >> "$GITHUB_ENV"
+          echo "INSTALL_NAME_ADDONS=lite-xl-${{ needs.release.outputs.version }}-addons-macos-${{ matrix.config.arch }}" >> "$GITHUB_ENV"
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Python Setup
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install Dependencies
+        run: |
+          brew install bash md5sha1sum cmake
+          pip install meson ninja dmgbuild
+
+      - name: Build
+        run: |
+          bash --version
+          bash scripts/build.sh --bundle --debug --forcefallback --release --lto
+
+      - name: Create DMG Image
+        run: |
+          bash scripts/package.sh --version ${INSTALL_REF} --debug --dmg --release
+          bash scripts/package.sh --version ${INSTALL_REF} --debug --addons --dmg --release
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: macOS DMG Images (${{ matrix.config.arch }})
+          path: |
+            ${{ env.INSTALL_NAME }}.dmg
+            ${{ env.INSTALL_NAME_ADDONS }}.dmg
+
+  build_macos_universal:
+    name: macOS (Universal)
+    needs: [release, build_macos]
+    runs-on: macos-14
+
+    steps:
+      - name: System Information
+        run: |
+          system_profiler SPSoftwareDataType
+          bash --version
+          gcc -v
+          xcodebuild -version
+
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_BASE=lite-xl-${{ needs.release.outputs.version }}-macos" >> "$GITHUB_ENV"
+          echo "INSTALL_BASE_ADDONS=lite-xl-${{ needs.release.outputs.version }}-addons-macos" >> "$GITHUB_ENV"
+
+      - uses: actions/checkout@v4
+
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        id: download
+        with:
+          pattern: macOS DMG Images *
+          merge-multiple: true
+          path: dmgs-original
+
+      - name: Python Setup
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dmgbuild
+        run: pip install dmgbuild
+
+      - name: Prepare DMG Images
+        run: |
+          mkdir -p dmgs-addons dmgs-normal
+          mv -v "${{ steps.download.outputs.download-path }}/$INSTALL_BASE-"{x86_64,arm64}.dmg dmgs-normal
+          mv -v "${{ steps.download.outputs.download-path }}/$INSTALL_BASE_ADDONS-"{x86_64,arm64}.dmg dmgs-addons
+
+      - name: Create Universal DMGs
+        run: |
+          bash --version
+          bash scripts/make-universal-binaries.sh dmgs-normal "$INSTALL_BASE-universal"
+          bash scripts/make-universal-binaries.sh dmgs-addons "$INSTALL_BASE_ADDONS-universal"
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: macOS DMG Images (Universal)
+          path: |
+            ${{ env.INSTALL_BASE }}-universal.dmg
+            ${{ env.INSTALL_BASE_ADDONS }}-universal.dmg
+
+  build_windows_msys2:
+    name: Windows
+    needs: release
+    runs-on: windows-2019
+    strategy:
+      matrix:
+        config:
+          - { msystem: MINGW32, arch: i686 }
+          - { msystem: MINGW64, arch: x86_64 }
+    defaults:
+      run:
+        shell: msys2 {0}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.config.msystem }}
+          update: true
+          install: >-
+            base-devel
+            git
+            zip
+            unzip
+            patch
+          pacboy: >-
+            gcc:p
+            meson:p
+            ca-certificates:p
+            ninja:p
+            pkg-config:p
+            cmake:p
+
+      - name: Set Environment Variables
+        run: |
+          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
+          echo "INSTALL_REF=${{ needs.release.outputs.version }}" >> "$GITHUB_ENV"
+          if [[ "${MSYSTEM}" == "MINGW64" ]]; then
+            echo "INSTALL_NAME=lite-xl-${{ needs.release.outputs.version }}-windows-x86_64" >> "$GITHUB_ENV"
+            echo "INSTALL_NAME_ADDONS=lite-xl-${{ needs.release.outputs.version }}-addons-windows-x86_64" >> "$GITHUB_ENV"
+          else
+            echo "INSTALL_NAME=lite-xl-${{ needs.release.outputs.version }}-windows-i686" >> "$GITHUB_ENV"
+            echo "INSTALL_NAME_ADDONS=lite-xl-${{ needs.release.outputs.version }}-addons-windows-i686" >> "$GITHUB_ENV"
+          fi
+
+      - name: Install Dependencies
+        if: false
+        run: bash scripts/install-dependencies.sh --debug
+
+      - name: Build
+        run: |
+          bash --version
+          bash scripts/build.sh -U --debug --forcefallback --release --lto
+
+      - name: Package
+        run: bash scripts/package.sh --version ${INSTALL_REF} --debug --binary --release
+
+      - name: Build Installer
+        run: bash scripts/innosetup/innosetup.sh --debug --version ${INSTALL_REF}
+
+      - name: Package With Addons
+        run: bash scripts/package.sh --version ${INSTALL_REF} --debug --addons --binary --release
+
+      - name: Build Installer With Addons
+        run: bash scripts/innosetup/innosetup.sh --debug --version ${INSTALL_REF} --addons
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: Windows Builds (${{ matrix.config.msystem }})
+          path: |
+            ${{ env.INSTALL_NAME }}.zip
+            ${{ env.INSTALL_NAME_ADDONS }}.zip
+            LiteXL-${{ env.INSTALL_REF }}-${{ matrix.config.arch }}-setup.exe
+            LiteXL-${{ env.INSTALL_REF }}-addons-${{ matrix.config.arch }}-setup.exe
+
+  upload_artifacts:
+    name: Upload Release Artifacts
+    runs-on: ubuntu-latest
+    needs:
+      [release, build_linux, build_macos, build_macos_universal, build_windows_msys2]
+    permissions:
+      contents: write
+
+    steps:
+      - name: Download Artifacts
+        uses: actions/download-artifact@v4
+        with:
+          merge-multiple: true
+
+      - name: Update Release
+        uses: ncipollo/release-action@v1
+        with:
+          tag: ${{ needs.release.outputs.version }}
+          omitBodyDuringUpdate: true
+          omitDraftDuringUpdate: true
+          omitNameDuringUpdate: true
+          omitPrereleaseDuringUpdate: true
+          allowUpdates: true
+          artifacts: "*.exe,*.zip,*.tar.gz,*.dmg,*.AppImage"

.gitignore

@@ -1,7 +1,30 @@
-build*
-.build*
-*.zip
+build*/
+.build*/
+lhelper/
+submodules/
+subprojects/*/
+/appimage*
+.vscode
+.cache
+.ccls-cache
 .lite-debug.log
-subprojects/lua
-subprojects/libagg
-sybprojects/lua
+.run*
+*.diff
+*.exe
+*.tar.gz
+*.zip
+*.DS_Store
+*App*
+compile_commands.json
+error.txt
+lite-xl*
+LiteXL*
+
+!resources/windows/*.diff
+!resources/windows/*.exe.manifest.in
+!resources/macos/*.py
+!scripts/innosetup/lite-xl@*.bmp
+!scripts/innosetup/lite-xl-banner@*.bmp
+debian/.debhelper/
+debian/files
+debhelper-build-stamp

LICENSE

@@ -1,4 +1,6 @@
 Copyright (c) 2020 rxi
+Copyright (c) 2020-2022 Francesco Abbate
+Copyright (c) 2022-present Lite XL Team
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

README.md

@@ -1,87 +1,193 @@
 # Lite XL
 
-![screenshot-dark](https://user-images.githubusercontent.com/433545/85227778-b42abc80-b3df-11ea-9dd3-e788f6c71882.png)
+[![CI]](https://github.com/lite-xl/lite-xl/actions/workflows/build.yml)
+[![Discord Badge Image]](https://discord.gg/RWzqC3nx7K)
 
-A lightweight text editor written in Lua, adapted from [Lite](https://github.com/rxi/lite)
+![screenshot-dark]
 
-* **[Get lite](https://github.com/franko/lite-xl/releases/latest)** — Download
-  for Windows and Linux
-* **[Get started](doc/usage.md)** — A quick overview on how to get started
-* **[Get plugins](https://github.com/rxi/lite-plugins)** — Add additional
-  functionality
-* **[Get color themes](https://github.com/rxi/lite-colors)** — Add additional colors
-  themes
+A lightweight text editor written in Lua, adapted from [lite].
 
-The differences between Lite XL and rxi/lite are listed in the [changelog](https://github.com/franko/lite-xl/blob/master/changelog.md).
+* **[Get Lite XL]** — Download for Windows, Linux and Mac OS.
+* **[Get plugins]** — Add additional functionality, adapted for Lite XL.
+* **[Get color themes]** — Add additional colors themes.
+
+Please refer to our [website] for the user and developer documentation,
+including [build] instructions details. A quick build guide is described below.
+
+Lite XL has support for high DPI display on Windows and Linux and,
+since 1.16.7 release, it supports **retina displays** on macOS.
+
+Please note that Lite XL is compatible with lite for most plugins and all color themes.
+We provide a separate lite-xl-plugins repository for Lite XL, because in some cases
+some adaptations may be needed to make them work better with Lite XL.
+The repository with modified plugins is https://github.com/lite-xl/lite-xl-plugins.
+
+The changes and differences between Lite XL and rxi/lite are listed in the
+[changelog].
 
 ## Overview
-Lite XL is derived from Lite. It is a lightweight text editor written mostly in Lua — it aims to provide
-something practical, pretty, *small* and fast easy to modify and extend, or to use without doing either.
 
-The aim of Lite XL compared to Lite is to be more user friendly, improve the quality of the font rendering and reduce CPU usage.
+Lite XL is derived from [lite].
+It is a lightweight text editor written mostly in Lua — it aims to provide
+something practical, pretty, *small* and fast easy to modify and extend,
+or to use without doing either.
+
+The aim of Lite XL compared to lite is to be more user friendly,
+improve the quality of font rendering, and reduce CPU usage.
 
 ## Customization
-Additional functionality can be added through plugins which are available from
-the [plugins repository](https://github.com/rxi/lite-plugins); additional color
-themes can be found in the [colors repository](https://github.com/rxi/lite-colors).
-The editor can be customized by making changes to the
-[user module](data/user/init.lua).
 
-## Building
+Additional functionality can be added through plugins which are available in
+the [plugins repository] or in the [Lite XL plugins repository].
 
-You can build the project yourself on Linux using the provided `build.sh`
-script or using the Meson build.
-The script `build-packages.sh` can be used to compile Lite XL and create a package adapted to the OS, Linux, Windows or Mac OS X.
+Additional color themes can be found in the [colors repository].
+These color themes are bundled with all releases of Lite XL by default.
 
-The following libraries are required:
+## Quick Build Guide
 
-- freetype2
-- SDL2
-
-The additional libraries libagg and Lua 5.2 are optional.
-If they are not found they will be included by the Meson build system.
-
-On a debian based systems the required library and Meson can be installed using the commands:
+If you compile Lite XL yourself, it is recommended to use the script
+`build-packages.sh`:
 
 ```sh
-# To install the required libraries:
-sudo apt install libfreetype6-dev libsdl2-dev
-
-# To install Meson:
-sudo apt install meson
-# or pip3 install --user meson
+bash build-packages.sh -h
 ```
 
-To build Lite XL with Meson use the commands:
-```sh
-# configure
-meson setup build
+The script will run Meson and create a tar compressed archive with the application or,
+for Windows, a zip file. Lite XL can be easily installed
+by unpacking the archive in any directory of your choice.
 
-# build
-ninja -C build
-
-# Only of linux:
-ninja -C build install
-```
-
-If you want to install Lite XL on Windows or Mac OS X we suggest to use the script `build-packages.sh`:
+Otherwise the following is an example of basic commands if you want to customize
+the build:
 
 ```sh
-bash build-packages.sh <version> <arch>
+meson setup --buildtype=release --prefix <prefix> build
+meson compile -C build
+DESTDIR="$(pwd)/lite-xl" meson install --skip-subprojects -C build
 ```
 
-It will run meson and create a Zip file that can be easily installed or uninstalled.
+where `<prefix>` might be one of `/`, `/usr` or `/opt`, the default is `/`.
+To build a bundle application on macOS:
+
+```sh
+meson setup --buildtype=release --Dbundle=true --prefix / build
+meson compile -C build
+DESTDIR="$(pwd)/Lite XL.app" meson install --skip-subprojects -C build
+```
+
+Please note that the package is relocatable to any prefix and the option prefix
+affects only the place where the application is actually installed.
+
+## Installing Prebuilt
+
+Head over to [releases](https://github.com/lite-xl/lite-xl/releases) and download the version for your operating system.
+
+### Windows
+
+Lite XL comes with installers on Windows for typical installations.
+Alternatively, we provide ZIP archives that you can download and extract anywhere and run directly.
+
+To make Lite XL portable (e.g. running Lite XL from a thumb drive),
+simply create a `user` folder where `lite-xl.exe` is located.
+Lite XL will load and store all your configurations and plugins in the folder.
+
+### macOS
+
+We provide DMG files for macOS. Simply drag the program into your Applications folder.
+
+> **Important**
+> Newer versions of Lite XL are signed with a self-signed certificate,
+> so you'll have to follow these steps when running Lite XL for the first time.
+>
+> 1. Find Lite XL in Finder (do not open it in Launchpad).
+> 2. Control-click Lite XL, then choose `Open` from the shortcut menu.
+> 3. Click `Open` in the popup menu.
+>
+> The correct steps may vary between macOS versions, so you should refer to
+> the [macOS User Guide](https://support.apple.com/en-my/guide/mac-help/mh40616/mac).
+>
+> On an older version of Lite XL, you will need to run these commands instead:
+> 
+> ```sh
+> # clears attributes from the directory
+> xattr -cr /Applications/Lite\ XL.app
+> ```
+>
+> Otherwise, macOS will display a **very misleading error** saying that the application is damaged.
+
+### Linux
+
+Unzip the file and `cd` into the `lite-xl` directory:
+
+```sh
+tar -xzf <file>
+cd lite-xl
+```
+
+To run lite-xl without installing:
+```sh
+./lite-xl
+```
+
+To install lite-xl copy files over into appropriate directories:
+
+```sh
+rm -rf  $HOME/.local/share/lite-xl $HOME/.local/bin/lite-xl
+mkdir -p $HOME/.local/bin && cp lite-xl $HOME/.local/bin/
+mkdir -p $HOME/.local/share/lite-xl && cp -r data/* $HOME/.local/share/lite-xl/
+```
+
+If `$HOME/.local/bin` is not in PATH:
+
+```sh
+echo -e 'export PATH=$PATH:$HOME/.local/bin' >> $HOME/.bashrc
+```
+
+To get the icon to show up in app launcher:
+
+```sh
+xdg-desktop-menu forceupdate
+```
+
+You may need to logout and login again to see icon in app launcher.
+
+To uninstall just run:
+
+```sh
+rm -f $HOME/.local/bin/lite-xl
+rm -rf $HOME/.local/share/icons/hicolor/scalable/apps/lite-xl.svg \
+          $HOME/.local/share/applications/org.lite_xl.lite_xl.desktop \
+          $HOME/.local/share/metainfo/org.lite_xl.lite_xl.appdata.xml \
+          $HOME/.local/share/lite-xl
+```
 
-Please note the, while compiling Lite XL on Mac OS X should work Mac OS X
-is not well supported.
 
 ## Contributing
+
 Any additional functionality that can be added through a plugin should be done
-so as a plugin, after which a pull request to the
-[plugins repository](https://github.com/rxi/lite-plugins) can be made.
+as a plugin, after which a pull request to the [Lite XL plugins repository] can be made.
 
 Pull requests to improve or modify the editor itself are welcome.
 
-## License
+## Licenses
+
 This project is free software; you can redistribute it and/or modify it under
-the terms of the MIT license. See [LICENSE](LICENSE) for details.
+the terms of the MIT license. See [LICENSE] for details.
+
+See the [licenses] file for details on licenses used by the required dependencies.
+
+
+[CI]:                         https://github.com/lite-xl/lite-xl/actions/workflows/build.yml/badge.svg
+[Discord Badge Image]:        https://img.shields.io/discord/847122429742809208?label=discord&logo=discord
+[screenshot-dark]:            https://user-images.githubusercontent.com/433545/111063905-66943980-84b1-11eb-9040-3876f1133b20.png
+[lite]:                       https://github.com/rxi/lite
+[website]:                    https://lite-xl.com
+[build]:                      https://lite-xl.com/en/documentation/build
+[Get Lite XL]:                https://github.com/lite-xl/lite-xl/releases/latest
+[Get plugins]:                https://github.com/lite-xl/lite-xl-plugins
+[Get color themes]:           https://github.com/lite-xl/lite-xl-colors
+[changelog]:                  https://github.com/lite-xl/lite-xl/blob/master/changelog.md
+[Lite XL plugins repository]: https://github.com/lite-xl/lite-xl-plugins
+[plugins repository]:         https://github.com/rxi/lite-plugins
+[colors repository]:          https://github.com/lite-xl/lite-xl-colors
+[LICENSE]:                    LICENSE
+[licenses]:                   licenses/licenses.md

build-packages.sh

@@ -1,135 +1,206 @@
 #!/bin/bash
+set -e
 
-copy_directory_from_repo () {
-  local dirname="$1"
-  local destdir="$2"
-  git --work-tree="$destdir" checkout HEAD -f -- "$dirname"
+if [ ! -e "src/api/api.h" ]; then
+  echo "Please run this script from the root directory of Lite XL."; exit 1
+fi
+
+source scripts/common.sh
+
+show_help() {
+  echo
+  echo "Usage: $0 <OPTIONS>"
+  echo
+  echo "Common options:"
+  echo
+  echo "-h --help                     Show this help and exit."
+  echo "-b --builddir DIRNAME         Set the name of the build directory (not path)."
+  echo "                              Default: '$(get_default_build_dir)'."
+  echo "-p --prefix PREFIX            Install directory prefix."
+  echo "                              Default: '/'."
+  echo "   --cross-platform PLATFORM  The platform to cross compile for."
+  echo "   --cross-arch ARCH          The architecture to cross compile for."
+  echo "   --debug                    Debug this script."
+  echo
+  echo "Build options:"
+  echo
+  echo "-f --forcefallback            Force to build subprojects dependencies statically."
+  echo "-B --bundle                   Create an App bundle (macOS only)"
+  echo "-P --portable                 Create a portable package."
+  echo "-O --pgo                      Use profile guided optimizations (pgo)."
+  echo "                              Requires running the application iteractively."
+  echo "   --cross-file CROSS_FILE    The cross file used for compiling."
+  echo
+  echo "Package options:"
+  echo
+  echo "-d --destdir DIRNAME          Set the name of the package directory (not path)."
+  echo "                              Default: 'lite-xl'."
+  echo "-v --version VERSION          Sets the version on the package name."
+  echo "-A --appimage                 Create an AppImage (Linux only)."
+  echo "-D --dmg                      Create a DMG disk image (macOS only)."
+  echo "                              Requires dmgbuild."
+  echo "-I --innosetup                Create an InnoSetup installer (Windows only)."
+  echo "-r --release                  Compile in release mode."
+  echo "-S --source                   Create a source code package,"
+  echo "                              including subprojects dependencies."
+  echo
 }
 
-# Check if build directory is ok to be used to build.
-build_dir_is_usable () {
-  local build="$1"
-  if [[ $build == */* || -z "$build" ]]; then
-    echo "invalid build directory, no path allowed: \"$build\""
-    return 1
-  fi
-  git ls-files --error-unmatch "$build" &> /dev/null
-  if [ $? == 0 ]; then
-    echo "invalid path, \"$build\" is under revision control"
-    return 1
-  fi
-}
+main() {
+  local build_dir
+  local build_dir_option=()
+  local dest_dir
+  local dest_dir_option=()
+  local prefix
+  local prefix_option=()
+  local version
+  local version_option=()
+  local debug
+  local force_fallback
+  local appimage
+  local bundle
+  local innosetup
+  local portable
+  local pgo
+  local release
+  local cross_platform
+  local cross_platform_option=()
+  local cross_arch
+  local cross_arch_option=()
+  local cross_file
+  local cross_file_option=()
 
-# Ordinary release build
-lite_build () {
-  local build="$1"
-  build_dir_is_usable "$build" || exit 1
-  rm -fr "$build"
-  meson setup --buildtype=release "$build" || exit 1
-  ninja -C "$build" || exit 1
-}
+  for i in "$@"; do
+    case $i in
+      -h|--help)
+        show_help
+        exit 0
+        ;;
+      -b|--builddir)
+        build_dir="$2"
+        shift
+        shift
+        ;;
+      -d|--destdir)
+        dest_dir="$2"
+        shift
+        shift
+        ;;
+      -f|--forcefallback)
+        force_fallback="--forcefallback"
+        shift
+        ;;
+      -p|--prefix)
+        prefix="$2"
+        shift
+        shift
+        ;;
+      -v|--version)
+        version="$2"
+        shift
+        shift
+        ;;
+      -A|--appimage)
+        appimage="--appimage"
+        shift
+        ;;
+      -B|--bundle)
+        bundle="--bundle"
+        shift
+        ;;
+      -D|--dmg)
+        dmg="--dmg"
+        shift
+        ;;
+      -I|--innosetup)
+        innosetup="--innosetup"
+        shift
+        ;;
+      -P|--portable)
+        portable="--portable"
+        shift
+        ;;
+      -r|--release)
+        release="--release"
+        shift
+        ;;
+      -S|--source)
+        source="--source"
+        shift
+        ;;
+      -O|--pgo)
+        pgo="--pgo"
+        shift
+        ;;
+      --cross-platform)
+        cross_platform="$2"
+        shift
+        shift
+        ;;
+      --cross-arch)
+        cross_arch="$2"
+        shift
+        shift
+        ;;
+      --cross-file)
+        cross_file="$2"
+        shift
+        shift
+        ;;
+      --debug)
+        debug="--debug"
+        set -x
+        shift
+        ;;
+      *)
+        # unknown option
+        ;;
+    esac
+  done
 
-# Build using Profile Guided Optimizations (PGO)
-lite_build_pgo () {
-  local build="$1"
-  build_dir_is_usable "$build" || exit 1
-  rm -fr "$build"
-  meson setup --buildtype=release -Db_pgo=generate "$build" || exit 1
-  ninja -C "$build" || exit 1
-  copy_directory_from_repo data "$build/src"
-  "$build/src/lite"
-  meson configure -Db_pgo=use "$build"
-  ninja -C "$build" || exit 1
-}
-
-lite_build_package_windows () {
-  build="$1"
-  version="$2"
-  arch="$3"
-  os="win"
-  local pdir=".package-build/lite-xl"
-  mkdir -p "$pdir"
-  copy_directory_from_repo data "$pdir"
-  cp "$build/src/lite.exe" "$pdir"
-  strip --strip-all "$pdir/lite.exe"
-  pushd ".package-build"
-  local package_name="lite-xl-$version-$os-$arch.zip"
-  zip "$package_name" -r "lite-xl"
-  mv "$package_name" ..
-  popd
-  rm -fr ".package-build"
-  echo "created package $package_name"
-}
-
-lite_build_package_macosx () {
-  build="$1"
-  version="$2"
-  arch="$3"
-  os="macosx"
-  local pdir=".package-build/lite-xl.app/Contents/MacOS"
-  mkdir -p "$pdir"
-  copy_directory_from_repo data "$pdir"
-  cp "$build/src/lite" "$pdir"
-  strip "$pdir/lite"
-  pushd ".package-build"
-  local package_name="lite-xl-$version-$os-$arch.zip"
-  zip "$package_name" -r "lite-xl.app"
-  mv "$package_name" ..
-  popd
-  rm -fr ".package-build"
-  echo "created package $package_name"
-}
-
-lite_build_package_linux () {
-  build="$1"
-  version="$2"
-  arch="$3"
-  os="linux"
-  local pdir=".package-build/lite-xl"
-  mkdir -p "$pdir"
-  copy_directory_from_repo data "$pdir"
-  cp "$build/src/lite" "$pdir"
-  strip "$pdir/lite"
-  pushd ".package-build"
-  local package_name="lite-xl-$version-$os-$arch.tar.gz"
-  tar czf "$package_name" "lite-xl"
-  mv "$package_name" ..
-  popd
-  rm -fr ".package-build"
-  echo "created package $package_name"
-}
-
-lite_build_package () {
-  if [[ "$OSTYPE" == msys || "$OSTYPE" == win32 ]]; then
-    lite_build_package_windows "$@"
-  elif [[ "$OSTYPE" == "darwin"* ]]; then
-    lite_build_package_macosx "$@"
-  elif [[ "$OSTYPE" == "linux"* || "$OSTYPE" == "freebsd"* ]]; then
-    lite_build_package_linux "$@"
-  else
-    echo "Unknown OS type \"$OSTYPE\""
+  if [[ -n $1 ]]; then
+    show_help
     exit 1
   fi
+
+  if [[ -n $build_dir ]]; then build_dir_option=("--builddir" "${build_dir}"); fi
+  if [[ -n $dest_dir ]]; then dest_dir_option=("--destdir" "${dest_dir}"); fi
+  if [[ -n $prefix ]]; then prefix_option=("--prefix" "${prefix}"); fi
+  if [[ -n $version ]]; then version_option=("--version" "${version}"); fi
+  if [[ -n $cross_platform ]]; then cross_platform_option=("--cross-platform" "${cross_platform}"); fi
+  if [[ -n $cross_arch ]]; then cross_arch_option=("--cross-arch" "${cross_arch}"); fi
+  if [[ -n $cross_file ]]; then cross_file_option=("--cross-file" "${cross_file}"); fi
+
+
+
+  source scripts/build.sh \
+    ${build_dir_option[@]} \
+    ${prefix_option[@]} \
+    ${cross_platform_option[@]} \
+    ${cross_arch_option[@]} \
+    ${cross_file_option[@]} \
+    $debug \
+    $force_fallback \
+    $bundle \
+    $portable \
+    $release \
+    $pgo
+
+  source scripts/package.sh \
+    ${build_dir_option[@]} \
+    ${dest_dir_option[@]} \
+    ${prefix_option[@]} \
+    ${version_option[@]} \
+    ${cross_platform_option[@]} \
+    ${cross_arch_option[@]} \
+    --binary \
+    --addons \
+    $debug \
+    $appimage \
+    $dmg \
+    $innosetup \
+    $release \
+    $source
 }
 
-if [[ -z "$1" || -z "$2" ]]; then
-  echo "usage: $0 <version> <arch>"
-  exit 1
-fi
-
-if [[ "$1" == "-pgo" ]]; then
-  pgo=true
-  shift
-fi
-
-version="$1"
-arch="$2"
-build_dir=".build-$arch"
-
-if [ -z ${pgo+set} ]; then
-  lite_build "$build_dir"
-else
-  lite_build_pgo "$build_dir"
-fi
-lite_build_package "$build_dir" "$version" "$arch"
-
+main "$@"

build.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-cflags="-Wall -O3 -g -std=gnu11 -fno-strict-aliasing -Isrc -Ilib/font_renderer"
-cflags+=" $(pkg-config --cflags lua5.2) $(sdl2-config --cflags)"
-lflags="-static-libgcc -static-libstdc++"
-for package in libagg freetype2 lua5.2; do
-  lflags+=" $(pkg-config --libs $package)"
-done
-lflags+=" $(sdl2-config --libs) -lm"
-
-if [[ $* == *windows* ]]; then
-  echo "cross compiling for windows is not yet supported"
-  exit 1
-else
-  outfile="lite"
-  compiler="gcc"
-  cxxcompiler="g++"
-fi
-
-lib/font_renderer/build.sh || exit 1
-libs=libfontrenderer.a
-
-echo "compiling lite..."
-for f in `find src -name "*.c"`; do
-  $compiler -c $cflags $f -o "${f//\//_}.o"
-  if [[ $? -ne 0 ]]; then
-    got_error=true
-  fi
-done
-
-if [[ ! $got_error ]]; then
-  echo "linking..."
-  $cxxcompiler -o $outfile *.o $libs $lflags
-fi
-
-echo "cleaning up..."
-rm *.o *.a
-echo "done"
-

data/colors/default.lua

@@ -0,0 +1,46 @@
+local style = require "core.style"
+local common = require "core.common"
+
+style.background = { common.color "#2e2e32" }  -- Docview
+style.background2 = { common.color "#252529" } -- Treeview
+style.background3 = { common.color "#252529" } -- Command view
+style.text = { common.color "#97979c" }
+style.caret = { common.color "#93DDFA" }
+style.accent = { common.color "#e1e1e6" }
+-- style.dim - text color for nonactive tabs, tabs divider, prefix in log and
+-- search result, hotkeys for context menu and command view
+style.dim = { common.color "#525257" }
+style.divider = { common.color "#202024" } -- Line between nodes
+style.selection = { common.color "#48484f" }
+style.line_number = { common.color "#525259" }
+style.line_number2 = { common.color "#83838f" } -- With cursor
+style.line_highlight = { common.color "#343438" }
+style.scrollbar = { common.color "#414146" }
+style.scrollbar2 = { common.color "#4b4b52" } -- Hovered
+style.scrollbar_track = { common.color "#252529" }
+style.nagbar = { common.color "#FF0000" }
+style.nagbar_text = { common.color "#FFFFFF" }
+style.nagbar_dim = { common.color "rgba(0, 0, 0, 0.45)" }
+style.drag_overlay = { common.color "rgba(255,255,255,0.1)" }
+style.drag_overlay_tab = { common.color "#93DDFA" }
+style.good = { common.color "#72b886" }
+style.warn = { common.color "#FFA94D" }
+style.error = { common.color "#FF3333" }
+style.modified = { common.color "#1c7c9c" }
+
+style.syntax["normal"] = { common.color "#e1e1e6" }
+style.syntax["symbol"] = { common.color "#e1e1e6" }
+style.syntax["comment"] = { common.color "#676b6f" }
+style.syntax["keyword"] = { common.color "#E58AC9" }  -- local function end if case
+style.syntax["keyword2"] = { common.color "#F77483" } -- self int float
+style.syntax["number"] = { common.color "#FFA94D" }
+style.syntax["literal"] = { common.color "#FFA94D" }  -- true false nil
+style.syntax["string"] = { common.color "#f7c95c" }
+style.syntax["operator"] = { common.color "#93DDFA" } -- = + - / < >
+style.syntax["function"] = { common.color "#93DDFA" }
+
+style.log["INFO"]  = { icon = "i", color = style.text }
+style.log["WARN"]  = { icon = "!", color = style.warn }
+style.log["ERROR"] = { icon = "!", color = style.error }
+
+return style

data/colors/textadept.lua

@@ -0,0 +1,51 @@
+local b05 = 'rgba(0,0,0,0.5)'   local red = '#994D4D'
+local b80 = '#333333'       local orange  = '#B3661A'
+local b60 = '#808080'       local green   = '#52994D'
+local b40 = '#ADADAD'       local teal    = '#4D9999'
+local b20 = '#CECECE'       local blue    = '#1A66B3'
+local b00 = '#E6E6E6'       local magenta = '#994D99'
+--------------------------=--------------------------
+local style               =     require  'core.style'
+local common              =     require 'core.common'
+--------------------------=--------------------------
+style.line_highlight      =     { common.color(b20) }
+style.background          =     { common.color(b00) }
+style.background2         =     { common.color(b20) }
+style.background3         =     { common.color(b20) }
+style.text                =     { common.color(b60) }
+style.caret               =     { common.color(b80) }
+style.accent              =     { common.color(b80) }
+style.dim                 =     { common.color(b60) }
+style.divider             =     { common.color(b40) }
+style.selection           =     { common.color(b40) }
+style.line_number         =     { common.color(b60) }
+style.line_number2        =     { common.color(b80) }
+style.scrollbar           =     { common.color(b40) }
+style.scrollbar2          =     { common.color(b60) }
+style.nagbar              =     { common.color(red) }
+style.nagbar_text         =     { common.color(b00) }
+style.nagbar_dim          =     { common.color(b05) }
+--------------------------=--------------------------
+style.syntax              =                        {}
+style.syntax['normal']    =     { common.color(b80) }
+style.syntax['symbol']    =     { common.color(b80) }
+style.syntax['comment']   =     { common.color(b60) }
+style.syntax['keyword']   =    { common.color(blue) }
+style.syntax['keyword2']  =     { common.color(red) }
+style.syntax['number']    =    { common.color(teal) }
+style.syntax['literal']   =    { common.color(blue) }
+style.syntax['string']    =   { common.color(green) }
+style.syntax['operator']  = { common.color(magenta) }
+style.syntax['function']  =    { common.color(blue) }
+--------------------------=--------------------------
+style.syntax.paren1       = { common.color(magenta) }
+style.syntax.paren2       =  { common.color(orange) }
+style.syntax.paren3       =    { common.color(teal) }
+style.syntax.paren4       =    { common.color(blue) }
+style.syntax.paren5       =     { common.color(red) }
+--------------------------=--------------------------
+style.lint                =                        {}
+style.lint.info           =    { common.color(blue) }
+style.lint.hint           =   { common.color(green) }
+style.lint.warning        =     { common.color(red) }
+style.lint.error          =  { common.color(orange) }

data/core/bit.lua

@@ -0,0 +1,36 @@
+local bit = {}
+
+local LUA_NBITS = 32
+local ALLONES = (~(((~0) << (LUA_NBITS - 1)) << 1))
+
+local function trim(x)
+	return (x & ALLONES)
+end
+
+local function mask(n)
+	return (~((ALLONES << 1) << ((n) - 1)))
+end
+
+local function check_args(field, width)
+	assert(field >= 0, "field cannot be negative")
+	assert(width > 0, "width must be positive")
+	assert(field + width < LUA_NBITS and field + width >= 0,
+	       "trying to access non-existent bits")
+end
+
+function bit.extract(n, field, width)
+	local w = width or 1
+	check_args(field, w)
+	local m = trim(n)
+	return m >> field & mask(w)
+end
+
+function bit.replace(n, v, field, width)
+	local w = width or 1
+	check_args(field, w)
+	local m = trim(n)
+	local x = v & mask(width);
+	return m & ~(mask(w) << field) | (x << field)
+end
+
+return bit

data/core/command.lua

@@ -1,22 +1,93 @@
 local core = require "core"
 local command = {}
 
+---A predicate function accepts arguments from `command.perform()` and evaluates to a boolean. </br>
+---If the function returns true, then the function associated with the command is executed.
+---
+---The predicate function can also return other values after the boolean, which will
+---be passed into the function associated with the command.
+---@alias core.command.predicate_function fun(...: any): boolean, ...
+
+---A predicate is a string, an Object or a function, that is used to determine
+---whether a command should be executed.
+---
+---If the predicate is a string, it is resolved into an `Object` via `require()`
+---and checked against the active view with `Object:extends()`. </br>
+---For example, `"core.docview"` will match any view that inherits from `DocView`. </br>
+---A `!` can be appended to the predicate to strictly match the current view via `Object:is()`,
+---instead of matching any view that inherits the predicate.
+---
+---If the predicate is a table, it is checked against the active view with `Object:extends()`.
+---Strict matching via `Object:is()` is not available.
+---
+---If the predicate is a function, it must behave like a predicate function.
+---@see core.command.predicate_function
+---@alias core.command.predicate string|core.object|core.command.predicate_function
+
+---A command is identified by a command name.
+---The command name contains a category and the name itself, separated by a colon (':').
+---
+---All commands should be in lowercase and should not contain whitespaces; instead
+---they should be replaced by a dash ('-').
+---@alias core.command.command_name string
+
+---The predicate and its associated function.
+---@class core.command.command
+---@field predicate core.command.predicate_function
+---@field perform fun(...: any)
+
+---@type { [string]: core.command.command }
 command.map = {}
 
+---@type core.command.predicate_function
 local always_true = function() return true end
 
 
-function command.add(predicate, map)
+---This function takes in a predicate and produces a predicate function
+---that is internally used to dispatch and execute commands.
+---
+---This function should not be called manually.
+---@see core.command.predicate
+---@param predicate core.command.predicate|nil If nil, the predicate always evaluates to true.
+---@return core.command.predicate_function
+function command.generate_predicate(predicate)
   predicate = predicate or always_true
+  local strict = false
   if type(predicate) == "string" then
+    if predicate:match("!$") then
+      strict = true
+      predicate = predicate:gsub("!$", "")
+    end
     predicate = require(predicate)
   end
   if type(predicate) == "table" then
     local class = predicate
-    predicate = function() return core.active_view:is(class) end
+    if not strict then
+      predicate = function(...) return core.active_view:extends(class), core.active_view, ... end
+    else
+      predicate = function(...) return core.active_view:is(class), core.active_view, ... end
+    end
   end
+  ---@cast predicate core.command.predicate_function
+  return predicate
+end
+
+
+---Adds commands to the map.
+---
+---The function accepts a table containing a list of commands
+---and their functions. </br>
+---If a command already exists, it will be replaced.
+---@see core.command.predicate
+---@see core.command.command_name
+---@param predicate core.command.predicate
+---@param map { [core.command.command_name]: fun(...: any) }
+function command.add(predicate, map)
+  predicate = command.generate_predicate(predicate)
   for name, fn in pairs(map) do
-    assert(not command.map[name], "command already exists: " .. name)
+    if command.map[name] then
+      core.log_quiet("Replacing existing command \"%s\"", name)
+    end
     command.map[name] = { predicate = predicate, perform = fn }
   end
 end
@@ -26,40 +97,86 @@ local function capitalize_first(str)
   return str:sub(1, 1):upper() .. str:sub(2)
 end
 
+---Prettifies the command name.
+---
+---This function adds a space between the colon and the command name,
+---replaces dashes with spaces and capitalizes the command appropriately.
+---@see core.command.command_name
+---@param name core.command.command_name
+---@return string
 function command.prettify_name(name)
+  ---@diagnostic disable-next-line: redundant-return-value
   return name:gsub(":", ": "):gsub("-", " "):gsub("%S+", capitalize_first)
 end
 
 
+---Returns all the commands that can be executed (their predicates evaluate to true).
+---@return core.command.command_name[]
 function command.get_all_valid()
   local res = {}
+  local memoized_predicates = {}
   for name, cmd in pairs(command.map) do
-    if cmd.predicate() then
+    if memoized_predicates[cmd.predicate] == nil then
+      memoized_predicates[cmd.predicate] = cmd.predicate()
+    end
+    if memoized_predicates[cmd.predicate] then
       table.insert(res, name)
     end
   end
   return res
 end
 
+---Checks whether a command can be executed (its predicate evaluates to true).
+---@param name core.command.command_name
+---@param ... any
+---@return boolean
+function command.is_valid(name, ...)
+  return command.map[name] and command.map[name].predicate(...)
+end
 
-local function perform(name)
+local function perform(name, ...)
   local cmd = command.map[name]
-  if cmd and cmd.predicate() then
-    cmd.perform()
+  if not cmd then return false end
+  local res = { cmd.predicate(...) }
+  if table.remove(res, 1) then
+    if #res > 0 then
+      -- send values returned from predicate
+      cmd.perform(table.unpack(res))
+    else
+      -- send original parameters
+      cmd.perform(...)
+    end
     return true
   end
   return false
 end
 
 
-function command.perform(...)
-  local ok, res = core.try(perform, ...)
+---Performs a command.
+---
+---The arguments passed into this function are forwarded to the predicate function. </br>
+---If the predicate function returns more than 1 value, the other values are passed
+---to the command.
+---
+---Otherwise, the arguments passed into this function are passed directly
+---to the command.
+---@see core.command.predicate
+---@see core.command.predicate_function
+---@param name core.command.command_name
+---@param ... any
+---@return boolean # true if the command is performed successfully.
+function command.perform(name, ...)
+  local ok, res = core.try(perform, name, ...)
   return not ok or res
 end
 
 
+---Inserts the default commands for Lite XL into the map.
 function command.add_defaults()
-  local reg = { "core", "root", "command", "doc", "findreplace" }
+  local reg = {
+    "core", "root", "command", "doc", "findreplace",
+    "files", "dialog", "log", "statusbar"
+  }
   for _, name in ipairs(reg) do
     require("core.commands." .. name)
   end

data/core/commands/command.lua

@@ -1,30 +1,24 @@
 local core = require "core"
 local command = require "core.command"
-local CommandView = require "core.commandview"
 
-local function has_commandview()
-  return core.active_view:is(CommandView)
-end
-
-
-command.add(has_commandview, {
-  ["command:submit"] = function()
-    core.active_view:submit()
+command.add("core.commandview", {
+  ["command:submit"] = function(active_view)
+    active_view:submit()
   end,
 
-  ["command:complete"] = function()
-    core.active_view:complete()
+  ["command:complete"] = function(active_view)
+    active_view:complete()
   end,
 
-  ["command:escape"] = function()
-    core.active_view:exit()
+  ["command:escape"] = function(active_view)
+    active_view:exit()
   end,
 
-  ["command:select-previous"] = function()
-    core.active_view:move_suggestion_idx(1)
+  ["command:select-previous"] = function(active_view)
+    active_view:move_suggestion_idx(1)
   end,
 
-  ["command:select-next"] = function()
-    core.active_view:move_suggestion_idx(-1)
+  ["command:select-next"] = function(active_view)
+    active_view:move_suggestion_idx(-1)
   end,
 })

data/core/commands/core.lua

@@ -6,109 +6,265 @@ local LogView = require "core.logview"
 
 
 local fullscreen = false
+local restore_title_view = false
+
+local function suggest_directory(text)
+  text = common.home_expand(text)
+  local basedir = common.dirname(core.project_dir)
+  return common.home_encode_list((basedir and text == basedir .. PATHSEP or text == "") and
+    core.recent_projects or common.dir_path_suggest(text))
+end
+
+local function check_directory_path(path)
+    local abs_path = system.absolute_path(path)
+    local info = abs_path and system.get_file_info(abs_path)
+    if not info or info.type ~= 'dir' then
+      return nil
+    end
+    return abs_path
+end
 
 command.add(nil, {
   ["core:quit"] = function()
     core.quit()
   end,
 
+  ["core:restart"] = function()
+    core.restart()
+  end,
+
   ["core:force-quit"] = function()
     core.quit(true)
   end,
 
   ["core:toggle-fullscreen"] = function()
     fullscreen = not fullscreen
+    if fullscreen then
+      restore_title_view = core.title_view.visible
+    end
     system.set_window_mode(fullscreen and "fullscreen" or "normal")
+    core.show_title_bar(not fullscreen and restore_title_view)
+    core.title_view:configure_hit_test(not fullscreen and restore_title_view)
   end,
 
   ["core:reload-module"] = function()
-    core.command_view:enter("Reload Module", function(text, item)
-      local text = item and item.text or text
-      core.reload_module(text)
-      core.log("Reloaded module %q", text)
-    end, function(text)
-      local items = {}
-      for name in pairs(package.loaded) do
-        table.insert(items, name)
+    core.command_view:enter("Reload Module", {
+      submit = function(text, item)
+        local text = item and item.text or text
+        core.reload_module(text)
+        core.log("Reloaded module %q", text)
+      end,
+      suggest = function(text)
+        local items = {}
+        for name in pairs(package.loaded) do
+          table.insert(items, name)
+        end
+        return common.fuzzy_match(items, text)
       end
-      return common.fuzzy_match(items, text)
-    end)
+    })
   end,
 
   ["core:find-command"] = function()
     local commands = command.get_all_valid()
-    core.command_view:enter("Do Command", function(text, item)
-      if item then
-        command.perform(item.command)
+    core.command_view:enter("Do Command", {
+      submit = function(text, item)
+        if item then
+          command.perform(item.command)
+        end
+      end,
+      suggest = function(text)
+        local res = common.fuzzy_match(commands, text)
+        for i, name in ipairs(res) do
+          res[i] = {
+            text = command.prettify_name(name),
+            info = keymap.get_binding(name),
+            command = name,
+          }
+        end
+        return res
       end
-    end, function(text)
-      local res = common.fuzzy_match(commands, text)
-      for i, name in ipairs(res) do
-        res[i] = {
-          text = command.prettify_name(name),
-          info = keymap.get_binding(name),
-          command = name,
-        }
-      end
-      return res
-    end)
+    })
   end,
 
   ["core:find-file"] = function()
+    if not core.project_files_number() then
+       return command.perform "core:open-file"
+    end
     local files = {}
-    for _, item in pairs(core.project_files) do
+    for dir, item in core.get_project_files() do
       if item.type == "file" then
-        table.insert(files, item.filename)
+        local path = (dir == core.project_dir and "" or dir .. PATHSEP)
+        table.insert(files, common.home_encode(path .. item.filename))
       end
     end
-    core.command_view:enter("Open File From Project", function(text, item)
-      text = item and item.text or text
-      core.root_view:open_doc(core.open_doc(text))
-    end, function(text)
-      if text == "" then
-        local recent_files = {}
-        for i = 2, #core.visited_files do
-            table.insert(recent_files, core.visited_files[i])
-        end
-        table.insert(recent_files, core.visited_files[1])
-        local other_files = common.fuzzy_match(files, "")
-        for i = 1, #other_files do
-          table.insert(recent_files, other_files[i])
-        end
-        return recent_files
-      else
-        return common.fuzzy_match(files, text)
+    core.command_view:enter("Open File From Project", {
+      submit = function(text, item)
+        text = item and item.text or text
+        core.root_view:open_doc(core.open_doc(common.home_expand(text)))
+      end,
+      suggest = function(text)
+        return common.fuzzy_match_with_recents(files, core.visited_files, text)
       end
-    end)
+    })
   end,
 
   ["core:new-doc"] = function()
     core.root_view:open_doc(core.open_doc())
   end,
 
+  ["core:new-named-doc"] = function()
+    core.command_view:enter("File name", {
+      submit = function(text)
+        core.root_view:open_doc(core.open_doc(text))
+      end
+    })
+  end,
+
   ["core:open-file"] = function()
-    core.command_view:enter("Open File", function(text)
-      core.root_view:open_doc(core.open_doc(text))
-    end, common.path_suggest)
+    local view = core.active_view
+    local text
+    if view.doc and view.doc.abs_filename then
+      local dirname, filename = view.doc.abs_filename:match("(.*)[/\\](.+)$")
+      if dirname then
+        dirname = core.normalize_to_project_dir(dirname)
+        text = dirname == core.project_dir and "" or common.home_encode(dirname) .. PATHSEP
+      end
+    end
+    core.command_view:enter("Open File", {
+      text = text,
+      submit = function(text)
+        local filename = system.absolute_path(common.home_expand(text))
+        core.root_view:open_doc(core.open_doc(filename))
+      end,
+      suggest = function (text)
+          return common.home_encode_list(common.path_suggest(common.home_expand(text)))
+        end,
+      validate = function(text)
+          local filename = common.home_expand(text)
+          local path_stat, err = system.get_file_info(filename)
+          if err then
+            if err:find("No such file", 1, true) then
+              -- check if the containing directory exists
+              local dirname = common.dirname(filename)
+              local dir_stat = dirname and system.get_file_info(dirname)
+              if not dirname or (dir_stat and dir_stat.type == 'dir') then
+                return true
+              end
+            end
+            core.error("Cannot open file %s: %s", text, err)
+          elseif path_stat.type == 'dir' then
+            core.error("Cannot open %s, is a folder", text)
+          else
+            return true
+          end
+        end,
+    })
   end,
 
   ["core:open-log"] = function()
-    local node = core.root_view:get_active_node()
+    local node = core.root_view:get_active_node_default()
     node:add_view(LogView())
   end,
 
   ["core:open-user-module"] = function()
-    core.root_view:open_doc(core.open_doc(EXEDIR .. "/data/user/init.lua"))
+    local user_module_doc = core.open_doc(USERDIR .. "/init.lua")
+    if not user_module_doc then return end
+    core.root_view:open_doc(user_module_doc)
   end,
 
   ["core:open-project-module"] = function()
-    local filename = ".lite_project.lua"
-    if system.get_file_info(filename) then
-      core.root_view:open_doc(core.open_doc(filename))
-    else
-      local doc = core.open_doc()
-      core.root_view:open_doc(doc)
-      doc:save(filename)
+    if not system.get_file_info(".lite_project.lua") then
+      core.try(core.write_init_project_module, ".lite_project.lua")
     end
+    local doc = core.open_doc(".lite_project.lua")
+    core.root_view:open_doc(doc)
+    doc:save()
+  end,
+
+  ["core:change-project-folder"] = function()
+    local dirname = common.dirname(core.project_dir)
+    local text
+    if dirname then
+      text = common.home_encode(dirname) .. PATHSEP
+    end
+    core.command_view:enter("Change Project Folder", {
+      text = text,
+      submit = function(text)
+        local path = common.home_expand(text)
+        local abs_path = check_directory_path(path)
+        if not abs_path then
+          core.error("Cannot open directory %q", path)
+          return
+        end
+        if abs_path == core.project_dir then return end
+        core.confirm_close_docs(core.docs, function(dirpath)
+          core.open_folder_project(dirpath)
+        end, abs_path)
+      end,
+      suggest = suggest_directory
+    })
+  end,
+
+  ["core:open-project-folder"] = function()
+    local dirname = common.dirname(core.project_dir)
+    local text
+    if dirname then
+      text = common.home_encode(dirname) .. PATHSEP
+    end
+    core.command_view:enter("Open Project", {
+      text = text,
+      submit = function(text)
+        local path = common.home_expand(text)
+        local abs_path = check_directory_path(path)
+        if not abs_path then
+          core.error("Cannot open directory %q", path)
+          return
+        end
+        if abs_path == core.project_dir then
+          core.error("Directory %q is currently opened", abs_path)
+          return
+        end
+        system.exec(string.format("%q %q", EXEFILE, abs_path))
+      end,
+      suggest = suggest_directory
+    })
+  end,
+
+  ["core:add-directory"] = function()
+    core.command_view:enter("Add Directory", {
+      submit = function(text)
+        text = common.home_expand(text)
+        local path_stat, err = system.get_file_info(text)
+        if not path_stat then
+          core.error("cannot open %q: %s", text, err)
+          return
+        elseif path_stat.type ~= 'dir' then
+          core.error("%q is not a directory", text)
+          return
+        end
+        core.add_project_directory(system.absolute_path(text))
+      end,
+      suggest = suggest_directory
+    })
+  end,
+
+  ["core:remove-directory"] = function()
+    local dir_list = {}
+    local n = #core.project_directories
+    for i = n, 2, -1 do
+      dir_list[n - i + 1] = core.project_directories[i].name
+    end
+    core.command_view:enter("Remove Directory", {
+      submit = function(text, item)
+        text = common.home_expand(item and item.text or text)
+        if not core.remove_project_directory(text) then
+          core.error("No directory %q to be removed", text)
+        end
+      end,
+      suggest = function(text)
+        text = common.home_expand(text)
+        return common.home_encode_list(common.dir_list_suggest(text, dir_list))
+      end
+    })
   end,
 })

data/core/commands/dialog.lua

@@ -0,0 +1,30 @@
+local core = require "core"
+local command = require "core.command"
+local common = require "core.common"
+
+command.add("core.nagview", {
+  ["dialog:previous-entry"] = function(v)
+    local hover = v.hovered_item or 1
+    v:change_hovered(hover == 1 and #v.options or hover - 1)
+  end,
+  ["dialog:next-entry"] = function(v)
+    local hover = v.hovered_item or 1
+    v:change_hovered(hover == #v.options and 1 or hover + 1)
+  end,
+  ["dialog:select-yes"] = function(v)
+    if v ~= core.nag_view then return end
+    v:change_hovered(common.find_index(v.options, "default_yes"))
+    command.perform "dialog:select"
+  end,
+  ["dialog:select-no"] = function(v)
+    if v ~= core.nag_view then return end
+    v:change_hovered(common.find_index(v.options, "default_no"))
+    command.perform "dialog:select"
+  end,
+  ["dialog:select"] = function(v)
+    if v.hovered_item then
+      v.on_selected(v.options[v.hovered_item])
+      v:next()
+    end
+  end
+})

data/core/commands/doc.lua

@@ -3,12 +3,9 @@ local command = require "core.command"
 local common = require "core.common"
 local config = require "core.config"
 local translate = require "core.doc.translate"
+local style = require "core.style"
 local DocView = require "core.docview"
-
-
-local function dv()
-  return core.active_view
-end
+local tokenizer = require "core.tokenizer"
 
 
 local function doc()
@@ -16,246 +13,507 @@ local function doc()
 end
 
 
-local function get_indent_string()
-  if config.tab_type == "hard" then
-    return "\t"
-  end
-  return string.rep(" ", config.indent_size)
-end
-
-
-local function insert_at_start_of_selected_lines(text, skip_empty)
-  local line1, col1, line2, col2, swap = doc():get_selection(true)
-  if line2 > line1 and col2 == 1 then
-    line2 = line2 - 1
-    col2 = #doc().lines[line2]
-  end
-  for line = line1, line2 do
-    local line_text = doc().lines[line]
-    if (not skip_empty or line_text:find("%S")) then
-      doc():insert(line, 1, text)
+local function doc_multiline_selections(sort)
+  local iter, state, idx, line1, col1, line2, col2 = doc():get_selections(sort)
+  return function()
+    idx, line1, col1, line2, col2 = iter(state, idx)
+    if idx and line2 > line1 and col2 == 1 then
+      line2 = line2 - 1
+      col2 = #doc().lines[line2]
     end
+    return idx, line1, col1, line2, col2
   end
-  doc():set_selection(line1, col1 + #text, line2, col2 + #text, swap)
 end
 
-
-local function remove_from_start_of_selected_lines(text, skip_empty)
-  local line1, col1, line2, col2, swap = doc():get_selection(true)
-  for line = line1, line2 do
-    local line_text = doc().lines[line]
-    if  line_text:sub(1, #text) == text
-    and (not skip_empty or line_text:find("%S"))
-    then
-      doc():remove(line, 1, line, #text + 1)
-    end
-  end
-  doc():set_selection(line1, col1 - #text, line2, col2 - #text, swap)
-end
-
-
 local function append_line_if_last_line(line)
   if line >= #doc().lines then
     doc():insert(line, math.huge, "\n")
   end
 end
 
-
 local function save(filename)
-  doc():save(filename)
-  core.log("Saved \"%s\"", doc().filename)
+  local abs_filename
+  if filename then
+    filename = core.normalize_to_project_dir(filename)
+    abs_filename = core.project_absolute_path(filename)
+  end
+  local ok, err = pcall(doc().save, doc(), filename, abs_filename)
+  if ok then
+    local saved_filename = doc().filename
+    core.log("Saved \"%s\"", saved_filename)
+  else
+    core.error(err)
+    core.nag_view:show("Saving failed", string.format("Couldn't save file \"%s\". Do you want to save to another location?", doc().filename), {
+      { text = "Yes", default_yes = true },
+      { text = "No", default_no = true }
+    }, function(item)
+      if item.text == "Yes" then
+        core.add_thread(function()
+          -- we need to run this in a thread because of the odd way the nagview is.
+          command.perform("doc:save-as")
+        end)
+      end
+    end)
+  end
 end
 
+local function cut_or_copy(delete)
+  local full_text = ""
+  local text = ""
+  core.cursor_clipboard = {}
+  core.cursor_clipboard_whole_line = {}
+  for idx, line1, col1, line2, col2 in doc():get_selections(true, true) do
+    if line1 ~= line2 or col1 ~= col2 then
+      text = doc():get_text(line1, col1, line2, col2)
+      full_text = full_text == "" and text or (text .. " " .. full_text)
+      core.cursor_clipboard_whole_line[idx] = false
+      if delete then
+        doc():delete_to_cursor(idx, 0)
+      end
+    else -- Cut/copy whole line
+      -- Remove newline from the text. It will be added as needed on paste.
+      text = string.sub(doc().lines[line1], 1, -2)
+      full_text = full_text == "" and text .. "\n" or (text .. "\n" .. full_text)
+      core.cursor_clipboard_whole_line[idx] = true
+      if delete then
+        if line1 < #doc().lines then
+          doc():remove(line1, 1, line1 + 1, 1)
+        elseif #doc().lines == 1 then
+          doc():remove(line1, 1, line1, math.huge)
+        else
+          doc():remove(line1 - 1, math.huge, line1, math.huge)
+        end
+        doc():set_selections(idx, line1, col1, line2, col2)
+      end
+    end
+    core.cursor_clipboard[idx] = text
+  end
+  if delete then doc():merge_cursors() end
+  core.cursor_clipboard["full"] = full_text
+  system.set_clipboard(full_text)
+end
+
+local function split_cursor(dv, direction)
+  local new_cursors = {}
+  local dv_translate = direction < 0
+    and DocView.translate.previous_line
+    or DocView.translate.next_line
+  for _, line1, col1 in dv.doc:get_selections() do
+    if line1 + direction >= 1 and line1 + direction <= #dv.doc.lines then
+      table.insert(new_cursors, { dv_translate(dv.doc, line1, col1, dv) })
+    end
+  end
+  -- add selections in the order that will leave the "last" added one as doc.last_selection
+  local start, stop = 1, #new_cursors
+  if direction < 0 then
+    start, stop = #new_cursors, 1
+  end
+  for i = start, stop, direction do
+    local v = new_cursors[i]
+    dv.doc:add_selection(v[1], v[2])
+  end
+  core.blink_reset()
+end
+
+local function set_cursor(dv, x, y, snap_type)
+  local line, col = dv:resolve_screen_position(x, y)
+  dv.doc:set_selection(line, col, line, col)
+  if snap_type == "word" or snap_type == "lines" then
+    command.perform("doc:select-" .. snap_type)
+  end
+  dv.mouse_selecting = { line, col, snap_type }
+  core.blink_reset()
+end
+
+local function line_comment(comment, line1, col1, line2, col2)
+  local start_comment = (type(comment) == 'table' and comment[1] or comment) .. " "
+  local end_comment = (type(comment) == 'table' and " " .. comment[2])
+  local uncomment = true
+  local start_offset = math.huge
+  for line = line1, line2 do
+    local text = doc().lines[line]
+    local s = text:find("%S")
+    if s then
+      local cs, ce = text:find(start_comment, s, true)
+      if cs ~= s then
+        uncomment = false
+      end
+      start_offset = math.min(start_offset, s)
+    end
+  end
+
+  local end_line = col2 == #doc().lines[line2]
+  for line = line1, line2 do
+    local text = doc().lines[line]
+    local s = text:find("%S")
+    if s and uncomment then
+      if end_comment and text:sub(#text - #end_comment, #text - 1) == end_comment then
+        doc():remove(line, #text - #end_comment, line, #text)
+      end
+      local cs, ce = text:find(start_comment, s, true)
+      if ce then
+        doc():remove(line, cs, line, ce + 1)
+      end
+    elseif s then
+      doc():insert(line, start_offset, start_comment)
+      if end_comment then
+        doc():insert(line, #doc().lines[line], " " .. comment[2])
+      end
+    end
+  end
+  col1 = col1 + (col1 > start_offset and #start_comment or 0) * (uncomment and -1 or 1)
+  col2 = col2 + (col2 > start_offset and #start_comment or 0) * (uncomment and -1 or 1)
+  if end_comment and end_line then
+    col2 = col2 + #end_comment * (uncomment and -1 or 1)
+  end
+  return line1, col1, line2, col2
+end
+
+local function block_comment(comment, line1, col1, line2, col2)
+  -- automatically skip spaces
+  local word_start = doc():get_text(line1, col1, line1, math.huge):find("%S")
+  local word_end = doc():get_text(line2, 1, line2, col2):find("%s*$")
+  col1 = col1 + (word_start and (word_start - 1) or 0)
+  col2 = word_end and word_end or col2
+
+  local block_start = doc():get_text(line1, col1, line1, col1 + #comment[1])
+  local block_end = doc():get_text(line2, col2 - #comment[2], line2, col2)
+
+  if block_start == comment[1] and block_end == comment[2] then
+    -- remove up to 1 whitespace after the comment
+    local start_len, stop_len = #comment[1], #comment[2]
+    if doc():get_text(line1, col1 + #comment[1], line1, col1 + #comment[1] + 1):find("%s$") then
+      start_len = start_len + 1
+    end
+    if doc():get_text(line2, col2 - #comment[2] - 1, line2, col2):find("^%s") then
+      stop_len = stop_len + 1
+    end
+
+    doc():remove(line1, col1, line1, col1 + start_len)
+    col2 = col2 - (line1 == line2 and start_len or 0)
+    doc():remove(line2, col2 - stop_len, line2, col2)
+
+    return line1, col1, line2, col2 - stop_len
+  else
+    doc():insert(line1, col1, comment[1] .. " ")
+    col2 = col2 + (line1 == line2 and (#comment[1] + 1) or 0)
+    doc():insert(line2, col2, " " .. comment[2])
+
+    return line1, col1, line2, col2 + #comment[2] + 1
+  end
+end
+
+local function insert_paste(doc, value, whole_line, idx)
+  if whole_line then
+    local line1, col1 = doc:get_selection_idx(idx)
+    doc:insert(line1, 1, value:gsub("\r", "").."\n")
+    -- Because we're inserting at the start of the line,
+    -- if the cursor is in the middle of the line
+    -- it gets carried to the next line along with the old text.
+    -- If it's at the start of the line it doesn't get carried,
+    -- so we move it of as many characters as we're adding.
+    if col1 == 1 then
+      doc:move_to_cursor(idx, #value+1)
+    end
+  else
+    doc:text_input(value:gsub("\r", ""), idx)
+  end
+end
 
 local commands = {
-  ["doc:undo"] = function()
-    doc():undo()
-  end,
-
-  ["doc:redo"] = function()
-    doc():redo()
+  ["doc:select-none"] = function(dv)
+    local l1, c1 = dv.doc:get_selection_idx(dv.doc.last_selection)
+    if not l1 then
+      l1, c1 = dv.doc:get_selection_idx(1)
+    end
+    dv.doc:set_selection(l1, c1)
   end,
 
   ["doc:cut"] = function()
-    if doc():has_selection() then
-      local text = doc():get_text(doc():get_selection())
-      system.set_clipboard(text)
-      doc():delete_to(0)
-    end
+    cut_or_copy(true)
   end,
 
   ["doc:copy"] = function()
-    if doc():has_selection() then
-      local text = doc():get_text(doc():get_selection())
-      system.set_clipboard(text)
+    cut_or_copy(false)
+  end,
+
+  ["doc:undo"] = function(dv)
+    dv.doc:undo()
+  end,
+
+  ["doc:redo"] = function(dv)
+    dv.doc:redo()
+  end,
+
+  ["doc:paste"] = function(dv)
+    local clipboard = system.get_clipboard()
+    -- If the clipboard has changed since our last look, use that instead
+    if core.cursor_clipboard["full"] ~= clipboard then
+      core.cursor_clipboard = {}
+      core.cursor_clipboard_whole_line = {}
+      for idx in dv.doc:get_selections() do
+        insert_paste(dv.doc, clipboard, false, idx)
+      end
+      return
+    end
+    -- Use internal clipboard(s)
+    -- If there are mixed whole lines and normal lines, consider them all as normal
+    local only_whole_lines = true
+    for _,whole_line in pairs(core.cursor_clipboard_whole_line) do
+      if not whole_line then
+        only_whole_lines = false
+        break
+      end
+    end
+    if #core.cursor_clipboard_whole_line == (#dv.doc.selections/4) then
+    -- If we have the same number of clipboards and selections,
+    -- paste each clipboard into its corresponding selection
+      for idx in dv.doc:get_selections() do
+        insert_paste(dv.doc, core.cursor_clipboard[idx], only_whole_lines, idx)
+      end
+    else
+      -- Paste every clipboard and add a selection at the end of each one
+      local new_selections = {}
+      for idx in dv.doc:get_selections() do
+        for cb_idx in ipairs(core.cursor_clipboard_whole_line) do
+          insert_paste(dv.doc, core.cursor_clipboard[cb_idx], only_whole_lines, idx)
+          if not only_whole_lines then
+            table.insert(new_selections, {dv.doc:get_selection_idx(idx)})
+          end
+        end
+        if only_whole_lines then
+          table.insert(new_selections, {dv.doc:get_selection_idx(idx)})
+        end
+      end
+      local first = true
+      for _,selection in pairs(new_selections) do
+        if first then
+          dv.doc:set_selection(table.unpack(selection))
+          first = false
+        else
+          dv.doc:add_selection(table.unpack(selection))
+        end
+      end
     end
   end,
 
-  ["doc:paste"] = function()
-    doc():text_input(system.get_clipboard():gsub("\r", ""))
-  end,
-
-  ["doc:newline"] = function()
-    local line, col = doc():get_selection()
-    local indent = doc().lines[line]:match("^[\t ]*")
-    if col <= #indent then
-      indent = indent:sub(#indent + 2 - col)
+  ["doc:newline"] = function(dv)
+    for idx, line, col in dv.doc:get_selections(false, true) do
+      local indent = dv.doc.lines[line]:match("^[\t ]*")
+      if col <= #indent then
+        indent = indent:sub(#indent + 2 - col)
+      end
+      -- Remove current line if it contains only whitespace
+      if not config.keep_newline_whitespace and dv.doc.lines[line]:match("^%s+$") then
+        dv.doc:remove(line, 1, line, math.huge)
+      end
+      dv.doc:text_input("\n" .. indent, idx)
     end
-    doc():text_input("\n" .. indent)
   end,
 
-  ["doc:newline-below"] = function()
-    local line = doc():get_selection()
-    local indent = doc().lines[line]:match("^[\t ]*")
-    doc():insert(line, math.huge, "\n" .. indent)
-    doc():set_selection(line + 1, math.huge)
-  end,
-
-  ["doc:newline-above"] = function()
-    local line = doc():get_selection()
-    local indent = doc().lines[line]:match("^[\t ]*")
-    doc():insert(line, 1, indent .. "\n")
-    doc():set_selection(line, math.huge)
-  end,
-
-  ["doc:delete"] = function()
-    local line, col = doc():get_selection()
-    if not doc():has_selection() and doc().lines[line]:find("^%s*$", col) then
-      doc():remove(line, col, line, math.huge)
+  ["doc:newline-below"] = function(dv)
+    for idx, line in dv.doc:get_selections(false, true) do
+      local indent = dv.doc.lines[line]:match("^[\t ]*")
+      dv.doc:insert(line, math.huge, "\n" .. indent)
+      dv.doc:set_selections(idx, line + 1, math.huge)
     end
-    doc():delete_to(translate.next_char)
   end,
 
-  ["doc:backspace"] = function()
-    local line, col = doc():get_selection()
-    if not doc():has_selection() then
-      local text = doc():get_text(line, 1, line, col)
-      if #text >= config.indent_size and text:find("^ *$") then
-        doc():delete_to(0, -config.indent_size)
+  ["doc:newline-above"] = function(dv)
+    for idx, line in dv.doc:get_selections(false, true) do
+      local indent = dv.doc.lines[line]:match("^[\t ]*")
+      dv.doc:insert(line, 1, indent .. "\n")
+      dv.doc:set_selections(idx, line, math.huge)
+    end
+  end,
+
+  ["doc:delete"] = function(dv)
+    for idx, line1, col1, line2, col2 in dv.doc:get_selections(true, true) do
+      if line1 == line2 and col1 == col2 and dv.doc.lines[line1]:find("^%s*$", col1) then
+        dv.doc:remove(line1, col1, line1, math.huge)
+      end
+      dv.doc:delete_to_cursor(idx, translate.next_char)
+    end
+  end,
+
+  ["doc:backspace"] = function(dv)
+    local _, indent_size = dv.doc:get_indent_info()
+    for idx, line1, col1, line2, col2 in dv.doc:get_selections(true, true) do
+      if line1 == line2 and col1 == col2 then
+        local text = dv.doc:get_text(line1, 1, line1, col1)
+        if #text >= indent_size and text:find("^ *$") then
+          dv.doc:delete_to_cursor(idx, 0, -indent_size)
+          goto continue
+        end
+      end
+      dv.doc:delete_to_cursor(idx, translate.previous_char)
+      ::continue::
+    end
+  end,
+
+  ["doc:select-all"] = function(dv)
+    dv.doc:set_selection(1, 1, math.huge, math.huge)
+    -- avoid triggering DocView:scroll_to_make_visible
+    dv.last_line1 = 1
+    dv.last_col1 = 1
+    dv.last_line2 = #dv.doc.lines
+    dv.last_col2 = #dv.doc.lines[#dv.doc.lines]
+  end,
+
+  ["doc:select-lines"] = function(dv)
+    for idx, line1, _, line2 in dv.doc:get_selections(true) do
+      append_line_if_last_line(line2)
+      dv.doc:set_selections(idx, line1, 1, line2 + 1, 1)
+    end
+  end,
+
+  ["doc:select-word"] = function(dv)
+    for idx, line1, col1 in dv.doc:get_selections(true) do
+      local line1, col1 = translate.start_of_word(dv.doc, line1, col1)
+      local line2, col2 = translate.end_of_word(dv.doc, line1, col1)
+      dv.doc:set_selections(idx, line2, col2, line1, col1)
+    end
+  end,
+
+  ["doc:join-lines"] = function(dv)
+    for idx, line1, col1, line2, col2 in dv.doc:get_selections(true) do
+      if line1 == line2 then line2 = line2 + 1 end
+      local text = dv.doc:get_text(line1, 1, line2, math.huge)
+      text = text:gsub("(.-)\n[\t ]*", function(x)
+        return x:find("^%s*$") and x or x .. " "
+      end)
+      dv.doc:insert(line1, 1, text)
+      dv.doc:remove(line1, #text + 1, line2, math.huge)
+      if line1 ~= line2 or col1 ~= col2 then
+        dv.doc:set_selections(idx, line1, math.huge)
+      end
+    end
+  end,
+
+  ["doc:indent"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      local l1, c1, l2, c2 = dv.doc:indent_text(false, line1, col1, line2, col2)
+      if l1 then
+        dv.doc:set_selections(idx, l1, c1, l2, c2)
+      end
+    end
+  end,
+
+  ["doc:unindent"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      local l1, c1, l2, c2 = dv.doc:indent_text(true, line1, col1, line2, col2)
+      if l1 then
+        dv.doc:set_selections(idx, l1, c1, l2, c2)
+      end
+    end
+  end,
+
+  ["doc:duplicate-lines"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      append_line_if_last_line(line2)
+      local text = doc():get_text(line1, 1, line2 + 1, 1)
+      dv.doc:insert(line2 + 1, 1, text)
+      local n = line2 - line1 + 1
+      dv.doc:set_selections(idx, line1 + n, col1, line2 + n, col2)
+    end
+  end,
+
+  ["doc:delete-lines"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      append_line_if_last_line(line2)
+      dv.doc:remove(line1, 1, line2 + 1, 1)
+      dv.doc:set_selections(idx, line1, col1)
+    end
+  end,
+
+  ["doc:move-lines-up"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      append_line_if_last_line(line2)
+      if line1 > 1 then
+        local text = doc().lines[line1 - 1]
+        dv.doc:insert(line2 + 1, 1, text)
+        dv.doc:remove(line1 - 1, 1, line1, 1)
+        dv.doc:set_selections(idx, line1 - 1, col1, line2 - 1, col2)
+      end
+    end
+  end,
+
+  ["doc:move-lines-down"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      append_line_if_last_line(line2 + 1)
+      if line2 < #dv.doc.lines then
+        local text = dv.doc.lines[line2 + 1]
+        dv.doc:remove(line2 + 1, 1, line2 + 2, 1)
+        dv.doc:insert(line1, 1, text)
+        dv.doc:set_selections(idx, line1 + 1, col1, line2 + 1, col2)
+      end
+    end
+  end,
+
+  ["doc:toggle-block-comments"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      local current_syntax = dv.doc.syntax
+      if line1 > 1 then
+        -- Use the previous line state, as it will be the state
+        -- of the beginning of the current line
+        local state = dv.doc.highlighter:get_line(line1 - 1).state
+        local syntaxes = tokenizer.extract_subsyntaxes(dv.doc.syntax, state)
+        -- Go through all the syntaxes until the first with `block_comment` defined
+        for _, s in pairs(syntaxes) do
+          if s.block_comment then
+            current_syntax = s
+            break
+          end
+        end
+      end
+      local comment = current_syntax.block_comment
+      if not comment then
+        if dv.doc.syntax.comment then
+          command.perform "doc:toggle-line-comments"
+        end
         return
       end
-    end
-    doc():delete_to(translate.previous_char)
-  end,
-
-  ["doc:select-all"] = function()
-    doc():set_selection(1, 1, math.huge, math.huge)
-  end,
-
-  ["doc:select-none"] = function()
-    local line, col = doc():get_selection()
-    doc():set_selection(line, col)
-  end,
-
-  ["doc:select-lines"] = function()
-    local line1, _, line2, _, swap = doc():get_selection(true)
-    append_line_if_last_line(line2)
-    doc():set_selection(line1, 1, line2 + 1, 1, swap)
-  end,
-
-  ["doc:select-word"] = function()
-    local line1, col1 = doc():get_selection(true)
-    local line1, col1 = translate.start_of_word(doc(), line1, col1)
-    local line2, col2 = translate.end_of_word(doc(), line1, col1)
-    doc():set_selection(line2, col2, line1, col1)
-  end,
-
-  ["doc:join-lines"] = function()
-    local line1, _, line2 = doc():get_selection(true)
-    if line1 == line2 then line2 = line2 + 1 end
-    local text = doc():get_text(line1, 1, line2, math.huge)
-    text = text:gsub("(.-)\n[\t ]*", function(x)
-      return x:find("^%s*$") and x or x .. " "
-    end)
-    doc():insert(line1, 1, text)
-    doc():remove(line1, #text + 1, line2, math.huge)
-    if doc():has_selection() then
-      doc():set_selection(line1, math.huge)
+      -- if nothing is selected, toggle the whole line
+      if line1 == line2 and col1 == col2 then
+        col1 = 1
+        col2 = #dv.doc.lines[line2]
+      end
+      dv.doc:set_selections(idx, block_comment(comment, line1, col1, line2, col2))
     end
   end,
 
-  ["doc:indent"] = function()
-    local text = get_indent_string()
-    if doc():has_selection() then
-      insert_at_start_of_selected_lines(text)
-    else
-      doc():text_input(text)
-    end
-  end,
-
-  ["doc:unindent"] = function()
-    local text = get_indent_string()
-    remove_from_start_of_selected_lines(text)
-  end,
-
-  ["doc:duplicate-lines"] = function()
-    local line1, col1, line2, col2, swap = doc():get_selection(true)
-    append_line_if_last_line(line2)
-    local text = doc():get_text(line1, 1, line2 + 1, 1)
-    doc():insert(line2 + 1, 1, text)
-    local n = line2 - line1 + 1
-    doc():set_selection(line1 + n, col1, line2 + n, col2, swap)
-  end,
-
-  ["doc:delete-lines"] = function()
-    local line1, col1, line2 = doc():get_selection(true)
-    append_line_if_last_line(line2)
-    doc():remove(line1, 1, line2 + 1, 1)
-    doc():set_selection(line1, col1)
-  end,
-
-  ["doc:move-lines-up"] = function()
-    local line1, col1, line2, col2, swap = doc():get_selection(true)
-    append_line_if_last_line(line2)
-    if line1 > 1 then
-      local text = doc().lines[line1 - 1]
-      doc():insert(line2 + 1, 1, text)
-      doc():remove(line1 - 1, 1, line1, 1)
-      doc():set_selection(line1 - 1, col1, line2 - 1, col2, swap)
-    end
-  end,
-
-  ["doc:move-lines-down"] = function()
-    local line1, col1, line2, col2, swap = doc():get_selection(true)
-    append_line_if_last_line(line2 + 1)
-    if line2 < #doc().lines then
-      local text = doc().lines[line2 + 1]
-      doc():remove(line2 + 1, 1, line2 + 2, 1)
-      doc():insert(line1, 1, text)
-      doc():set_selection(line1 + 1, col1, line2 + 1, col2, swap)
-    end
-  end,
-
-  ["doc:toggle-line-comments"] = function()
-    local comment = doc().syntax.comment
-    if not comment then return end
-    local comment_text = comment .. " "
-    local line1, _, line2 = doc():get_selection(true)
-    local uncomment = true
-    for line = line1, line2 do
-      local text = doc().lines[line]
-      if text:find("%S") and text:find(comment_text, 1, true) ~= 1 then
-        uncomment = false
+  ["doc:toggle-line-comments"] = function(dv)
+    for idx, line1, col1, line2, col2 in doc_multiline_selections(true) do
+      local current_syntax = dv.doc.syntax
+      if line1 > 1 then
+        -- Use the previous line state, as it will be the state
+        -- of the beginning of the current line
+        local state = dv.doc.highlighter:get_line(line1 - 1).state
+        local syntaxes = tokenizer.extract_subsyntaxes(dv.doc.syntax, state)
+        -- Go through all the syntaxes until the first with comments defined
+        for _, s in pairs(syntaxes) do
+          if s.comment or s.block_comment then
+            current_syntax = s
+            break
+          end
+        end
+      end
+      local comment = current_syntax.comment or current_syntax.block_comment
+      if comment then
+        dv.doc:set_selections(idx, line_comment(comment, line1, col1, line2, col2))
       end
     end
-    if uncomment then
-      remove_from_start_of_selected_lines(comment_text, true)
-    else
-      insert_at_start_of_selected_lines(comment_text, true)
-    end
   end,
 
-  ["doc:upper-case"] = function()
-    doc():replace(string.upper)
+  ["doc:upper-case"] = function(dv)
+    dv.doc:replace(string.uupper)
   end,
 
-  ["doc:lower-case"] = function()
-    doc():replace(string.lower)
+  ["doc:lower-case"] = function(dv)
+    dv.doc:replace(string.ulower)
   end,
 
-  ["doc:go-to-line"] = function()
-    local dv = dv()
-
+  ["doc:go-to-line"] = function(dv)
     local items
     local function init_items()
       if items then return end
@@ -267,103 +525,197 @@ local commands = {
       end
     end
 
-    core.command_view:enter("Go To Line", function(text, item)
-      local line = item and item.line or tonumber(text)
-      if not line then
-        core.error("Invalid line number or unmatched string")
-        return
+    core.command_view:enter("Go To Line", {
+      submit = function(text, item)
+        local line = item and item.line or tonumber(text)
+        if not line then
+          core.error("Invalid line number or unmatched string")
+          return
+        end
+        dv.doc:set_selection(line, 1  )
+        dv:scroll_to_line(line, true)
+      end,
+      suggest = function(text)
+        if not text:find("^%d*$") then
+          init_items()
+          return common.fuzzy_match(items, text)
+        end
       end
-      dv.doc:set_selection(line, 1  )
-      dv:scroll_to_line(line, true)
-
-    end, function(text)
-      if not text:find("^%d*$") then
-        init_items()
-        return common.fuzzy_match(items, text)
-      end
-    end)
+    })
   end,
 
-  ["doc:toggle-line-ending"] = function()
-    doc().crlf = not doc().crlf
+  ["doc:toggle-line-ending"] = function(dv)
+    dv.doc.crlf = not dv.doc.crlf
   end,
 
-  ["doc:save-as"] = function()
-    if doc().filename then
-      core.command_view:set_text(doc().filename)
+  ["doc:save-as"] = function(dv)
+    local last_doc = core.last_active_view and core.last_active_view.doc
+    local text
+    if dv.doc.filename then
+      text = dv.doc.filename
+    elseif last_doc and last_doc.filename then
+      local dirname, filename = core.last_active_view.doc.abs_filename:match("(.*)[/\\](.+)$")
+      text = core.normalize_to_project_dir(dirname) .. PATHSEP
     end
-    core.command_view:enter("Save As", function(filename)
-      save(filename)
-    end, common.path_suggest)
+    core.command_view:enter("Save As", {
+      text = text,
+      submit = function(filename)
+        save(common.home_expand(filename))
+      end,
+      suggest = function (text)
+        return common.home_encode_list(common.path_suggest(common.home_expand(text)))
+      end
+    })
   end,
 
-  ["doc:save"] = function()
-    if doc().filename then
+  ["doc:save"] = function(dv)
+    if dv.doc.filename then
       save()
     else
       command.perform("doc:save-as")
     end
   end,
 
-  ["doc:rename"] = function()
-    local old_filename = doc().filename
+  ["doc:reload"] = function(dv)
+    dv.doc:reload()
+  end,
+
+  ["file:rename"] = function(dv)
+    local old_filename = dv.doc.filename
     if not old_filename then
       core.error("Cannot rename unsaved doc")
       return
     end
-    core.command_view:set_text(old_filename)
-    core.command_view:enter("Rename", function(filename)
-      doc():save(filename)
-      core.log("Renamed \"%s\" to \"%s\"", old_filename, filename)
-      if filename ~= old_filename then
-        os.remove(old_filename)
+    core.command_view:enter("Rename", {
+      text = old_filename,
+      submit = function(filename)
+        save(common.home_expand(filename))
+        core.log("Renamed \"%s\" to \"%s\"", old_filename, filename)
+        if filename ~= old_filename then
+          os.remove(old_filename)
+        end
+      end,
+      suggest = function (text)
+        return common.home_encode_list(common.path_suggest(common.home_expand(text)))
       end
-    end, common.path_suggest)
+    })
   end,
+
+
+  ["file:delete"] = function(dv)
+    local filename = dv.doc.abs_filename
+    if not filename then
+      core.error("Cannot remove unsaved doc")
+      return
+    end
+    for i,docview in ipairs(core.get_views_referencing_doc(dv.doc)) do
+      local node = core.root_view.root_node:get_node_for_view(docview)
+      node:close_view(core.root_view.root_node, docview)
+    end
+    os.remove(filename)
+    core.log("Removed \"%s\"", filename)
+  end,
+
+  ["doc:select-to-cursor"] = function(dv, x, y, clicks)
+    local line1, col1 = select(3, doc():get_selection())
+    local line2, col2 = dv:resolve_screen_position(x, y)
+    dv.mouse_selecting = { line1, col1, nil }
+    dv.doc:set_selection(line2, col2, line1, col1)
+  end,
+
+  ["doc:create-cursor-previous-line"] = function(dv)
+    split_cursor(dv, -1)
+    dv.doc:merge_cursors()
+  end,
+
+  ["doc:create-cursor-next-line"] = function(dv)
+    split_cursor(dv, 1)
+    dv.doc:merge_cursors()
+  end
+
 }
 
+command.add(function(x, y)
+  if x == nil or y == nil or not core.active_view:extends(DocView) then return false end
+  local dv = core.active_view
+  local x1,y1,x2,y2 = dv.position.x, dv.position.y, dv.position.x + dv.size.x, dv.position.y + dv.size.y
+  return x >= x1 + dv:get_gutter_width() and x < x2 and y >= y1 and y < y2, dv, x, y
+end, {
+  ["doc:set-cursor"] = function(dv, x, y)
+    set_cursor(dv, x, y, "set")
+  end,
+
+  ["doc:set-cursor-word"] = function(dv, x, y)
+    set_cursor(dv, x, y, "word")
+  end,
+
+  ["doc:set-cursor-line"] = function(dv, x, y, clicks)
+    set_cursor(dv, x, y, "lines")
+  end,
+
+  ["doc:split-cursor"] = function(dv, x, y, clicks)
+    local line, col = dv:resolve_screen_position(x, y)
+    local removal_target = nil
+    for idx, line1, col1 in dv.doc:get_selections(true) do
+      if line1 == line and col1 == col and #doc().selections > 4 then
+        removal_target = idx
+      end
+    end
+    if removal_target then
+      dv.doc:remove_selection(removal_target)
+    else
+      dv.doc:add_selection(line, col, line, col)
+    end
+    dv.mouse_selecting = { line, col, "set" }
+  end
+})
 
 local translations = {
-  ["previous-char"] = translate.previous_char,
-  ["next-char"] = translate.next_char,
-  ["previous-word-start"] = translate.previous_word_start,
-  ["next-word-end"] = translate.next_word_end,
-  ["previous-block-start"] = translate.previous_block_start,
-  ["next-block-end"] = translate.next_block_end,
-  ["start-of-doc"] = translate.start_of_doc,
-  ["end-of-doc"] = translate.end_of_doc,
-  ["start-of-line"] = translate.start_of_line,
-  ["end-of-line"] = translate.end_of_line,
-  ["start-of-word"] = translate.start_of_word,
-  ["end-of-word"] = translate.end_of_word,
-  ["previous-line"] = DocView.translate.previous_line,
-  ["next-line"] = DocView.translate.next_line,
-  ["previous-page"] = DocView.translate.previous_page,
-  ["next-page"] = DocView.translate.next_page,
+  ["previous-char"] = translate,
+  ["next-char"] = translate,
+  ["previous-word-start"] = translate,
+  ["next-word-end"] = translate,
+  ["previous-block-start"] = translate,
+  ["next-block-end"] = translate,
+  ["start-of-doc"] = translate,
+  ["end-of-doc"] = translate,
+  ["start-of-line"] = translate,
+  ["end-of-line"] = translate,
+  ["start-of-word"] = translate,
+  ["start-of-indentation"] = translate,
+  ["end-of-word"] = translate,
+  ["previous-line"] = DocView.translate,
+  ["next-line"] = DocView.translate,
+  ["previous-page"] = DocView.translate,
+  ["next-page"] = DocView.translate,
 }
 
-for name, fn in pairs(translations) do
-  commands["doc:move-to-" .. name] = function() doc():move_to(fn, dv()) end
-  commands["doc:select-to-" .. name] = function() doc():select_to(fn, dv()) end
-  commands["doc:delete-to-" .. name] = function() doc():delete_to(fn, dv()) end
+for name, obj in pairs(translations) do
+  commands["doc:move-to-" .. name] = function(dv) dv.doc:move_to(obj[name:gsub("-", "_")], dv) end
+  commands["doc:select-to-" .. name] = function(dv) dv.doc:select_to(obj[name:gsub("-", "_")], dv) end
+  commands["doc:delete-to-" .. name] = function(dv) dv.doc:delete_to(obj[name:gsub("-", "_")], dv) end
 end
 
-commands["doc:move-to-previous-char"] = function()
-  if doc():has_selection() then
-    local line, col = doc():get_selection(true)
-    doc():set_selection(line, col)
-  else
-    doc():move_to(translate.previous_char)
+commands["doc:move-to-previous-char"] = function(dv)
+  for idx, line1, col1, line2, col2 in dv.doc:get_selections(true) do
+    if line1 ~= line2 or col1 ~= col2 then
+      dv.doc:set_selections(idx, line1, col1)
+    else
+      dv.doc:move_to_cursor(idx, translate.previous_char)
+    end
   end
+  dv.doc:merge_cursors()
 end
 
-commands["doc:move-to-next-char"] = function()
-  if doc():has_selection() then
-    local _, _, line, col = doc():get_selection(true)
-    doc():set_selection(line, col)
-  else
-    doc():move_to(translate.next_char)
+commands["doc:move-to-next-char"] = function(dv)
+  for idx, line1, col1, line2, col2 in dv.doc:get_selections(true) do
+    if line1 ~= line2 or col1 ~= col2 then
+      dv.doc:set_selections(idx, line2, col2)
+    else
+      dv.doc:move_to_cursor(idx, translate.next_char)
+    end
   end
+  dv.doc:merge_cursors()
 end
 
 command.add("core.docview", commands)

data/core/commands/files.lua

@@ -0,0 +1,16 @@
+local core = require "core"
+local command = require "core.command"
+local common = require "core.common"
+
+command.add(nil, {
+  ["files:create-directory"] = function()
+    core.command_view:enter("New directory name", {
+      submit = function(text)
+        local success, err, path = common.mkdirp(text)
+        if not success then
+          core.error("cannot create directory %q: %s", path, err)
+        end
+      end
+    })
+  end,
+})

data/core/commands/findreplace.lua

@@ -2,151 +2,224 @@ local core = require "core"
 local command = require "core.command"
 local config = require "core.config"
 local search = require "core.doc.search"
+local keymap = require "core.keymap"
 local DocView = require "core.docview"
+local CommandView = require "core.commandview"
+local StatusView = require "core.statusview"
 
-local max_previous_finds = 50
+local last_view, last_fn, last_text, last_sel
 
+local case_sensitive = config.find_case_sensitive or false
+local find_regex = config.find_regex or false
+local found_expression
 
 local function doc()
-  return core.active_view.doc
+  local is_DocView = core.active_view:is(DocView) and not core.active_view:is(CommandView)
+  return is_DocView and core.active_view.doc or (last_view and last_view.doc)
+end
+
+local function get_find_tooltip()
+  local rf = keymap.get_binding("find-replace:repeat-find")
+  local ti = keymap.get_binding("find-replace:toggle-sensitivity")
+  local tr = keymap.get_binding("find-replace:toggle-regex")
+  return (find_regex and "[Regex] " or "") ..
+    (case_sensitive and "[Sensitive] " or "") ..
+    (rf and ("Press " .. rf .. " to select the next match.") or "") ..
+    (ti and (" " .. ti .. " toggles case sensitivity.") or "") ..
+    (tr and (" " .. tr .. " toggles regex find.") or "")
+end
+
+local function update_preview(sel, search_fn, text)
+  local ok, line1, col1, line2, col2 = pcall(search_fn, last_view.doc,
+    sel[1], sel[2], text, case_sensitive, find_regex)
+  if ok and line1 and text ~= "" then
+    last_view.doc:set_selection(line2, col2, line1, col1)
+    last_view:scroll_to_line(line2, true)
+    found_expression = true
+  else
+    last_view.doc:set_selection(table.unpack(sel))
+    found_expression = false
+  end
 end
 
 
-local previous_finds
-local last_doc
-local last_fn, last_text
-
-
-local function push_previous_find(doc, sel)
-  if last_doc ~= doc then
-    last_doc = doc
-    previous_finds = {}
+local function insert_unique(t, v)
+  local n = #t
+  for i = 1, n do
+    if t[i] == v then
+      table.remove(t, i)
+      break
+    end
   end
-  if #previous_finds >= max_previous_finds then
-    table.remove(previous_finds, 1)
-  end
-  table.insert(previous_finds, sel or { doc:get_selection() })
+  table.insert(t, 1, v)
 end
 
 
 local function find(label, search_fn)
-  local dv = core.active_view
-  local sel = { dv.doc:get_selection() }
-  local text = dv.doc:get_text(table.unpack(sel))
-  local found = false
+  last_view, last_sel = core.active_view,
+    { core.active_view.doc:get_selection() }
+  local text = last_view.doc:get_text(table.unpack(last_sel))
+  found_expression = false
 
-  core.command_view:set_text(text, true)
+  core.status_view:show_tooltip(get_find_tooltip())
 
-  core.command_view:enter(label, function(text)
-    if found then
+  core.command_view:enter(label, {
+    text = text,
+    select_text = true,
+    show_suggestions = false,
+    submit = function(text, item)
+      insert_unique(core.previous_find, text)
+      core.status_view:remove_tooltip()
+      if found_expression then
+        last_fn, last_text = search_fn, text
+      else
+        core.error("Couldn't find %q", text)
+        last_view.doc:set_selection(table.unpack(last_sel))
+        last_view:scroll_to_make_visible(table.unpack(last_sel))
+      end
+    end,
+    suggest = function(text)
+      update_preview(last_sel, search_fn, text)
       last_fn, last_text = search_fn, text
-      previous_finds = {}
-      push_previous_find(dv.doc, sel)
-    else
-      core.error("Couldn't find %q", text)
-      dv.doc:set_selection(table.unpack(sel))
-      dv:scroll_to_make_visible(sel[1], sel[2])
+      return core.previous_find
+    end,
+    cancel = function(explicit)
+      core.status_view:remove_tooltip()
+      if explicit then
+        last_view.doc:set_selection(table.unpack(last_sel))
+        last_view:scroll_to_make_visible(table.unpack(last_sel))
+      end
     end
-
-  end, function(text)
-    local ok, line1, col1, line2, col2 = pcall(search_fn, dv.doc, sel[1], sel[2], text)
-    if ok and line1 and text ~= "" then
-      dv.doc:set_selection(line2, col2, line1, col1)
-      dv:scroll_to_line(line2, true)
-      found = true
-    else
-      dv.doc:set_selection(table.unpack(sel))
-      found = false
-    end
-
-  end, function(explicit)
-    if explicit then
-      dv.doc:set_selection(table.unpack(sel))
-      dv:scroll_to_make_visible(sel[1], sel[2])
-    end
-  end)
+  })
 end
 
 
 local function replace(kind, default, fn)
-  core.command_view:set_text(default, true)
+  core.status_view:show_tooltip(get_find_tooltip())
+  core.command_view:enter("Find To Replace " .. kind, {
+    text = default,
+    select_text = true,
+    show_suggestions = false,
+    submit = function(old)
+      insert_unique(core.previous_find, old)
 
-  core.command_view:enter("Find To Replace " .. kind, function(old)
-    core.command_view:set_text(old, true)
-
-    local s = string.format("Replace %s %q With", kind, old)
-    core.command_view:enter(s, function(new)
-      local n = doc():replace(function(text)
-        return fn(text, old, new)
-      end)
-      core.log("Replaced %d instance(s) of %s %q with %q", n, kind, old, new)
-    end)
-  end)
+      local s = string.format("Replace %s %q With", kind, old)
+      core.command_view:enter(s, {
+        text = old,
+        select_text = true,
+        show_suggestions = false,
+        submit = function(new)
+          core.status_view:remove_tooltip()
+          insert_unique(core.previous_replace, new)
+          local results = doc():replace(function(text)
+            return fn(text, old, new)
+          end)
+          local n = 0
+          for _,v in pairs(results) do
+            n = n + v
+          end
+          core.log("Replaced %d instance(s) of %s %q with %q", n, kind, old, new)
+        end,
+        suggest = function() return core.previous_replace end,
+        cancel = function()
+          core.status_view:remove_tooltip()
+        end
+      })
+    end,
+    suggest = function() return core.previous_find end,
+    cancel = function()
+      core.status_view:remove_tooltip()
+    end
+  })
 end
 
-
 local function has_selection()
-  return core.active_view:is(DocView)
-     and core.active_view.doc:has_selection()
+  return core.active_view:is(DocView) and core.active_view.doc:has_selection()
 end
 
-command.add(has_selection, {
-  ["find-replace:select-next"] = function()
-    local l1, c1, l2, c2 = doc():get_selection(true)
-    local text = doc():get_text(l1, c1, l2, c2)
-    local l1, c1, l2, c2 = search.find(doc(), l2, c2, text, { wrap = true })
-    if l2 then doc():set_selection(l2, c2, l1, c1) end
+local function has_unique_selection()
+  if not doc() then return false end
+  local text = nil
+  for idx, line1, col1, line2, col2 in doc():get_selections(true, true) do
+    if line1 == line2 and col1 == col2 then return false end
+    local selection = doc():get_text(line1, col1, line2, col2)
+    if text ~= nil and text ~= selection then return false end
+    text = selection
   end
+  return text ~= nil
+end
+
+local function is_in_selection(line, col, l1, c1, l2, c2)
+  if line < l1 or line > l2 then return false end
+  if line == l1 and col <= c1 then return false end
+  if line == l2 and col > c2 then return false end
+  return true
+end
+
+local function is_in_any_selection(line, col)
+  for idx, l1, c1, l2, c2 in doc():get_selections(true, false) do
+    if is_in_selection(line, col, l1, c1, l2, c2) then return true end
+  end
+  return false
+end
+
+local function select_add_next(all)
+  local il1, ic1
+  for _, l1, c1, l2, c2 in doc():get_selections(true, true) do
+    if not il1 then
+      il1, ic1 = l1, c1
+    end
+    local text = doc():get_text(l1, c1, l2, c2)
+    repeat
+      l1, c1, l2, c2 = search.find(doc(), l2, c2, text, { wrap = true })
+      if l1 == il1 and c1 == ic1 then break end
+      if l2 and not is_in_any_selection(l2, c2) then
+        doc():add_selection(l2, c2, l1, c1)
+        if not all then
+          core.active_view:scroll_to_make_visible(l2, c2)
+          return
+        end
+      end
+    until not all or not l2
+    if all then break end
+  end
+end
+
+local function select_next(reverse)
+  local l1, c1, l2, c2 = doc():get_selection(true)
+  local text = doc():get_text(l1, c1, l2, c2)
+  if reverse then
+    l1, c1, l2, c2 = search.find(doc(), l1, c1, text, { wrap = true, reverse = true })
+  else
+    l1, c1, l2, c2 = search.find(doc(), l2, c2, text, { wrap = true })
+  end
+  if l2 then doc():set_selection(l2, c2, l1, c1) end
+end
+
+command.add(has_unique_selection, {
+  ["find-replace:select-next"] = select_next,
+  ["find-replace:select-previous"] = function() select_next(true) end,
+  ["find-replace:select-add-next"] = select_add_next,
+  ["find-replace:select-add-all"] = function() select_add_next(true) end
 })
 
-command.add("core.docview", {
+command.add("core.docview!", {
   ["find-replace:find"] = function()
-    find("Find Text", function(doc, line, col, text)
-      local opt = { wrap = true, no_case = true }
+    find("Find Text", function(doc, line, col, text, case_sensitive, find_regex, find_reverse)
+      local opt = { wrap = true, no_case = not case_sensitive, regex = find_regex, reverse = find_reverse }
       return search.find(doc, line, col, text, opt)
     end)
   end,
 
-  ["find-replace:find-pattern"] = function()
-    find("Find Text Pattern", function(doc, line, col, text)
-      local opt = { wrap = true, no_case = true, pattern = true }
-      return search.find(doc, line, col, text, opt)
-    end)
-  end,
-
-  ["find-replace:repeat-find"] = function()
-    if not last_fn then
-      core.error("No find to continue from")
-    else
-      local line, col = doc():get_selection()
-      local line1, col1, line2, col2 = last_fn(doc(), line, col, last_text)
-      if line1 then
-        push_previous_find(doc())
-        doc():set_selection(line2, col2, line1, col1)
-        core.active_view:scroll_to_line(line2, true)
-      end
-    end
-  end,
-
-  ["find-replace:previous-find"] = function()
-    local sel = table.remove(previous_finds)
-    if not sel or doc() ~= last_doc then
-      core.error("No previous finds")
-      return
-    end
-    doc():set_selection(table.unpack(sel))
-    core.active_view:scroll_to_line(sel[3], true)
-  end,
-
   ["find-replace:replace"] = function()
-    replace("Text", "", function(text, old, new)
-      return text:gsub(old:gsub("%W", "%%%1"), new:gsub("%%", "%%%%"), nil)
-    end)
-  end,
-
-  ["find-replace:replace-pattern"] = function()
-    replace("Pattern", "", function(text, old, new)
-      return text:gsub(old, new)
+    local l1, c1, l2, c2 = doc():get_selection()
+    local selected_text = doc():get_text(l1, c1, l2, c2)
+    replace("Text", l1 == l2 and selected_text or "", function(text, old, new)
+      if not find_regex then
+        return text:gsub(old:gsub("%W", "%%%1"), new:gsub("%%", "%%%%"), nil)
+      end
+      local result, matches = regex.gsub(regex.compile(old, "m"), text, new)
+      return result, matches
     end)
   end,
 
@@ -168,3 +241,57 @@ command.add("core.docview", {
     end)
   end,
 })
+
+local function valid_for_finding()
+  -- Allow using this while in the CommandView
+  if core.active_view:is(CommandView) and last_view then
+    return true, last_view
+  end
+  return core.active_view:is(DocView), core.active_view
+end
+
+command.add(valid_for_finding, {
+  ["find-replace:repeat-find"] = function(dv)
+    if not last_fn then
+      core.error("No find to continue from")
+    else
+      local sl1, sc1, sl2, sc2 = dv.doc:get_selection(true)
+      local line1, col1, line2, col2 = last_fn(dv.doc, sl2, sc2, last_text, case_sensitive, find_regex, false)
+      if line1 then
+        dv.doc:set_selection(line2, col2, line1, col1)
+        dv:scroll_to_line(line2, true)
+      else
+        core.error("Couldn't find %q", last_text)
+      end
+    end
+  end,
+
+  ["find-replace:previous-find"] = function(dv)
+    if not last_fn then
+      core.error("No find to continue from")
+    else
+      local sl1, sc1, sl2, sc2 = dv.doc:get_selection(true)
+      local line1, col1, line2, col2 = last_fn(dv.doc, sl1, sc1, last_text, case_sensitive, find_regex, true)
+      if line1 then
+        dv.doc:set_selection(line2, col2, line1, col1)
+        dv:scroll_to_line(line2, true)
+      else
+        core.error("Couldn't find %q", last_text)
+      end
+    end
+  end,
+})
+
+command.add("core.commandview", {
+  ["find-replace:toggle-sensitivity"] = function()
+    case_sensitive = not case_sensitive
+    core.status_view:show_tooltip(get_find_tooltip())
+    if last_sel then update_preview(last_sel, last_fn, last_text) end
+  end,
+
+  ["find-replace:toggle-regex"] = function()
+    find_regex = not find_regex
+    core.status_view:show_tooltip(get_find_tooltip())
+    if last_sel then update_preview(last_sel, last_fn, last_text) end
+  end
+})

data/core/commands/log.lua

@@ -0,0 +1,16 @@
+local core = require "core"
+local command = require "core.command"
+
+
+command.add(nil, {
+  ["log:open-as-doc"] = function()
+    local doc = core.open_doc("logs.txt")
+    core.root_view:open_doc(doc)
+    doc:insert(1, 1, core.get_log())
+    doc.new_file = false
+    doc:clean()
+  end,
+  ["log:copy-to-clipboard"] = function()
+    system.set_clipboard(core.get_log())
+  end
+})

data/core/commands/root.lua

@@ -3,32 +3,47 @@ local style = require "core.style"
 local DocView = require "core.docview"
 local command = require "core.command"
 local common = require "core.common"
+local config = require "core.config"
 
 
 local t = {
-  ["root:close"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:close"] = function(node)
     node:close_active_view(core.root_view.root_node)
   end,
 
-  ["root:switch-to-previous-tab"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:close-or-quit"] = function(node)
+    if node and (not node:is_empty() or not node.is_primary_node) then
+      node:close_active_view(core.root_view.root_node)
+    else
+      core.quit()
+    end
+  end,
+
+  ["root:close-all"] = function()
+    core.confirm_close_docs(core.docs, core.root_view.close_all_docviews, core.root_view)
+  end,
+
+  ["root:close-all-others"] = function()
+    local active_doc, docs = core.active_view and core.active_view.doc, {}
+    for i, v in ipairs(core.docs) do if v ~= active_doc then table.insert(docs, v) end end
+    core.confirm_close_docs(docs, core.root_view.close_all_docviews, core.root_view, true)
+  end,
+
+  ["root:switch-to-previous-tab"] = function(node)
     local idx = node:get_view_idx(core.active_view)
     idx = idx - 1
     if idx < 1 then idx = #node.views end
     node:set_active_view(node.views[idx])
   end,
 
-  ["root:switch-to-next-tab"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:switch-to-next-tab"] = function(node)
     local idx = node:get_view_idx(core.active_view)
     idx = idx + 1
     if idx > #node.views then idx = 1 end
     node:set_active_view(node.views[idx])
   end,
 
-  ["root:move-tab-left"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:move-tab-left"] = function(node)
     local idx = node:get_view_idx(core.active_view)
     if idx > 1 then
       table.remove(node.views, idx)
@@ -36,8 +51,7 @@ local t = {
     end
   end,
 
-  ["root:move-tab-right"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:move-tab-right"] = function(node)
     local idx = node:get_view_idx(core.active_view)
     if idx < #node.views then
       table.remove(node.views, idx)
@@ -45,25 +59,22 @@ local t = {
     end
   end,
 
-  ["root:shrink"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:shrink"] = function(node)
     local parent = node:get_parent_node(core.root_view.root_node)
     local n = (parent.a == node) and -0.1 or 0.1
     parent.divider = common.clamp(parent.divider + n, 0.1, 0.9)
   end,
 
-  ["root:grow"] = function()
-    local node = core.root_view:get_active_node()
+  ["root:grow"] = function(node)
     local parent = node:get_parent_node(core.root_view.root_node)
     local n = (parent.a == node) and 0.1 or -0.1
     parent.divider = common.clamp(parent.divider + n, 0.1, 0.9)
-  end,
+  end
 }
 
 
 for i = 1, 9 do
-  t["root:switch-to-tab-" .. i] = function()
-    local node = core.root_view:get_active_node()
+  t["root:switch-to-tab-" .. i] = function(node)
     local view = node.views[i]
     if view then
       node:set_active_view(view)
@@ -73,8 +84,7 @@ end
 
 
 for _, dir in ipairs { "left", "right", "up", "down" } do
-  t["root:split-" .. dir] = function()
-    local node = core.root_view:get_active_node()
+  t["root:split-" .. dir] = function(node)
     local av = node.active_view
     node:split(dir)
     if av:is(DocView) then
@@ -82,8 +92,7 @@ for _, dir in ipairs { "left", "right", "up", "down" } do
     end
   end
 
-  t["root:switch-to-" .. dir] = function()
-    local node = core.root_view:get_active_node()
+  t["root:switch-to-" .. dir] = function(node)
     local x, y
     if dir == "left" or dir == "right" then
       y = node.position.y + node.size.y / 2
@@ -93,7 +102,8 @@ for _, dir in ipairs { "left", "right", "up", "down" } do
       y = node.position.y + (dir == "up"   and -1 or node.size.y + style.divider_size)
     end
     local node = core.root_view.root_node:get_child_overlapping_point(x, y)
-    if not node:get_locked_size() then
+    local sx, sy = node:get_locked_size()
+    if not sx and not sy then
       core.set_active_view(node.active_view)
     end
   end
@@ -101,5 +111,25 @@ end
 
 command.add(function()
   local node = core.root_view:get_active_node()
-  return not node:get_locked_size()
+  local sx, sy = node:get_locked_size()
+  return not sx and not sy, node
 end, t)
+
+command.add(nil, {
+  ["root:scroll"] = function(delta)
+    local view = (core.root_view.overlapping_node and core.root_view.overlapping_node.active_view) or core.active_view
+    if view and view.scrollable then
+      view.scroll.to.y = view.scroll.to.y + delta * -config.mouse_wheel_scroll
+      return true
+    end
+    return false
+  end,
+  ["root:horizontal-scroll"] = function(delta)
+    local view = (core.root_view.overlapping_node and core.root_view.overlapping_node.active_view) or core.active_view
+    if view and view.scrollable then
+      view.scroll.to.x = view.scroll.to.x + delta * -config.mouse_wheel_scroll
+      return true
+    end
+    return false
+  end
+})

data/core/commands/statusbar.lua

@@ -0,0 +1,71 @@
+local core = require "core"
+local command = require "core.command"
+local common = require "core.common"
+local style = require "core.style"
+local StatusView = require "core.statusview"
+
+local function status_view_item_names()
+  local items = core.status_view:get_items_list()
+  local names = {}
+  for _, item in ipairs(items) do
+    table.insert(names, item.name)
+  end
+  return names
+end
+
+local function status_view_items_data(names)
+  local data = {}
+  for _, name in ipairs(names) do
+    local item = core.status_view:get_item(name)
+    table.insert(data, {
+      text = command.prettify_name(item.name),
+      info = item.alignment == StatusView.Item.LEFT and "Left" or "Right",
+      name = item.name
+    })
+  end
+  return data
+end
+
+local function status_view_get_items(text)
+  local names = status_view_item_names()
+  local results = common.fuzzy_match(names, text)
+  results = status_view_items_data(results)
+  return results
+end
+
+command.add(nil, {
+  ["status-bar:toggle"] = function()
+    core.status_view:toggle()
+  end,
+  ["status-bar:show"] = function()
+    core.status_view:show()
+  end,
+  ["status-bar:hide"] = function()
+    core.status_view:hide()
+  end,
+  ["status-bar:disable-messages"] = function()
+    core.status_view:display_messages(false)
+  end,
+  ["status-bar:enable-messages"] = function()
+    core.status_view:display_messages(true)
+  end,
+  ["status-bar:hide-item"] = function()
+    core.command_view:enter("Status bar item to hide", {
+      submit = function(text, item)
+        core.status_view:hide_items(item.name)
+      end,
+      suggest = status_view_get_items
+    })
+  end,
+  ["status-bar:show-item"] = function()
+    core.command_view:enter("Status bar item to show", {
+      submit = function(text, item)
+        core.status_view:show_items(item.name)
+      end,
+      suggest = status_view_get_items
+    })
+  end,
+  ["status-bar:reset-items"] = function()
+    core.status_view:show_items()
+  end,
+})

data/core/commandview.lua

@@ -6,32 +6,59 @@ local DocView = require "core.docview"
 local View = require "core.view"
 
 
+---@class core.commandview.input : core.doc
+---@field super core.doc
 local SingleLineDoc = Doc:extend()
 
+function SingleLineDoc:__tostring() return "SingleLineDoc" end
+
 function SingleLineDoc:insert(line, col, text)
   SingleLineDoc.super.insert(self, line, col, text:gsub("\n", ""))
 end
 
-
+---@class core.commandview : core.docview
+---@field super core.docview
 local CommandView = DocView:extend()
 
+function CommandView:__tostring() return "CommandView" end
+
+CommandView.context = "application"
+
 local max_suggestions = 10
 
 local noop = function() end
 
+---@class core.commandview.state
+---@field submit function
+---@field suggest function
+---@field cancel function
+---@field validate function
+---@field text string
+---@field select_text boolean
+---@field show_suggestions boolean
+---@field typeahead boolean
+---@field wrap boolean
 local default_state = {
   submit = noop,
   suggest = noop,
   cancel = noop,
+  validate = function() return true end,
+  text = "",
+  select_text = false,
+  show_suggestions = true,
+  typeahead = true,
+  wrap = true,
 }
 
 
 function CommandView:new()
   CommandView.super.new(self, SingleLineDoc())
   self.suggestion_idx = 1
+  self.suggestions_offset = 1
   self.suggestions = {}
   self.suggestions_height = 0
   self.last_change_id = 0
+  self.last_text = ""
   self.gutter_width = 0
   self.gutter_text_brightness = 0
   self.selection_offset = 0
@@ -42,13 +69,20 @@ function CommandView:new()
 end
 
 
+---@deprecated
+function CommandView:set_hidden_suggestions()
+  core.warn("Using deprecated function CommandView:set_hidden_suggestions")
+  self.state.show_suggestions = false
+end
+
+
 function CommandView:get_name()
   return View.get_name(self)
 end
 
 
-function CommandView:get_line_screen_position()
-  local x = CommandView.super.get_line_screen_position(self, 1)
+function CommandView:get_line_screen_position(line, col)
+  local x = CommandView.super.get_line_screen_position(self, 1, col)
   local _, y = self:get_content_offset()
   local lh = self:get_line_height()
   return x, y + (self.size.y - lh) / 2
@@ -59,6 +93,10 @@ function CommandView:get_scrollable_size()
   return 0
 end
 
+function CommandView:get_h_scrollable_size()
+  return 0
+end
+
 
 function CommandView:scroll_to_make_visible()
   -- no-op function to disable this functionality
@@ -71,6 +109,7 @@ end
 
 
 function CommandView:set_text(text, select)
+  self.last_text = text
   self.doc:remove(1, 1, math.huge, math.huge)
   self.doc:text_input(text)
   if select then
@@ -80,10 +119,58 @@ end
 
 
 function CommandView:move_suggestion_idx(dir)
-  local n = self.suggestion_idx + dir
-  self.suggestion_idx = common.clamp(n, 1, #self.suggestions)
-  self:complete()
-  self.last_change_id = self.doc:get_change_id()
+  local function overflow_suggestion_idx(n, count)
+    if count == 0 then return 0 end
+    if self.state.wrap then
+      return (n - 1) % count + 1
+    else
+      return common.clamp(n, 1, count)
+    end
+  end
+
+  local function get_suggestions_offset()
+    local max_visible = math.min(max_suggestions, #self.suggestions)
+    if dir > 0 then
+      if self.suggestions_offset + max_visible < self.suggestion_idx + 1 then
+        return self.suggestion_idx - max_visible + 1
+      elseif self.suggestions_offset > self.suggestion_idx then
+        return self.suggestion_idx
+      end
+    else
+      if self.suggestions_offset > self.suggestion_idx then
+        return self.suggestion_idx
+      elseif self.suggestions_offset + max_visible < self.suggestion_idx + 1 then
+        return self.suggestion_idx - max_visible + 1
+      end
+    end
+    return self.suggestions_offset
+  end
+
+  if self.state.show_suggestions then
+    local n = self.suggestion_idx + dir
+    self.suggestion_idx = overflow_suggestion_idx(n, #self.suggestions)
+    self:complete()
+    self.last_change_id = self.doc:get_change_id()
+  else
+    local current_suggestion = #self.suggestions > 0 and self.suggestions[self.suggestion_idx].text
+    local text = self:get_text()
+    if text == current_suggestion then
+      local n = self.suggestion_idx + dir
+      if n == 0 and self.save_suggestion then
+        self:set_text(self.save_suggestion)
+      else
+        self.suggestion_idx = overflow_suggestion_idx(n, #self.suggestions)
+        self:complete()
+      end
+    else
+      self.save_suggestion = text
+      self:complete()
+    end
+    self.last_change_id = self.doc:get_change_id()
+    self.state.suggest(self:get_text())
+  end
+
+  self.suggestions_offset = get_suggestions_offset()
 end
 
 
@@ -97,25 +184,60 @@ end
 function CommandView:submit()
   local suggestion = self.suggestions[self.suggestion_idx]
   local text = self:get_text()
-  local submit = self.state.submit
-  self:exit(true)
-  submit(text, suggestion)
+  if self.state.validate(text, suggestion) then
+    local submit = self.state.submit
+    self:exit(true)
+    submit(text, suggestion)
+  end
 end
 
-
-function CommandView:enter(text, submit, suggest, cancel)
+---@param label string
+---@varargs any
+---@overload fun(label:string, options: core.commandview.state)
+function CommandView:enter(label, ...)
   if self.state ~= default_state then
     return
   end
-  self.state = {
-    submit = submit or noop,
-    suggest = suggest or noop,
-    cancel = cancel or noop,
-  }
+  local options = select(1, ...)
+
+  if type(options) ~= "table" then
+    core.warn("Using CommandView:enter in a deprecated way")
+    local submit, suggest, cancel, validate = ...
+    options = {
+      submit = submit,
+      suggest = suggest,
+      cancel = cancel,
+      validate = validate,
+    }
+  end
+
+  -- Support deprecated CommandView:set_hidden_suggestions
+  -- Remove this when set_hidden_suggestions is not supported anymore
+  if options.show_suggestions == nil then
+    options.show_suggestions = self.state.show_suggestions
+  end
+
+  self.state = common.merge(default_state, options)
+
+  -- We need to keep the text entered with CommandView:set_text to
+  -- maintain compatibility with deprecated usage, but still allow
+  -- overwriting with options.text
+  local old_text = self:get_text()
+  if old_text ~= "" then
+    core.warn("Using deprecated function CommandView:set_text")
+  end
+  if options.text or options.select_text then
+    local text = options.text or old_text
+    self:set_text(text, self.state.select_text)
+  end
+  -- Replace with a simple
+  -- self:set_text(self.state.text, self.state.select_text)
+  -- once old usage is removed
+
   core.set_active_view(self)
   self:update_suggestions()
   self.gutter_text_brightness = 100
-  self.label = text .. ": "
+  self.label = label .. ": "
 end
 
 
@@ -128,6 +250,13 @@ function CommandView:exit(submitted, inexplicit)
   self.doc:reset()
   self.suggestions = {}
   if not submitted then cancel(not inexplicit) end
+  self.save_suggestion = nil
+  self.last_text = ""
+end
+
+
+function CommandView:get_line_height()
+  return math.floor(self:get_font():get_height() * 1.2)
 end
 
 
@@ -145,9 +274,6 @@ function CommandView:update_suggestions()
   local t = self.state.suggest(self:get_text()) or {}
   local res = {}
   for i, item in ipairs(t) do
-    if i == max_suggestions then
-      break
-    end
     if type(item) == "string" then
       item = { text = item }
     end
@@ -155,6 +281,7 @@ function CommandView:update_suggestions()
   end
   self.suggestions = res
   self.suggestion_idx = 1
+  self.suggestions_offset = 1
 end
 
 
@@ -168,35 +295,45 @@ function CommandView:update()
   -- update suggestions if text has changed
   if self.last_change_id ~= self.doc:get_change_id() then
     self:update_suggestions()
+    if self.state.typeahead and self.suggestions[self.suggestion_idx] then
+      local current_text = self:get_text()
+      local suggested_text = self.suggestions[self.suggestion_idx].text or ""
+      if #self.last_text < #current_text and
+         string.find(suggested_text, current_text, 1, true) == 1 then
+        self:set_text(suggested_text)
+        self.doc:set_selection(1, #current_text + 1, 1, math.huge)
+      end
+      self.last_text = current_text
+    end
     self.last_change_id = self.doc:get_change_id()
   end
 
   -- update gutter text color brightness
-  self:move_towards("gutter_text_brightness", 0, 0.1)
+  self:move_towards("gutter_text_brightness", 0, 0.1, "commandview")
 
   -- update gutter width
   local dest = self:get_font():get_width(self.label) + style.padding.x
   if self.size.y <= 0 then
     self.gutter_width = dest
   else
-    self:move_towards("gutter_width", dest)
+    self:move_towards("gutter_width", dest, nil, "commandview")
   end
 
   -- update suggestions box height
   local lh = self:get_suggestion_line_height()
-  local dest = #self.suggestions * lh
-  self:move_towards("suggestions_height", dest)
+  local dest = self.state.show_suggestions and math.min(#self.suggestions, max_suggestions) * lh or 0
+  self:move_towards("suggestions_height", dest, nil, "commandview")
 
   -- update suggestion cursor offset
-  local dest = self.suggestion_idx * self:get_suggestion_line_height()
-  self:move_towards("selection_offset", dest)
+  local dest = (self.suggestion_idx - self.suggestions_offset + 1) * self:get_suggestion_line_height()
+  self:move_towards("selection_offset", dest, nil, "commandview")
 
   -- update size based on whether this is the active_view
   local dest = 0
   if self == core.active_view then
     dest = style.font:get_height() + style.padding.y * 2
   end
-  self:move_towards(self.size, "y", dest)
+  self:move_towards(self.size, "y", dest, nil, "commandview")
 end
 
 
@@ -213,6 +350,7 @@ function CommandView:draw_line_gutter(idx, x, y)
   x = x + style.padding.x
   renderer.draw_text(self:get_font(), self.label, x, y + yoffset, color)
   core.pop_clip_rect()
+  return self:get_line_height()
 end
 
 
@@ -223,6 +361,7 @@ local function draw_suggestions_box(self)
   local h = math.ceil(self.suggestions_height)
   local rx, ry, rw, rh = self.position.x, self.position.y - h - dh, self.size.x, h
 
+  core.push_clip_rect(rx, ry, rw, rh)
   -- draw suggestions background
   if #self.suggestions > 0 then
     renderer.draw_rect(rx, ry, rw, rh, style.background3)
@@ -232,10 +371,12 @@ local function draw_suggestions_box(self)
   end
 
   -- draw suggestion text
-  core.push_clip_rect(rx, ry, rw, rh)
-  for i, item in ipairs(self.suggestions) do
+  local first = math.max(self.suggestions_offset, 1)
+  local last = math.min(self.suggestions_offset + max_suggestions, #self.suggestions)
+  for i=first, last do
+    local item = self.suggestions[i]
     local color = (i == self.suggestion_idx) and style.accent or style.text
-    local y = self.position.y - i * lh - dh
+    local y = self.position.y - (i - first + 1) * lh - dh
     common.draw_text(self:get_font(), color, item.text, nil, x, y, 0, lh)
 
     if item.info then
@@ -249,8 +390,9 @@ end
 
 function CommandView:draw()
   CommandView.super.draw(self)
-  core.root_view:defer_draw(draw_suggestions_box, self)
+  if self.state.show_suggestions then
+    core.root_view:defer_draw(draw_suggestions_box, self)
+  end
 end
 
-
 return CommandView

data/core/common.lua

@@ -1,27 +1,86 @@
 local common = {}
 
 
-function common.is_utf8_cont(char)
-  local byte = char:byte()
+---Checks if the byte at offset is a UTF-8 continuation byte.
+---
+---UTF-8 encodes code points in 1 to 4 bytes.
+---For a multi-byte sequence, each byte following the start byte is a continuation byte.
+---@param s string
+---@param offset? integer The offset of the string to start searching. Defaults to 1.
+---@return boolean
+function common.is_utf8_cont(s, offset)
+  local byte = s:byte(offset or 1)
   return byte >= 0x80 and byte < 0xc0
 end
 
 
+---Returns an iterator that yields a UTF-8 character on each iteration.
+---@param text string
+---@return fun(): string
 function common.utf8_chars(text)
   return text:gmatch("[\0-\x7f\xc2-\xf4][\x80-\xbf]*")
 end
 
 
+---Clamps the number n between lo and hi.
+---@param n number
+---@param lo number
+---@param hi number
+---@return number
 function common.clamp(n, lo, hi)
   return math.max(math.min(n, hi), lo)
 end
 
 
+---Returns a new table containing the contents of b merged into a.
+---@param a table|nil
+---@param b table?
+---@return table
+function common.merge(a, b)
+  a = type(a) == "table" and a or {}
+  local t = {}
+  for k, v in pairs(a) do
+    t[k] = v
+  end
+  if b and type(b) == "table" then
+    for k, v in pairs(b) do
+      t[k] = v
+    end
+  end
+  return t
+end
+
+
+---Returns the value of a number rounded to the nearest integer.
+---@param n number
+---@return number
 function common.round(n)
   return n >= 0 and math.floor(n + 0.5) or math.ceil(n - 0.5)
 end
 
 
+---Returns the first index where a subtable in tbl has prop set.
+---If none is found, nil is returned.
+---@param tbl table
+---@param prop any
+---@return number|nil
+function common.find_index(tbl, prop)
+  for i, o in ipairs(tbl) do
+    if o[prop] then return i end
+  end
+end
+
+
+---Returns a value between a and b on a linear scale, based on the
+---interpolation point t.
+---
+---If a and b are tables, a table containing the result for all the
+---elements in a and b is returned.
+---@param a number
+---@param b number
+---@param t number
+---@return number
+---@overload fun(a: table, b: table, t: number): table
 function common.lerp(a, b, t)
   if type(a) ~= "table" then
     return a + (b - a) * t
@@ -34,23 +93,61 @@ function common.lerp(a, b, t)
 end
 
 
+---Returns the euclidean distance between two points.
+---@param x1 number
+---@param y1 number
+---@param x2 number
+---@param y2 number
+---@return number
+function common.distance(x1, y1, x2, y2)
+    return math.sqrt(((x2-x1) ^ 2)+((y2-y1) ^ 2))
+end
+
+
+---Parses a CSS color string.
+---
+---Only these formats are supported:
+---* `rgb(r, g, b)`
+---* `rgba(r, g, b, a)`
+---* `#rrggbbaa`
+---* `#rrggbb`
+---@param str string
+---@return number r
+---@return number g
+---@return number b
+---@return number a
 function common.color(str)
-  local r, g, b, a = str:match("#(%x%x)(%x%x)(%x%x)")
+  local r, g, b, a = str:match("^#(%x%x)(%x%x)(%x%x)(%x?%x?)$")
   if r then
     r = tonumber(r, 16)
     g = tonumber(g, 16)
     b = tonumber(b, 16)
-    a = 1
+    a = tonumber(a, 16) or 0xff
   elseif str:match("rgba?%s*%([%d%s%.,]+%)") then
     local f = str:gmatch("[%d.]+")
     r = (f() or 0)
     g = (f() or 0)
     b = (f() or 0)
-    a = f() or 1
+    a = (f() or 1) * 0xff
   else
     error(string.format("bad color string '%s'", str))
   end
-  return r, g, b, a * 0xff
+  return r, g, b, a
+end
+
+
+---Splices a numerically indexed table.
+---This function mutates the original table.
+---@param t any[]
+---@param at number Index at which to start splicing.
+---@param remove number Number of elements to remove.
+---@param insert? any[] A table containing elements to insert after splicing.
+function common.splice(t, at, remove, insert)
+  assert(remove >= 0, "bad argument #3 to 'splice' (non-negative value expected)")
+  insert = insert or {}
+  local len = #insert
+  if remove ~= len then table.move(t, at + remove, #t + remove, at + len) end
+  table.move(insert, 1, len, at, t)
 end
 
 
@@ -58,10 +155,11 @@ local function compare_score(a, b)
   return a.score > b.score
 end
 
-local function fuzzy_match_items(items, needle)
+local function fuzzy_match_items(items, needle, files)
   local res = {}
+  needle = (PLATFORM == "Windows" and files) and needle:gsub('/', PATHSEP) or needle
   for _, item in ipairs(items) do
-    local score = system.fuzzy_match(tostring(item), needle)
+    local score = system.fuzzy_match(tostring(item), needle, files)
     if score then
       table.insert(res, { text = item, score = score })
     end
@@ -74,17 +172,85 @@ local function fuzzy_match_items(items, needle)
 end
 
 
-function common.fuzzy_match(haystack, needle)
+---Performs fuzzy matching.
+---
+---If the haystack is a string, a score ranging from 0 to 1 is returned. </br>
+---If the haystack is a table, a table containing the haystack sorted in ascending
+---order of similarity is returned.
+---@param haystack string
+---@param needle string
+---@param files boolean If true, the matching process will be performed in reverse to better match paths.
+---@return number
+---@overload fun(haystack: string[], needle: string, files: boolean): string[]
+function common.fuzzy_match(haystack, needle, files)
   if type(haystack) == "table" then
-    return fuzzy_match_items(haystack, needle)
+    return fuzzy_match_items(haystack, needle, files)
   end
-  return system.fuzzy_match(haystack, needle)
+  return system.fuzzy_match(haystack, needle, files)
 end
 
 
-function common.path_suggest(text)
-  local path, name = text:match("^(.-)([^/\\]*)$")
-  local files = system.list_dir(path == "" and "." or path) or {}
+---Performs fuzzy matching and returns recently used strings if needed.
+---
+---If the needle is empty, then a list of recently used strings
+---are added to the result, followed by strings from the haystack.
+---@param haystack string[]
+---@param recents string[]
+---@param needle string
+---@return string[]
+function common.fuzzy_match_with_recents(haystack, recents, needle)
+  if needle == "" then
+    local recents_ext = {}
+    for i = 2, #recents do
+      table.insert(recents_ext, recents[i])
+    end
+    table.insert(recents_ext, recents[1])
+    local others = common.fuzzy_match(haystack, "", true)
+    for i = 1, #others do
+      table.insert(recents_ext, others[i])
+    end
+    return recents_ext
+  else
+    return fuzzy_match_items(haystack, needle, true)
+  end
+end
+
+
+---Returns a list of paths that are relative to the input path.
+---
+---If a root directory is specified, the function returns paths
+---that are relative to the root directory.
+---@param text string The input path.
+---@param root? string The root directory.
+---@return string[]
+function common.path_suggest(text, root)
+  if root and root:sub(-1) ~= PATHSEP then
+    root = root .. PATHSEP
+  end
+
+  local pathsep = PATHSEP
+  if PLATFORM == "Windows" then
+    pathsep = "\\/"
+  end
+  local path = text:match("^(.-)[^"..pathsep.."]*$")
+  local clean_dotslash = false
+  -- ignore root if path is absolute
+  local is_absolute = common.is_absolute_path(text)
+  if not is_absolute then
+    if path == "" then
+      path = root or "."
+      clean_dotslash = not root
+    else
+      path = (root or "") .. path
+    end
+  end
+
+  -- Only in Windows allow using both styles of PATHSEP
+  if (PATHSEP == "\\" and not string.match(path:sub(-1), "[\\/]")) or
+     (PATHSEP ~= "\\" and path:sub(-1) ~= PATHSEP) then
+    path = path .. PATHSEP
+  end
+  local files = system.list_dir(path) or {}
   local res = {}
   for _, file in ipairs(files) do
     file = path .. file
@@ -93,6 +259,19 @@ function common.path_suggest(text)
       if info.type == "dir" then
         file = file .. PATHSEP
       end
+      if root then
+        -- remove root part from file path
+        local s, e = file:find(root, nil, true)
+        if s == 1 then
+          file = file:sub(e + 1)
+        end
+      elseif clean_dotslash then
+        -- remove added dot slash
+        local s, e = file:find("." .. PATHSEP, nil, true)
+        if s == 1 then
+          file = file:sub(e + 1)
+        end
+      end
       if file:lower():find(text:lower(), nil, true) == 1 then
         table.insert(res, file)
       end
@@ -102,6 +281,49 @@ function common.path_suggest(text)
 end
 
 
+---Returns a list of directories that are related to a path.
+---@param text string The input path.
+---@return string[]
+function common.dir_path_suggest(text)
+  local path, name = text:match("^(.-)([^"..PATHSEP.."]*)$")
+  local files = system.list_dir(path == "" and "." or path) or {}
+  local res = {}
+  for _, file in ipairs(files) do
+    file = path .. file
+    local info = system.get_file_info(file)
+    if info and info.type == "dir" and file:lower():find(text:lower(), nil, true) == 1 then
+      table.insert(res, file)
+    end
+  end
+  return res
+end
+
+
+---Filters a list of paths to find those that are related to the input path.
+---@param text string The input path.
+---@param dir_list string[] A list of paths to filter.
+---@return string[]
+function common.dir_list_suggest(text, dir_list)
+  local path, name = text:match("^(.-)([^"..PATHSEP.."]*)$")
+  local res = {}
+  for _, dir_path in ipairs(dir_list) do
+    if dir_path:lower():find(text:lower(), nil, true) == 1 then
+      table.insert(res, dir_path)
+    end
+  end
+  return res
+end
+
+
+---Matches a string against a list of patterns.
+---
+---If a match was found, its start and end index is returned.
+---Otherwise, false is returned.
+---@param text string
+---@param pattern string|string[]
+---@param ... any Other options for string.find().
+---@return number|boolean start_index
+---@return number|nil end_index
 function common.match_pattern(text, pattern, ...)
   if type(pattern) == "string" then
     return text:find(pattern, ...)
@@ -114,8 +336,24 @@ function common.match_pattern(text, pattern, ...)
 end
 
 
+---Draws text onto the window.
+---The function returns the X and Y coordinates of the bottom-right
+---corner of the text.
+---@param font renderer.font
+---@param color renderer.color
+---@param text string
+---@param align string
+---| '"left"'   # Align text to the left of the bounding box
+---| '"right"'  # Align text to the right of the bounding box
+---| '"center"' # Center text in the bounding box
+---@param x number
+---@param y number
+---@param w number
+---@param h number
+---@return number x_advance
+---@return number y_advance
 function common.draw_text(font, color, text, align, x,y,w,h)
-  local tw, th = font:get_width(text), font:get_height(text)
+  local tw, th = font:get_width(text), font:get_height()
   if align == "center" then
     x = x + (w - tw) / 2
   elseif align == "right" then
@@ -126,6 +364,16 @@ function common.draw_text(font, color, text, align, x,y,w,h)
 end
 
 
+---Prints the execution time of a function.
+---
+---The execution time and percentage of frame time
+---for the function is printed to standard output. </br>
+---The frame rate is always assumed to be 60 FPS, thus
+---a value of 100% would mean that the benchmark took
+---1/60 of a second to execute.
+---@param name string
+---@param fn fun(...: any): any
+---@return any # The result returned by the function
 function common.bench(name, fn, ...)
   local start = system.get_time()
   local res = fn(...)
@@ -136,5 +384,343 @@ function common.bench(name, fn, ...)
   return res
 end
 
+-- From gvx/Ser
+local oddvals = {[tostring(1/0)] = "1/0", [tostring(-1/0)] = "-1/0", [tostring(-(0/0))] = "-(0/0)", [tostring(0/0)] = "0/0"}
+
+local function serialize(val, pretty, indent_str, escape, sort, limit, level)
+  local space = pretty and " " or ""
+  local indent = pretty and string.rep(indent_str, level) or ""
+  local newline = pretty and "\n" or ""
+  local ty = type(val)
+  if ty == "string" then
+    local out = string.format("%q", val)
+    if escape then
+      out = string.gsub(out, "\\\n", "\\n")
+      out = string.gsub(out, "\\7", "\\a")
+      out = string.gsub(out, "\\8", "\\b")
+      out = string.gsub(out, "\\9", "\\t")
+      out = string.gsub(out, "\\11", "\\v")
+      out = string.gsub(out, "\\12", "\\f")
+      out = string.gsub(out, "\\13", "\\r")
+    end
+    return out
+  elseif ty == "table" then
+    -- early exit
+    if level >= limit then return tostring(val) end
+    local next_indent = pretty and (indent .. indent_str) or ""
+    local t = {}
+    for k, v in pairs(val) do
+      table.insert(t,
+        next_indent .. "[" ..
+          serialize(k, pretty, indent_str, escape, sort, limit, level + 1) ..
+        "]" .. space .. "=" .. space .. serialize(v, pretty, indent_str, escape, sort, limit, level + 1))
+    end
+    if #t == 0 then return "{}" end
+    if sort then table.sort(t) end
+    return "{" .. newline .. table.concat(t, "," .. newline) .. newline .. indent .. "}"
+  end
+  if ty == "number" then
+    -- tostring is locale-dependent, so we need to replace an eventual `,` with `.`
+    local res, _ = tostring(val):gsub(",", ".")
+    -- handle inf/nan
+    return oddvals[res] or res
+  end
+  return tostring(val)
+end
+
+
+---@class common.serializeoptions
+---@field pretty boolean Enables pretty printing.
+---@field indent_str string The indentation character to use. Defaults to `"  "`.
+---@field escape boolean Uses normal escape characters ("\n") instead of decimal escape sequences ("\10").
+---@field limit number Limits the depth when serializing nested tables. Defaults to `math.huge`.
+---@field sort boolean Sorts the output if it is a sortable table.
+---@field initial_indent number The initial indentation level. Defaults to 0.
+
+---Serializes a value into a Lua string that is loadable with load().
+---
+---Only these basic types are supported:
+---* nil
+---* boolean
+---* number (except very large numbers and special constants, e.g. `math.huge`, `inf` and `nan`)
+---* integer
+---* string
+---* table
+---
+---@param val any
+---@param opts? common.serializeoptions
+---@return string
+function common.serialize(val, opts)
+  opts = opts or {}
+  local indent_str = opts.indent_str or "  "
+  local initial_indent = opts.initial_indent or 0
+  local indent = opts.pretty and string.rep(indent_str, initial_indent) or ""
+  local limit = (opts.limit or math.huge) + initial_indent
+  return indent .. serialize(val, opts.pretty, indent_str,
+                   opts.escape, opts.sort, limit, initial_indent)
+end
+
+
+---Returns the last portion of a path.
+---@param path string
+---@return string
+function common.basename(path)
+  -- a path should never end by / or \ except if it is '/' (unix root) or
+  -- 'X:\' (windows drive)
+  return path:match("[^"..PATHSEP.."]+$") or path
+end
+
+
+---Returns the directory name of a path.
+---If the path doesn't have a directory, this function may return nil.
+---@param path string
+---@return string|nil
+function common.dirname(path)
+  return path:match("(.+)["..PATHSEP.."][^"..PATHSEP.."]+$")
+end
+
+
+---Returns a path where the user's home directory is replaced by `"~"`.
+---@param text string
+---@return string
+function common.home_encode(text)
+  if HOME and string.find(text, HOME, 1, true) == 1 then
+    local dir_pos = #HOME + 1
+    -- ensure we don't replace if the text is just "$HOME" or "$HOME/" so
+    -- it must have a "/" following the $HOME and some characters following.
+    if string.find(text, PATHSEP, dir_pos, true) == dir_pos and #text > dir_pos then
+      return "~" .. text:sub(dir_pos)
+    end
+  end
+  return text
+end
+
+
+---Returns a list of paths where the user's home directory is replaced by `"~"`.
+---@param paths string[] A list of paths to encode
+---@return string[]
+function common.home_encode_list(paths)
+  local t = {}
+  for i = 1, #paths do
+    t[i] = common.home_encode(paths[i])
+  end
+  return t
+end
+
+
+---Expands the `"~"` prefix in a path into the user's home directory.
+---This function is not guaranteed to return an absolute path.
+---@param text string
+---@return string
+function common.home_expand(text)
+  return HOME and text:gsub("^~", HOME) or text
+end
+
+
+local function split_on_slash(s, sep_pattern)
+  local t = {}
+  if s:match("^["..PATHSEP.."]") then
+    t[#t + 1] = ""
+  end
+  for fragment in string.gmatch(s, "([^"..PATHSEP.."]+)") do
+    t[#t + 1] = fragment
+  end
+  return t
+end
+
+
+---Normalizes the drive letter in a Windows path to uppercase.
+---This function expects an absolute path, e.g. a path from `system.absolute_path`.
+---
+---This function is needed because the path returned by `system.absolute_path`
+---may contain drive letters in upper or lowercase.
+---@param filename string|nil The input path.
+---@return string|nil
+function common.normalize_volume(filename)
+  if not filename then return end
+  if PATHSEP == '\\' then
+    local drive, rem = filename:match('^([a-zA-Z]:\\)(.-)'..PATHSEP..'?$')
+    if drive then
+      return drive:upper() .. rem
+    end
+  end
+  return filename
+end
+
+
+---Normalizes a path into the same format across platforms.
+---
+---On Windows, all drive letters are converted to uppercase.
+---UNC paths with drive letters are converted back to ordinary Windows paths.
+---All path separators (`"/"`, `"\\"`) are converted to platform-specific ones.
+---@param filename string|nil
+---@return string|nil
+function common.normalize_path(filename)
+  if not filename then return end
+  local volume
+  if PATHSEP == '\\' then
+    filename = filename:gsub('[/\\]', '\\')
+    local drive, rem = filename:match('^([a-zA-Z]:\\)(.*)')
+    if drive then
+      volume, filename = drive:upper(), rem
+    else
+      drive, rem = filename:match('^(\\\\[^\\]+\\[^\\]+\\)(.*)')
+      if drive then
+        volume, filename = drive, rem
+      end
+    end
+  else
+    local relpath = filename:match('^/(.+)')
+    if relpath then
+      volume, filename = "/", relpath
+    end
+  end
+  local parts = split_on_slash(filename, PATHSEP)
+  local accu = {}
+  for _, part in ipairs(parts) do
+    if part == '..' then
+      if #accu > 0 and accu[#accu] ~= ".." then
+        table.remove(accu)
+      elseif volume then
+        error("invalid path " .. volume .. filename)
+      else
+        table.insert(accu, part)
+      end
+    elseif part ~= '.' then
+      table.insert(accu, part)
+    end
+  end
+  local npath = table.concat(accu, PATHSEP)
+  return (volume or "") .. (npath == "" and PATHSEP or npath)
+end
+
+
+---Checks whether a path is absolute or relative.
+---@param path string
+---@return boolean
+function common.is_absolute_path(path)
+  return path:sub(1, 1) == PATHSEP or path:match("^(%a):\\")
+end
+
+
+---Checks whether a path belongs to a parent directory.
+---@param filename string The path to check.
+---@param path string The parent path.
+---@return boolean
+function common.path_belongs_to(filename, path)
+  return string.find(filename, path .. PATHSEP, 1, true) == 1
+end
+
+
+---Checks whether a path is relative to another path.
+---@param ref_dir string The path to check against.
+---@param dir string The input path.
+---@return boolean
+function common.relative_path(ref_dir, dir)
+  local drive_pattern = "^(%a):\\"
+  local drive, ref_drive = dir:match(drive_pattern), ref_dir:match(drive_pattern)
+  if drive and ref_drive and drive ~= ref_drive then
+    -- Windows, different drives, system.absolute_path fails for C:\..\D:\
+    return dir
+  end
+  local ref_ls = split_on_slash(ref_dir)
+  local dir_ls = split_on_slash(dir)
+  local i = 1
+  while i <= #ref_ls do
+    if dir_ls[i] ~= ref_ls[i] then
+      break
+    end
+    i = i + 1
+  end
+  local ups = ""
+  for k = i, #ref_ls do
+    ups = ups .. ".." .. PATHSEP
+  end
+  local rel_path = ups .. table.concat(dir_ls, PATHSEP, i)
+  return rel_path ~= "" and rel_path or "."
+end
+
+
+---Creates a directory recursively if necessary.
+---@param path string
+---@return boolean success
+---@return string|nil error
+---@return string|nil path The path where an error occured.
+function common.mkdirp(path)
+  local stat = system.get_file_info(path)
+  if stat and stat.type then
+    return false, "path exists", path
+  end
+  local subdirs = {}
+  while path and path ~= "" do
+    local success_mkdir = system.mkdir(path)
+    if success_mkdir then break end
+    local updir, basedir = path:match("(.*)["..PATHSEP.."](.+)$")
+    table.insert(subdirs, 1, basedir or path)
+    path = updir
+  end
+  for _, dirname in ipairs(subdirs) do
+    path = path and path .. PATHSEP .. dirname or dirname
+    if not system.mkdir(path) then
+      return false, "cannot create directory", path
+    end
+  end
+  return true
+end
+
+
+---Removes a path.
+---@param path string
+---@param recursively boolean If true, the function will attempt to remove everything in the specified path.
+---@return boolean success
+---@return string|nil error
+---@return string|nil path The path where the error occured.
+function common.rm(path, recursively)
+  local stat = system.get_file_info(path)
+  if not stat or (stat.type ~= "file" and stat.type ~= "dir") then
+    return false, "invalid path given", path
+  end
+
+  if stat.type == "file" then
+    local removed, error = os.remove(path)
+    if not removed then
+      return false, error, path
+    end
+  else
+    local contents = system.list_dir(path)
+    if #contents > 0 and not recursively then
+      return false, "directory is not empty", path
+    end
+
+    for _, item in pairs(contents) do
+      local item_path = path .. PATHSEP .. item
+      local item_stat = system.get_file_info(item_path)
+
+      if not item_stat then
+        return false, "invalid file encountered", item_path
+      end
+
+      if item_stat.type == "dir" then
+        local deleted, error, ipath = common.rm(item_path, recursively)
+        if not deleted then
+          return false, error, ipath
+        end
+      elseif item_stat.type == "file" then
+        local removed, error = os.remove(item_path)
+        if not removed then
+          return false, error, item_path
+        end
+      end
+    end
+
+    local removed, error = system.rmdir(path)
+    if not removed then
+      return false, error, path
+    end
+  end
+
+  return true
+end
+
 
 return common

data/core/config.lua

@@ -1,22 +1,105 @@
+local common = require "core.common"
+
 local config = {}
 
-config.project_scan_rate = 5
 config.fps = 60
-config.max_log_items = 80
-config.message_timeout = 3
+config.max_log_items = 800
+config.message_timeout = 5
 config.mouse_wheel_scroll = 50 * SCALE
+config.animate_drag_scroll = false
+config.scroll_past_end = true
+---@type "expanded" | "contracted" | false @Force the scrollbar status of the DocView
+config.force_scrollbar_status = false
 config.file_size_limit = 10
-config.ignore_files = "^%."
+config.ignore_files = {
+  -- folders
+  "^%.svn/",        "^%.git/",   "^%.hg/",        "^CVS/", "^%.Trash/", "^%.Trash%-.*/",
+  "^node_modules/", "^%.cache/", "^__pycache__/",
+  -- files
+  "%.pyc$",         "%.pyo$",       "%.exe$",        "%.dll$",   "%.obj$", "%.o$",
+  "%.a$",           "%.lib$",       "%.so$",         "%.dylib$", "%.ncb$", "%.sdf$",
+  "%.suo$",         "%.pdb$",       "%.idb$",        "%.class$", "%.psd$", "%.db$",
+  "^desktop%.ini$", "^%.DS_Store$", "^%.directory$",
+}
 config.symbol_pattern = "[%a_][%w_]*"
 config.non_word_chars = " \t\n/\\()\"':,.;<>~!@#$%^&*|+=[]{}`?-"
 config.undo_merge_timeout = 0.3
 config.max_undos = 10000
+config.max_tabs = 8
+config.always_show_tabs = true
+-- Possible values: false, true, "no_selection"
 config.highlight_current_line = true
 config.line_height = 1.2
 config.indent_size = 2
 config.tab_type = "soft"
+config.keep_newline_whitespace = false
 config.line_limit = 80
-config.max_symbols = 4000
 config.max_project_files = 2000
+config.transitions = true
+config.disabled_transitions = {
+  scroll = false,
+  commandview = false,
+  contextmenu = false,
+  logview = false,
+  nagbar = false,
+  tabs = false,
+  tab_drag = false,
+  statusbar = false,
+}
+config.animation_rate = 1.0
+config.blink_period = 0.8
+config.disable_blink = false
+config.draw_whitespace = false
+config.borderless = false
+config.tab_close_button = true
+config.max_clicks = 3
+
+-- set as true to be able to test non supported plugins
+config.skip_plugins_version = false
+
+-- holds the plugins real config table
+local plugins_config = {}
+
+-- virtual representation of plugins config table
+config.plugins = {}
+
+-- allows virtual access to the plugins config table
+setmetatable(config.plugins, {
+  __index = function(_, k)
+    if not plugins_config[k] then
+      plugins_config[k] = { enabled = true, config = {} }
+    end
+    if plugins_config[k].enabled ~= false then
+      return plugins_config[k].config
+    end
+    return false
+  end,
+  __newindex = function(_, k, v)
+    if not plugins_config[k] then
+      plugins_config[k] = { enabled = nil, config = {} }
+    end
+    if v == false and package.loaded["plugins."..k] then
+      local core = require "core"
+      core.warn("[%s] is already enabled, restart the editor for the change to take effect", k)
+      return
+    elseif plugins_config[k].enabled == false and v ~= false then
+      plugins_config[k].enabled = true
+    end
+    if v == false then
+      plugins_config[k].enabled = false
+    elseif type(v) == "table" then
+      plugins_config[k].enabled = true
+      plugins_config[k].config = common.merge(plugins_config[k].config, v)
+    end
+  end,
+  __pairs = function()
+    return coroutine.wrap(function()
+      for name, status in pairs(plugins_config) do
+        coroutine.yield(name, status.config)
+      end
+    end)
+  end
+})
+
 
 return config

data/core/contextmenu.lua

@@ -0,0 +1,294 @@
+local core = require "core"
+local common = require "core.common"
+local command = require "core.command"
+local config = require "core.config"
+local keymap = require "core.keymap"
+local style = require "core.style"
+local Object = require "core.object"
+local View = require "core.view"
+
+local border_width = 1
+local divider_width = 1
+local divider_padding = 5
+local DIVIDER = {}
+
+---An item in the context menu.
+---@class core.contextmenu.item
+---@field text string
+---@field info string|nil If provided, this text is displayed on the right side of the menu.
+---@field command string|fun()
+
+---A list of items with the same predicate.
+---@see core.command.predicate
+---@class core.contextmenu.itemset
+---@field predicate core.command.predicate
+---@field items core.contextmenu.item[]
+
+---A context menu.
+---@class core.contextmenu : core.object
+---@field itemset core.contextmenu.itemset[]
+---@field show_context_menu boolean
+---@field selected number
+---@field position core.view.position
+---@field current_scale number
+local ContextMenu = Object:extend()
+
+function ContextMenu:__tostring() return "ContextMenu" end
+
+---A unique value representing the divider in a context menu.
+ContextMenu.DIVIDER = DIVIDER
+
+---Creates a new context menu.
+function ContextMenu:new()
+  self.itemset = {}
+  self.show_context_menu = false
+  self.selected = -1
+  self.height = 0
+  self.position = { x = 0, y = 0 }
+  self.current_scale = SCALE
+end
+
+local function get_item_size(item)
+  local lw, lh
+  if item == DIVIDER then
+    lw = 0
+    lh = divider_width + divider_padding * SCALE * 2
+  else
+    lw = style.font:get_width(item.text)
+    if item.info then
+      lw = lw + style.padding.x + style.font:get_width(item.info)
+    end
+    lh = style.font:get_height() + style.padding.y
+  end
+  return lw, lh
+end
+
+local function update_items_size(items, update_binding)
+  local width, height = 0, 0
+  for _, item in ipairs(items) do
+    if update_binding and item ~= DIVIDER then
+      item.info = keymap.get_binding(item.command)
+    end
+    local lw, lh = get_item_size(item)
+    width = math.max(width, lw)
+    height = height + lh
+  end
+  width = width + style.padding.x * 2
+  items.width, items.height = width, height
+end
+
+---Registers a list of items into the context menu with a predicate.
+---@param predicate core.command.predicate
+---@param items core.contextmenu.item[]
+function ContextMenu:register(predicate, items)
+  predicate = command.generate_predicate(predicate)
+  update_items_size(items, true)
+  table.insert(self.itemset, { predicate = predicate, items = items })
+end
+
+---Shows the context menu.
+---@param x number
+---@param y number
+---@return boolean # If true, the context menu is shown.
+function ContextMenu:show(x, y)
+  self.items = nil
+  local items_list = { width = 0, height = 0 }
+  for _, items in ipairs(self.itemset) do
+    if items.predicate(x, y) then
+      items_list.width = math.max(items_list.width, items.items.width)
+      items_list.height = items_list.height
+      for _, subitems in ipairs(items.items) do
+        if not subitems.command or command.is_valid(subitems.command) then
+          local lw, lh = get_item_size(subitems)
+          items_list.height = items_list.height + lh
+          table.insert(items_list, subitems)
+        end
+      end
+    end
+  end
+
+  if #items_list > 0 then
+    self.items = items_list
+    local w, h = self.items.width, self.items.height
+
+    -- by default the box is opened on the right and below
+    x = common.clamp(x, 0, core.root_view.size.x - w - style.padding.x)
+    y = common.clamp(y, 0, core.root_view.size.y - h)
+
+    self.position.x, self.position.y = x, y
+    self.show_context_menu = true
+    core.request_cursor("arrow")
+    return true
+  end
+  return false
+end
+
+---Hides the context menu.
+function ContextMenu:hide()
+  self.show_context_menu = false
+  self.items = nil
+  self.selected = -1
+  self.height = 0
+  core.request_cursor(core.active_view.cursor)
+end
+
+---Returns an iterator that iterates over each context menu item and their dimensions.
+---@return fun(): number, core.contextmenu.item, number, number, number, number
+function ContextMenu:each_item()
+  local x, y, w = self.position.x, self.position.y, self.items.width
+  local oy = y
+  return coroutine.wrap(function()
+    for i, item in ipairs(self.items) do
+      local _, lh = get_item_size(item)
+      if y - oy > self.height then break end
+      coroutine.yield(i, item, x, y, w, lh)
+      y = y + lh
+    end
+  end)
+end
+
+---Event handler for mouse movements.
+---@param px any
+---@param py any
+---@return boolean # true if the event is caught.
+function ContextMenu:on_mouse_moved(px, py)
+  if not self.show_context_menu then return false end
+
+  self.selected = -1
+  for i, item, x, y, w, h in self:each_item() do
+    if px > x and px <= x + w and py > y and py <= y + h then
+      self.selected = i
+      break
+    end
+  end
+  return true
+end
+
+---Event handler for when the selection is confirmed.
+---@param item core.contextmenu.item
+function ContextMenu:on_selected(item)
+  if type(item.command) == "string" then
+    command.perform(item.command)
+  else
+    item.command()
+  end
+end
+
+local function change_value(value, change)
+  return value + change
+end
+
+---Selects the the previous item.
+function ContextMenu:focus_previous()
+  self.selected = (self.selected == -1 or self.selected == 1) and #self.items or change_value(self.selected, -1)
+  if self:get_item_selected() == DIVIDER then
+    self.selected = change_value(self.selected, -1)
+  end
+end
+
+---Selects the next item.
+function ContextMenu:focus_next()
+  self.selected = (self.selected == -1 or self.selected == #self.items) and 1 or change_value(self.selected, 1)
+  if self:get_item_selected() == DIVIDER then
+    self.selected = change_value(self.selected, 1)
+  end
+end
+
+---Gets the currently selected item.
+---@return core.contextmenu.item|nil
+function ContextMenu:get_item_selected()
+  return (self.items or {})[self.selected]
+end
+
+---Hides the context menu and performs the command if an item is selected.
+function ContextMenu:call_selected_item()
+    local selected = self:get_item_selected()
+    self:hide()
+    if selected then
+      self:on_selected(selected)
+    end
+end
+
+---Event handler for mouse press.
+---@param button core.view.mousebutton
+---@param px number
+---@param py number
+---@param clicks number
+---@return boolean # true if the event is caught.
+function ContextMenu:on_mouse_pressed(button, px, py, clicks)
+  local caught = false
+
+  if self.show_context_menu then
+    if button == "left" then
+      local selected = self:get_item_selected()
+      if selected then
+        self:on_selected(selected)
+      end
+    end
+    self:hide()
+    caught = true
+  else
+    if button == "right" then
+      caught = self:show(px, py)
+    end
+  end
+  return caught
+end
+
+---@type fun(self: table, k: string, dest: number, rate?: number, name?: string)
+ContextMenu.move_towards = View.move_towards
+
+---Event handler for content update.
+function ContextMenu:update()
+  if self.show_context_menu then
+    self:move_towards("height", self.items.height, nil, "contextmenu")
+  end
+end
+
+---Draws the context menu.
+---
+---This wraps `ContextMenu:draw_context_menu()`.
+---@see core.contextmenu.draw_context_menu
+function ContextMenu:draw()
+  if not self.show_context_menu then return end
+  if self.current_scale ~= SCALE then
+    update_items_size(self.items)
+    for _, set in ipairs(self.itemset) do
+      update_items_size(set.items)
+    end
+    self.current_scale = SCALE
+  end
+  core.root_view:defer_draw(self.draw_context_menu, self)
+end
+
+---Draws the context menu.
+function ContextMenu:draw_context_menu()
+  if not self.items then return end
+  local bx, by, bw, bh = self.position.x, self.position.y, self.items.width, self.height
+
+  renderer.draw_rect(
+    bx - border_width,
+    by - border_width,
+    bw + (border_width * 2),
+    bh + (border_width * 2),
+    style.divider
+  )
+  renderer.draw_rect(bx, by, bw, bh, style.background3)
+
+  for i, item, x, y, w, h in self:each_item() do
+    if item == DIVIDER then
+      renderer.draw_rect(x, y + divider_padding * SCALE, w, divider_width, style.divider)
+    else
+      if i == self.selected then
+        renderer.draw_rect(x, y, w, h, style.selection)
+      end
+
+      common.draw_text(style.font, style.text, item.text, "left", x + style.padding.x, y, w, h)
+      if item.info then
+        common.draw_text(style.font, style.dim, item.info, "right", x, y, w - style.padding.x, h)
+      end
+    end
+  end
+end
+
+return ContextMenu

data/core/dirwatch.lua

@@ -0,0 +1,238 @@
+local common = require "core.common"
+local config = require "core.config"
+local dirwatch = {}
+
+function dirwatch:__index(idx)
+  local value = rawget(self, idx)
+  if value ~= nil then return value end
+  return dirwatch[idx]
+end
+
+function dirwatch.new()
+  local t = {
+    scanned = {},
+    watched = {},
+    reverse_watched = {},
+    monitor = dirmonitor.new(),
+    single_watch_top = nil,
+    single_watch_count = 0
+  }
+  setmetatable(t, dirwatch)
+  return t
+end
+
+
+function dirwatch:scan(directory, bool)
+  if bool == false then return self:unwatch(directory) end
+  self.scanned[directory] = system.get_file_info(directory).modified
+end
+
+-- Should be called on every directory in a subdirectory.
+-- In windows, this is a no-op for anything underneath a top-level directory,
+-- but code should be called anyway, so we can ensure that we have a proper
+-- experience across all platforms. Should be an absolute path.
+-- Can also be called on individual files, though this should be used sparingly,
+-- so as not to run into system limits (like in the autoreload plugin).
+function dirwatch:watch(directory, bool)
+  if bool == false then return self:unwatch(directory) end
+  local info = system.get_file_info(directory)
+  if not info then return end
+  if not self.watched[directory] and not self.scanned[directory] then
+    if self.monitor:mode() == "single" then
+      if info.type ~= "dir" then return self:scan(directory) end
+      if not self.single_watch_top or directory:find(self.single_watch_top, 1, true) ~= 1 then
+        -- Get the highest level of directory that is common to this directory, and the original.
+        local target = directory
+        while self.single_watch_top and self.single_watch_top:find(target, 1, true) ~= 1 do
+          target = common.dirname(target)
+        end
+        if target ~= self.single_watch_top then
+          local value = self.monitor:watch(target)
+          if value and value < 0 then
+            return self:scan(directory)
+          end
+          self.single_watch_top = target
+        end
+      end
+      self.single_watch_count = self.single_watch_count + 1
+      self.watched[directory] = true
+    else
+      local value = self.monitor:watch(directory)
+      -- If for whatever reason, we can't watch this directory, revert back to scanning.
+      -- Don't bother trying to find out why, for now.
+      if value and value < 0 then
+        return self:scan(directory)
+      end
+      self.watched[directory] = value
+      self.reverse_watched[value] = directory
+    end
+  end
+end
+
+-- this should be an absolute path
+function dirwatch:unwatch(directory)
+  if self.watched[directory] then
+    if self.monitor:mode() == "multiple" then
+      self.monitor:unwatch(self.watched[directory])
+      self.reverse_watched[directory] = nil
+    else
+      self.single_watch_count = self.single_watch_count - 1
+      if self.single_watch_count == 0 then
+        self.single_watch_top = nil
+        self.monitor:unwatch(directory)
+      end
+    end
+    self.watched[directory] = nil
+  elseif self.scanned[directory] then
+    self.scanned[directory] = nil
+  end
+end
+
+-- designed to be run inside a coroutine.
+function dirwatch:check(change_callback, scan_time, wait_time)
+  local had_change = false
+  local last_error
+  self.monitor:check(function(id)
+    had_change = true
+    if self.monitor:mode() == "single" then
+      local path = common.dirname(id)
+      if not string.match(id, "^/") and not string.match(id, "^%a:[/\\]") then
+        path = common.dirname(self.single_watch_top .. PATHSEP .. id)
+      end
+      change_callback(path)
+    elseif self.reverse_watched[id] then
+      change_callback(self.reverse_watched[id])
+    end
+  end, function(err)
+    last_error = err
+  end)
+  if last_error ~= nil then error(last_error) end
+  local start_time = system.get_time()
+  for directory, old_modified in pairs(self.scanned) do
+    if old_modified then
+      local info = system.get_file_info(directory)
+      local new_modified = info and info.modified
+      if old_modified ~= new_modified then
+        change_callback(directory)
+        had_change = true
+        self.scanned[directory] = new_modified
+      end
+    end
+    if system.get_time() - start_time > (scan_time or 0.01) then
+      coroutine.yield(wait_time or 0.01)
+      start_time = system.get_time()
+    end
+  end
+  return had_change
+end
+
+
+-- inspect config.ignore_files patterns and prepare ready to use entries.
+local function compile_ignore_files()
+  local ipatterns = config.ignore_files
+  local compiled = {}
+  -- config.ignore_files could be a simple string...
+  if type(ipatterns) ~= "table" then ipatterns = {ipatterns} end
+  for i, pattern in ipairs(ipatterns) do
+    -- we ignore malformed pattern that raise an error
+    if pcall(string.match, "a", pattern) then
+      table.insert(compiled, {
+        use_path = pattern:match("/[^/$]"), -- contains a slash but not at the end
+        -- An '/' or '/$' at the end means we want to match a directory.
+        match_dir = pattern:match(".+/%$?$"), -- to be used as a boolen value
+        pattern = pattern -- get the actual pattern
+      })
+    end
+  end
+  return compiled
+end
+
+
+local function fileinfo_pass_filter(info, ignore_compiled)
+  if info.size >= config.file_size_limit * 1e6 then return false end
+  local basename = common.basename(info.filename)
+  -- replace '\' with '/' for Windows where PATHSEP = '\'
+  local fullname = "/" .. info.filename:gsub("\\", "/")
+  for _, compiled in ipairs(ignore_compiled) do
+    local test = compiled.use_path and fullname or basename
+    if compiled.match_dir then
+      if info.type == "dir" and string.match(test .. "/", compiled.pattern) then
+        return false
+      end
+    else
+      if string.match(test, compiled.pattern) then
+        return false
+      end
+    end
+  end
+  return true
+end
+
+
+local function compare_file(a, b)
+  return system.path_compare(a.filename, a.type, b.filename, b.type)
+end
+
+
+-- compute a file's info entry completed with "filename" to be used
+-- in project scan or falsy if it shouldn't appear in the list.
+local function get_project_file_info(root, file, ignore_compiled)
+  local info = system.get_file_info(root .. PATHSEP .. file)
+  -- info can be not nil but info.type may be nil if is neither a file neither
+  -- a directory, for example for /dev/* entries on linux.
+  if info and info.type then
+    info.filename = file
+    return fileinfo_pass_filter(info, ignore_compiled) and info
+  end
+end
+
+
+-- "root" will by an absolute path without trailing '/'
+-- "path" will be a path starting without '/' and without trailing '/'
+--    or the empty string.
+--    It identifies a sub-path within "root".
+-- The current path location will therefore always be: root .. path.
+-- When recursing, "root" will always be the same, only "path" will change.
+-- Returns a list of file "items". In each item the "filename" will be the
+-- complete file path relative to "root" *without* the trailing '/', and without the starting '/'.
+function dirwatch.get_directory_files(dir, root, path, entries_count, recurse_pred)
+  local t = {}
+  local t0 = system.get_time()
+  local ignore_compiled = compile_ignore_files()
+
+  local all = system.list_dir(root .. PATHSEP .. path)
+  if not all then return nil end
+  local entries = { }
+  for _, file in ipairs(all) do
+    local info = get_project_file_info(root, (path ~= "" and (path .. PATHSEP) or "") .. file, ignore_compiled)
+    if info then
+      table.insert(entries, info)
+    end
+  end
+  table.sort(entries, compare_file)
+
+  local recurse_complete = true
+  for _, info in ipairs(entries) do
+    table.insert(t, info)
+    entries_count = entries_count + 1
+    if info.type == "dir" then
+      if recurse_pred(dir, info.filename, entries_count, system.get_time() - t0) then
+        local t_rec, complete, n = dirwatch.get_directory_files(dir, root, info.filename, entries_count, recurse_pred)
+        recurse_complete = recurse_complete and complete
+        if n ~= nil then
+          entries_count = n
+          for _, info_rec in ipairs(t_rec) do
+            table.insert(t, info_rec)
+          end
+        end
+      else
+        recurse_complete = false
+      end
+    end
+  end
+
+  return t, recurse_complete, entries_count
+end
+
+
+return dirwatch

data/core/doc/highlighter.lua

@@ -1,4 +1,5 @@
 local core = require "core"
+local common = require "core.common"
 local config = require "core.config"
 local tokenizer = require "core.tokenizer"
 local Object = require "core.object"
@@ -6,56 +7,105 @@ local Object = require "core.object"
 
 local Highlighter = Object:extend()
 
+function Highlighter:__tostring() return "Highlighter" end
 
 function Highlighter:new(doc)
   self.doc = doc
+  self.running = false
   self:reset()
+end
 
-  -- init incremental syntax highlighting
+-- init incremental syntax highlighting
+function Highlighter:start()
+  if self.running then return end
+  self.running = true
   core.add_thread(function()
-    while true do
-      if self.first_invalid_line > self.max_wanted_line then
-        self.max_wanted_line = 0
-        coroutine.yield(1 / config.fps)
-
-      else
-        local max = math.min(self.first_invalid_line + 40, self.max_wanted_line)
-
-        for i = self.first_invalid_line, max do
-          local state = (i > 1) and self.lines[i - 1].state
-          local line = self.lines[i]
-          if not (line and line.init_state == state) then
-            self.lines[i] = self:tokenize_line(i, state)
+    while self.first_invalid_line <= self.max_wanted_line do
+      local max = math.min(self.first_invalid_line + 40, self.max_wanted_line)
+      local retokenized_from
+      for i = self.first_invalid_line, max do
+        local state = (i > 1) and self.lines[i - 1].state
+        local line = self.lines[i]
+        if line and line.resume and (line.init_state ~= state or line.text ~= self.doc.lines[i]) then
+          -- Reset the progress if no longer valid
+          line.resume = nil
+        end
+        if not (line and line.init_state == state and line.text == self.doc.lines[i] and not line.resume) then
+          retokenized_from = retokenized_from or i
+          self.lines[i] = self:tokenize_line(i, state, line and line.resume)
+          if self.lines[i].resume then
+            self.first_invalid_line = i
+            goto yield
           end
+        elseif retokenized_from then
+          self:update_notify(retokenized_from, i - retokenized_from - 1)
+          retokenized_from = nil
         end
-
-        self.first_invalid_line = max + 1
-        core.redraw = true
-        coroutine.yield()
       end
+
+      self.first_invalid_line = max + 1
+      ::yield::
+      if retokenized_from then
+        self:update_notify(retokenized_from, max - retokenized_from)
+      end
+      core.redraw = true
+      coroutine.yield()
     end
+    self.max_wanted_line = 0
+    self.running = false
   end, self)
 end
 
+local function set_max_wanted_lines(self, amount)
+  self.max_wanted_line = amount
+  if self.first_invalid_line <= self.max_wanted_line then
+    self:start()
+  end
+end
+
 
 function Highlighter:reset()
   self.lines = {}
+  self:soft_reset()
+end
+
+function Highlighter:soft_reset()
+  for i=1,#self.lines do
+    self.lines[i] = false
+  end
   self.first_invalid_line = 1
   self.max_wanted_line = 0
 end
 
-
 function Highlighter:invalidate(idx)
   self.first_invalid_line = math.min(self.first_invalid_line, idx)
-  self.max_wanted_line = math.min(self.max_wanted_line, #self.doc.lines)
+  set_max_wanted_lines(self, math.min(self.max_wanted_line, #self.doc.lines))
+end
+
+function Highlighter:insert_notify(line, n)
+  self:invalidate(line)
+  local blanks = { }
+  for i = 1, n do
+    blanks[i] = false
+  end
+  common.splice(self.lines, line, 0, blanks)
+end
+
+function Highlighter:remove_notify(line, n)
+  self:invalidate(line)
+  common.splice(self.lines, line, n)
+end
+
+function Highlighter:update_notify(line, n)
+  -- plugins can hook here to be notified that lines have been retokenized
 end
 
 
-function Highlighter:tokenize_line(idx, state)
+function Highlighter:tokenize_line(idx, state, resume)
   local res = {}
   res.init_state = state
   res.text = self.doc.lines[idx]
-  res.tokens, res.state = tokenizer.tokenize(self.doc.syntax, res.text, state)
+  res.tokens, res.state, res.resume = tokenizer.tokenize(self.doc.syntax, res.text, state, resume)
   return res
 end
 
@@ -66,8 +116,9 @@ function Highlighter:get_line(idx)
     local prev = self.lines[idx - 1]
     line = self:tokenize_line(idx, prev and prev.state)
     self.lines[idx] = line
+    self:update_notify(idx, 0)
   end
-  self.max_wanted_line = math.max(self.max_wanted_line, idx)
+  set_max_wanted_lines(self, math.max(self.max_wanted_line, idx))
   return line
 end
 
@@ -76,5 +127,4 @@ function Highlighter:each_token(idx)
   return tokenizer.each_token(self:get_line(idx).tokens)
 end
 
-
 return Highlighter

data/core/doc/init.lua

@@ -1,12 +1,14 @@
 local Object = require "core.object"
 local Highlighter = require "core.doc.highlighter"
+local core = require "core"
 local syntax = require "core.syntax"
 local config = require "core.config"
 local common = require "core.common"
 
-
+---@class core.doc : core.object
 local Doc = Object:extend()
 
+function Doc:__tostring() return "Doc" end
 
 local function split_lines(text)
   local res = {}
@@ -17,36 +19,22 @@ local function split_lines(text)
 end
 
 
-local function splice(t, at, remove, insert)
-  insert = insert or {}
-  local offset = #insert - remove
-  local old_len = #t
-  if offset < 0 then
-    for i = at - offset, old_len - offset do
-      t[i + offset] = t[i]
-    end
-  elseif offset > 0 then
-    for i = old_len, at, -1 do
-      t[i + offset] = t[i]
-    end
-  end
-  for i, item in ipairs(insert) do
-    t[at + i - 1] = item
-  end
-end
-
-
-function Doc:new(filename)
+function Doc:new(filename, abs_filename, new_file)
+  self.new_file = new_file
   self:reset()
   if filename then
-    self:load(filename)
+    self:set_filename(filename, abs_filename)
+    if not new_file then
+      self:load(filename)
+    end
   end
 end
 
 
 function Doc:reset()
   self.lines = { "\n" }
-  self.selection = { a = { line=1, col=1 }, b = { line=1, col=1 } }
+  self.selections = { 1, 1, 1, 1 }
+  self.last_selection = 1
   self.undo_stack = { idx = 1 }
   self.redo_stack = { idx = 1 }
   self.clean_change_id = 1
@@ -57,25 +45,39 @@ end
 
 function Doc:reset_syntax()
   local header = self:get_text(1, 1, self:position_offset(1, 1, 128))
-  local syn = syntax.get(self.filename or "", header)
+  local path = self.abs_filename
+  if not path and self.filename then
+    path = core.project_dir .. PATHSEP .. self.filename
+  end
+  if path then path = common.normalize_path(path) end
+  local syn = syntax.get(path, header)
   if self.syntax ~= syn then
     self.syntax = syn
-    self.highlighter:reset()
+    self.highlighter:soft_reset()
   end
 end
 
 
+function Doc:set_filename(filename, abs_filename)
+  self.filename = filename
+  self.abs_filename = abs_filename
+  self:reset_syntax()
+end
+
+
 function Doc:load(filename)
   local fp = assert( io.open(filename, "rb") )
   self:reset()
-  self.filename = filename
   self.lines = {}
+  local i = 1
   for line in fp:lines() do
     if line:byte(-1) == 13 then
       line = line:sub(1, -2)
       self.crlf = true
     end
     table.insert(self.lines, line .. "\n")
+    self.highlighter.lines[i] = false
+    i = i + 1
   end
   if #self.lines == 0 then
     table.insert(self.lines, "\n")
@@ -85,16 +87,32 @@ function Doc:load(filename)
 end
 
 
-function Doc:save(filename)
-  filename = filename or assert(self.filename, "no filename set to default to")
+function Doc:reload()
+  if self.filename then
+    local sel = { self:get_selection() }
+    self:load(self.filename)
+    self:clean()
+    self:set_selection(table.unpack(sel))
+  end
+end
+
+
+function Doc:save(filename, abs_filename)
+  if not filename then
+    assert(self.filename, "no filename set to default to")
+    filename = self.filename
+    abs_filename = self.abs_filename
+  else
+    assert(self.filename or abs_filename, "calling save on unnamed doc without absolute path")
+  end
   local fp = assert( io.open(filename, "wb") )
   for _, line in ipairs(self.lines) do
     if self.crlf then line = line:gsub("\n", "\r\n") end
     fp:write(line)
   end
   fp:close()
-  self.filename = filename or self.filename
-  self:reset_syntax()
+  self:set_filename(filename, abs_filename)
+  self.new_file = false
   self:clean()
 end
 
@@ -105,7 +123,12 @@ end
 
 
 function Doc:is_dirty()
-  return self.clean_change_id ~= self:get_change_id()
+  if self.new_file then
+    if self.filename then return true end
+    return #self.lines > 1 or #self.lines[1] > 1
+  else
+    return self.clean_change_id ~= self:get_change_id()
+  end
 end
 
 
@@ -114,54 +137,160 @@ function Doc:clean()
 end
 
 
+function Doc:get_indent_info()
+  if not self.indent_info then return config.tab_type, config.indent_size, false end
+  return self.indent_info.type or config.tab_type,
+         self.indent_info.size or config.indent_size,
+         self.indent_info.confirmed
+end
+
+
 function Doc:get_change_id()
   return self.undo_stack.idx
 end
 
-
-function Doc:set_selection(line1, col1, line2, col2, swap)
-  assert(not line2 == not col2, "expected 2 or 4 arguments")
-  if swap then line1, col1, line2, col2 = line2, col2, line1, col1 end
-  line1, col1 = self:sanitize_position(line1, col1)
-  line2, col2 = self:sanitize_position(line2 or line1, col2 or col1)
-  self.selection.a.line, self.selection.a.col = line1, col1
-  self.selection.b.line, self.selection.b.col = line2, col2
-end
-
-
 local function sort_positions(line1, col1, line2, col2)
-  if line1 > line2
-  or line1 == line2 and col1 > col2 then
+  if line1 > line2 or line1 == line2 and col1 > col2 then
     return line2, col2, line1, col1, true
   end
   return line1, col1, line2, col2, false
 end
 
-
+-- Cursor section. Cursor indices are *only* valid during a get_selections() call.
+-- Cursors will always be iterated in order from top to bottom. Through normal operation
+-- curors can never swap positions; only merge or split, or change their position in cursor
+-- order.
 function Doc:get_selection(sort)
-  local a, b = self.selection.a, self.selection.b
-  if sort then
-    return sort_positions(a.line, a.col, b.line, b.col)
+  local line1, col1, line2, col2, swap = self:get_selection_idx(self.last_selection, sort)
+  if not line1 then
+    line1, col1, line2, col2, swap = self:get_selection_idx(1, sort)
   end
-  return a.line, a.col, b.line, b.col
+  return line1, col1, line2, col2, swap
 end
 
 
+---Get the selection specified by `idx`
+---@param idx integer @the index of the selection to retrieve
+---@param sort? boolean @whether to sort the selection returned
+---@return integer,integer,integer,integer,boolean? @line1, col1, line2, col2, was the selection sorted
+function Doc:get_selection_idx(idx, sort)
+  local line1, col1, line2, col2 = self.selections[idx*4-3], self.selections[idx*4-2], self.selections[idx*4-1], self.selections[idx*4]
+  if line1 and sort then
+    return sort_positions(line1, col1, line2, col2)
+  else
+    return line1, col1, line2, col2
+  end
+end
+
+function Doc:get_selection_text(limit)
+  limit = limit or math.huge
+  local result = {}
+  for idx, line1, col1, line2, col2 in self:get_selections() do
+    if idx > limit then break end
+    if line1 ~= line2 or col1 ~= col2 then
+      local text = self:get_text(line1, col1, line2, col2)
+      if text ~= "" then result[#result + 1] = text end
+    end
+  end
+  return table.concat(result, "\n")
+end
+
 function Doc:has_selection()
-  local a, b = self.selection.a, self.selection.b
-  return not (a.line == b.line and a.col == b.col)
+  local line1, col1, line2, col2 = self:get_selection(false)
+  return line1 ~= line2 or col1 ~= col2
 end
 
+function Doc:has_any_selection()
+  for idx, line1, col1, line2, col2 in self:get_selections() do
+    if line1 ~= line2 or col1 ~= col2 then return true end
+  end
+  return false
+end
 
 function Doc:sanitize_selection()
-  self:set_selection(self:get_selection())
+  for idx, line1, col1, line2, col2 in self:get_selections() do
+    self:set_selections(idx, line1, col1, line2, col2)
+  end
+end
+
+function Doc:set_selections(idx, line1, col1, line2, col2, swap, rm)
+  assert(not line2 == not col2, "expected 3 or 5 arguments")
+  if swap then line1, col1, line2, col2 = line2, col2, line1, col1 end
+  line1, col1 = self:sanitize_position(line1, col1)
+  line2, col2 = self:sanitize_position(line2 or line1, col2 or col1)
+  common.splice(self.selections, (idx - 1)*4 + 1, rm == nil and 4 or rm, { line1, col1, line2, col2 })
+end
+
+function Doc:add_selection(line1, col1, line2, col2, swap)
+  local l1, c1 = sort_positions(line1, col1, line2 or line1, col2 or col1)
+  local target = #self.selections / 4 + 1
+  for idx, tl1, tc1 in self:get_selections(true) do
+    if l1 < tl1 or l1 == tl1 and c1 < tc1 then
+      target = idx
+      break
+    end
+  end
+  self:set_selections(target, line1, col1, line2, col2, swap, 0)
+  self.last_selection = target
 end
 
 
+function Doc:remove_selection(idx)
+  if self.last_selection >= idx then
+    self.last_selection = self.last_selection - 1
+  end
+  common.splice(self.selections, (idx - 1) * 4 + 1, 4)
+end
+
+
+function Doc:set_selection(line1, col1, line2, col2, swap)
+  self.selections = {}
+  self:set_selections(1, line1, col1, line2, col2, swap)
+  self.last_selection = 1
+end
+
+function Doc:merge_cursors(idx)
+  local table_index = idx and (idx - 1) * 4 + 1
+  for i = (table_index or (#self.selections - 3)), (table_index or 5), -4 do
+    for j = 1, i - 4, 4 do
+      if self.selections[i] == self.selections[j] and
+        self.selections[i+1] == self.selections[j+1] then
+          common.splice(self.selections, i, 4)
+          if self.last_selection >= (i+3)/4 then
+            self.last_selection = self.last_selection - 1
+          end
+          break
+      end
+    end
+  end
+end
+
+local function selection_iterator(invariant, idx)
+  local target = invariant[3] and (idx*4 - 7) or (idx*4 + 1)
+  if target > #invariant[1] or target <= 0 or (type(invariant[3]) == "number" and invariant[3] ~= idx - 1) then return end
+  if invariant[2] then
+    return idx+(invariant[3] and -1 or 1), sort_positions(table.unpack(invariant[1], target, target+4))
+  else
+    return idx+(invariant[3] and -1 or 1), table.unpack(invariant[1], target, target+4)
+  end
+end
+
+-- If idx_reverse is true, it'll reverse iterate. If nil, or false, regular iterate.
+-- If a number, runs for exactly that iteration.
+function Doc:get_selections(sort_intra, idx_reverse)
+  return selection_iterator, { self.selections, sort_intra, idx_reverse },
+    idx_reverse == true and ((#self.selections / 4) + 1) or ((idx_reverse or -1)+1)
+end
+-- End of cursor seciton.
+
 function Doc:sanitize_position(line, col)
-  line = common.clamp(line, 1, #self.lines)
-  col = common.clamp(col, 1, #self.lines[line])
-  return line, col
+  local nlines = #self.lines
+  if line > nlines then
+    return nlines, #self.lines[nlines]
+  elseif line < 1 then
+    return 1, 1
+  end
+  return line, common.clamp(col, 1, #self.lines[line])
 end
 
 
@@ -233,7 +362,7 @@ local function push_undo(undo_stack, time, type, ...)
 end
 
 
-local function pop_undo(self, undo_stack, redo_stack)
+local function pop_undo(self, undo_stack, redo_stack, modified)
   -- pop command
   local cmd = undo_stack[undo_stack.idx - 1]
   if not cmd then return end
@@ -243,21 +372,25 @@ local function pop_undo(self, undo_stack, redo_stack)
   if cmd.type == "insert" then
     local line, col, text = table.unpack(cmd)
     self:raw_insert(line, col, text, redo_stack, cmd.time)
-
   elseif cmd.type == "remove" then
     local line1, col1, line2, col2 = table.unpack(cmd)
     self:raw_remove(line1, col1, line2, col2, redo_stack, cmd.time)
-
   elseif cmd.type == "selection" then
-    self.selection.a.line, self.selection.a.col = cmd[1], cmd[2]
-    self.selection.b.line, self.selection.b.col = cmd[3], cmd[4]
+    self.selections = { table.unpack(cmd) }
+    self:sanitize_selection()
   end
 
+  modified = modified or (cmd.type ~= "selection")
+
   -- if next undo command is within the merge timeout then treat as a single
   -- command and continue to execute it
   local next = undo_stack[undo_stack.idx - 1]
   if next and math.abs(cmd.time - next.time) < config.undo_merge_timeout then
-    return pop_undo(self, undo_stack, redo_stack)
+    return pop_undo(self, undo_stack, redo_stack, modified)
+  end
+
+  if modified then
+    self:on_text_change("undo")
   end
 end
 
@@ -265,6 +398,7 @@ end
 function Doc:raw_insert(line, col, text, undo_stack, time)
   -- split text into lines and merge with line at insertion point
   local lines = split_lines(text)
+  local len = #lines[#lines]
   local before = self.lines[line]:sub(1, col - 1)
   local after = self.lines[line]:sub(col)
   for i = 1, #lines - 1 do
@@ -274,15 +408,23 @@ function Doc:raw_insert(line, col, text, undo_stack, time)
   lines[#lines] = lines[#lines] .. after
 
   -- splice lines into line array
-  splice(self.lines, line, 1, lines)
+  common.splice(self.lines, line, 1, lines)
+
+  -- keep cursors where they should be
+  for idx, cline1, ccol1, cline2, ccol2 in self:get_selections(true, true) do
+    if cline1 < line then break end
+    local line_addition = (line < cline1 or col < ccol1) and #lines - 1 or 0
+    local column_addition = line == cline1 and ccol1 > col and len or 0
+    self:set_selections(idx, cline1 + line_addition, ccol1 + column_addition, cline2 + line_addition, ccol2 + column_addition)
+  end
 
   -- push undo
   local line2, col2 = self:position_offset(line, col, #text)
-  push_undo(undo_stack, time, "selection", self:get_selection())
+  push_undo(undo_stack, time, "selection", table.unpack(self.selections))
   push_undo(undo_stack, time, "remove", line, col, line2, col2)
 
   -- update highlighter and assure selection is in bounds
-  self.highlighter:invalidate(line)
+  self.highlighter:insert_notify(line, #lines - 1)
   self:sanitize_selection()
 end
 
@@ -290,26 +432,71 @@ end
 function Doc:raw_remove(line1, col1, line2, col2, undo_stack, time)
   -- push undo
   local text = self:get_text(line1, col1, line2, col2)
-  push_undo(undo_stack, time, "selection", self:get_selection())
+  push_undo(undo_stack, time, "selection", table.unpack(self.selections))
   push_undo(undo_stack, time, "insert", line1, col1, text)
 
   -- get line content before/after removed text
   local before = self.lines[line1]:sub(1, col1 - 1)
   local after = self.lines[line2]:sub(col2)
 
+  local line_removal = line2 - line1
+  local col_removal = col2 - col1
+
   -- splice line into line array
-  splice(self.lines, line1, line2 - line1 + 1, { before .. after })
+  common.splice(self.lines, line1, line_removal + 1, { before .. after })
+
+  local merge = false
+
+  -- keep selections in correct positions: each pair (line, col)
+  -- * remains unchanged if before the deleted text
+  -- * is set to (line1, col1) if in the deleted text
+  -- * is set to (line1, col - col_removal) if on line2 but out of the deleted text
+  -- * is set to (line - line_removal, col) if after line2
+  for idx, cline1, ccol1, cline2, ccol2 in self:get_selections(true, true) do
+    if cline2 < line1 then break end
+    local l1, c1, l2, c2 = cline1, ccol1, cline2, ccol2
+
+    if cline1 > line1 or (cline1 == line1 and ccol1 > col1) then
+      if cline1 > line2 then
+        l1 = l1 - line_removal
+      else
+        l1 = line1
+        c1 = (cline1 == line2 and ccol1 > col2) and c1 - col_removal or col1
+      end
+    end
+
+    if cline2 > line1 or (cline2 == line1 and ccol2 > col1) then
+      if cline2 > line2 then
+        l2 = l2 - line_removal
+      else
+        l2 = line1
+        c2 = (cline2 == line2 and ccol2 > col2) and c2 - col_removal or col1
+      end
+    end
+
+    if l1 == line1 and c1 == col1 then merge = true end
+    self:set_selections(idx, l1, c1, l2, c2)
+  end
+
+  if merge then
+    self:merge_cursors()
+  end
 
   -- update highlighter and assure selection is in bounds
-  self.highlighter:invalidate(line1)
+  self.highlighter:remove_notify(line1, line_removal)
   self:sanitize_selection()
 end
 
 
 function Doc:insert(line, col, text)
   self.redo_stack = { idx = 1 }
+  -- Reset the clean id when we're pushing something new before it
+  if self:get_change_id() < self.clean_change_id then
+    self.clean_change_id = -1
+  end
   line, col = self:sanitize_position(line, col)
   self:raw_insert(line, col, text, self.undo_stack, system.get_time())
+  self:on_text_change("insert")
 end
 
 
@@ -319,74 +506,174 @@ function Doc:remove(line1, col1, line2, col2)
   line2, col2 = self:sanitize_position(line2, col2)
   line1, col1, line2, col2 = sort_positions(line1, col1, line2, col2)
   self:raw_remove(line1, col1, line2, col2, self.undo_stack, system.get_time())
+  self:on_text_change("remove")
 end
 
 
 function Doc:undo()
-  pop_undo(self, self.undo_stack, self.redo_stack)
+  pop_undo(self, self.undo_stack, self.redo_stack, false)
 end
 
 
 function Doc:redo()
-  pop_undo(self, self.redo_stack, self.undo_stack)
+  pop_undo(self, self.redo_stack, self.undo_stack, false)
 end
 
 
-function Doc:text_input(text)
-  if self:has_selection() then
-    self:delete_to()
+function Doc:text_input(text, idx)
+  for sidx, line1, col1, line2, col2 in self:get_selections(true, idx or true) do
+    if line1 ~= line2 or col1 ~= col2 then
+      self:delete_to_cursor(sidx)
+    end
+    self:insert(line1, col1, text)
+    self:move_to_cursor(sidx, #text)
   end
-  local line, col = self:get_selection()
-  self:insert(line, col, text)
-  self:move_to(#text)
 end
 
 
-function Doc:replace(fn)
-  local line1, col1, line2, col2, swap
-  local had_selection = self:has_selection()
-  if had_selection then
-    line1, col1, line2, col2, swap = self:get_selection(true)
-  else
-    line1, col1, line2, col2 = 1, 1, #self.lines, #self.lines[#self.lines]
+function Doc:ime_text_editing(text, start, length, idx)
+  for sidx, line1, col1, line2, col2 in self:get_selections(true, idx or true) do
+    if line1 ~= line2 or col1 ~= col2 then
+      self:delete_to_cursor(sidx)
+    end
+    self:insert(line1, col1, text)
+    self:set_selections(sidx, line1, col1 + #text, line1, col1)
   end
+end
+
+
+function Doc:replace_cursor(idx, line1, col1, line2, col2, fn)
   local old_text = self:get_text(line1, col1, line2, col2)
-  local new_text, n = fn(old_text)
+  local new_text, res = fn(old_text)
   if old_text ~= new_text then
     self:insert(line2, col2, new_text)
     self:remove(line1, col1, line2, col2)
-    if had_selection then
+    if line1 == line2 and col1 == col2 then
       line2, col2 = self:position_offset(line1, col1, #new_text)
-      self:set_selection(line1, col1, line2, col2, swap)
+      self:set_selections(idx, line1, col1, line2, col2)
     end
   end
-  return n
+  return res
 end
 
-
-function Doc:delete_to(...)
-  local line, col = self:get_selection(true)
-  if self:has_selection() then
-    self:remove(self:get_selection())
-  else
-    local line2, col2 = self:position_offset(line, col, ...)
-    self:remove(line, col, line2, col2)
-    line, col = sort_positions(line, col, line2, col2)
+function Doc:replace(fn)
+  local has_selection, results = false, { }
+  for idx, line1, col1, line2, col2 in self:get_selections(true) do
+    if line1 ~= line2 or col1 ~= col2 then
+      results[idx] = self:replace_cursor(idx, line1, col1, line2, col2, fn)
+      has_selection = true
+    end
   end
-  self:set_selection(line, col)
+  if not has_selection then
+    self:set_selection(table.unpack(self.selections))
+    results[1] = self:replace_cursor(1, 1, 1, #self.lines, #self.lines[#self.lines], fn)
+  end
+  return results
 end
 
 
-function Doc:move_to(...)
-  local line, col = self:get_selection()
-  self:set_selection(self:position_offset(line, col, ...))
+function Doc:delete_to_cursor(idx, ...)
+  for sidx, line1, col1, line2, col2 in self:get_selections(true, idx) do
+    if line1 ~= line2 or col1 ~= col2 then
+      self:remove(line1, col1, line2, col2)
+    else
+      local l2, c2 = self:position_offset(line1, col1, ...)
+      self:remove(line1, col1, l2, c2)
+      line1, col1 = sort_positions(line1, col1, l2, c2)
+    end
+    self:set_selections(sidx, line1, col1)
+  end
+  self:merge_cursors(idx)
+end
+function Doc:delete_to(...) return self:delete_to_cursor(nil, ...) end
+
+function Doc:move_to_cursor(idx, ...)
+  for sidx, line, col in self:get_selections(false, idx) do
+    self:set_selections(sidx, self:position_offset(line, col, ...))
+  end
+  self:merge_cursors(idx)
+end
+function Doc:move_to(...) return self:move_to_cursor(nil, ...) end
+
+
+function Doc:select_to_cursor(idx, ...)
+  for sidx, line, col, line2, col2 in self:get_selections(false, idx) do
+    line, col = self:position_offset(line, col, ...)
+    self:set_selections(sidx, line, col, line2, col2)
+  end
+  self:merge_cursors(idx)
+end
+function Doc:select_to(...) return self:select_to_cursor(nil, ...) end
+
+
+function Doc:get_indent_string()
+  local indent_type, indent_size = self:get_indent_info()
+  if indent_type == "hard" then
+    return "\t"
+  end
+  return string.rep(" ", indent_size)
 end
 
+-- returns the size of the original indent, and the indent
+-- in your config format, rounded either up or down
+function Doc:get_line_indent(line, rnd_up)
+  local _, e = line:find("^[ \t]+")
+  local indent_type, indent_size = self:get_indent_info()
+  local soft_tab = string.rep(" ", indent_size)
+  if indent_type == "hard" then
+    local indent = e and line:sub(1, e):gsub(soft_tab, "\t") or ""
+    return e, indent:gsub(" +", rnd_up and "\t" or "")
+  else
+    local indent = e and line:sub(1, e):gsub("\t", soft_tab) or ""
+    local number = #indent / #soft_tab
+    return e, indent:sub(1,
+      (rnd_up and math.ceil(number) or math.floor(number))*#soft_tab)
+  end
+end
 
-function Doc:select_to(...)
-  local line, col, line2, col2 = self:get_selection()
-  line, col = self:position_offset(line, col, ...)
-  self:set_selection(line, col, line2, col2)
+-- un/indents text; behaviour varies based on selection and un/indent.
+-- * if there's a selection, it will stay static around the
+--   text for both indenting and unindenting.
+-- * if you are in the beginning whitespace of a line, and are indenting, the
+--   cursor will insert the exactly appropriate amount of spaces, and jump the
+--   cursor to the beginning of first non whitespace characters
+-- * if you are not in the beginning whitespace of a line, and you indent, it
+--   inserts the appropriate whitespace, as if you typed them normally.
+-- * if you are unindenting, the cursor will jump to the start of the line,
+--   and remove the appropriate amount of spaces (or a tab).
+function Doc:indent_text(unindent, line1, col1, line2, col2)
+  local text = self:get_indent_string()
+  local _, se = self.lines[line1]:find("^[ \t]+")
+  local in_beginning_whitespace = col1 == 1 or (se and col1 <= se + 1)
+  local has_selection = line1 ~= line2 or col1 ~= col2
+  if unindent or has_selection or in_beginning_whitespace then
+    local l1d, l2d = #self.lines[line1], #self.lines[line2]
+    for line = line1, line2 do
+      if not has_selection or #self.lines[line] > 1 then -- don't indent empty lines in a selection
+        local e, rnded = self:get_line_indent(self.lines[line], unindent)
+        self:remove(line, 1, line, (e or 0) + 1)
+        self:insert(line, 1,
+          unindent and rnded:sub(1, #rnded - #text) or rnded .. text)
+      end
+    end
+    l1d, l2d = #self.lines[line1] - l1d, #self.lines[line2] - l2d
+    if (unindent or in_beginning_whitespace) and not has_selection then
+      local start_cursor = (se and se + 1 or 1) + l1d or #(self.lines[line1])
+      return line1, start_cursor, line2, start_cursor
+    end
+    return line1, col1 + l1d, line2, col2 + l2d
+  end
+  self:insert(line1, col1, text)
+  return line1, col1 + #text, line1, col1 + #text
+end
+
+-- For plugins to add custom actions of document change
+function Doc:on_text_change(type)
+end
+
+-- For plugins to get notified when a document is closed
+function Doc:on_close()
+  core.log_quiet("Closed doc \"%s\"", self:get_name())
 end
 
 

data/core/doc/search.lua

@@ -15,36 +15,80 @@ local function init_args(doc, line, col, text, opt)
   opt = opt or default_opt
   line, col = doc:sanitize_position(line, col)
 
-  if opt.no_case then
-    if opt.pattern then
-      text = text:gsub("%%?.", pattern_lower)
-    else
-      text = text:lower()
-    end
+  if opt.no_case and not opt.regex then
+    text = text:lower()
   end
 
   return doc, line, col, text, opt
 end
 
+-- This function is needed to uniform the behavior of
+-- `regex:cmatch` and `string.find`.
+local function regex_func(text, re, index, _)
+  local s, e = re:cmatch(text, index)
+  return s, e and e - 1
+end
+
+local function rfind(func, text, pattern, index, plain)
+  local s, e = func(text, pattern, 1, plain)
+  local last_s, last_e
+  if index < 0 then index = #text - index + 1 end
+  while e and e <= index do
+    last_s, last_e = s, e
+    s, e = func(text, pattern, s + 1, plain)
+  end
+  return last_s, last_e
+end
+
 
 function search.find(doc, line, col, text, opt)
   doc, line, col, text, opt = init_args(doc, line, col, text, opt)
-
-  for line = line, #doc.lines do
+  local plain = not opt.pattern
+  local pattern = text
+  local search_func = string.find
+  if opt.regex then
+    pattern = regex.compile(text, opt.no_case and "i" or "")
+    search_func = regex_func
+  end
+  local start, finish, step = line, #doc.lines, 1
+  if opt.reverse then
+    start, finish, step = line, 1, -1
+  end
+  for line = start, finish, step do
     local line_text = doc.lines[line]
-    if opt.no_case then
+    if opt.no_case and not opt.regex then
       line_text = line_text:lower()
     end
-    local s, e = line_text:find(text, col, not opt.pattern)
-    if s then
-      return line, s, line, e + 1
+    local s, e
+    if opt.reverse then
+      s, e = rfind(search_func, line_text, pattern, col - 1, plain)
+    else
+      s, e = search_func(line_text, pattern, col, plain)
     end
-    col = 1
+    if s then
+      local line2 = line
+      -- If we've matched the newline too,
+      -- return until the initial character of the next line.
+      if e >= #doc.lines[line] then
+        line2 = line + 1
+        e = 0
+      end
+      -- Avoid returning matches that go beyond the last line.
+      -- This is needed to avoid selecting the "last" newline.
+      if line2 <= #doc.lines then
+        return line, s, line2, e + 1
+      end
+    end
+    col = opt.reverse and -1 or 1
   end
 
   if opt.wrap then
-    opt = { no_case = opt.no_case, pattern = opt.pattern }
-    return search.find(doc, 1, 1, text, opt)
+    opt = { no_case = opt.no_case, regex = opt.regex, reverse = opt.reverse }
+    if opt.reverse then
+      return search.find(doc, #doc.lines, #doc.lines[#doc.lines], text, opt)
+    else
+      return search.find(doc, 1, 1, text, opt)
+    end
   end
 end
 

data/core/doc/translate.lua

@@ -117,6 +117,10 @@ function translate.start_of_line(doc, line, col)
   return line, 1
 end
 
+function translate.start_of_indentation(doc, line, col)
+  local s, e = doc.lines[line]:find("^%s*")
+  return line, col > e + 1 and e + 1 or 1
+end
 
 function translate.end_of_line(doc, line, col)
   return line, math.huge

data/core/docview.lua

@@ -4,11 +4,16 @@ local config = require "core.config"
 local style = require "core.style"
 local keymap = require "core.keymap"
 local translate = require "core.doc.translate"
+local ime = require "core.ime"
 local View = require "core.view"
 
-
+---@class core.docview : core.view
+---@field super core.view
 local DocView = View:extend()
 
+function DocView:__tostring() return "DocView" end
+
+DocView.context = "session"
 
 local function move_to_line_offset(dv, line, col, offset)
   local xo = dv.last_x_offset
@@ -28,6 +33,9 @@ DocView.translate = {
   end,
 
   ["next_page"] = function(doc, line, col, dv)
+    if line == #doc.lines then
+      return #doc.lines, #doc.lines[line]
+    end
     local min, max = dv:get_visible_line_range()
     return line + (max - min), 1
   end,
@@ -47,8 +55,6 @@ DocView.translate = {
   end,
 }
 
-local blink_period = 0.8
-
 
 function DocView:new(doc)
   DocView.super.new(self)
@@ -57,26 +63,33 @@ function DocView:new(doc)
   self.doc = assert(doc)
   self.font = "code_font"
   self.last_x_offset = {}
-  self.blink_timer = 0
+  self.ime_selection = { from = 0, size = 0 }
+  self.ime_status = false
+  self.hovering_gutter = false
+  self.v_scrollbar:set_forced_status(config.force_scrollbar_status)
+  self.h_scrollbar:set_forced_status(config.force_scrollbar_status)
 end
 
 
 function DocView:try_close(do_close)
   if self.doc:is_dirty()
   and #core.get_views_referencing_doc(self.doc) == 1 then
-    core.command_view:enter("Unsaved Changes; Confirm Close", function(_, item)
-      if item.text:match("^[cC]") then
-        do_close()
-      elseif item.text:match("^[sS]") then
-        self.doc:save()
-        do_close()
+    core.command_view:enter("Unsaved Changes; Confirm Close", {
+      submit = function(_, item)
+        if item.text:match("^[cC]") then
+          do_close()
+        elseif item.text:match("^[sS]") then
+          self.doc:save()
+          do_close()
+        end
+      end,
+      suggest = function(text)
+        local items = {}
+        if not text:find("^[^cC]") then table.insert(items, "Close Without Saving") end
+        if not text:find("^[^sS]") then table.insert(items, "Save And Close") end
+        return items
       end
-    end, function(text)
-      local items = {}
-      if not text:find("^[^cC]") then table.insert(items, "Close Without Saving") end
-      if not text:find("^[^sS]") then table.insert(items, "Save And Close") end
-      return items
-    end)
+    })
   else
     do_close()
   end
@@ -90,10 +103,27 @@ function DocView:get_name()
 end
 
 
+function DocView:get_filename()
+  if self.doc.abs_filename then
+    local post = self.doc:is_dirty() and "*" or ""
+    return common.home_encode(self.doc.abs_filename) .. post
+  end
+  return self:get_name()
+end
+
+
 function DocView:get_scrollable_size()
+  if not config.scroll_past_end then
+    local _, _, _, h_scroll = self.h_scrollbar:get_track_rect()
+    return self:get_line_height() * (#self.doc.lines) + style.padding.y * 2 + h_scroll
+  end
   return self:get_line_height() * (#self.doc.lines - 1) + self.size.y
 end
 
+function DocView:get_h_scrollable_size()
+  return math.huge
+end
+
 
 function DocView:get_font()
   return style[self.font]
@@ -106,18 +136,23 @@ end
 
 
 function DocView:get_gutter_width()
-  return self:get_font():get_width(#self.doc.lines) + style.padding.x * 2
+  local padding = style.padding.x * 2
+  return self:get_font():get_width(#self.doc.lines) + padding, padding
 end
 
 
-function DocView:get_line_screen_position(idx)
+function DocView:get_line_screen_position(line, col)
   local x, y = self:get_content_offset()
   local lh = self:get_line_height()
   local gw = self:get_gutter_width()
-  return x + gw, y + (idx-1) * lh + style.padding.y
+  y = y + (line-1) * lh + style.padding.y
+  if col then
+    return x + gw + self:get_col_x_offset(line, col), y
+  else
+    return x + gw, y
+  end
 end
 
-
 function DocView:get_line_text_y_offset()
   local lh = self:get_line_height()
   local th = self:get_font():get_height()
@@ -128,34 +163,72 @@ end
 function DocView:get_visible_line_range()
   local x, y, x2, y2 = self:get_content_bounds()
   local lh = self:get_line_height()
-  local minline = math.max(1, math.floor(y / lh))
-  local maxline = math.min(#self.doc.lines, math.floor(y2 / lh) + 1)
+  local minline = math.max(1, math.floor((y - style.padding.y) / lh) + 1)
+  local maxline = math.min(#self.doc.lines, math.floor((y2 - style.padding.y) / lh) + 1)
   return minline, maxline
 end
 
 
 function DocView:get_col_x_offset(line, col)
-  local text = self.doc.lines[line]
-  if not text then return 0 end
-  return self:get_font():get_width(text:sub(1, col - 1))
+  local default_font = self:get_font()
+  local _, indent_size = self.doc:get_indent_info()
+  default_font:set_tab_size(indent_size)
+  local column = 1
+  local xoffset = 0
+  for _, type, text in self.doc.highlighter:each_token(line) do
+    local font = style.syntax_fonts[type] or default_font
+    if font ~= default_font then font:set_tab_size(indent_size) end
+    local length = #text
+    if column + length <= col then
+      xoffset = xoffset + font:get_width(text)
+      column = column + length
+      if column >= col then
+        return xoffset
+      end
+    else
+      for char in common.utf8_chars(text) do
+        if column >= col then
+          return xoffset
+        end
+        xoffset = xoffset + font:get_width(char)
+        column = column + #char
+      end
+    end
+  end
+
+  return xoffset
 end
 
 
 function DocView:get_x_offset_col(line, x)
-  local text = self.doc.lines[line]
+  local line_text = self.doc.lines[line]
 
-  local xoffset, last_i, i = 0, 1, 1
-  for char in common.utf8_chars(text) do
-    local w = self:get_font():get_width(char)
-    if xoffset >= x then
-      return (xoffset - x > w / 2) and last_i or i
+  local xoffset, i = 0, 1
+  local default_font = self:get_font()
+  local _, indent_size = self.doc:get_indent_info()
+  default_font:set_tab_size(indent_size)
+  for _, type, text in self.doc.highlighter:each_token(line) do
+    local font = style.syntax_fonts[type] or default_font
+    if font ~= default_font then font:set_tab_size(indent_size) end
+    local width = font:get_width(text)
+    -- Don't take the shortcut if the width matches x,
+    -- because we need last_i which should be calculated using utf-8.
+    if xoffset + width < x then
+      xoffset = xoffset + width
+      i = i + #text
+    else
+      for char in common.utf8_chars(text) do
+        local w = font:get_width(char)
+        if xoffset + w >= x then
+          return (x <= xoffset + (w / 2)) and i or i + #char
+        end
+        xoffset = xoffset + w
+        i = i + #char
+      end
     end
-    xoffset = xoffset + w
-    last_i = i
-    i = i + #char
   end
 
-  return #text
+  return #line_text
 end
 
 
@@ -171,8 +244,10 @@ end
 function DocView:scroll_to_line(line, ignore_if_visible, instant)
   local min, max = self:get_visible_line_range()
   if not (ignore_if_visible and line > min and line < max) then
-    local lh = self:get_line_height()
-    self.scroll.to.y = math.max(0, lh * (line - 1) - self.size.y / 2)
+    local x, y = self:get_line_screen_position(line)
+    local ox, oy = self:get_content_offset()
+    local _, _, _, scroll_h = self.h_scrollbar:get_track_rect()
+    self.scroll.to.y = math.max(0, y - oy - (self.size.y - scroll_h) / 2)
     if instant then
       self.scroll.y = self.scroll.to.y
     end
@@ -181,30 +256,70 @@ end
 
 
 function DocView:scroll_to_make_visible(line, col)
-  local min = self:get_line_height() * (line - 1)
-  local max = self:get_line_height() * (line + 2) - self.size.y
-  self.scroll.to.y = math.min(self.scroll.to.y, min)
-  self.scroll.to.y = math.max(self.scroll.to.y, max)
+  local _, oy = self:get_content_offset()
+  local _, ly = self:get_line_screen_position(line, col)
+  local lh = self:get_line_height()
+  local _, _, _, scroll_h = self.h_scrollbar:get_track_rect()
+  local overscroll = math.min(lh * 2, self.size.y) -- always show the previous / next line when possible
+  self.scroll.to.y = common.clamp(self.scroll.to.y, ly - oy - self.size.y + scroll_h + overscroll, ly - oy - lh)
   local gw = self:get_gutter_width()
   local xoffset = self:get_col_x_offset(line, col)
-  local max = xoffset - self.size.x + gw + self.size.x / 5
-  self.scroll.to.x = math.max(0, max)
+  local xmargin = 3 * self:get_font():get_width(' ')
+  local xsup = xoffset + gw + xmargin
+  local xinf = xoffset - xmargin
+  local _, _, scroll_w = self.v_scrollbar:get_track_rect()
+  local size_x = math.max(0, self.size.x - scroll_w)
+  if xsup > self.scroll.x + size_x then
+    self.scroll.to.x = xsup - size_x
+  elseif xinf < self.scroll.x then
+    self.scroll.to.x = math.max(0, xinf)
+  end
+end
+
+function DocView:on_mouse_moved(x, y, ...)
+  DocView.super.on_mouse_moved(self, x, y, ...)
+
+  self.hovering_gutter = false
+  local gw = self:get_gutter_width()
+
+  if self:scrollbar_hovering() or self:scrollbar_dragging() then
+    self.cursor = "arrow"
+  elseif gw > 0 and x >= self.position.x and x <= (self.position.x + gw) then
+    self.cursor = "arrow"
+    self.hovering_gutter = true
+  else
+    self.cursor = "ibeam"
+  end
+
+  if self.mouse_selecting then
+    local l1, c1 = self:resolve_screen_position(x, y)
+    local l2, c2, snap_type = table.unpack(self.mouse_selecting)
+    if keymap.modkeys["ctrl"] then
+      if l1 > l2 then l1, l2 = l2, l1 end
+      self.doc.selections = { }
+      for i = l1, l2 do
+        self.doc:set_selections(i - l1 + 1, i, math.min(c1, #self.doc.lines[i]), i, math.min(c2, #self.doc.lines[i]))
+      end
+    else
+      if snap_type then
+        l1, c1, l2, c2 = self:mouse_selection(self.doc, snap_type, l1, c1, l2, c2)
+      end
+      self.doc:set_selection(l1, c1, l2, c2)
+    end
+  end
 end
 
 
-local function mouse_selection(doc, clicks, line1, col1, line2, col2)
+function DocView:mouse_selection(doc, snap_type, line1, col1, line2, col2)
   local swap = line2 < line1 or line2 == line1 and col2 <= col1
   if swap then
     line1, col1, line2, col2 = line2, col2, line1, col1
   end
-  if clicks == 2 then
+  if snap_type == "word" then
     line1, col1 = translate.start_of_word(doc, line1, col1)
     line2, col2 = translate.end_of_word(doc, line2, col2)
-  elseif clicks == 3 then
-    if line2 == #doc.lines and doc.lines[#doc.lines] ~= "\n" then
-      doc:insert(math.huge, math.huge, "\n")
-    end
-    line1, col1, line2, col2 = line1, 1, line2 + 1, 1
+  elseif snap_type == "lines" then
+    col1, col2 = 1, math.huge
   end
   if swap then
     return line2, col2, line1, col1
@@ -214,45 +329,30 @@ end
 
 
 function DocView:on_mouse_pressed(button, x, y, clicks)
-  local caught = DocView.super.on_mouse_pressed(self, button, x, y, clicks)
-  if caught then
-    return
+  if button ~= "left" or not self.hovering_gutter then
+    return DocView.super.on_mouse_pressed(self, button, x, y, clicks)
   end
+  local line = self:resolve_screen_position(x, y)
   if keymap.modkeys["shift"] then
-    if clicks == 1 then
-      local line1, col1 = select(3, self.doc:get_selection())
-      local line2, col2 = self:resolve_screen_position(x, y)
-      self.doc:set_selection(line2, col2, line1, col1)
+    local sline, scol, sline2, scol2 = self.doc:get_selection(true)
+    if line > sline then
+      self.doc:set_selection(sline, 1, line,  #self.doc.lines[line])
+    else
+      self.doc:set_selection(line, 1, sline2, #self.doc.lines[sline2])
     end
   else
-    local line, col = self:resolve_screen_position(x, y)
-    self.doc:set_selection(mouse_selection(self.doc, clicks, line, col, line, col))
-    self.mouse_selecting = { line, col, clicks = clicks }
+    if clicks == 1 then
+      self.doc:set_selection(line, 1, line, 1)
+    elseif clicks == 2 then
+      self.doc:set_selection(line, 1, line, #self.doc.lines[line])
+    end
   end
-  self.blink_timer = 0
+  return true
 end
 
 
-function DocView:on_mouse_moved(x, y, ...)
-  DocView.super.on_mouse_moved(self, x, y, ...)
-
-  if self:scrollbar_overlaps_point(x, y) or self.dragging_scrollbar then
-    self.cursor = "arrow"
-  else
-    self.cursor = "ibeam"
-  end
-
-  if self.mouse_selecting then
-    local l1, c1 = self:resolve_screen_position(x, y)
-    local l2, c2 = table.unpack(self.mouse_selecting)
-    local clicks = self.mouse_selecting.clicks
-    self.doc:set_selection(mouse_selection(self.doc, clicks, l1, c1, l2, c2))
-  end
-end
-
-
-function DocView:on_mouse_released(button)
-  DocView.super.on_mouse_released(self, button)
+function DocView:on_mouse_released(...)
+  DocView.super.on_mouse_released(self, ...)
   self.mouse_selecting = nil
 end
 
@@ -261,28 +361,72 @@ function DocView:on_text_input(text)
   self.doc:text_input(text)
 end
 
+function DocView:on_ime_text_editing(text, start, length)
+  self.doc:ime_text_editing(text, start, length)
+  self.ime_status = #text > 0
+  self.ime_selection.from = start
+  self.ime_selection.size = length
+
+  -- Set the composition bounding box that the system IME
+  -- will consider when drawing its interface
+  local line1, col1, line2, col2 = self.doc:get_selection(true)
+  local col = math.min(col1, col2)
+  self:update_ime_location()
+  self:scroll_to_make_visible(line1, col + start)
+end
+
+---Update the composition bounding box that the system IME
+---will consider when drawing its interface
+function DocView:update_ime_location()
+  if not self.ime_status then return end
+
+  local line1, col1, line2, col2 = self.doc:get_selection(true)
+  local x, y = self:get_line_screen_position(line1)
+  local h = self:get_line_height()
+  local col = math.min(col1, col2)
+
+  local x1, x2 = 0, 0
+
+  if self.ime_selection.size > 0 then
+    -- focus on a part of the text
+    local from = col + self.ime_selection.from
+    local to = from + self.ime_selection.size
+    x1 = self:get_col_x_offset(line1, from)
+    x2 = self:get_col_x_offset(line1, to)
+  else
+    -- focus the whole text
+    x1 = self:get_col_x_offset(line1, col1)
+    x2 = self:get_col_x_offset(line2, col2)
+  end
+
+  ime.set_location(x + x1, y, x2 - x1, h)
+end
 
 function DocView:update()
   -- scroll to make caret visible and reset blink timer if it moved
-  local line, col = self.doc:get_selection()
-  if (line ~= self.last_line or col ~= self.last_col) and self.size.x > 0 then
-    if core.active_view == self then
-      self:scroll_to_make_visible(line, col)
+  local line1, col1, line2, col2 = self.doc:get_selection()
+  if (line1 ~= self.last_line1 or col1 ~= self.last_col1 or
+      line2 ~= self.last_line2 or col2 ~= self.last_col2) and self.size.x > 0 then
+    if core.active_view == self and not ime.editing then
+      self:scroll_to_make_visible(line1, col1)
     end
-    self.blink_timer = 0
-    self.last_line, self.last_col = line, col
+    core.blink_reset()
+    self.last_line1, self.last_col1 = line1, col1
+    self.last_line2, self.last_col2 = line2, col2
   end
 
   -- update blink timer
   if self == core.active_view and not self.mouse_selecting then
-    local n = blink_period / 2
-    local prev = self.blink_timer
-    self.blink_timer = (self.blink_timer + 1 / config.fps) % blink_period
-    if (self.blink_timer > n) ~= (prev > n) then
+    local T, t0 = config.blink_period, core.blink_start
+    local ta, tb = core.blink_timer, system.get_time()
+    if ((tb - t0) % T < T / 2) ~= ((ta - t0) % T < T / 2) then
       core.redraw = true
     end
+    core.blink_timer = tb
   end
 
+  self:update_ime_location()
+
   DocView.super.update(self)
 end
 
@@ -293,91 +437,159 @@ function DocView:draw_line_highlight(x, y)
 end
 
 
-function DocView:draw_line_text(idx, x, y)
+function DocView:draw_line_text(line, x, y)
+  local default_font = self:get_font()
   local tx, ty = x, y + self:get_line_text_y_offset()
-  local font = self:get_font()
-  for _, type, text in self.doc.highlighter:each_token(idx) do
-    local color = style.syntax[type]
-    tx = renderer.draw_text(font, text, tx, ty, color)
+  local last_token = nil
+  local tokens = self.doc.highlighter:get_line(line).tokens
+  local tokens_count = #tokens
+  if string.sub(tokens[tokens_count], -1) == "\n" then
+    last_token = tokens_count - 1
   end
+  for tidx, type, text in self.doc.highlighter:each_token(line) do
+    local color = style.syntax[type]
+    local font = style.syntax_fonts[type] or default_font
+    -- do not render newline, fixes issue #1164
+    if tidx == last_token then text = text:sub(1, -2) end
+    tx = renderer.draw_text(font, text, tx, ty, color)
+    if tx > self.position.x + self.size.x then break end
+  end
+  return self:get_line_height()
 end
 
-
-function DocView:draw_line_body(idx, x, y)
-  local line, col = self.doc:get_selection()
-
-  -- draw selection if it overlaps this line
-  local line1, col1, line2, col2 = self.doc:get_selection(true)
-  if idx >= line1 and idx <= line2 then
-    local text = self.doc.lines[idx]
-    if line1 ~= idx then col1 = 1 end
-    if line2 ~= idx then col2 = #text + 1 end
-    local x1 = x + self:get_col_x_offset(idx, col1)
-    local x2 = x + self:get_col_x_offset(idx, col2)
+function DocView:draw_caret(x, y)
     local lh = self:get_line_height()
-    renderer.draw_rect(x1, y, x2 - x1, lh, style.selection)
-  end
+    renderer.draw_rect(x, y, style.caret_width, lh, style.caret)
+end
 
-  -- draw line highlight if caret is on this line
-  if config.highlight_current_line and not self.doc:has_selection()
-  and line == idx and core.active_view == self then
+function DocView:draw_line_body(line, x, y)
+  -- draw highlight if any selection ends on this line
+  local draw_highlight = false
+  local hcl = config.highlight_current_line
+  if hcl ~= false then
+    for lidx, line1, col1, line2, col2 in self.doc:get_selections(false) do
+      if line1 == line then
+        if hcl == "no_selection" then
+          if (line1 ~= line2) or (col1 ~= col2) then
+            draw_highlight = false
+            break
+          end
+        end
+        draw_highlight = true
+        break
+      end
+    end
+  end
+  if draw_highlight and core.active_view == self then
     self:draw_line_highlight(x + self.scroll.x, y)
   end
 
+  -- draw selection if it overlaps this line
+  local lh = self:get_line_height()
+  for lidx, line1, col1, line2, col2 in self.doc:get_selections(true) do
+    if line >= line1 and line <= line2 then
+      local text = self.doc.lines[line]
+      if line1 ~= line then col1 = 1 end
+      if line2 ~= line then col2 = #text + 1 end
+      local x1 = x + self:get_col_x_offset(line, col1)
+      local x2 = x + self:get_col_x_offset(line, col2)
+      if x1 ~= x2 then
+        renderer.draw_rect(x1, y, x2 - x1, lh, style.selection)
+      end
+    end
+  end
+
   -- draw line's text
-  self:draw_line_text(idx, x, y)
-
-  -- draw caret if it overlaps this line
-  if line == idx and core.active_view == self
-  and self.blink_timer < blink_period / 2
-  and system.window_has_focus() then
-    local lh = self:get_line_height()
-    local x1 = x + self:get_col_x_offset(line, col)
-    renderer.draw_rect(x1, y, style.caret_width, lh, style.caret)
-  end
+  return self:draw_line_text(line, x, y)
 end
 
 
-function DocView:draw_line_gutter(idx, x, y)
+function DocView:draw_line_gutter(line, x, y, width)
   local color = style.line_number
-  local line1, _, line2, _ = self.doc:get_selection(true)
-  if idx >= line1 and idx <= line2 then
-    color = style.line_number2
+  for _, line1, _, line2 in self.doc:get_selections(true) do
+    if line >= line1 and line <= line2 then
+      color = style.line_number2
+      break
+    end
   end
-  local yoffset = self:get_line_text_y_offset()
   x = x + style.padding.x
-  renderer.draw_text(self:get_font(), idx, x, y + yoffset, color)
+  local lh = self:get_line_height()
+  common.draw_text(self:get_font(), color, line, "right", x, y, width, lh)
+  return lh
 end
 
 
+function DocView:draw_ime_decoration(line1, col1, line2, col2)
+  local x, y = self:get_line_screen_position(line1)
+  local line_size = math.max(1, SCALE)
+  local lh = self:get_line_height()
+
+  -- Draw IME underline
+  local x1 = self:get_col_x_offset(line1, col1)
+  local x2 = self:get_col_x_offset(line2, col2)
+  renderer.draw_rect(x + math.min(x1, x2), y + lh - line_size, math.abs(x1 - x2), line_size, style.text)
+
+  -- Draw IME selection
+  local col = math.min(col1, col2)
+  local from = col + self.ime_selection.from
+  local to = from + self.ime_selection.size
+  x1 = self:get_col_x_offset(line1, from)
+  if from ~= to then
+    x2 = self:get_col_x_offset(line1, to)
+    line_size = style.caret_width
+    renderer.draw_rect(x + math.min(x1, x2), y + lh - line_size, math.abs(x1 - x2), line_size, style.caret)
+  end
+  self:draw_caret(x + x1, y)
+end
+
+
+function DocView:draw_overlay()
+  if core.active_view == self then
+    local minline, maxline = self:get_visible_line_range()
+    -- draw caret if it overlaps this line
+    local T = config.blink_period
+    for _, line1, col1, line2, col2 in self.doc:get_selections() do
+      if line1 >= minline and line1 <= maxline
+      and system.window_has_focus() then
+        if ime.editing then
+          self:draw_ime_decoration(line1, col1, line2, col2)
+        else
+          if config.disable_blink
+          or (core.blink_timer - core.blink_start) % T < T / 2 then
+            self:draw_caret(self:get_line_screen_position(line1, col1))
+          end
+        end
+      end
+    end
+  end
+end
+
 function DocView:draw()
   self:draw_background(style.background)
-
-  local font = self:get_font()
-  font:set_tab_width(font:get_width(" ") * config.indent_size)
+  local _, indent_size = self.doc:get_indent_info()
+  self:get_font():set_tab_size(indent_size)
 
   local minline, maxline = self:get_visible_line_range()
   local lh = self:get_line_height()
 
-  local _, y = self:get_line_screen_position(minline)
-  local x = self.position.x
+  local x, y = self:get_line_screen_position(minline)
+  local gw, gpad = self:get_gutter_width()
   for i = minline, maxline do
-    self:draw_line_gutter(i, x, y)
-    y = y + lh
+    y = y + (self:draw_line_gutter(i, self.position.x, y, gpad and gw - gpad or gw) or lh)
   end
 
-  local x, y = self:get_line_screen_position(minline)
-  local gw = self:get_gutter_width()
   local pos = self.position
-  core.push_clip_rect(pos.x + gw, pos.y, self.size.x, self.size.y)
+  x, y = self:get_line_screen_position(minline)
+  -- the clip below ensure we don't write on the gutter region. On the
+  -- right side it is redundant with the Node's clip.
+  core.push_clip_rect(pos.x + gw, pos.y, self.size.x - gw, self.size.y)
   for i = minline, maxline do
-    self:draw_line_body(i, x, y)
-    y = y + lh
+    y = y + (self:draw_line_body(i, x, y) or lh)
   end
+  self:draw_overlay()
   core.pop_clip_rect()
 
   self:draw_scrollbar()
 end
 
-
 return DocView

data/core/emptyview.lua

@@ -0,0 +1,62 @@
+local style = require "core.style"
+local keymap = require "core.keymap"
+local View = require "core.view"
+
+---@class core.emptyview : core.view
+---@field super core.view
+local EmptyView = View:extend()
+
+function EmptyView:__tostring() return "EmptyView" end
+
+function EmptyView:get_name()
+  return "Get Started"
+end
+
+function EmptyView:get_filename()
+  return ""
+end
+
+local function draw_text(x, y, color)
+  local lines = {
+    { fmt = "%s to run a command", cmd = "core:find-command" },
+    { fmt = "%s to open a file from the project", cmd = "core:find-file" },
+    { fmt = "%s to change project folder", cmd = "core:change-project-folder" },
+    { fmt = "%s to open a project folder", cmd = "core:open-project-folder" },
+  }
+  local th = style.big_font:get_height()
+  local dh = 2 * th + style.padding.y * 2
+  local x1, y1 = x, y + ((dh - th) / #lines)
+  local xv = x1
+  local title = "Lite XL"
+  local version = "version " .. VERSION
+  local title_width = style.big_font:get_width(title)
+  local version_width = style.font:get_width(version)
+  if version_width > title_width then
+    version = VERSION
+    version_width = style.font:get_width(version)
+    xv = x1 - (version_width - title_width)
+  end
+  x = renderer.draw_text(style.big_font, title, x1, y1, color)
+  renderer.draw_text(style.font, version, xv, y1 + th, color)
+  x = x + style.padding.x
+  renderer.draw_rect(x, y, math.ceil(1 * SCALE), dh, color)
+  th = style.font:get_height()
+  y = y + (dh - (th + style.padding.y) * #lines) / 2
+  local w = 0
+  for _, line in ipairs(lines) do
+    local text = string.format(line.fmt, keymap.get_binding(line.cmd))
+    w = math.max(w, renderer.draw_text(style.font, text, x + style.padding.x, y, color))
+    y = y + th + style.padding.y
+  end
+  return w, dh
+end
+
+function EmptyView:draw()
+  self:draw_background(style.background)
+  local w, h = draw_text(0, 0, { 0, 0, 0, 0 })
+  local x = self.position.x + math.max(style.padding.x, (self.size.x - w) / 2)
+  local y = self.position.y + (self.size.y - h) / 2
+  draw_text(x, y, style.dim)
+end
+
+return EmptyView

data/core/ime.lua

@@ -0,0 +1,92 @@
+local core = require "core"
+
+local ime = { }
+
+function ime.reset()
+  ime.editing = false
+  ime.last_location = { x = 0, y = 0, w = 0, h = 0 }
+end
+
+---Convert from utf-8 offset and length (from SDL) to byte offsets
+---@param text string @Textediting string
+---@param start integer @0-based utf-8 offset of the starting position of the selection
+---@param length integer @Size of the utf-8 length of the selection
+function ime.ingest(text, start, length)
+  if #text == 0 then
+    -- finished textediting
+    ime.reset()
+    return "", 0, 0
+  end
+
+  ime.editing = true
+
+  if start < 0 then
+    -- we assume no selection and caret at the end
+    return text, #text, 0
+  end
+
+  -- start is 0-based, so we use start + 1
+  local start_byte = utf8.offset(text, start + 1)
+  if not start_byte then
+    -- bad start offset
+    -- we assume it meant the last byte of the text
+    start_byte = #text
+  else
+    start_byte = math.min(start_byte - 1, #text)
+  end
+
+  if length < 0 then
+    -- caret only
+    return text, start_byte, 0
+  end
+
+  local end_byte = utf8.offset(text, start + length + 1)
+  if not end_byte or end_byte - 1 < start_byte then
+    -- bad length, assume caret only
+    return text, start_byte, 0
+  end
+
+  end_byte = math.min(end_byte - 1, #text)
+  return text, start_byte, end_byte - start_byte
+end
+
+---Forward the given textediting SDL event data to Views.
+---@param text string @Textediting string
+---@param start integer @0-based utf-8 offset of the starting position of the selection
+---@param length integer @Size of the utf-8 length of the selection
+function ime.on_text_editing(text, start, length, ...)
+  if ime.editing or #text > 0 then
+    core.root_view:on_ime_text_editing(ime.ingest(text, start, length, ...))
+  end
+end
+
+---Stop IME composition.
+---Might not completely work on every platform.
+function ime.stop()
+  if ime.editing then
+    -- SDL_ClearComposition for now doesn't work everywhere
+    system.clear_ime()
+    ime.on_text_editing("", 0, 0)
+  end
+end
+
+---Set the bounding box of the text pertaining the IME.
+---The IME will draw its interface based on this info.
+---@param x number
+---@param y number
+---@param w number
+---@param h number
+function ime.set_location(x, y, w, h)
+  if not ime.last_location or
+     ime.last_location.x ~= x or
+     ime.last_location.y ~= y or
+     ime.last_location.w ~= w or
+     ime.last_location.h ~= h
+  then
+    ime.last_location.x, ime.last_location.y, ime.last_location.w, ime.last_location.h = x, y, w, h
+    system.set_text_input_rect(x, y, w, h)
+  end
+end
+
+ime.reset()
+return ime

data/core/keymap-macos.lua

@@ -0,0 +1,127 @@
+local function keymap_macos(keymap)
+  keymap.add_direct {
+    ["cmd+shift+p"] = "core:find-command",
+    ["cmd+p"] = "core:find-file",
+    ["cmd+o"] = "core:open-file",
+    ["cmd+n"] = "core:new-doc",
+    ["cmd+shift+c"] = "core:change-project-folder",
+    ["cmd+shift+o"] = "core:open-project-folder",
+    ["cmd+option+r"] = "core:restart",
+    ["cmd+ctrl+return"] = "core:toggle-fullscreen",
+
+    ["cmd+ctrl+shift+j"] = "root:split-left",
+    ["cmd+ctrl+shift+l"] = "root:split-right",
+    ["cmd+ctrl+shift+i"] = "root:split-up",
+    ["cmd+ctrl+shift+k"] = "root:split-down",
+    ["cmd+ctrl+j"] = "root:switch-to-left",
+    ["cmd+ctrl+l"] = "root:switch-to-right",
+    ["cmd+ctrl+i"] = "root:switch-to-up",
+    ["cmd+ctrl+k"] = "root:switch-to-down",
+
+
+    ["cmd+w"] = "root:close-or-quit",
+    ["ctrl+tab"] = "root:switch-to-next-tab",
+    ["ctrl+shift+tab"] = "root:switch-to-previous-tab",
+    ["cmd+pageup"] = "root:move-tab-left",
+    ["cmd+pagedown"] = "root:move-tab-right",
+    ["cmd+1"] = "root:switch-to-tab-1",
+    ["cmd+2"] = "root:switch-to-tab-2",
+    ["cmd+3"] = "root:switch-to-tab-3",
+    ["cmd+4"] = "root:switch-to-tab-4",
+    ["cmd+5"] = "root:switch-to-tab-5",
+    ["cmd+6"] = "root:switch-to-tab-6",
+    ["cmd+7"] = "root:switch-to-tab-7",
+    ["cmd+8"] = "root:switch-to-tab-8",
+    ["cmd+9"] = "root:switch-to-tab-9",
+    ["wheel"] = "root:scroll",
+    ["hwheel"] = "root:horizontal-scroll",
+    ["shift+hwheel"] = "root:horizontal-scroll",
+
+    ["cmd+f"] = "find-replace:find",
+    ["cmd+r"] = "find-replace:replace",
+    ["f3"] = "find-replace:repeat-find",
+    ["shift+f3"] = "find-replace:previous-find",
+    ["cmd+g"] = "doc:go-to-line",
+    ["cmd+s"] = "doc:save",
+    ["cmd+shift+s"] = "doc:save-as",
+
+    ["cmd+z"] = "doc:undo",
+    ["cmd+y"] = "doc:redo",
+    ["cmd+x"] = "doc:cut",
+    ["cmd+c"] = "doc:copy",
+    ["cmd+v"] = "doc:paste",
+    ["ctrl+insert"] = "doc:copy",
+    ["shift+insert"] = "doc:paste",
+    ["escape"] = { "command:escape", "doc:select-none", "dialog:select-no" },
+    ["tab"] = { "command:complete", "doc:indent" },
+    ["shift+tab"] = "doc:unindent",
+    ["backspace"] = "doc:backspace",
+    ["shift+backspace"] = "doc:backspace",
+    ["option+backspace"] = "doc:delete-to-previous-word-start",
+    ["cmd+shift+backspace"] = "doc:delete-to-previous-word-start",
+    ["cmd+backspace"] = "doc:delete-to-start-of-indentation",
+    ["delete"] = "doc:delete",
+    ["shift+delete"] = "doc:delete",
+    ["option+delete"] = "doc:delete-to-next-word-end",
+    ["cmd+shift+delete"] = "doc:delete-to-next-word-end",
+    ["cmd+delete"] = "doc:delete-to-end-of-line",
+    ["return"] = { "command:submit", "doc:newline", "dialog:select" },
+    ["keypad enter"] = { "command:submit", "doc:newline", "dialog:select" },
+    ["cmd+return"] = "doc:newline-below",
+    ["cmd+shift+return"] = "doc:newline-above",
+    ["cmd+j"] = "doc:join-lines",
+    ["cmd+a"] = "doc:select-all",
+    ["cmd+d"] = { "find-replace:select-add-next", "doc:select-word" },
+    ["cmd+f3"] = "find-replace:select-next",
+    ["cmd+l"] = "doc:select-lines",
+    ["cmd+shift+l"] = { "find-replace:select-add-all", "doc:select-word" },
+    ["cmd+/"] = "doc:toggle-line-comments",
+    ["option+up"] = "doc:move-lines-up",
+    ["option+down"] = "doc:move-lines-down",
+    ["cmd+shift+d"] = "doc:duplicate-lines",
+    ["cmd+shift+k"] = "doc:delete-lines",
+
+    ["left"] = { "doc:move-to-previous-char", "dialog:previous-entry" },
+    ["right"] = { "doc:move-to-next-char", "dialog:next-entry"},
+    ["up"] = { "command:select-previous", "doc:move-to-previous-line" },
+    ["down"] = { "command:select-next", "doc:move-to-next-line" },
+    ["option+left"] = "doc:move-to-previous-word-start",
+    ["option+right"] = "doc:move-to-next-word-end",
+    ["cmd+left"] = "doc:move-to-start-of-indentation",
+    ["cmd+right"] = "doc:move-to-end-of-line",
+    ["cmd+["] = "doc:move-to-previous-block-start",
+    ["cmd+]"] = "doc:move-to-next-block-end",
+    ["home"] = "doc:move-to-start-of-indentation",
+    ["end"] = "doc:move-to-end-of-line",
+    ["cmd+up"] = "doc:move-to-start-of-doc",
+    ["cmd+down"] = "doc:move-to-end-of-doc",
+    ["pageup"] = "doc:move-to-previous-page",
+    ["pagedown"] = "doc:move-to-next-page",
+
+    ["shift+1lclick"] = "doc:select-to-cursor",
+    ["ctrl+1lclick"] = "doc:split-cursor",
+    ["1lclick"] = "doc:set-cursor",
+    ["2lclick"] = "doc:set-cursor-word",
+    ["3lclick"] = "doc:set-cursor-line",
+    ["shift+left"] = "doc:select-to-previous-char",
+    ["shift+right"] = "doc:select-to-next-char",
+    ["shift+up"] = "doc:select-to-previous-line",
+    ["shift+down"] = "doc:select-to-next-line",
+    ["option+shift+left"] = "doc:select-to-previous-word-start",
+    ["option+shift+right"] = "doc:select-to-next-word-end",
+    ["cmd+shift+left"] = "doc:select-to-start-of-indentation",
+    ["cmd+shift+right"] = "doc:select-to-end-of-line",
+    ["cmd+shift+["] = "doc:select-to-previous-block-start",
+    ["cmd+shift+]"] = "doc:select-to-next-block-end",
+    ["shift+home"] = "doc:select-to-start-of-indentation",
+    ["shift+end"] = "doc:select-to-end-of-line",
+    ["cmd+shift+up"] = "doc:select-to-start-of-doc",
+    ["cmd+shift+down"] = "doc:select-to-end-of-doc",
+    ["shift+pageup"] = "doc:select-to-previous-page",
+    ["shift+pagedown"] = "doc:select-to-next-page",
+    ["cmd+option+up"] = "doc:create-cursor-previous-line",
+    ["cmd+option+down"] = "doc:create-cursor-next-line"
+  }
+end
+
+return keymap_macos

data/core/keymap.lua

@@ -1,38 +1,163 @@
+local core = require "core"
 local command = require "core.command"
+local config = require "core.config"
+local ime = require "core.ime"
 local keymap = {}
 
+---@alias keymap.shortcut string
+---@alias keymap.command string
+---@alias keymap.modkey string
+---@alias keymap.pressed boolean
+---@alias keymap.map table<keymap.shortcut,keymap.command|keymap.command[]>
+---@alias keymap.rmap table<keymap.command, keymap.shortcut|keymap.shortcut[]>
+
+---Pressed status of mod keys.
+---@type table<keymap.modkey, keymap.pressed>
 keymap.modkeys = {}
+
+---List of commands assigned to a shortcut been the key of the map the shortcut.
+---@type keymap.map
 keymap.map = {}
+
+---List of shortcuts assigned to a command been the key of the map the command.
+---@type keymap.rmap
 keymap.reverse_map = {}
 
-local modkey_map = {
-  ["left ctrl"]   = "ctrl",
-  ["right ctrl"]  = "ctrl",
-  ["left shift"]  = "shift",
-  ["right shift"] = "shift",
-  ["left alt"]    = "alt",
-  ["right alt"]   = "altgr",
-}
+local macos = PLATFORM == "Mac OS X"
 
-local modkeys = { "ctrl", "alt", "altgr", "shift" }
+-- Thanks to mathewmariani, taken from his lite-macos github repository.
+local modkeys_os = require("core.modkeys-" .. (macos and "macos" or "generic"))
 
-local function key_to_stroke(k)
-  local stroke = ""
-  for _, mk in ipairs(modkeys) do
-    if keymap.modkeys[mk] then
-      stroke = stroke .. mk .. "+"
-    end
+---@type table<keymap.modkey, keymap.modkey>
+local modkey_map = modkeys_os.map
+
+---@type keymap.modkey[]
+local modkeys = modkeys_os.keys
+
+
+---Normalizes a stroke sequence to follow the modkeys table
+---@param stroke string
+---@return string
+local function normalize_stroke(stroke)
+  local stroke_table = {}
+  for key in stroke:gmatch("[^+]+") do
+    table.insert(stroke_table, key)
   end
-  return stroke .. k
+  table.sort(stroke_table, function(a, b)
+    if a == b then return false end
+    for _, mod in ipairs(modkeys) do
+      if a == mod or b == mod then
+        return a == mod
+      end
+    end
+    return a < b
+  end)
+  return table.concat(stroke_table, "+")
 end
 
 
-function keymap.add(map, overwrite)
+---Generates a stroke sequence including currently pressed mod keys.
+---@param key string
+---@return string
+local function key_to_stroke(key)
+  local keys = { key }
+  for _, mk in ipairs(modkeys) do
+    if keymap.modkeys[mk] then
+      table.insert(keys, mk)
+    end
+  end
+  return normalize_stroke(table.concat(keys, "+"))
+end
+
+
+---Remove the given value from an array associated to a key in a table.
+---@param tbl table<string, string> The table containing the key
+---@param k string The key containing the array
+---@param v? string The value to remove from the array
+local function remove_only(tbl, k, v)
+  if tbl[k] then
+    if v then
+      local j = 0
+      for i=1, #tbl[k] do
+        while tbl[k][i + j] == v do
+          j = j + 1
+        end
+        tbl[k][i] = tbl[k][i + j]
+      end
+    else
+      tbl[k] = nil
+    end
+  end
+end
+
+
+---Removes from a keymap.map the bindings that are already registered.
+---@param map keymap.map
+local function remove_duplicates(map)
   for stroke, commands in pairs(map) do
-    if type(commands) == "string" then
+    local normalized_stroke = normalize_stroke(stroke)
+    if type(commands) == "string" or type(commands) == "function" then
       commands = { commands }
     end
+    if keymap.map[normalized_stroke] then
+      for _, registered_cmd in ipairs(keymap.map[normalized_stroke]) do
+        local j = 0
+        for i=1, #commands do
+          while commands[i + j] == registered_cmd do
+            j = j + 1
+          end
+          commands[i] = commands[i + j]
+        end
+      end
+    end
+    if #commands < 1 then
+      map[stroke] = nil
+    else
+      map[stroke] = commands
+    end
+  end
+end
+
+---Add bindings by replacing commands that were previously assigned to a shortcut.
+---@param map keymap.map
+function keymap.add_direct(map)
+  for stroke, commands in pairs(map) do
+    stroke = normalize_stroke(stroke)
+
+    if type(commands) == "string" or type(commands) == "function" then
+      commands = { commands }
+    end
+    if keymap.map[stroke] then
+      for _, cmd in ipairs(keymap.map[stroke]) do
+        remove_only(keymap.reverse_map, cmd, stroke)
+      end
+    end
+    keymap.map[stroke] = commands
+    for _, cmd in ipairs(commands) do
+      keymap.reverse_map[cmd] = keymap.reverse_map[cmd] or {}
+      table.insert(keymap.reverse_map[cmd], stroke)
+    end
+  end
+end
+
+
+---Adds bindings by appending commands to already registered shortcut or by
+---replacing currently assigned commands if overwrite is specified.
+---@param map keymap.map
+---@param overwrite? boolean
+function keymap.add(map, overwrite)
+  remove_duplicates(map)
+  for stroke, commands in pairs(map) do
+    if macos then
+      stroke = stroke:gsub("%f[%a]ctrl%f[%A]", "cmd")
+    end
+    stroke = normalize_stroke(stroke)
     if overwrite then
+      if keymap.map[stroke] then
+        for _, cmd in ipairs(keymap.map[stroke]) do
+          remove_only(keymap.reverse_map, cmd, stroke)
+        end
+      end
       keymap.map[stroke] = commands
     else
       keymap.map[stroke] = keymap.map[stroke] or {}
@@ -41,18 +166,43 @@ function keymap.add(map, overwrite)
       end
     end
     for _, cmd in ipairs(commands) do
-      keymap.reverse_map[cmd] = stroke
+      keymap.reverse_map[cmd] = keymap.reverse_map[cmd] or {}
+      table.insert(keymap.reverse_map[cmd], stroke)
     end
   end
 end
 
 
+---Unregisters the given shortcut and associated command.
+---@param shortcut string
+---@param cmd string
+function keymap.unbind(shortcut, cmd)
+  shortcut = normalize_stroke(shortcut)
+  remove_only(keymap.map, shortcut, cmd)
+  remove_only(keymap.reverse_map, cmd, shortcut)
+end
+
+
+---Returns all the shortcuts associated to a command unpacked for easy assignment.
+---@param cmd string
+---@return ...
 function keymap.get_binding(cmd)
+  return table.unpack(keymap.reverse_map[cmd] or {})
+end
+
+
+---Returns all the shortcuts associated to a command packed in a table.
+---@param cmd string
+---@return table<integer, string> | nil shortcuts
+function keymap.get_bindings(cmd)
   return keymap.reverse_map[cmd]
 end
 
 
-function keymap.on_key_pressed(k)
+--------------------------------------------------------------------------------
+-- Events listening
+--------------------------------------------------------------------------------
+function keymap.on_key_pressed(k, ...)
   local mk = modkey_map[k]
   if mk then
     keymap.modkeys[mk] = true
@@ -62,18 +212,62 @@ function keymap.on_key_pressed(k)
     end
   else
     local stroke = key_to_stroke(k)
-    local commands = keymap.map[stroke]
+    local commands, performed = keymap.map[stroke], false
     if commands then
       for _, cmd in ipairs(commands) do
-        local performed = command.perform(cmd)
+        if type(cmd) == "function" then
+          local ok, res = core.try(cmd, ...)
+          if ok then
+            performed = not (res == false)
+          else
+            performed = true
+          end
+        else
+          performed = command.perform(cmd, ...)
+        end
         if performed then break end
       end
-      return true
+      return performed
     end
   end
   return false
 end
 
+function keymap.on_mouse_wheel(delta_y, delta_x, ...)
+  local y_direction = delta_y > 0 and "up" or "down"
+  local x_direction = delta_x > 0 and "left" or "right"
+  -- Try sending a "cumulative" event for both scroll directions
+  if delta_y ~= 0 and delta_x ~= 0 then
+    local result = keymap.on_key_pressed("wheel" .. y_direction .. x_direction, delta_y, delta_x, ...)
+    if not result then
+      result = keymap.on_key_pressed("wheelyx", delta_y, delta_x, ...)
+    end
+    if result then return true end
+  end
+  -- Otherwise send each direction as its own separate event
+  local y_result, x_result
+  if delta_y ~= 0 then
+    y_result = keymap.on_key_pressed("wheel" .. y_direction, delta_y, ...)
+    if not y_result then
+      y_result = keymap.on_key_pressed("wheel", delta_y, ...)
+    end
+  end
+  if delta_x ~= 0 then
+    x_result = keymap.on_key_pressed("wheel" .. x_direction, delta_x, ...)
+    if not x_result then
+      x_result = keymap.on_key_pressed("hwheel", delta_x, ...)
+    end
+  end
+  return y_result or x_result
+end
+
+function keymap.on_mouse_pressed(button, x, y, clicks)
+  local click_number = (((clicks - 1) % config.max_clicks) + 1)
+  return not (keymap.on_key_pressed(click_number  .. button:sub(1,1) .. "click", x, y, clicks) or
+    keymap.on_key_pressed(button:sub(1,1) .. "click", x, y, clicks) or
+    keymap.on_key_pressed(click_number .. "click", x, y, clicks) or
+    keymap.on_key_pressed("click", x, y, clicks))
+end
 
 function keymap.on_key_released(k)
   local mk = modkey_map[k]
@@ -83,12 +277,25 @@ function keymap.on_key_released(k)
 end
 
 
-keymap.add {
+--------------------------------------------------------------------------------
+-- Register default bindings
+--------------------------------------------------------------------------------
+if macos then
+  local keymap_macos = require("core.keymap-macos")
+  keymap_macos(keymap)
+  return keymap
+end
+
+keymap.add_direct {
   ["ctrl+shift+p"] = "core:find-command",
   ["ctrl+p"] = "core:find-file",
   ["ctrl+o"] = "core:open-file",
   ["ctrl+n"] = "core:new-doc",
+  ["ctrl+shift+c"] = "core:change-project-folder",
+  ["ctrl+shift+o"] = "core:open-project-folder",
+  ["ctrl+alt+r"] = "core:restart",
   ["alt+return"] = "core:toggle-fullscreen",
+  ["f11"] = "core:toggle-fullscreen",
 
   ["alt+shift+j"] = "root:split-left",
   ["alt+shift+l"] = "root:split-right",
@@ -113,11 +320,16 @@ keymap.add {
   ["alt+7"] = "root:switch-to-tab-7",
   ["alt+8"] = "root:switch-to-tab-8",
   ["alt+9"] = "root:switch-to-tab-9",
+  ["wheel"] = "root:scroll",
+  ["hwheel"] = "root:horizontal-scroll",
+  ["shift+wheel"] = "root:horizontal-scroll",
 
   ["ctrl+f"] = "find-replace:find",
   ["ctrl+r"] = "find-replace:replace",
   ["f3"] = "find-replace:repeat-find",
   ["shift+f3"] = "find-replace:previous-find",
+  ["ctrl+i"] = "find-replace:toggle-sensitivity",
+  ["ctrl+shift+i"] = "find-replace:toggle-regex",
   ["ctrl+g"] = "doc:go-to-line",
   ["ctrl+s"] = "doc:save",
   ["ctrl+shift+s"] = "doc:save-as",
@@ -127,7 +339,9 @@ keymap.add {
   ["ctrl+x"] = "doc:cut",
   ["ctrl+c"] = "doc:copy",
   ["ctrl+v"] = "doc:paste",
-  ["escape"] = { "command:escape", "doc:select-none" },
+  ["ctrl+insert"] = "doc:copy",
+  ["shift+insert"] = "doc:paste",
+  ["escape"] = { "command:escape", "doc:select-none", "dialog:select-no" },
   ["tab"] = { "command:complete", "doc:indent" },
   ["shift+tab"] = "doc:unindent",
   ["backspace"] = "doc:backspace",
@@ -138,35 +352,44 @@ keymap.add {
   ["shift+delete"] = "doc:delete",
   ["ctrl+delete"] = "doc:delete-to-next-word-end",
   ["ctrl+shift+delete"] = "doc:delete-to-next-word-end",
-  ["return"] = { "command:submit", "doc:newline" },
-  ["keypad enter"] = { "command:submit", "doc:newline" },
+  ["return"] = { "command:submit", "doc:newline", "dialog:select" },
+  ["keypad enter"] = { "command:submit", "doc:newline", "dialog:select" },
   ["ctrl+return"] = "doc:newline-below",
   ["ctrl+shift+return"] = "doc:newline-above",
   ["ctrl+j"] = "doc:join-lines",
   ["ctrl+a"] = "doc:select-all",
-  ["ctrl+d"] = { "find-replace:select-next", "doc:select-word" },
+  ["ctrl+d"] = { "find-replace:select-add-next", "doc:select-word" },
+  ["ctrl+f3"] = "find-replace:select-next",
+  ["ctrl+shift+f3"] = "find-replace:select-previous",
   ["ctrl+l"] = "doc:select-lines",
+  ["ctrl+shift+l"] = { "find-replace:select-add-all", "doc:select-word" },
   ["ctrl+/"] = "doc:toggle-line-comments",
+  ["ctrl+shift+/"] = "doc:toggle-block-comments",
   ["ctrl+up"] = "doc:move-lines-up",
   ["ctrl+down"] = "doc:move-lines-down",
   ["ctrl+shift+d"] = "doc:duplicate-lines",
   ["ctrl+shift+k"] = "doc:delete-lines",
 
-  ["left"] = "doc:move-to-previous-char",
-  ["right"] = "doc:move-to-next-char",
+  ["left"] = { "doc:move-to-previous-char", "dialog:previous-entry" },
+  ["right"] = { "doc:move-to-next-char", "dialog:next-entry"},
   ["up"] = { "command:select-previous", "doc:move-to-previous-line" },
   ["down"] = { "command:select-next", "doc:move-to-next-line" },
   ["ctrl+left"] = "doc:move-to-previous-word-start",
   ["ctrl+right"] = "doc:move-to-next-word-end",
   ["ctrl+["] = "doc:move-to-previous-block-start",
   ["ctrl+]"] = "doc:move-to-next-block-end",
-  ["home"] = "doc:move-to-start-of-line",
+  ["home"] = "doc:move-to-start-of-indentation",
   ["end"] = "doc:move-to-end-of-line",
   ["ctrl+home"] = "doc:move-to-start-of-doc",
   ["ctrl+end"] = "doc:move-to-end-of-doc",
   ["pageup"] = "doc:move-to-previous-page",
   ["pagedown"] = "doc:move-to-next-page",
 
+  ["shift+1lclick"] = "doc:select-to-cursor",
+  ["ctrl+1lclick"] = "doc:split-cursor",
+  ["1lclick"] = "doc:set-cursor",
+  ["2lclick"] = "doc:set-cursor-word",
+  ["3lclick"] = "doc:set-cursor-line",
   ["shift+left"] = "doc:select-to-previous-char",
   ["shift+right"] = "doc:select-to-next-char",
   ["shift+up"] = "doc:select-to-previous-line",
@@ -175,12 +398,14 @@ keymap.add {
   ["ctrl+shift+right"] = "doc:select-to-next-word-end",
   ["ctrl+shift+["] = "doc:select-to-previous-block-start",
   ["ctrl+shift+]"] = "doc:select-to-next-block-end",
-  ["shift+home"] = "doc:select-to-start-of-line",
+  ["shift+home"] = "doc:select-to-start-of-indentation",
   ["shift+end"] = "doc:select-to-end-of-line",
   ["ctrl+shift+home"] = "doc:select-to-start-of-doc",
   ["ctrl+shift+end"] = "doc:select-to-end-of-doc",
   ["shift+pageup"] = "doc:select-to-previous-page",
   ["shift+pagedown"] = "doc:select-to-next-page",
+  ["ctrl+shift+up"] = "doc:create-cursor-previous-line",
+  ["ctrl+shift+down"] = "doc:create-cursor-next-line"
 }
 
 return keymap

data/core/logview.lua

@@ -1,16 +1,53 @@
 local core = require "core"
+local common = require "core.common"
+local config = require "core.config"
+local keymap = require "core.keymap"
 local style = require "core.style"
 local View = require "core.view"
 
 
+local function lines(text)
+  if text == "" then return 0 end
+  local l = 1
+  for _ in string.gmatch(text, "\n") do
+    l = l + 1
+  end
+  return l
+end
+
+
+local item_height_result = {}
+
+
+local function get_item_height(item)
+  local h = item_height_result[item]
+  if not h then
+    h = {}
+    local l = 1 + lines(item.text) + lines(item.info or "")
+    h.normal = style.font:get_height() + style.padding.y
+    h.expanded = l * style.font:get_height() + style.padding.y
+    h.current = h.normal
+    h.target = h.current
+    item_height_result[item] = h
+  end
+  return h
+end
+
 local LogView = View:extend()
 
+function LogView:__tostring() return "LogView" end
+
+LogView.context = "session"
+
 
 function LogView:new()
   LogView.super.new(self)
   self.last_item = core.log_items[#core.log_items]
+  self.expanding = {}
   self.scrollable = true
   self.yoffset = 0
+
+  core.status_view:show_message("i", style.text, "ctrl+click to copy entry")
 end
 
 
@@ -19,15 +56,100 @@ function LogView:get_name()
 end
 
 
+local function is_expanded(item)
+  local item_height = get_item_height(item)
+  return item_height.target == item_height.expanded
+end
+
+
+function LogView:expand_item(item)
+  item = get_item_height(item)
+  item.target = item.target == item.expanded and item.normal or item.expanded
+  table.insert(self.expanding, item)
+end
+
+
+function LogView:each_item()
+  local x, y = self:get_content_offset()
+  y = y + style.padding.y + self.yoffset
+  return coroutine.wrap(function()
+    for i = #core.log_items, 1, -1 do
+      local item = core.log_items[i]
+      local h = get_item_height(item).current
+      coroutine.yield(i, item, x, y, self.size.x, h)
+      y = y + h
+    end
+  end)
+end
+
+
+function LogView:get_scrollable_size()
+  local _, y_off = self:get_content_offset()
+  local last_y, last_h = 0, 0
+  for i, item, x, y, w, h in self:each_item() do
+    last_y, last_h = y, h
+  end
+  if not config.scroll_past_end then
+    return last_y + last_h - y_off + style.padding.y
+  end
+  return last_y + self.size.y - y_off
+end
+
+
+function LogView:on_mouse_pressed(button, px, py, clicks)
+  if LogView.super.on_mouse_pressed(self, button, px, py, clicks) then
+    return true
+  end
+
+  local index, selected
+  for i, item, x, y, w, h in self:each_item() do
+    if px >= x and py >= y and px < x + w and py < y + h then
+      index = i
+      selected = item
+      break
+    end
+  end
+
+  if selected then
+    if keymap.modkeys["ctrl"] then
+      system.set_clipboard(core.get_log(selected))
+      core.status_view:show_message("i", style.text, "copied entry #"..index.." to clipboard.")
+    else
+      self:expand_item(selected)
+    end
+  end
+
+  return true
+end
+
+
 function LogView:update()
   local item = core.log_items[#core.log_items]
   if self.last_item ~= item then
+    local lh = style.font:get_height() + style.padding.y
+    if 0 < self.scroll.to.y then
+      local index = #core.log_items
+      while index > 1 and self.last_item ~= core.log_items[index] do
+        index = index - 1
+      end
+      local diff_index = #core.log_items - index
+      self.scroll.to.y = self.scroll.to.y + diff_index * lh
+      self.scroll.y = self.scroll.to.y
+    else
+      self.yoffset = -lh
+    end
     self.last_item = item
-    self.scroll.to.y = 0
-    self.yoffset = -(style.font:get_height() + style.padding.y)
   end
 
-  self:move_towards("yoffset", 0)
+  local expanding = self.expanding[1]
+  if expanding then
+    self:move_towards(expanding, "current", expanding.target, nil, "logview")
+    if expanding.current == expanding.target then
+      table.remove(self.expanding, 1)
+    end
+  end
+
+  self:move_towards("yoffset", 0, nil, "logview")
 
   LogView.super.update(self)
 end
@@ -35,40 +157,70 @@ end
 
 local function draw_text_multiline(font, text, x, y, color)
   local th = font:get_height()
-  local resx, resy = x, y
+  local resx = x
   for line in text:gmatch("[^\n]+") do
-    resy = y
     resx = renderer.draw_text(style.font, line, x, y, color)
     y = y + th
   end
-  return resx, resy
+  return resx, y
 end
 
-
+-- this is just to get a date string that's consistent
+local datestr = os.date()
 function LogView:draw()
   self:draw_background(style.background)
 
-  local ox, oy = self:get_content_offset()
   local th = style.font:get_height()
-  local y = oy + style.padding.y + self.yoffset
+  local lh = th + style.padding.y -- for one line
+  local iw = math.max(
+    style.icon_font:get_width(style.log.ERROR.icon),
+    style.icon_font:get_width(style.log.INFO.icon)
+  )
 
-  for i = #core.log_items, 1, -1 do
-    local x = ox + style.padding.x
-    local item = core.log_items[i]
-    local time = os.date(nil, item.time)
-    x = renderer.draw_text(style.font, time, x, y, style.dim)
-    x = x + style.padding.x
-    local subx = x
-    x, y = draw_text_multiline(style.font, item.text, x, y, style.text)
-    renderer.draw_text(style.font, " at " .. item.at, x, y, style.dim)
-    y = y + th
-    if item.info then
-      subx, y = draw_text_multiline(style.font, item.info, subx, y, style.dim)
-      y = y + th
+  local tw = style.font:get_width(datestr)
+  for _, item, x, y, w, h in self:each_item() do
+    if y + h >= self.position.y and y <= self.position.y + self.size.y then
+      core.push_clip_rect(x, y, w, h)
+      x = x + style.padding.x
+
+      x = common.draw_text(
+        style.icon_font,
+        style.log[item.level].color,
+        style.log[item.level].icon,
+        "center",
+        x, y, iw, lh
+      )
+      x = x + style.padding.x
+
+      -- timestamps are always 15% of the width
+      local time = os.date(nil, item.time)
+      common.draw_text(style.font, style.dim, time, "left", x, y, tw, lh)
+      x = x + tw + style.padding.x
+
+      w = w - (x - self:get_content_offset())
+
+      if is_expanded(item) then
+        y = y + common.round(style.padding.y / 2)
+        _, y = draw_text_multiline(style.font, item.text, x, y, style.text)
+
+        local at = "at " .. common.home_encode(item.at)
+        _, y = common.draw_text(style.font, style.dim, at, "left", x, y, w, lh)
+
+        if item.info then
+          _, y = draw_text_multiline(style.font, item.info, x, y, style.dim)
+        end
+      else
+        local line, has_newline = string.match(item.text, "([^\n]+)(\n?)")
+        if has_newline ~= "" then
+          line = line .. " ..."
+        end
+        _, y = common.draw_text(style.font, style.text, line, "left", x, y, w, lh)
+      end
+
+      core.pop_clip_rect()
     end
-    y = y + style.padding.y
   end
+  LogView.super.draw_scrollbar(self)
 end
 
-
 return LogView

data/core/modkeys-generic.lua

@@ -0,0 +1,14 @@
+local modkeys = {}
+
+modkeys.map = {
+  ["left ctrl"]   = "ctrl",
+  ["right ctrl"]  = "ctrl",
+  ["left shift"]  = "shift",
+  ["right shift"] = "shift",
+  ["left alt"]    = "alt",
+  ["right alt"]   = "altgr",
+}
+
+modkeys.keys = { "ctrl", "shift", "alt", "altgr" }
+
+return modkeys

data/core/modkeys-macos.lua

@@ -0,0 +1,18 @@
+local modkeys = {}
+
+modkeys.map = {
+  ["left command"]   = "cmd",
+  ["right command"]  = "cmd",
+  ["left ctrl"]      = "ctrl",
+  ["right ctrl"]     = "ctrl",
+  ["left shift"]     = "shift",
+  ["right shift"]    = "shift",
+  ["left option"]    = "option",
+  ["right option"]   = "option",
+  ["left alt"]       = "alt",
+  ["right alt"]      = "altgr",
+}
+
+modkeys.keys = { "ctrl", "alt", "option", "altgr", "shift", "cmd" }
+
+return modkeys

data/core/nagview.lua

@@ -0,0 +1,305 @@
+local core = require "core"
+local command = require "core.command"
+local common = require "core.common"
+local config = require "core.config"
+local View = require "core.view"
+local style = require "core.style"
+
+local BORDER_WIDTH = common.round(1 * SCALE)
+local UNDERLINE_WIDTH = common.round(2 * SCALE)
+local UNDERLINE_MARGIN = common.round(1 * SCALE)
+
+local noop = function() end
+
+---@class core.nagview : core.view
+---@field super core.view
+local NagView = View:extend()
+
+function NagView:__tostring() return "NagView" end
+
+function NagView:new()
+  NagView.super.new(self)
+  self.size.y = 0
+  self.show_height = 0
+  self.force_focus = false
+  self.queue = {}
+  self.scrollable = true
+  self.target_height = 0
+  self.on_mouse_pressed_root = nil
+end
+
+function NagView:get_title()
+  return self.title
+end
+
+-- The two methods below are duplicated from DocView
+function NagView:get_line_height()
+  return math.floor(style.font:get_height() * config.line_height)
+end
+
+function NagView:get_line_text_y_offset()
+  local lh = self:get_line_height()
+  local th = style.font:get_height()
+  return (lh - th) / 2
+end
+
+-- Buttons height without padding
+function NagView:get_buttons_height()
+  local lh = style.font:get_height()
+  local bt_padding = lh / 2
+  return lh + 2 * BORDER_WIDTH + 2 * bt_padding
+end
+
+function NagView:get_target_height()
+  return self.target_height + 2 * style.padding.y
+end
+
+function NagView:get_scrollable_size()
+  local w, h = system.get_window_size()
+  if self.visible and self:get_target_height() > h then
+    self.size.y = h
+    return self:get_target_height()
+  else
+    self.size.y = 0
+  end
+  return 0
+end
+
+function NagView:dim_window_content()
+  local ox, oy = self:get_content_offset()
+  oy = oy + self.show_height
+  local w, h = core.root_view.size.x, core.root_view.size.y - oy
+  core.root_view:defer_draw(function()
+    renderer.draw_rect(ox, oy, w, h, style.nagbar_dim)
+  end)
+end
+
+function NagView:change_hovered(i)
+  if i ~= self.hovered_item then
+    self.hovered_item = i
+    self.underline_progress = 0
+    core.redraw = true
+  end
+end
+
+function NagView:each_option()
+  return coroutine.wrap(function()
+    if not self.options then return end
+    local opt, bw,bh,ox,oy
+    bh = self:get_buttons_height()
+    ox,oy = self:get_content_offset()
+    ox = ox + self.size.x
+    oy = oy + self.show_height - bh - style.padding.y
+
+    for i = #self.options, 1, -1 do
+      opt = self.options[i]
+      bw = style.font:get_width(opt.text) + 2 * BORDER_WIDTH + style.padding.x
+
+      ox = ox - bw - style.padding.x
+      coroutine.yield(i, opt, ox,oy,bw,bh)
+    end
+  end)
+end
+
+function NagView:on_mouse_moved(mx, my, ...)
+  if not self.visible then return end
+  core.set_active_view(self)
+  NagView.super.on_mouse_moved(self, mx, my, ...)
+  for i, _, x,y,w,h in self:each_option() do
+    if mx >= x and my >= y and mx < x + w and my < y + h then
+      self:change_hovered(i)
+      break
+    end
+  end
+end
+
+local function register_mouse_pressed(self)
+  if self.on_mouse_pressed_root then return end
+  -- RootView is loaded locally to avoid NagView and RootView being
+  -- mutually recursive
+  local RootView = require "core.rootview"
+  self.on_mouse_pressed_root = RootView.on_mouse_pressed
+  local this = self
+  function RootView:on_mouse_pressed(button, x, y, clicks)
+    if
+      not this:on_mouse_pressed(button, x, y, clicks)
+    then
+      return this.on_mouse_pressed_root(self, button, x, y, clicks)
+    else
+      return true
+    end
+  end
+  self.new_on_mouse_pressed_root = RootView.on_mouse_pressed
+end
+
+local function unregister_mouse_pressed(self)
+  local RootView = require "core.rootview"
+  if
+    self.on_mouse_pressed_root
+    and
+    -- just in case prevent overwriting what something else may
+    -- have overwrote after us, but after testing with various
+    -- plugins this doesn't seems to happen, but just in case
+    self.new_on_mouse_pressed_root == RootView.on_mouse_pressed
+  then
+    RootView.on_mouse_pressed = self.on_mouse_pressed_root
+    self.on_mouse_pressed_root = nil
+    self.new_on_mouse_pressed_root = nil
+  end
+end
+
+function NagView:on_mouse_pressed(button, mx, my, clicks)
+  if not self.visible then return false end
+  if NagView.super.on_mouse_pressed(self, button, mx, my, clicks) then return true end
+  for i, _, x,y,w,h in self:each_option() do
+    if mx >= x and my >= y and mx < x + w and my < y + h then
+      self:change_hovered(i)
+      command.perform "dialog:select"
+    end
+  end
+  return true
+end
+
+function NagView:on_text_input(text)
+  if not self.visible then return end
+  if text:lower() == "y" then
+    command.perform "dialog:select-yes"
+  elseif text:lower() == "n" then
+    command.perform "dialog:select-no"
+  end
+end
+
+function NagView:update()
+  if not self.visible and self.show_height <= 0 then return end
+  NagView.super.update(self)
+
+  if self.visible and core.active_view == self and self.title then
+    self:move_towards(self, "show_height", self:get_target_height(), nil, "nagbar")
+    self:move_towards(self, "underline_progress", 1, nil, "nagbar")
+  else
+    self:move_towards(self, "show_height", 0, nil, "nagbar")
+    if self.show_height <= 0 then
+      self.title = nil
+      self.message = nil
+      self.options = nil
+      self.on_selected = nil
+    end
+  end
+end
+
+local function draw_nagview_message(self)
+  self:dim_window_content()
+
+  -- draw message's background
+  local ox, oy = self:get_content_offset()
+  renderer.draw_rect(ox, oy, self.size.x, self.show_height, style.nagbar)
+
+  ox = ox + style.padding.x
+
+  core.push_clip_rect(ox, oy, self.size.x, self.show_height)
+
+  -- if there are other items, show it
+  if #self.queue > 0 then
+    local str = string.format("[%d]", #self.queue)
+    ox = common.draw_text(style.font, style.nagbar_text, str, "left", ox, oy, self.size.x, self.show_height)
+    ox = ox + style.padding.x
+  end
+
+  -- draw message
+  local lh = style.font:get_height() * config.line_height
+  oy = oy + style.padding.y + (self.target_height - self:get_message_height()) / 2
+  for msg_line in self.message:gmatch("(.-)\n") do
+    local ty = oy + self:get_line_text_y_offset()
+    renderer.draw_text(style.font, msg_line, ox, ty, style.nagbar_text)
+    oy = oy + lh
+  end
+
+  -- draw buttons
+  for i, opt, bx,by,bw,bh in self:each_option() do
+    local fw,fh = bw - 2 * BORDER_WIDTH, bh - 2 * BORDER_WIDTH
+    local fx,fy = bx + BORDER_WIDTH, by + BORDER_WIDTH
+
+    -- draw the button
+    renderer.draw_rect(bx,by,bw,bh, style.nagbar_text)
+    renderer.draw_rect(fx,fy,fw,fh, style.nagbar)
+
+    if i == self.hovered_item then -- draw underline
+      local uw = fw - 2 * UNDERLINE_MARGIN
+      local halfuw = uw / 2
+      local lx = fx + UNDERLINE_MARGIN + halfuw - (halfuw * self.underline_progress)
+      local ly = fy + fh - UNDERLINE_MARGIN - UNDERLINE_WIDTH
+      uw = uw * self.underline_progress
+      renderer.draw_rect(lx,ly,uw,UNDERLINE_WIDTH, style.nagbar_text)
+    end
+
+    common.draw_text(style.font, style.nagbar_text, opt.text, "center", fx,fy,fw,fh)
+  end
+
+  self:draw_scrollbar()
+
+  core.pop_clip_rect()
+end
+
+function NagView:draw()
+  if (not self.visible and self.show_height <= 0) or not self.title then
+    return
+  end
+  core.root_view:defer_draw(draw_nagview_message, self)
+end
+
+function NagView:on_scale_change(new_scale, old_scale)
+  BORDER_WIDTH = common.round(1 * new_scale)
+  UNDERLINE_WIDTH = common.round(2 * new_scale)
+  UNDERLINE_MARGIN = common.round(1 * new_scale)
+  self.target_height = math.max(
+    self:get_message_height(),
+    self:get_buttons_height()
+  )
+end
+
+function NagView:get_message_height()
+  local h = 0
+  for str in string.gmatch(self.message, "(.-)\n") do
+    h = h + style.font:get_height() * config.line_height
+  end
+  return h
+end
+
+function NagView:next()
+  local opts = table.remove(self.queue, 1) or {}
+  if opts.title and opts.message and opts.options then
+    self.visible = true
+    self.title = opts.title
+    self.message = opts.message and opts.message .. "\n"
+    self.options = opts.options
+    self.on_selected = opts.on_selected
+
+    local message_height = self:get_message_height()
+    -- self.target_height is the nagview height needed to display the message and
+    -- the buttons, excluding the top and bottom padding space.
+    self.target_height = math.max(message_height, self:get_buttons_height())
+    self:change_hovered(common.find_index(self.options, "default_yes"))
+
+    self.force_focus = true
+    core.set_active_view(self)
+    -- We add a hook to manage all the mouse_pressed events.
+    register_mouse_pressed(self)
+  else
+    self.force_focus = false
+    core.set_active_view(core.next_active_view or core.last_active_view)
+    self.visible = false
+    unregister_mouse_pressed(self)
+  end
+end
+
+function NagView:show(title, message, options, on_select)
+  local opts = {}
+  opts.title = assert(title, "No title")
+  opts.message = assert(message, "No message")
+  opts.options = assert(options, "No options")
+  opts.on_selected = on_select or noop
+  table.insert(self.queue, opts)
+  self:next()
+end
+
+return NagView

data/core/node.lua

@@ -0,0 +1,765 @@
+local core = require "core"
+local common = require "core.common"
+local config = require "core.config"
+local style = require "core.style"
+local Object = require "core.object"
+local EmptyView = require "core.emptyview"
+local View = require "core.view"
+
+---@class core.node : core.object
+local Node = Object:extend()
+
+function Node:__tostring() return "Node" end
+
+function Node:new(type)
+  self.type = type or "leaf"
+  self.position = { x = 0, y = 0 }
+  self.size = { x = 0, y = 0 }
+  self.views = {}
+  self.divider = 0.5
+  if self.type == "leaf" then
+    self:add_view(EmptyView())
+  end
+  self.hovered = {x = -1, y = -1 }
+  self.hovered_close = 0
+  self.tab_shift = 0
+  self.tab_offset = 1
+  self.tab_width = style.tab_width
+  self.move_towards = View.move_towards
+end
+
+
+function Node:propagate(fn, ...)
+  self.a[fn](self.a, ...)
+  self.b[fn](self.b, ...)
+end
+
+
+function Node:on_mouse_moved(x, y, ...)
+  if self.type == "leaf" then
+    self.hovered.x, self.hovered.y = x, y
+    self.active_view:on_mouse_moved(x, y, ...)
+  else
+    self:propagate("on_mouse_moved", x, y, ...)
+  end
+end
+
+
+function Node:on_mouse_released(...)
+  if self.type == "leaf" then
+    self.active_view:on_mouse_released(...)
+  else
+    self:propagate("on_mouse_released", ...)
+  end
+end
+
+
+function Node:on_mouse_left()
+  if self.type == "leaf" then
+    self.active_view:on_mouse_left()
+  else
+    self:propagate("on_mouse_left")
+  end
+end
+
+
+function Node:consume(node)
+  for k, _ in pairs(self) do self[k] = nil end
+  for k, v in pairs(node) do self[k] = v   end
+end
+
+
+local type_map = { up="vsplit", down="vsplit", left="hsplit", right="hsplit" }
+
+-- The "locked" argument below should be in the form {x = <boolean>, y = <boolean>}
+-- and it indicates if the node want to have a fixed size along the axis where the
+-- boolean is true. If not it will be expanded to take all the available space.
+-- The "resizable" flag indicates if, along the "locked" axis the node can be resized
+-- by the user. If the node is marked as resizable their view should provide a
+-- set_target_size method.
+function Node:split(dir, view, locked, resizable)
+  assert(self.type == "leaf", "Tried to split non-leaf node")
+  local node_type = assert(type_map[dir], "Invalid direction")
+  local last_active = core.active_view
+  local child = Node()
+  child:consume(self)
+  self:consume(Node(node_type))
+  self.a = child
+  self.b = Node()
+  if view then self.b:add_view(view) end
+  if locked then
+    assert(type(locked) == 'table')
+    self.b.locked = locked
+    self.b.resizable = resizable or false
+    core.set_active_view(last_active)
+  end
+  if dir == "up" or dir == "left" then
+    self.a, self.b = self.b, self.a
+    return self.a
+  end
+  return self.b
+end
+
+function Node:remove_view(root, view)
+  if #self.views > 1 then
+    local idx = self:get_view_idx(view)
+    if idx < self.tab_offset then
+      self.tab_offset = self.tab_offset - 1
+    end
+    table.remove(self.views, idx)
+    if self.active_view == view then
+      self:set_active_view(self.views[idx] or self.views[#self.views])
+    end
+  else
+    local parent = self:get_parent_node(root)
+    local is_a = (parent.a == self)
+    local other = parent[is_a and "b" or "a"]
+    local locked_size_x, locked_size_y = other:get_locked_size()
+    local locked_size
+    if parent.type == "hsplit" then
+      locked_size = locked_size_x
+    else
+      locked_size = locked_size_y
+    end
+    local next_primary
+    if self.is_primary_node then
+      next_primary = core.root_view:select_next_primary_node()
+    end
+    if locked_size or (self.is_primary_node and not next_primary) then
+      self.views = {}
+      self:add_view(EmptyView())
+    else
+      if other == next_primary then
+        next_primary = parent
+      end
+      parent:consume(other)
+      local p = parent
+      while p.type ~= "leaf" do
+        p = p[is_a and "a" or "b"]
+      end
+      p:set_active_view(p.active_view)
+      if self.is_primary_node then
+        next_primary.is_primary_node = true
+      end
+    end
+  end
+  core.last_active_view = nil
+end
+
+function Node:close_view(root, view)
+  local do_close = function()
+    self:remove_view(root, view)
+  end
+  view:try_close(do_close)
+end
+
+
+function Node:close_active_view(root)
+  self:close_view(root, self.active_view)
+end
+
+
+function Node:add_view(view, idx)
+  assert(self.type == "leaf", "Tried to add view to non-leaf node")
+  assert(not self.locked, "Tried to add view to locked node")
+  if self.views[1] and self.views[1]:is(EmptyView) then
+    table.remove(self.views)
+  end
+  table.insert(self.views, idx or (#self.views + 1), view)
+  self:set_active_view(view)
+end
+
+
+function Node:set_active_view(view)
+  assert(self.type == "leaf", "Tried to set active view on non-leaf node")
+  local last_active_view = self.active_view
+  self.active_view = view
+  core.set_active_view(view)
+  if last_active_view and last_active_view ~= view then
+    last_active_view:on_mouse_left()
+  end
+end
+
+
+function Node:get_view_idx(view)
+  for i, v in ipairs(self.views) do
+    if v == view then return i end
+  end
+end
+
+
+function Node:get_node_for_view(view)
+  for _, v in ipairs(self.views) do
+    if v == view then return self end
+  end
+  if self.type ~= "leaf" then
+    return self.a:get_node_for_view(view) or self.b:get_node_for_view(view)
+  end
+end
+
+
+function Node:get_parent_node(root)
+  if root.a == self or root.b == self then
+    return root
+  elseif root.type ~= "leaf" then
+    return self:get_parent_node(root.a) or self:get_parent_node(root.b)
+  end
+end
+
+
+function Node:get_children(t)
+  t = t or {}
+  for _, view in ipairs(self.views) do
+    table.insert(t, view)
+  end
+  if self.a then self.a:get_children(t) end
+  if self.b then self.b:get_children(t) end
+  return t
+end
+
+
+-- return the width including the padding space and separately
+-- the padding space itself
+local function get_scroll_button_width()
+  local w = style.icon_font:get_width(">")
+  local pad = w
+  return w + 2 * pad, pad
+end
+
+
+function Node:get_divider_overlapping_point(px, py)
+  if self.type ~= "leaf" then
+    local axis = self.type == "hsplit" and "x" or "y"
+    if self.a:is_resizable(axis) and self.b:is_resizable(axis) then
+      local p = 6
+      local x, y, w, h = self:get_divider_rect()
+      x, y = x - p, y - p
+      w, h = w + p * 2, h + p * 2
+      if px > x and py > y and px < x + w and py < y + h then
+        return self
+      end
+    end
+    return self.a:get_divider_overlapping_point(px, py)
+        or self.b:get_divider_overlapping_point(px, py)
+  end
+end
+
+
+function Node:get_visible_tabs_number()
+  return math.min(#self.views - self.tab_offset + 1, config.max_tabs)
+end
+
+
+function Node:get_tab_overlapping_point(px, py)
+  if not self:should_show_tabs() then return nil end
+  local tabs_number = self:get_visible_tabs_number()
+  local x1, y1, w, h = self:get_tab_rect(self.tab_offset)
+  local x2, y2 = self:get_tab_rect(self.tab_offset + tabs_number)
+  if px >= x1 and py >= y1 and px < x2 and py < y1 + h then
+    return math.floor((px - x1) / w) + self.tab_offset
+  end
+end
+
+
+function Node:should_show_tabs()
+  if self.locked then return false end
+  local dn = core.root_view.dragged_node
+  if #self.views > 1
+     or (dn and dn.dragging) then -- show tabs while dragging
+    return true
+  elseif config.always_show_tabs then
+    return not self.views[1]:is(EmptyView)
+  end
+  return false
+end
+
+
+local function close_button_location(x, w)
+  local cw = style.icon_font:get_width("C")
+  local pad = style.padding.x / 2
+  return x + w - cw - pad, cw, pad
+end
+
+
+function Node:get_scroll_button_index(px, py)
+  if #self.views == 1 then return end
+  for i = 1, 2 do
+    local x, y, w, h = self:get_scroll_button_rect(i)
+    if px >= x and px < x + w and py >= y and py < y + h then
+      return i
+    end
+  end
+end
+
+
+function Node:tab_hovered_update(px, py)
+  local tab_index = self:get_tab_overlapping_point(px, py)
+  self.hovered_tab = tab_index
+  self.hovered_close = 0
+  self.hovered_scroll_button = 0
+  if tab_index then
+    local x, y, w, h = self:get_tab_rect(tab_index)
+    local cx, cw = close_button_location(x, w)
+    if px >= cx and px < cx + cw and py >= y and py < y + h and config.tab_close_button then
+      self.hovered_close = tab_index
+    end
+  else
+    self.hovered_scroll_button = self:get_scroll_button_index(px, py) or 0
+  end
+end
+
+
+function Node:get_child_overlapping_point(x, y)
+  local child
+  if self.type == "leaf" then
+    return self
+  elseif self.type == "hsplit" then
+    child = (x < self.b.position.x) and self.a or self.b
+  elseif self.type == "vsplit" then
+    child = (y < self.b.position.y) and self.a or self.b
+  end
+  return child:get_child_overlapping_point(x, y)
+end
+
+
+function Node:get_scroll_button_rect(index)
+  local w, pad = get_scroll_button_width()
+  local h = style.font:get_height() + style.padding.y * 2
+  local x = self.position.x + (index == 1 and self.size.x - w * 2 or self.size.x - w)
+  return x, self.position.y, w, h, pad
+end
+
+
+function Node:get_tab_rect(idx)
+  local maxw = self.size.x
+  local x0 = self.position.x
+  local x1 = x0 + common.clamp(self.tab_width * (idx - 1) - self.tab_shift, 0, maxw)
+  local x2 = x0 + common.clamp(self.tab_width * idx - self.tab_shift, 0, maxw)
+  local h = style.font:get_height() + style.padding.y * 2
+  return x1, self.position.y, x2 - x1, h
+end
+
+
+function Node:get_divider_rect()
+  local x, y = self.position.x, self.position.y
+  if self.type == "hsplit" then
+    return x + self.a.size.x, y, style.divider_size, self.size.y
+  elseif self.type == "vsplit" then
+    return x, y + self.a.size.y, self.size.x, style.divider_size
+  end
+end
+
+
+-- Return two values for x and y axis and each of them is either falsy or a number.
+-- A falsy value indicate no fixed size along the corresponding direction.
+function Node:get_locked_size()
+  if self.type == "leaf" then
+    if self.locked then
+      local size = self.active_view.size
+      -- The values below should be either a falsy value or a number
+      local sx = (self.locked and self.locked.x) and size.x
+      local sy = (self.locked and self.locked.y) and size.y
+      return sx, sy
+    end
+  else
+    local x1, y1 = self.a:get_locked_size()
+    local x2, y2 = self.b:get_locked_size()
+    -- The values below should be either a falsy value or a number
+    local sx, sy
+    if self.type == 'hsplit' then
+      if x1 and x2 then
+        local dsx = (x1 < 1 or x2 < 1) and 0 or style.divider_size
+        sx = x1 + x2 + dsx
+      end
+      sy = y1 or y2
+    else
+      if y1 and y2 then
+        local dsy = (y1 < 1 or y2 < 1) and 0 or style.divider_size
+        sy = y1 + y2 + dsy
+      end
+      sx = x1 or x2
+    end
+    return sx, sy
+  end
+end
+
+
+function Node.copy_position_and_size(dst, src)
+  dst.position.x, dst.position.y = src.position.x, src.position.y
+  dst.size.x, dst.size.y = src.size.x, src.size.y
+end
+
+
+-- calculating the sizes is the same for hsplits and vsplits, except the x/y
+-- axis are swapped; this function lets us use the same code for both
+local function calc_split_sizes(self, x, y, x1, x2, y1, y2)
+  local ds = ((x1 and x1 < 1) or (x2 and x2 < 1)) and 0 or style.divider_size
+  local n = x1 and x1 + ds or (x2 and self.size[x] - x2 or math.floor(self.size[x] * self.divider))
+  self.a.position[x] = self.position[x]
+  self.a.position[y] = self.position[y]
+  self.a.size[x] = n - ds
+  self.a.size[y] = self.size[y]
+  self.b.position[x] = self.position[x] + n
+  self.b.position[y] = self.position[y]
+  self.b.size[x] = self.size[x] - n
+  self.b.size[y] = self.size[y]
+end
+
+
+function Node:update_layout()
+  if self.type == "leaf" then
+    local av = self.active_view
+    if self:should_show_tabs() then
+      local _, _, _, th = self:get_tab_rect(1)
+      av.position.x, av.position.y = self.position.x, self.position.y + th
+      av.size.x, av.size.y = self.size.x, self.size.y - th
+    else
+      Node.copy_position_and_size(av, self)
+    end
+  else
+    local x1, y1 = self.a:get_locked_size()
+    local x2, y2 = self.b:get_locked_size()
+    if self.type == "hsplit" then
+      calc_split_sizes(self, "x", "y", x1, x2)
+    elseif self.type == "vsplit" then
+      calc_split_sizes(self, "y", "x", y1, y2)
+    end
+    self.a:update_layout()
+    self.b:update_layout()
+  end
+end
+
+
+function Node:scroll_tabs_to_visible()
+  local index = self:get_view_idx(self.active_view)
+  if index then
+    local tabs_number = self:get_visible_tabs_number()
+    if self.tab_offset > index then
+      self.tab_offset = index
+    elseif self.tab_offset + tabs_number - 1 < index then
+      self.tab_offset = index - tabs_number + 1
+    elseif tabs_number < config.max_tabs and self.tab_offset > 1 then
+      self.tab_offset = #self.views - config.max_tabs + 1
+    end
+  end
+end
+
+
+function Node:scroll_tabs(dir)
+  local view_index = self:get_view_idx(self.active_view)
+  if dir == 1 then
+    if self.tab_offset > 1 then
+      self.tab_offset = self.tab_offset - 1
+      local last_index = self.tab_offset + self:get_visible_tabs_number() - 1
+      if view_index > last_index then
+        self:set_active_view(self.views[last_index])
+      end
+    end
+  elseif dir == 2 then
+    local tabs_number = self:get_visible_tabs_number()
+    if self.tab_offset + tabs_number - 1 < #self.views then
+      self.tab_offset = self.tab_offset + 1
+      local view_index = self:get_view_idx(self.active_view)
+      if view_index < self.tab_offset then
+        self:set_active_view(self.views[self.tab_offset])
+      end
+    end
+  end
+end
+
+
+function Node:target_tab_width()
+  local n = self:get_visible_tabs_number()
+  local w = self.size.x
+  if #self.views > n then
+    w = self.size.x - get_scroll_button_width() * 2
+  end
+  return common.clamp(style.tab_width, w / config.max_tabs, w / n)
+end
+
+
+function Node:update()
+  if self.type == "leaf" then
+    self:scroll_tabs_to_visible()
+    for _, view in ipairs(self.views) do
+      view:update()
+    end
+    self:tab_hovered_update(self.hovered.x, self.hovered.y)
+    local tab_width = self:target_tab_width()
+    self:move_towards("tab_shift", tab_width * (self.tab_offset - 1), nil, "tabs")
+    self:move_towards("tab_width", tab_width, nil, "tabs")
+  else
+    self.a:update()
+    self.b:update()
+  end
+end
+
+function Node:draw_tab_title(view, font, is_active, is_hovered, x, y, w, h)
+  local text = view and view:get_name() or ""
+  local dots_width = font:get_width("…")
+  local align = "center"
+  if font:get_width(text) > w then
+    align = "left"
+    for i = 1, #text do
+      local reduced_text = text:sub(1, #text - i)
+      if font:get_width(reduced_text) + dots_width <= w then
+        text = reduced_text .. "…"
+        break
+      end
+    end
+  end
+  local color = style.dim
+  if is_active then color = style.text end
+  if is_hovered then color = style.text end
+  common.draw_text(font, color, text, align, x, y, w, h)
+end
+
+function Node:draw_tab_borders(view, is_active, is_hovered, x, y, w, h, standalone)
+  -- Tabs deviders
+  local ds = style.divider_size
+  local color = style.dim
+  local padding_y = style.padding.y
+  renderer.draw_rect(x + w, y + padding_y, ds, h - padding_y*2, style.dim)
+  if standalone then
+    renderer.draw_rect(x-1, y-1, w+2, h+2, style.background2)
+  end
+  -- Full border
+  if is_active then
+    color = style.text
+    renderer.draw_rect(x, y, w, h, style.background)
+    renderer.draw_rect(x + w, y, ds, h, style.divider)
+    renderer.draw_rect(x - ds, y, ds, h, style.divider)
+  end
+  return x + ds, y, w - ds*2, h
+end
+
+function Node:draw_tab(view, is_active, is_hovered, is_close_hovered, x, y, w, h, standalone)
+  x, y, w, h = self:draw_tab_borders(view, is_active, is_hovered, x, y, w, h, standalone)
+  -- Close button
+  local cx, cw, cpad = close_button_location(x, w)
+  local show_close_button = ((is_active or is_hovered) and not standalone and config.tab_close_button)
+  if show_close_button then
+    local close_style = is_close_hovered and style.text or style.dim
+    common.draw_text(style.icon_font, close_style, "C", nil, cx, y, cw, h)
+  end
+  -- Title
+  x = x + cpad
+  w = cx - x
+  core.push_clip_rect(x, y, w, h)
+  self:draw_tab_title(view, style.font, is_active, is_hovered, x, y, w, h)
+  core.pop_clip_rect()
+end
+
+function Node:draw_tabs()
+  local _, y, w, h, scroll_padding = self:get_scroll_button_rect(1)
+  local x = self.position.x
+  local ds = style.divider_size
+  local dots_width = style.font:get_width("…")
+  core.push_clip_rect(x, y, self.size.x, h)
+  renderer.draw_rect(x, y, self.size.x, h, style.background2)
+  renderer.draw_rect(x, y + h - ds, self.size.x, ds, style.divider)
+  local tabs_number = self:get_visible_tabs_number()
+
+  for i = self.tab_offset, self.tab_offset + tabs_number - 1 do
+    local view = self.views[i]
+    local x, y, w, h = self:get_tab_rect(i)
+    self:draw_tab(view, view == self.active_view,
+                  i == self.hovered_tab, i == self.hovered_close,
+                  x, y, w, h)
+  end
+
+  if #self.views > tabs_number then
+    local _, pad = get_scroll_button_width()
+    local xrb, yrb, wrb, hrb = self:get_scroll_button_rect(1)
+    renderer.draw_rect(xrb + pad, yrb, wrb * 2, hrb, style.background2)
+    local left_button_style = (self.hovered_scroll_button == 1 and self.tab_offset > 1) and style.text or style.dim
+    common.draw_text(style.icon_font, left_button_style, "<", nil, xrb + scroll_padding, yrb, 0, h)
+
+    xrb, yrb, wrb = self:get_scroll_button_rect(2)
+    local right_button_style = (self.hovered_scroll_button == 2 and #self.views > self.tab_offset + tabs_number - 1) and style.text or style.dim
+    common.draw_text(style.icon_font, right_button_style, ">", nil, xrb + scroll_padding, yrb, 0, h)
+  end
+
+  core.pop_clip_rect()
+end
+
+
+function Node:draw()
+  if self.type == "leaf" then
+    if self:should_show_tabs() then
+      self:draw_tabs()
+    end
+    local pos, size = self.active_view.position, self.active_view.size
+    core.push_clip_rect(pos.x, pos.y, size.x, size.y)
+    self.active_view:draw()
+    core.pop_clip_rect()
+  else
+    local x, y, w, h = self:get_divider_rect()
+    renderer.draw_rect(x, y, w, h, style.divider)
+    self:propagate("draw")
+  end
+end
+
+
+function Node:is_empty()
+  if self.type == "leaf" then
+    return #self.views == 0 or (#self.views == 1 and self.views[1]:is(EmptyView))
+  else
+    return self.a:is_empty() and self.b:is_empty()
+  end
+end
+
+
+function Node:close_all_docviews(keep_active)
+  local node_active_view = self.active_view
+  local lost_active_view = false
+  if self.type == "leaf" then
+    local i = 1
+    while i <= #self.views do
+      local view = self.views[i]
+      if view.context == "session" and (not keep_active or view ~= self.active_view) then
+        table.remove(self.views, i)
+        if view == node_active_view then
+          lost_active_view = true
+        end
+      else
+        i = i + 1
+      end
+    end
+    self.tab_offset = 1
+    if #self.views == 0 and self.is_primary_node then
+      -- if we are not the primary view and we had the active view it doesn't
+      -- matter to reattribute the active view because, within the close_all_docviews
+      -- top call, the primary node will take the active view anyway.
+      -- Set the empty view and takes the active view.
+      self:add_view(EmptyView())
+    elseif #self.views > 0 and lost_active_view then
+      -- In practice we never get there but if a view remain we need
+      -- to reset the Node's active view.
+      self:set_active_view(self.views[1])
+    end
+  else
+    self.a:close_all_docviews(keep_active)
+    self.b:close_all_docviews(keep_active)
+    if self.a:is_empty() and not self.a.is_primary_node then
+      self:consume(self.b)
+    elseif self.b:is_empty() and not self.b.is_primary_node then
+      self:consume(self.a)
+    end
+  end
+end
+
+-- Returns true for nodes that accept either "proportional" resizes (based on the
+-- node.divider) or "locked" resizable nodes (along the resize axis).
+function Node:is_resizable(axis)
+  if self.type == 'leaf' then
+    return not self.locked or not self.locked[axis] or self.resizable
+  else
+    local a_resizable = self.a:is_resizable(axis)
+    local b_resizable = self.b:is_resizable(axis)
+    return a_resizable and b_resizable
+  end
+end
+
+
+-- Return true iff it is a locked pane along the rezise axis and is
+-- declared "resizable".
+function Node:is_locked_resizable(axis)
+  return self.locked and self.locked[axis] and self.resizable
+end
+
+
+function Node:resize(axis, value)
+  -- the application works fine with non-integer values but to have pixel-perfect
+  -- placements of view elements, like the scrollbar, we round the value to be
+  -- an integer.
+  value = math.floor(value)
+  if self.type == 'leaf' then
+    -- If it is not locked we don't accept the
+    -- resize operation here because for proportional panes the resize is
+    -- done using the "divider" value of the parent node.
+    if self:is_locked_resizable(axis) then
+      return self.active_view:set_target_size(axis, value)
+    end
+  else
+    if self.type == (axis == "x" and "hsplit" or "vsplit") then
+      -- we are resizing a node that is splitted along the resize axis
+      if self.a:is_locked_resizable(axis) and self.b:is_locked_resizable(axis) then
+        local rem_value = value - self.a.size[axis]
+        if rem_value >= 0 then
+          return self.b.active_view:set_target_size(axis, rem_value)
+        else
+          self.b.active_view:set_target_size(axis, 0)
+          return self.a.active_view:set_target_size(axis, value)
+        end
+      end
+    else
+      -- we are resizing a node that is splitted along the axis perpendicular
+      -- to the resize axis
+      local a_resizable = self.a:is_resizable(axis)
+      local b_resizable = self.b:is_resizable(axis)
+      if a_resizable and b_resizable then
+        self.a:resize(axis, value)
+        self.b:resize(axis, value)
+      end
+    end
+  end
+end
+
+
+function Node:get_split_type(mouse_x, mouse_y)
+  local x, y = self.position.x, self.position.y
+  local w, h = self.size.x, self.size.y
+  local _, _, _, tab_h = self:get_scroll_button_rect(1)
+  y = y + tab_h
+  h = h - tab_h
+
+  local local_mouse_x = mouse_x - x
+  local local_mouse_y = mouse_y - y
+
+  if local_mouse_y < 0 then
+    return "tab"
+  else
+    local left_pct = local_mouse_x * 100 / w
+    local top_pct = local_mouse_y * 100 / h
+    if left_pct <= 30 then
+      return "left"
+    elseif left_pct >= 70 then
+      return "right"
+    elseif top_pct <= 30 then
+      return "up"
+    elseif top_pct >= 70 then
+      return "down"
+    end
+    return "middle"
+  end
+end
+
+
+function Node:get_drag_overlay_tab_position(x, y, dragged_node, dragged_index)
+  local tab_index = self:get_tab_overlapping_point(x, y)
+  if not tab_index then
+    local first_tab_x = self:get_tab_rect(1)
+    if x < first_tab_x then
+      -- mouse before first visible tab
+      tab_index = self.tab_offset or 1
+    else
+      -- mouse after last visible tab
+      tab_index = self:get_visible_tabs_number() + (self.tab_offset - 1 or 0)
+    end
+  end
+  local tab_x, tab_y, tab_w, tab_h = self:get_tab_rect(tab_index)
+  if x > tab_x + tab_w / 2 and tab_index <= #self.views then
+    -- use next tab
+    tab_x = tab_x + tab_w
+    tab_index = tab_index + 1
+  end
+  if self == dragged_node and dragged_index and tab_index > dragged_index then
+    -- the tab we are moving is counted in tab_index
+    tab_index = tab_index - 1
+    tab_x = tab_x - tab_w
+  end
+  return tab_index, tab_x, tab_y, tab_w, tab_h
+end
+
+return Node

data/core/object.lua

@@ -1,11 +1,12 @@
+---@class core.object
+---@field super core.object
 local Object = {}
 Object.__index = Object
 
+---Can be overrided by child objects to implement a constructor.
+function Object:new() end
 
-function Object:new()
-end
-
-
+---@return core.object
 function Object:extend()
   local cls = {}
   for k, v in pairs(self) do
@@ -19,19 +20,17 @@ function Object:extend()
   return cls
 end
 
-
-function Object:implement(...)
-  for _, cls in pairs({...}) do
-    for k, v in pairs(cls) do
-      if self[k] == nil and type(v) == "function" then
-        self[k] = v
-      end
-    end
-  end
+---Check if the object is strictly of the given type.
+---@param T any
+---@return boolean
+function Object:is(T)
+  return getmetatable(self) == T
 end
 
-
-function Object:is(T)
+---Check if the object inherits from the given type.
+---@param T any
+---@return boolean
+function Object:extends(T)
   local mt = getmetatable(self)
   while mt do
     if mt == T then
@@ -42,12 +41,14 @@ function Object:is(T)
   return false
 end
 
-
+---Metamethod to get a string representation of an object.
+---@return string
 function Object:__tostring()
   return "Object"
 end
 
-
+---Metamethod to allow using the object call as a constructor.
+---@return core.object
 function Object:__call(...)
   local obj = setmetatable({}, self)
   obj:new(...)

data/core/process.lua

@@ -0,0 +1,50 @@
+local function env_key(str)
+  if PLATFORM == "Windows" then return str:upper() else return str end
+end
+
+---Sorts the environment variable by its key, converted to uppercase.
+---This is only needed on Windows.
+local function compare_env(a, b)
+  return env_key(a:match("([^=]*)=")) < env_key(b:match("([^=]*)="))
+end
+
+local old_start = process.start
+function process.start(command, options)
+  assert(type(command) == "table" or type(command) == "string", "invalid argument #1 to process.start(), expected string or table, got "..type(command))
+  assert(type(options) == "table" or type(options) == "nil", "invalid argument #2 to process.start(), expected table or nil, got "..type(options))
+  if PLATFORM == "Windows" then
+    if type(command) == "table" then
+      -- escape the arguments into a command line string
+      -- https://github.com/python/cpython/blob/48f9d3e3faec5faaa4f7c9849fecd27eae4da213/Lib/subprocess.py#L531
+      local arglist = {}
+      for _, v in ipairs(command) do
+        local backslash, arg = 0, {}
+        for c in v:gmatch(".") do
+          if     c == "\\" then backslash = backslash + 1
+          elseif c == '"'  then arg[#arg+1] = string.rep("\\", backslash * 2 + 1)..'"'; backslash = 0
+          else                  arg[#arg+1] = string.rep("\\", backslash) .. c;         backslash = 0 end
+        end
+        arg[#arg+1] = string.rep("\\", backslash) -- add remaining backslashes
+        if #v == 0 or v:find("[\t\v\r\n ]") then arglist[#arglist+1] = '"'..table.concat(arg, "")..'"'
+        else                                     arglist[#arglist+1] = table.concat(arg, "") end
+      end
+      command = table.concat(arglist, " ")
+    end
+  else
+    command = type(command) == "table" and command or { command }
+  end
+  if type(options) == "table" and options.env then
+    local user_env = options.env --[[@as table]]
+    options.env = function(system_env)
+      local final_env, envlist = {}, {}
+      for k, v in pairs(system_env) do final_env[env_key(k)] = k.."="..v end
+      for k, v in pairs(user_env)   do final_env[env_key(k)] = k.."="..v end
+      for _, v in pairs(final_env)  do envlist[#envlist+1] = v end
+      if PLATFORM == "Windows" then table.sort(envlist, compare_env) end
+      return table.concat(envlist, "\0").."\0\0"
+    end
+  end
+  return old_start(command, options)
+end
+
+return process

data/core/regex.lua

@@ -0,0 +1,82 @@
+-- So that in addition to regex.gsub(pattern, string), we can also do
+-- pattern:gsub(string).
+regex.__index = function(table, key) return regex[key]; end
+
+---Looks for the first match of `pattern` in the string `str`.
+---If it finds a match, it returns the indices of `str` where this occurrence
+---starts and ends; otherwise, it returns `nil`.
+---If the pattern has captures, the captured start and end indexes are returned,
+---after the two initial ones.
+---
+---@param pattern string|table The regex pattern to use, either as a simple string or precompiled.
+---@param str string The string to search for valid matches.
+---@param offset? integer The position on the subject to start searching.
+---@param options? integer A bit field of matching options, eg: regex.NOTBOL | regex.NOTEMPTY
+---
+---@return integer? start Offset where the first match was found; `nil` if no match.
+---@return integer? end Offset where the first match ends; `nil` if no match.
+---@return integer? ... #Captured matches offsets.
+regex.find_offsets = function(pattern, str, offset, options)
+  if type(pattern) ~= "table" then
+    pattern = regex.compile(pattern)
+  end
+  local res = { regex.cmatch(pattern, str, offset or 1, options or 0) }
+  -- Reduce every end delimiter by 1
+  for i = 2,#res,2 do
+    res[i] = res[i] - 1
+  end
+  return table.unpack(res)
+end
+
+---Behaves like `string.match`.
+---Looks for the first match of `pattern` in the string `str`.
+---If it finds a match, it returns the matched string; otherwise, it returns `nil`.
+---If the pattern has captures, only the captured strings are returned.
+---If a capture is empty, its offset is returned instead.
+---
+---@param pattern string|table The regex pattern to use, either as a simple string or precompiled.
+---@param str string The string to search for valid matches.
+---@param offset? integer The position on the subject to start searching.
+---@param options? integer A bit field of matching options, eg: regex.NOTBOL | regex.NOTEMPTY
+---
+---@return (string|integer)? ... #List of captured matches; the entire match if no matches were specified; if the match is empty, its offset is returned instead.
+regex.match = function(pattern, str, offset, options)
+  local res = { regex.find(pattern, str, offset, options) }
+  if #res == 0 then return end
+  -- If available, only return captures
+  if #res > 2 then return table.unpack(res, 3) end
+  return string.sub(str, res[1], res[2])
+end
+
+---Behaves like `string.find`.
+---Looks for the first match of `pattern` in the string `str`.
+---If it finds a match, it returns the indices of `str` where this occurrence
+---starts and ends; otherwise, it returns `nil`.
+---If the pattern has captures, the captured strings are returned,
+---after the two indexes ones.
+---If a capture is empty, its offset is returned instead.
+---
+---@param pattern string|table The regex pattern to use, either as a simple string or precompiled.
+---@param str string The string to search for valid matches.
+---@param offset? integer The position on the subject to start searching.
+---@param options? integer A bit field of matching options, eg: regex.NOTBOL | regex.NOTEMPTY
+---
+---@return integer? start Offset where the first match was found; `nil` if no match.
+---@return integer? end Offset where the first match ends; `nil` if no match.
+---@return (string|integer)? ... #List of captured matches; if the match is empty, its offset is returned instead.
+regex.find = function(pattern, str, offset, options)
+  local res = { regex.find_offsets(pattern, str, offset, options) }
+  local out = { }
+  if #res == 0 then return end
+  out[1] = res[1]
+  out[2] = res[2]
+  for i = 3,#res,2 do
+    if res[i] > res[i+1] then
+      -- Like in string.find, if the group has size 0, return the index
+      table.insert(out, res[i])
+    else
+      table.insert(out, string.sub(str, res[i], res[i+1]))
+    end
+  end
+  return table.unpack(out)
+end

data/core/rootview.lua

@@ -1,389 +1,32 @@
 local core = require "core"
 local common = require "core.common"
 local style = require "core.style"
-local keymap = require "core.keymap"
-local Object = require "core.object"
+local Node = require "core.node"
 local View = require "core.view"
 local DocView = require "core.docview"
 
-
-local EmptyView = View:extend()
-
-local function draw_text(x, y, color)
-  local th = style.big_font:get_height()
-  local dh = th + style.padding.y * 2
-  x = renderer.draw_text(style.big_font, "lite", x, y + (dh - th) / 2, color)
-  x = x + style.padding.x
-  renderer.draw_rect(x, y, math.ceil(1 * SCALE), dh, color)
-  local lines = {
-    { fmt = "%s to run a command", cmd = "core:find-command" },
-    { fmt = "%s to open a file from the project", cmd = "core:find-file" },
-  }
-  th = style.font:get_height()
-  y = y + (dh - th * 2 - style.padding.y) / 2
-  local w = 0
-  for _, line in ipairs(lines) do
-    local text = string.format(line.fmt, keymap.get_binding(line.cmd))
-    w = math.max(w, renderer.draw_text(style.font, text, x + style.padding.x, y, color))
-    y = y + th + style.padding.y
-  end
-  return w, dh
-end
-
-function EmptyView:draw()
-  self:draw_background(style.background)
-  local w, h = draw_text(0, 0, { 0, 0, 0, 0 })
-  local x = self.position.x + math.max(style.padding.x, (self.size.x - w) / 2)
-  local y = self.position.y + (self.size.y - h) / 2
-  draw_text(x, y, style.dim)
-end
-
-
-
-local Node = Object:extend()
-
-function Node:new(type)
-  self.type = type or "leaf"
-  self.position = { x = 0, y = 0 }
-  self.size = { x = 0, y = 0 }
-  self.views = {}
-  self.divider = 0.5
-  if self.type == "leaf" then
-    self:add_view(EmptyView())
-  end
-end
-
-
-function Node:propagate(fn, ...)
-  self.a[fn](self.a, ...)
-  self.b[fn](self.b, ...)
-end
-
-
-function Node:on_mouse_moved(x, y, ...)
-  self.hovered_tab = self:get_tab_overlapping_point(x, y)
-  if self.type == "leaf" then
-    self.active_view:on_mouse_moved(x, y, ...)
-  else
-    self:propagate("on_mouse_moved", x, y, ...)
-  end
-end
-
-
-function Node:on_mouse_released(...)
-  if self.type == "leaf" then
-    self.active_view:on_mouse_released(...)
-  else
-    self:propagate("on_mouse_released", ...)
-  end
-end
-
-
-function Node:consume(node)
-  for k, _ in pairs(self) do self[k] = nil end
-  for k, v in pairs(node) do self[k] = v   end
-end
-
-
-local type_map = { up="vsplit", down="vsplit", left="hsplit", right="hsplit" }
-
-function Node:split(dir, view, locked)
-  assert(self.type == "leaf", "Tried to split non-leaf node")
-  local type = assert(type_map[dir], "Invalid direction")
-  local last_active = core.active_view
-  local child = Node()
-  child:consume(self)
-  self:consume(Node(type))
-  self.a = child
-  self.b = Node()
-  if view then self.b:add_view(view) end
-  if locked then
-    self.b.locked = locked
-    core.set_active_view(last_active)
-  end
-  if dir == "up" or dir == "left" then
-    self.a, self.b = self.b, self.a
-  end
-  return child
-end
-
-
-function Node:close_active_view(root)
-  local do_close = function()
-    if #self.views > 1 then
-      local idx = self:get_view_idx(self.active_view)
-      table.remove(self.views, idx)
-      self:set_active_view(self.views[idx] or self.views[#self.views])
-    else
-      local parent = self:get_parent_node(root)
-      local is_a = (parent.a == self)
-      local other = parent[is_a and "b" or "a"]
-      if other:get_locked_size() then
-        self.views = {}
-        self:add_view(EmptyView())
-      else
-        parent:consume(other)
-        local p = parent
-        while p.type ~= "leaf" do
-          p = p[is_a and "a" or "b"]
-        end
-        p:set_active_view(p.active_view)
-      end
-    end
-    core.last_active_view = nil
-  end
-  self.active_view:try_close(do_close)
-end
-
-
-function Node:add_view(view)
-  assert(self.type == "leaf", "Tried to add view to non-leaf node")
-  assert(not self.locked, "Tried to add view to locked node")
-  if self.views[1] and self.views[1]:is(EmptyView) then
-    table.remove(self.views)
-  end
-  table.insert(self.views, view)
-  self:set_active_view(view)
-end
-
-
-function Node:set_active_view(view)
-  assert(self.type == "leaf", "Tried to set active view on non-leaf node")
-  self.active_view = view
-  core.set_active_view(view)
-end
-
-
-function Node:get_view_idx(view)
-  for i, v in ipairs(self.views) do
-    if v == view then return i end
-  end
-end
-
-
-function Node:get_node_for_view(view)
-  for _, v in ipairs(self.views) do
-    if v == view then return self end
-  end
-  if self.type ~= "leaf" then
-    return self.a:get_node_for_view(view) or self.b:get_node_for_view(view)
-  end
-end
-
-
-function Node:get_parent_node(root)
-  if root.a == self or root.b == self then
-    return root
-  elseif root.type ~= "leaf" then
-    return self:get_parent_node(root.a) or self:get_parent_node(root.b)
-  end
-end
-
-
-function Node:get_children(t)
-  t = t or {}
-  for _, view in ipairs(self.views) do
-    table.insert(t, view)
-  end
-  if self.a then self.a:get_children(t) end
-  if self.b then self.b:get_children(t) end
-  return t
-end
-
-
-function Node:get_divider_overlapping_point(px, py)
-  if self.type ~= "leaf" then
-    local p = 6
-    local x, y, w, h = self:get_divider_rect()
-    x, y = x - p, y - p
-    w, h = w + p * 2, h + p * 2
-    if px > x and py > y and px < x + w and py < y + h then
-      return self
-    end
-    return self.a:get_divider_overlapping_point(px, py)
-        or self.b:get_divider_overlapping_point(px, py)
-  end
-end
-
-
-function Node:get_tab_overlapping_point(px, py)
-  if #self.views == 1 then return nil end
-  local x, y, w, h = self:get_tab_rect(1)
-  if px >= x and py >= y and px < x + w * #self.views and py < y + h then
-    return math.floor((px - x) / w) + 1
-  end
-end
-
-
-function Node:get_child_overlapping_point(x, y)
-  local child
-  if self.type == "leaf" then
-    return self
-  elseif self.type == "hsplit" then
-    child = (x < self.b.position.x) and self.a or self.b
-  elseif self.type == "vsplit" then
-    child = (y < self.b.position.y) and self.a or self.b
-  end
-  return child:get_child_overlapping_point(x, y)
-end
-
-
-function Node:get_tab_rect(idx)
-  local tw = math.min(style.tab_width, math.ceil(self.size.x / #self.views))
-  local h = style.font:get_height() + style.padding.y * 2
-  return self.position.x + (idx-1) * tw, self.position.y, tw, h
-end
-
-
-function Node:get_divider_rect()
-  local x, y = self.position.x, self.position.y
-  if self.type == "hsplit" then
-    return x + self.a.size.x, y, style.divider_size, self.size.y
-  elseif self.type == "vsplit" then
-    return x, y + self.a.size.y, self.size.x, style.divider_size
-  end
-end
-
-
-function Node:get_locked_size()
-  if self.type == "leaf" then
-    if self.locked then
-      local size = self.active_view.size
-      return size.x, size.y
-    end
-  else
-    local x1, y1 = self.a:get_locked_size()
-    local x2, y2 = self.b:get_locked_size()
-    if x1 and x2 then
-      local dsx = (x1 < 1 or x2 < 1) and 0 or style.divider_size
-      local dsy = (y1 < 1 or y2 < 1) and 0 or style.divider_size
-      return x1 + x2 + dsx, y1 + y2 + dsy
-    end
-  end
-end
-
-
-local function copy_position_and_size(dst, src)
-  dst.position.x, dst.position.y = src.position.x, src.position.y
-  dst.size.x, dst.size.y = src.size.x, src.size.y
-end
-
-
--- calculating the sizes is the same for hsplits and vsplits, except the x/y
--- axis are swapped; this function lets us use the same code for both
-local function calc_split_sizes(self, x, y, x1, x2)
-  local n
-  local ds = (x1 and x1 < 1 or x2 and x2 < 1) and 0 or style.divider_size
-  if x1 then
-    n = x1 + ds
-  elseif x2 then
-    n = self.size[x] - x2
-  else
-    n = math.floor(self.size[x] * self.divider)
-  end
-  self.a.position[x] = self.position[x]
-  self.a.position[y] = self.position[y]
-  self.a.size[x] = n - ds
-  self.a.size[y] = self.size[y]
-  self.b.position[x] = self.position[x] + n
-  self.b.position[y] = self.position[y]
-  self.b.size[x] = self.size[x] - n
-  self.b.size[y] = self.size[y]
-end
-
-
-function Node:update_layout()
-  if self.type == "leaf" then
-    local av = self.active_view
-    if #self.views > 1 then
-      local _, _, _, th = self:get_tab_rect(1)
-      av.position.x, av.position.y = self.position.x, self.position.y + th
-      av.size.x, av.size.y = self.size.x, self.size.y - th
-    else
-      copy_position_and_size(av, self)
-    end
-  else
-    local x1, y1 = self.a:get_locked_size()
-    local x2, y2 = self.b:get_locked_size()
-    if self.type == "hsplit" then
-      calc_split_sizes(self, "x", "y", x1, x2)
-    elseif self.type == "vsplit" then
-      calc_split_sizes(self, "y", "x", y1, y2)
-    end
-    self.a:update_layout()
-    self.b:update_layout()
-  end
-end
-
-
-function Node:update()
-  if self.type == "leaf" then
-    for _, view in ipairs(self.views) do
-      view:update()
-    end
-  else
-    self.a:update()
-    self.b:update()
-  end
-end
-
-
-function Node:draw_tabs()
-  local x, y, _, h = self:get_tab_rect(1)
-  local ds = style.divider_size
-  core.push_clip_rect(x, y, self.size.x, h)
-  renderer.draw_rect(x, y, self.size.x, h, style.background2)
-  renderer.draw_rect(x, y + h - ds, self.size.x, ds, style.divider)
-
-  for i, view in ipairs(self.views) do
-    local x, y, w, h = self:get_tab_rect(i)
-    local text = view:get_name()
-    local color = style.dim
-    if view == self.active_view then
-      color = style.text
-      renderer.draw_rect(x, y, w, h, style.background)
-      renderer.draw_rect(x + w, y, ds, h, style.divider)
-      renderer.draw_rect(x - ds, y, ds, h, style.divider)
-    end
-    if i == self.hovered_tab then
-      color = style.text
-    end
-    core.push_clip_rect(x, y, w, h)
-    x, w = x + style.padding.x, w - style.padding.x * 2
-    local align = style.font:get_width(text) > w and "left" or "center"
-    common.draw_text(style.font, color, text, align, x, y, w, h)
-    core.pop_clip_rect()
-  end
-
-  core.pop_clip_rect()
-end
-
-
-function Node:draw()
-  if self.type == "leaf" then
-    if #self.views > 1 then
-      self:draw_tabs()
-    end
-    local pos, size = self.active_view.position, self.active_view.size
-    core.push_clip_rect(pos.x, pos.y, size.x + pos.x % 1, size.y + pos.y % 1)
-    self.active_view:draw()
-    core.pop_clip_rect()
-  else
-    local x, y, w, h = self:get_divider_rect()
-    renderer.draw_rect(x, y, w, h, style.divider)
-    self:propagate("draw")
-  end
-end
-
-
-
+---@class core.rootview : core.view
+---@field super core.view
+---@field root_node core.node
+---@field mouse core.view.position
 local RootView = View:extend()
 
+function RootView:__tostring() return "RootView" end
+
 function RootView:new()
   RootView.super.new(self)
   self.root_node = Node()
   self.deferred_draws = {}
   self.mouse = { x = 0, y = 0 }
+  self.drag_overlay = { x = 0, y = 0, w = 0, h = 0, visible = false, opacity = 0,
+                        base_color = style.drag_overlay,
+                        color = { table.unpack(style.drag_overlay) } }
+  self.drag_overlay.to = { x = 0, y = 0, w = 0, h = 0 }
+  self.drag_overlay_tab = { x = 0, y = 0, w = 0, h = 0, visible = false, opacity = 0,
+                            base_color = style.drag_overlay_tab,
+                            color = { table.unpack(style.drag_overlay_tab) } }
+  self.drag_overlay_tab.to = { x = 0, y = 0, w = 0, h = 0 }
+  self.first_dnd_processed = false
 end
 
 
@@ -392,37 +35,70 @@ function RootView:defer_draw(fn, ...)
 end
 
 
+---@return core.node
 function RootView:get_active_node()
-  return self.root_node:get_node_for_view(core.active_view)
+  local node = self.root_node:get_node_for_view(core.active_view)
+  if not node then node = self:get_primary_node() end
+  return node
 end
 
--- Get un unlocked node with at least one view.
-local function get_node_unlocked(node)
-  if not node.locked and #node.views > 0 then
+
+---@return core.node
+local function get_primary_node(node)
+  if node.is_primary_node then
     return node
   end
   if node.type ~= "leaf" then
-    local a = get_node_unlocked(node.a)
-    if a then return a end
-    return get_node_unlocked(node.b)
+    return get_primary_node(node.a) or get_primary_node(node.b)
   end
 end
 
-function RootView:get_document_view()
-  local node = get_node_unlocked(self.root_node)
-  if node then
-    return node.views[1]
-  end
-end
 
-function RootView:open_doc(doc)
-  local node = self:get_active_node()
+---@return core.node
+function RootView:get_active_node_default()
+  local node = self.root_node:get_node_for_view(core.active_view)
+  if not node then node = self:get_primary_node() end
   if node.locked then
-    local default_view = self:get_document_view()
-    assert(default_view, "Cannot find an unlocked node to open the document.")
+    local default_view = self:get_primary_node().views[1]
+    assert(default_view, "internal error: cannot find original document node.")
     core.set_active_view(default_view)
     node = self:get_active_node()
   end
+  return node
+end
+
+
+---@return core.node
+function RootView:get_primary_node()
+  return get_primary_node(self.root_node)
+end
+
+
+---@param node core.node
+---@return core.node
+local function select_next_primary_node(node)
+  if node.is_primary_node then return end
+  if node.type ~= "leaf" then
+    return select_next_primary_node(node.a) or select_next_primary_node(node.b)
+  else
+    local lx, ly = node:get_locked_size()
+    if not lx and not ly then
+      return node
+    end
+  end
+end
+
+
+---@return core.node
+function RootView:select_next_primary_node()
+  return select_next_primary_node(self.root_node)
+end
+
+
+---@param doc core.doc
+---@return core.docview
+function RootView:open_doc(doc)
+  local node = self:get_active_node_default()
   for i, view in ipairs(node.views) do
     if view.doc == doc then
       node:set_active_view(node.views[i])
@@ -437,65 +113,245 @@ function RootView:open_doc(doc)
 end
 
 
+---@param keep_active boolean
+function RootView:close_all_docviews(keep_active)
+  self.root_node:close_all_docviews(keep_active)
+end
+
+
+---Function to intercept mouse pressed events on the active view.
+---Do nothing by default.
+---@param button core.view.mousebutton
+---@param x number
+---@param y number
+---@param clicks integer
+function RootView.on_view_mouse_pressed(button, x, y, clicks)
+end
+
+
+---@param button core.view.mousebutton
+---@param x number
+---@param y number
+---@param clicks integer
+---@return boolean
 function RootView:on_mouse_pressed(button, x, y, clicks)
   local div = self.root_node:get_divider_overlapping_point(x, y)
-  if div then
-    self.dragged_divider = div
-    return
-  end
   local node = self.root_node:get_child_overlapping_point(x, y)
+  if div and (node and not node.active_view:scrollbar_overlaps_point(x, y)) then
+    self.dragged_divider = div
+    return true
+  end
+  if node.hovered_scroll_button > 0 then
+    node:scroll_tabs(node.hovered_scroll_button)
+    return true
+  end
   local idx = node:get_tab_overlapping_point(x, y)
   if idx then
-    node:set_active_view(node.views[idx])
-    if button == "middle" then
-      node:close_active_view(self.root_node)
+    if button == "middle" or node.hovered_close == idx then
+      node:close_view(self.root_node, node.views[idx])
+      return true
+    else
+      if button == "left" then
+        self.dragged_node = { node = node, idx = idx, dragging = false, drag_start_x = x, drag_start_y = y}
+      end
+      node:set_active_view(node.views[idx])
+      return true
     end
-  else
+  elseif not self.dragged_node then -- avoid sending on_mouse_pressed events when dragging tabs
     core.set_active_view(node.active_view)
-    node.active_view:on_mouse_pressed(button, x, y, clicks)
+    return self.on_view_mouse_pressed(button, x, y, clicks) or node.active_view:on_mouse_pressed(button, x, y, clicks)
   end
 end
 
 
-function RootView:on_mouse_released(...)
+function RootView:get_overlay_base_color(overlay)
+  if overlay == self.drag_overlay then
+    return style.drag_overlay
+  else
+    return style.drag_overlay_tab
+  end
+end
+
+
+function RootView:set_show_overlay(overlay, status)
+  overlay.visible = status
+  if status then -- reset colors
+    -- reload base_color
+    overlay.base_color = self:get_overlay_base_color(overlay)
+    overlay.color[1] = overlay.base_color[1]
+    overlay.color[2] = overlay.base_color[2]
+    overlay.color[3] = overlay.base_color[3]
+    overlay.color[4] = overlay.base_color[4]
+    overlay.opacity = 0
+  end
+end
+
+
+---@param button core.view.mousebutton
+---@param x number
+---@param y number
+function RootView:on_mouse_released(button, x, y, ...)
   if self.dragged_divider then
     self.dragged_divider = nil
   end
-  self.root_node:on_mouse_released(...)
+  if self.dragged_node then
+    if button == "left" then
+      if self.dragged_node.dragging then
+        local node = self.root_node:get_child_overlapping_point(self.mouse.x, self.mouse.y)
+        local dragged_node = self.dragged_node.node
+
+        if node and not node.locked
+           -- don't do anything if dragging onto own node, with only one view
+           and (node ~= dragged_node or #node.views > 1) then
+          local split_type = node:get_split_type(self.mouse.x, self.mouse.y)
+          local view = dragged_node.views[self.dragged_node.idx]
+
+          if split_type ~= "middle" and split_type ~= "tab" then -- needs splitting
+            local new_node = node:split(split_type)
+            self.root_node:get_node_for_view(view):remove_view(self.root_node, view)
+            new_node:add_view(view)
+          elseif split_type == "middle" and node ~= dragged_node then -- move to other node
+            dragged_node:remove_view(self.root_node, view)
+            node:add_view(view)
+            self.root_node:get_node_for_view(view):set_active_view(view)
+          elseif split_type == "tab" then -- move besides other tabs
+            local tab_index = node:get_drag_overlay_tab_position(self.mouse.x, self.mouse.y, dragged_node, self.dragged_node.idx)
+            dragged_node:remove_view(self.root_node, view)
+            node:add_view(view, tab_index)
+            self.root_node:get_node_for_view(view):set_active_view(view)
+          end
+          self.root_node:update_layout()
+          core.redraw = true
+        end
+      end
+      self:set_show_overlay(self.drag_overlay, false)
+      self:set_show_overlay(self.drag_overlay_tab, false)
+      if self.dragged_node and self.dragged_node.dragging then
+        core.request_cursor("arrow")
+      end
+      self.dragged_node = nil
+    end
+  else -- avoid sending on_mouse_released events when dragging tabs
+    self.root_node:on_mouse_released(button, x, y, ...)
+  end
 end
 
 
+local function resize_child_node(node, axis, value, delta)
+  local accept_resize = node.a:resize(axis, value)
+  if not accept_resize then
+    accept_resize = node.b:resize(axis, node.size[axis] - value)
+  end
+  if not accept_resize then
+    node.divider = node.divider + delta / node.size[axis]
+  end
+end
+
+
+---@param x number
+---@param y number
+---@param dx number
+---@param dy number
 function RootView:on_mouse_moved(x, y, dx, dy)
+  if core.active_view == core.nag_view then
+    core.request_cursor("arrow")
+    core.active_view:on_mouse_moved(x, y, dx, dy)
+    return
+  end
+
   if self.dragged_divider then
     local node = self.dragged_divider
     if node.type == "hsplit" then
-      node.divider = node.divider + dx / node.size.x
-    else
-      node.divider = node.divider + dy / node.size.y
+      x = common.clamp(x - node.position.x, 0, self.root_node.size.x * 0.95)
+      resize_child_node(node, "x", x, dx)
+    elseif node.type == "vsplit" then
+      y = common.clamp(y - node.position.y, 0, self.root_node.size.y * 0.95)
+      resize_child_node(node, "y", y, dy)
     end
     node.divider = common.clamp(node.divider, 0.01, 0.99)
     return
   end
 
   self.mouse.x, self.mouse.y = x, y
+
+  local dn = self.dragged_node
+  if dn and not dn.dragging then
+    -- start dragging only after enough movement
+    dn.dragging = common.distance(x, y, dn.drag_start_x, dn.drag_start_y) > style.tab_width * .05
+    if dn.dragging then
+      core.request_cursor("hand")
+    end
+  end
+
+  -- avoid sending on_mouse_moved events when dragging tabs
+  if dn then return end
+
   self.root_node:on_mouse_moved(x, y, dx, dy)
 
-  local node = self.root_node:get_child_overlapping_point(x, y)
-  local div = self.root_node:get_divider_overlapping_point(x, y)
-  if div then
-    system.set_cursor(div.type == "hsplit" and "sizeh" or "sizev")
-  elseif node:get_tab_overlapping_point(x, y) then
-    system.set_cursor("arrow")
-  else
-    system.set_cursor(node.active_view.cursor)
+  local last_overlapping_node = self.overlapping_node
+  self.overlapping_node = self.root_node:get_child_overlapping_point(x, y)
+
+  if last_overlapping_node and last_overlapping_node ~= self.overlapping_node then
+    last_overlapping_node:on_mouse_left()
   end
+
+  local div = self.root_node:get_divider_overlapping_point(x, y)
+  local tab_index = self.overlapping_node and self.overlapping_node:get_tab_overlapping_point(x, y)
+  if self.overlapping_node and self.overlapping_node:get_scroll_button_index(x, y) then
+    core.request_cursor("arrow")
+  elseif div and (self.overlapping_node and not self.overlapping_node.active_view:scrollbar_overlaps_point(x, y)) then
+    core.request_cursor(div.type == "hsplit" and "sizeh" or "sizev")
+  elseif tab_index then
+    core.request_cursor("arrow")
+  elseif self.overlapping_node then
+    core.request_cursor(self.overlapping_node.active_view.cursor)
+  end
+end
+
+
+function RootView:on_mouse_left()
+  if self.overlapping_node then
+    self.overlapping_node:on_mouse_left()
+  end
+end
+
+
+---@param filename string
+---@param x number
+---@param y number
+---@return boolean
+function RootView:on_file_dropped(filename, x, y)
+  local node = self.root_node:get_child_overlapping_point(x, y)
+  local result = node and node.active_view:on_file_dropped(filename, x, y)
+  if result then return result end
+  local info = system.get_file_info(filename)
+  if info and info.type == "dir" then
+    if self.first_dnd_processed then
+      -- first update done, open in new window
+      system.exec(string.format("%q %q", EXEFILE, filename))
+    else
+      -- DND event before first update, this is sent by macOS when folder is dropped into the dock
+      core.confirm_close_docs(core.docs, function(dirpath)
+        core.open_folder_project(dirpath)
+      end, system.absolute_path(filename))
+      self.first_dnd_processed = true
+    end
+  else
+    local ok, doc = core.try(core.open_doc, filename)
+    if ok then
+      local node = core.root_view.root_node:get_child_overlapping_point(x, y)
+      node:set_active_view(node.active_view)
+      core.root_view:open_doc(doc)
+    end
+  end
+  return true
 end
 
 
 function RootView:on_mouse_wheel(...)
   local x, y = self.mouse.x, self.mouse.y
   local node = self.root_node:get_child_overlapping_point(x, y)
-  node.active_view:on_mouse_wheel(...)
+  return node.active_view:on_mouse_wheel(...)
 end
 
 
@@ -503,11 +359,122 @@ function RootView:on_text_input(...)
   core.active_view:on_text_input(...)
 end
 
+function RootView:on_ime_text_editing(...)
+  core.active_view:on_ime_text_editing(...)
+end
+
+function RootView:on_focus_lost(...)
+  -- We force a redraw so documents can redraw without the cursor.
+  core.redraw = true
+end
+
+
+function RootView:interpolate_drag_overlay(overlay)
+  self:move_towards(overlay, "x", overlay.to.x, nil, "tab_drag")
+  self:move_towards(overlay, "y", overlay.to.y, nil, "tab_drag")
+  self:move_towards(overlay, "w", overlay.to.w, nil, "tab_drag")
+  self:move_towards(overlay, "h", overlay.to.h, nil, "tab_drag")
+
+  self:move_towards(overlay, "opacity", overlay.visible and 100 or 0, nil, "tab_drag")
+  overlay.color[4] = overlay.base_color[4] * overlay.opacity / 100
+end
+
 
 function RootView:update()
-  copy_position_and_size(self.root_node, self)
+  Node.copy_position_and_size(self.root_node, self)
   self.root_node:update()
   self.root_node:update_layout()
+
+  self:update_drag_overlay()
+  self:interpolate_drag_overlay(self.drag_overlay)
+  self:interpolate_drag_overlay(self.drag_overlay_tab)
+  -- set this to true because at this point there are no dnd requests
+  -- that are caused by the initial dnd into dock user action
+  self.first_dnd_processed = true
+end
+
+
+function RootView:set_drag_overlay(overlay, x, y, w, h, immediate)
+  overlay.to.x = x
+  overlay.to.y = y
+  overlay.to.w = w
+  overlay.to.h = h
+  if immediate then
+    overlay.x = x
+    overlay.y = y
+    overlay.w = w
+    overlay.h = h
+  end
+  if not overlay.visible then
+    self:set_show_overlay(overlay, true)
+  end
+end
+
+
+local function get_split_sizes(split_type, x, y, w, h)
+  if split_type == "left" then
+    w = w * .5
+  elseif split_type == "right" then
+    x = x + w * .5
+    w = w * .5
+  elseif split_type == "up" then
+    h = h * .5
+  elseif split_type == "down" then
+    y = y + h * .5
+    h = h * .5
+  end
+  return x, y, w, h
+end
+
+
+function RootView:update_drag_overlay()
+  if not (self.dragged_node and self.dragged_node.dragging) then return end
+  local over = self.root_node:get_child_overlapping_point(self.mouse.x, self.mouse.y)
+  if over and not over.locked then
+    local _, _, _, tab_h = over:get_scroll_button_rect(1)
+    local x, y = over.position.x, over.position.y
+    local w, h = over.size.x, over.size.y
+    local split_type = over:get_split_type(self.mouse.x, self.mouse.y)
+
+    if split_type == "tab" and (over ~= self.dragged_node.node or #over.views > 1) then
+      local tab_index, tab_x, tab_y, tab_w, tab_h = over:get_drag_overlay_tab_position(self.mouse.x, self.mouse.y)
+      self:set_drag_overlay(self.drag_overlay_tab,
+        tab_x + (tab_index and 0 or tab_w), tab_y,
+        style.caret_width, tab_h,
+        -- avoid showing tab overlay moving between nodes
+        over ~= self.drag_overlay_tab.last_over)
+      self:set_show_overlay(self.drag_overlay, false)
+      self.drag_overlay_tab.last_over = over
+    else
+      if (over ~= self.dragged_node.node or #over.views > 1) then
+        y = y + tab_h
+        h = h - tab_h
+        x, y, w, h = get_split_sizes(split_type, x, y, w, h)
+      end
+      self:set_drag_overlay(self.drag_overlay, x, y, w, h)
+      self:set_show_overlay(self.drag_overlay_tab, false)
+    end
+  else
+    self:set_show_overlay(self.drag_overlay, false)
+    self:set_show_overlay(self.drag_overlay_tab, false)
+  end
+end
+
+
+function RootView:draw_grabbed_tab()
+  local dn = self.dragged_node
+  local _,_, w, h = dn.node:get_tab_rect(dn.idx)
+  local x = self.mouse.x - w / 2
+  local y = self.mouse.y - h / 2
+  local view = dn.node.views[dn.idx]
+  self.root_node:draw_tab(view, true, true, false, x, y, w, h, true)
+end
+
+
+function RootView:draw_drag_overlay(ov)
+  if ov.opacity > 0 then
+    renderer.draw_rect(ov.x, ov.y, ov.w, ov.h, ov.color)
+  end
 end
 
 
@@ -517,7 +484,16 @@ function RootView:draw()
     local t = table.remove(self.deferred_draws)
     t.fn(table.unpack(t))
   end
+
+  self:draw_drag_overlay(self.drag_overlay)
+  self:draw_drag_overlay(self.drag_overlay_tab)
+  if self.dragged_node and self.dragged_node.dragging then
+    self:draw_grabbed_tab()
+  end
+  if core.cursor_change_req then
+    system.set_cursor(core.cursor_change_req)
+    core.cursor_change_req = nil
+  end
 end
 
-
 return RootView

data/core/scrollbar.lua

@@ -0,0 +1,344 @@
+local core = require "core"
+local common = require "core.common"
+local config = require "core.config"
+local style = require "core.style"
+local Object = require "core.object"
+
+---Scrollbar
+---Use Scrollbar:set_size to set the bounding box of the view the scrollbar belongs to.
+---Use Scrollbar:update to update the scrollbar animations.
+---Use Scrollbar:draw to draw the scrollbar.
+---Use Scrollbar:on_mouse_pressed, Scrollbar:on_mouse_released,
+---Scrollbar:on_mouse_moved and Scrollbar:on_mouse_left to react to mouse movements;
+---the scrollbar won't update automatically.
+---Use Scrollbar:set_percent to set the scrollbar location externally.
+---
+---To manage all the orientations, the scrollbar changes the coordinates system
+---accordingly. The "normal" coordinate system adapts the scrollbar coordinates
+---as if it's always a vertical scrollbar, positioned at the end of the bounding box.
+---@class core.scrollbar : core.object
+local Scrollbar = Object:extend()
+
+function Scrollbar:__tostring() return "Scrollbar" end
+
+---@class ScrollbarOptions
+---@field direction "v" | "h" @Vertical or Horizontal
+---@field alignment "s" | "e" @Start or End (left to right, top to bottom)
+---@field force_status "expanded" | "contracted" | false @Force the scrollbar status
+---@field expanded_size number? @Override the default value specified by `style.expanded_scrollbar_size`
+---@field contracted_size number? @Override the default value specified by `style.scrollbar_size`
+
+---@param options ScrollbarOptions
+function Scrollbar:new(options)
+  ---Position information of the owner
+  self.rect = {
+    x = 0, y = 0, w = 0, h = 0,
+    ---Scrollable size
+    scrollable = 0
+  }
+  self.normal_rect = {
+    across = 0,
+    along = 0,
+    across_size = 0,
+    along_size = 0,
+    scrollable = 0
+  }
+  ---@type integer @Position in percent [0-1]
+  self.percent = 0
+  ---@type boolean @Scrollbar dragging status
+  self.dragging = false
+  ---@type integer @Private. Used to offset the start of the drag from the top of the thumb
+  self.drag_start_offset = 0
+  ---What is currently being hovered. `thumb` implies` track`
+  self.hovering = { track = false, thumb = false }
+  ---@type "v" | "h"@Vertical or Horizontal
+  self.direction = options.direction or "v"
+  ---@type "s" | "e" @Start or End (left to right, top to bottom)
+  self.alignment = options.alignment or "e"
+  ---@type number @Private. Used to keep track of animations
+  self.expand_percent = 0
+  ---@type "expanded" | "contracted" | false @Force the scrollbar status
+  self.force_status = options.force_status
+  self:set_forced_status(options.force_status)
+  ---@type number? @Override the default value specified by `style.expanded_scrollbar_size`
+  self.contracted_size = options.contracted_size
+  ---@type number? @Override the default value specified by `style.scrollbar_size`
+  self.expanded_size = options.expanded_size
+end
+
+
+---Set the status the scrollbar is forced to keep
+---@param status "expanded" | "contracted" | false @The status to force
+function Scrollbar:set_forced_status(status)
+  self.force_status = status
+  if self.force_status == "expanded" then
+    self.expand_percent = 1
+  end
+end
+
+
+function Scrollbar:real_to_normal(x, y, w, h)
+  x, y, w, h = x or 0, y or 0, w or 0, h or 0
+  if self.direction == "v" then
+    if self.alignment == "s" then
+      x = (self.rect.x + self.rect.w) - x - w
+    end
+    return x, y, w, h
+  else
+    if self.alignment == "s" then
+      y = (self.rect.y + self.rect.h) - y - h
+    end
+    return y, x, h, w
+  end
+end
+
+
+function Scrollbar:normal_to_real(x, y, w, h)
+  x, y, w, h = x or 0, y or 0, w or 0, h or 0
+  if self.direction == "v" then
+    if self.alignment == "s" then
+      x = (self.rect.x + self.rect.w) - x - w
+    end
+    return x, y, w, h
+  else
+    if self.alignment == "s" then
+      x = (self.rect.y + self.rect.h) - x - w
+    end
+    return y, x, h, w
+  end
+end
+
+
+function Scrollbar:_get_thumb_rect_normal()
+  local nr = self.normal_rect
+  local sz = nr.scrollable
+  if sz == math.huge or sz <= nr.along_size
+  then
+    return 0, 0, 0, 0
+  end
+  local scrollbar_size = self.contracted_size or style.scrollbar_size
+  local expanded_scrollbar_size = self.expanded_size or style.expanded_scrollbar_size
+  local along_size = math.max(20, nr.along_size * nr.along_size / sz)
+  local across_size = scrollbar_size
+  across_size = across_size + (expanded_scrollbar_size - scrollbar_size) * self.expand_percent
+  return
+    nr.across + nr.across_size - across_size,
+    nr.along + self.percent * nr.scrollable * (nr.along_size - along_size) / (sz - nr.along_size),
+    across_size,
+    along_size
+end
+
+---Get the thumb rect (the part of the scrollbar that can be dragged)
+---@return integer,integer,integer,integer @x, y, w, h
+function Scrollbar:get_thumb_rect()
+  return self:normal_to_real(self:_get_thumb_rect_normal())
+end
+
+
+function Scrollbar:_get_track_rect_normal()
+  local nr = self.normal_rect
+  local sz = nr.scrollable
+  if sz <= nr.along_size or sz == math.huge then
+    return 0, 0, 0, 0
+  end
+  local scrollbar_size = self.contracted_size or style.scrollbar_size
+  local expanded_scrollbar_size = self.expanded_size or style.expanded_scrollbar_size
+  local across_size = scrollbar_size
+  across_size = across_size + (expanded_scrollbar_size - scrollbar_size) * self.expand_percent
+  return
+    nr.across + nr.across_size - across_size,
+    nr.along,
+    across_size,
+    nr.along_size
+end
+
+---Get the track rect (the "background" of the scrollbar)
+---@return number,number,number,number @x, y, w, h
+function Scrollbar:get_track_rect()
+  return self:normal_to_real(self:_get_track_rect_normal())
+end
+
+
+function Scrollbar:_overlaps_normal(x, y)
+  local sx, sy, sw, sh = self:_get_thumb_rect_normal()
+  local scrollbar_size = self.contracted_size or style.scrollbar_size
+  local result
+  if x >= sx - scrollbar_size * 3 and x <= sx + sw and y >= sy and y <= sy + sh then
+    result = "thumb"
+  else
+    sx, sy, sw, sh = self:_get_track_rect_normal()
+    if x >= sx - scrollbar_size * 3 and x <= sx + sw and y >= sy and y <= sy + sh then
+      result = "track"
+    end
+  end
+  return result
+end
+
+---Get what part of the scrollbar the coordinates overlap
+---@return "thumb"|"track"|nil
+function Scrollbar:overlaps(x, y)
+  x, y = self:real_to_normal(x, y)
+  return self:_overlaps_normal(x, y)
+end
+
+
+function Scrollbar:_on_mouse_pressed_normal(button, x, y, clicks)
+  local overlaps = self:_overlaps_normal(x, y)
+  if overlaps then
+    local _, along, _, along_size = self:_get_thumb_rect_normal()
+    self.dragging = true
+    if overlaps == "thumb" then
+      self.drag_start_offset = along - y
+      return true
+    elseif overlaps == "track" then
+      local nr = self.normal_rect
+      self.drag_start_offset = - along_size / 2
+      return common.clamp((y - nr.along - along_size / 2) / (nr.along_size - along_size), 0, 1)
+    end
+  end
+end
+
+---Updates the scrollbar with mouse pressed info.
+---Won't update the scrollbar position automatically.
+---Use Scrollbar:set_percent to update it.
+---
+---This sets the dragging status if needed.
+---
+---Returns a falsy value if the event happened outside the scrollbar.
+---Returns `true` if the thumb was pressed.
+---If the track was pressed this returns a value between 0 and 1
+---representing the percent of the position.
+---@return boolean|number
+function Scrollbar:on_mouse_pressed(button, x, y, clicks)
+  if button ~= "left" then return end
+  x, y = self:real_to_normal(x, y)
+  return self:_on_mouse_pressed_normal(button, x, y, clicks)
+end
+
+---Updates the scrollbar hover status.
+---This gets called by other functions and shouldn't be called manually
+function Scrollbar:_update_hover_status_normal(x, y)
+  local overlaps = self:_overlaps_normal(x, y)
+  self.hovering.thumb = overlaps == "thumb"
+  self.hovering.track = self.hovering.thumb or overlaps == "track"
+  return self.hovering.track or self.hovering.thumb
+end
+
+function Scrollbar:_on_mouse_released_normal(button, x, y)
+  self.dragging = false
+  return self:_update_hover_status_normal(x, y)
+end
+
+---Updates the scrollbar dragging status
+function Scrollbar:on_mouse_released(button, x, y)
+  if button ~= "left" then return end
+  x, y = self:real_to_normal(x, y)
+  return self:_on_mouse_released_normal(button, x, y)
+end
+
+
+function Scrollbar:_on_mouse_moved_normal(x, y, dx, dy)
+  if self.dragging then
+    local nr = self.normal_rect
+    return common.clamp((y - nr.along + self.drag_start_offset) / nr.along_size, 0, 1)
+  end
+  return self:_update_hover_status_normal(x, y)
+end
+
+---Updates the scrollbar with mouse moved info.
+---Won't update the scrollbar position automatically.
+---Use Scrollbar:set_percent to update it.
+---
+---This updates the hovering status.
+---
+---Returns a falsy value if the event happened outside the scrollbar.
+---Returns `true` if the scrollbar is hovered.
+---If the scrollbar was being dragged, this returns a value between 0 and 1
+---representing the percent of the position.
+---@return boolean|number
+function Scrollbar:on_mouse_moved(x, y, dx, dy)
+  x, y = self:real_to_normal(x, y)
+  dx, dy = self:real_to_normal(dx, dy) -- TODO: do we need this? (is this even correct?)
+  return self:_on_mouse_moved_normal(x, y, dx, dy)
+end
+
+---Updates the scrollbar hovering status
+function Scrollbar:on_mouse_left()
+  self.hovering.track, self.hovering.thumb = false, false
+end
+
+---Updates the bounding box of the view the scrollbar belongs to.
+---@param x number
+---@param y number
+---@param w number
+---@param h number
+---@param scrollable number @size of the scrollable area
+function Scrollbar:set_size(x, y, w, h, scrollable)
+  self.rect.x, self.rect.y, self.rect.w, self.rect.h = x, y, w, h
+  self.rect.scrollable = scrollable
+
+  local nr = self.normal_rect
+  nr.across, nr.along, nr.across_size, nr.along_size = self:real_to_normal(x, y, w, h)
+  nr.scrollable = scrollable
+end
+
+---Updates the scrollbar location
+---@param percent number @number between 0 and 1 representing the position of the middle part of the thumb
+function Scrollbar:set_percent(percent)
+  self.percent = percent
+end
+
+---Updates the scrollbar animations
+function Scrollbar:update()
+  -- TODO: move the animation code to its own class
+  if not self.force_status then
+    local dest = (self.hovering.track or self.dragging) and 1 or 0
+    local diff = math.abs(self.expand_percent - dest)
+    if not config.transitions or diff < 0.05 or config.disabled_transitions["scroll"] then
+      self.expand_percent = dest
+    else
+      local rate = 0.3
+      if config.fps ~= 60 or config.animation_rate ~= 1 then
+        local dt = 60 / config.fps
+        rate = 1 - common.clamp(1 - rate, 1e-8, 1 - 1e-8)^(config.animation_rate * dt)
+      end
+      self.expand_percent = common.lerp(self.expand_percent, dest, rate)
+    end
+    if diff > 1e-8 then
+      core.redraw = true
+    end
+  elseif self.force_status == "expanded" then
+    self.expand_percent = 1
+  elseif self.force_status == "contracted" then
+    self.expand_percent = 0
+  end
+end
+
+
+---Draw the scrollbar track
+function Scrollbar:draw_track()
+  if not (self.hovering.track or self.dragging)
+     and self.expand_percent == 0 then
+    return
+  end
+  local color = { table.unpack(style.scrollbar_track) }
+  color[4] = color[4] * self.expand_percent
+  local x, y, w, h = self:get_track_rect()
+  renderer.draw_rect(x, y, w, h, color)
+end
+
+---Draw the scrollbar thumb
+function Scrollbar:draw_thumb()
+  local highlight = self.hovering.thumb or self.dragging
+  local color = highlight and style.scrollbar2 or style.scrollbar
+  local x, y, w, h = self:get_thumb_rect()
+  renderer.draw_rect(x, y, w, h, color)
+end
+
+---Draw both the scrollbar track and thumb
+function Scrollbar:draw()
+  self:draw_track()
+  self:draw_thumb()
+end
+
+return Scrollbar

data/core/start.lua

@@ -0,0 +1,58 @@
+-- this file is used by lite-xl to setup the Lua environment when starting
+VERSION = "@PROJECT_VERSION@"
+MOD_VERSION = "3"
+
+SCALE = tonumber(os.getenv("LITE_SCALE") or os.getenv("GDK_SCALE") or os.getenv("QT_SCALE_FACTOR")) or 1
+PATHSEP = package.config:sub(1, 1)
+
+EXEDIR = EXEFILE:match("^(.+)[/\\][^/\\]+$")
+if MACOS_RESOURCES then
+  DATADIR = MACOS_RESOURCES
+else
+  local prefix = EXEDIR:match("^(.+)[/\\]bin$")
+  DATADIR = prefix and (prefix .. PATHSEP .. 'share' .. PATHSEP .. 'lite-xl') or (EXEDIR .. PATHSEP .. 'data')
+end
+USERDIR = (system.get_file_info(EXEDIR .. PATHSEP .. 'user') and (EXEDIR .. PATHSEP .. 'user'))
+       or os.getenv("LITE_USERDIR")
+       or ((os.getenv("XDG_CONFIG_HOME") and os.getenv("XDG_CONFIG_HOME") .. PATHSEP .. "lite-xl"))
+       or (HOME and (HOME .. PATHSEP .. '.config' .. PATHSEP .. 'lite-xl'))
+
+package.path = DATADIR .. '/?.lua;'
+package.path = DATADIR .. '/?/init.lua;' .. package.path
+package.path = USERDIR .. '/?.lua;' .. package.path
+package.path = USERDIR .. '/?/init.lua;' .. package.path
+
+local suffix = PLATFORM == "Mac OS X" and 'lib' or (PLATFORM == "Windows" and 'dll' or 'so')
+package.cpath =
+  USERDIR .. '/?.' .. ARCH .. "." .. suffix .. ";" ..
+  USERDIR .. '/?/init.' .. ARCH .. "." .. suffix .. ";" ..
+  USERDIR .. '/?.' .. suffix .. ";" ..
+  USERDIR .. '/?/init.' .. suffix .. ";" ..
+  DATADIR .. '/?.' .. ARCH .. "." .. suffix .. ";" ..
+  DATADIR .. '/?/init.' .. ARCH .. "." .. suffix .. ";" ..
+  DATADIR .. '/?.' .. suffix .. ";" ..
+  DATADIR .. '/?/init.' .. suffix .. ";"
+
+package.native_plugins = {}
+package.searchers = { package.searchers[1], package.searchers[2], function(modname)
+  local path, err = package.searchpath(modname, package.cpath)
+  if not path then return err end
+  return system.load_native_plugin, path
+end }
+
+table.pack = table.pack or pack or function(...) return {...} end
+table.unpack = table.unpack or unpack
+
+bit32 = bit32 or require "core.bit"
+
+require "core.utf8string"
+require "core.process"
+
+-- Because AppImages change the working directory before running the executable,
+-- we need to change it back to the original one.
+-- https://github.com/AppImage/AppImageKit/issues/172
+-- https://github.com/AppImage/AppImageKit/pull/191
+local appimage_owd = os.getenv("OWD")
+if os.getenv("APPIMAGE") and appimage_owd then
+  system.chdir(appimage_owd)
+end

data/core/style.lua

@@ -4,39 +4,39 @@ local style = {}
 style.padding = { x = common.round(14 * SCALE), y = common.round(7 * SCALE) }
 style.divider_size = common.round(1 * SCALE)
 style.scrollbar_size = common.round(4 * SCALE)
+style.expanded_scrollbar_size = common.round(12 * SCALE)
 style.caret_width = common.round(2 * SCALE)
 style.tab_width = common.round(170 * SCALE)
 
-style.font = renderer.font.load(EXEDIR .. "/data/fonts/font.ttf", 14 * SCALE)
-style.big_font = renderer.font.load(EXEDIR .. "/data/fonts/font.ttf", 34 * SCALE)
-style.icon_font = renderer.font.load(EXEDIR .. "/data/fonts/icons.ttf", 14 * SCALE)
-style.code_font = renderer.font.load(EXEDIR .. "/data/fonts/monospace.ttf", 13.5 * SCALE)
-
-style.background = { common.color "#2e2e32" }
-style.background2 = { common.color "#252529" }
-style.background3 = { common.color "#252529" }
-style.text = { common.color "#97979c" }
-style.caret = { common.color "#93DDFA" }
-style.accent = { common.color "#e1e1e6" }
-style.dim = { common.color "#525257" }
-style.divider = { common.color "#202024" }
-style.selection = { common.color "#48484f" }
-style.line_number = { common.color "#525259" }
-style.line_number2 = { common.color "#83838f" }
-style.line_highlight = { common.color "#343438" }
-style.scrollbar = { common.color "#414146" }
-style.scrollbar2 = { common.color "#4b4b52" }
+-- The function renderer.font.load can accept an option table as a second optional argument.
+-- It shoud be like the following:
+--
+-- {antialiasing= "grayscale", hinting = "full"}
+--
+-- The possible values for each option are:
+-- - for antialiasing: grayscale, subpixel
+-- - for hinting: none, slight, full
+--
+-- The defaults values are antialiasing subpixel and hinting slight for optimal visualization
+-- on ordinary LCD monitor with RGB patterns.
+--
+-- On High DPI monitor or non RGB monitor you may consider using antialiasing grayscale instead.
+-- The antialiasing grayscale with full hinting is interesting for crisp font rendering.
+style.font = renderer.font.load(DATADIR .. "/fonts/FiraSans-Regular.ttf", 15 * SCALE)
+style.big_font = style.font:copy(46 * SCALE)
+style.icon_font = renderer.font.load(DATADIR .. "/fonts/icons.ttf", 16 * SCALE, {antialiasing="grayscale", hinting="full"})
+style.icon_big_font = style.icon_font:copy(23 * SCALE)
+style.code_font = renderer.font.load(DATADIR .. "/fonts/JetBrainsMono-Regular.ttf", 15 * SCALE)
 
 style.syntax = {}
-style.syntax["normal"] = { common.color "#e1e1e6" }
-style.syntax["symbol"] = { common.color "#e1e1e6" }
-style.syntax["comment"] = { common.color "#676b6f" }
-style.syntax["keyword"] = { common.color "#E58AC9" }
-style.syntax["keyword2"] = { common.color "#F77483" }
-style.syntax["number"] = { common.color "#FFA94D" }
-style.syntax["literal"] = { common.color "#FFA94D" }
-style.syntax["string"] = { common.color "#f7c95c" }
-style.syntax["operator"] = { common.color "#93DDFA" }
-style.syntax["function"] = { common.color "#93DDFA" }
+
+-- This can be used to override fonts per syntax group.
+-- The syntax highlighter will take existing values from this table and
+-- override style.code_font on a per-token basis, so you can choose to eg.
+-- render comments in an italic font if you want to.
+style.syntax_fonts = {}
+-- style.syntax_fonts["comment"] = renderer.font.load(path_to_font, size_of_font, rendering_options)
+
+style.log = {}
 
 return style

data/core/syntax.lua

@@ -1,28 +1,99 @@
 local common = require "core.common"
+local core   = require "core"
 
 local syntax = {}
 syntax.items = {}
 
-local plain_text_syntax = { patterns = {}, symbols = {} }
+local plain_text_syntax = { name = "Plain Text", patterns = {}, symbols = {} }
 
 
+---Checks whether the pattern / regex compiles correctly and matches something.
+---A pattern / regex must not match an empty string.
+---@param pattern_type "regex"|"pattern"
+---@param pattern string
+---@return boolean ok
+---@return string? error
+local function check_pattern(pattern_type, pattern)
+  local ok, err, mstart, mend
+  if pattern_type == "regex" then
+    ok, err = regex.compile(pattern)
+    if ok then
+      mstart, mend = regex.find_offsets(ok, "")
+      if mstart and mstart > mend then
+        ok, err = false, "Regex matches an empty string"
+      end
+    end
+  else
+    ok, mstart, mend = pcall(string.ufind, "", pattern)
+    if ok and mstart and mstart > mend then
+      ok, err = false, "Pattern matches an empty string"
+    elseif not ok then
+      err = mstart --[[@as string]]
+    end
+  end
+  return ok --[[@as boolean]], err
+end
+
 function syntax.add(t)
+  if type(t.space_handling) ~= "boolean" then t.space_handling = true end
+
+  if t.patterns then
+    -- do a sanity check on the patterns / regex to make sure they are actually correct
+    for i, pattern in ipairs(t.patterns) do
+      local p, ok, err, name = pattern.pattern or pattern.regex, nil, nil, nil
+      if type(p) == "table" then
+        for j = 1, 2 do
+          ok, err = check_pattern(pattern.pattern and "pattern" or "regex", p[j])
+          if not ok then name = string.format("#%d:%d <%s>", i, j, p[j]) end
+        end
+      elseif type(p) == "string" then
+        ok, err = check_pattern(pattern.pattern and "pattern" or "regex", p)
+        if not ok then name = string.format("#%d <%s>", i, p) end
+      else
+        ok, err, name = false, "Missing pattern or regex", "#"..i
+      end
+      if not ok then
+        pattern.disabled = true
+        core.warn("Malformed pattern %s in %s language plugin: %s", name, t.name, err)
+      end
+    end
+
+    -- the rule %s+ gives us a performance gain for the tokenizer in lines with
+    -- long amounts of consecutive spaces, can be disabled by plugins where it
+    -- causes conflicts by declaring the table property: space_handling = false
+    if t.space_handling then
+      table.insert(t.patterns, { pattern = "%s+", type = "normal" })
+    end
+
+    -- this rule gives us additional performance gain by matching every word
+    -- that was not matched by the syntax patterns as a single token, preventing
+    -- the tokenizer from iterating over each character individually which is a
+    -- lot slower since iteration occurs in lua instead of C and adding to that
+    -- it will also try to match every pattern to a single char (same as spaces)
+    table.insert(t.patterns, { pattern = "%w+%f[%s]", type = "normal" })
+  end
+
   table.insert(syntax.items, t)
 end
 
 
 local function find(string, field)
+  local best_match = 0
+  local best_syntax
   for i = #syntax.items, 1, -1 do
     local t = syntax.items[i]
-    if common.match_pattern(string, t[field] or {}) then
-      return t
+    local s, e = common.match_pattern(string, t[field] or {})
+    if s and e - s > best_match then
+      best_match = e - s
+      best_syntax = t
     end
   end
+  return best_syntax
 end
 
 function syntax.get(filename, header)
-  return find(filename, "files")
-      or find(header, "headers")
+  return (filename and find(filename, "files"))
+      or (header and find(header, "headers"))
       or plain_text_syntax
 end
 

data/core/titleview.lua

@@ -0,0 +1,139 @@
+local core = require "core"
+local common = require "core.common"
+local style = require "core.style"
+local View = require "core.view"
+
+local icon_colors = {
+  bg = { common.color "#2e2e32ff" },
+  color6 = { common.color "#e1e1e6ff" },
+  color7 = { common.color "#ffa94dff" },
+  color8 = { common.color "#93ddfaff" },
+  color9 = { common.color "#f7c95cff" }
+};
+
+local restore_command = {
+  symbol = "w", action = function() system.set_window_mode("normal") end
+}
+
+local maximize_command = {
+  symbol = "W", action = function() system.set_window_mode("maximized") end
+}
+
+local title_commands = {
+  {symbol = "_", action = function() system.set_window_mode("minimized") end},
+  maximize_command,
+  {symbol = "X", action = function() core.quit() end},
+}
+
+---@class core.titleview : core.view
+---@field super core.view
+local TitleView = View:extend()
+
+function TitleView:__tostring() return "TitleView" end
+
+local function title_view_height()
+  return style.font:get_height() + style.padding.y * 2
+end
+
+function TitleView:new()
+  TitleView.super.new(self)
+  self.visible = true
+end
+
+function TitleView:configure_hit_test(borderless)
+  if borderless then
+    local title_height = title_view_height()
+    local icon_w = style.icon_font:get_width("_")
+    local icon_spacing = icon_w
+    local controls_width = (icon_w + icon_spacing) * #title_commands + icon_spacing
+    system.set_window_hit_test(title_height, controls_width, icon_spacing)
+    -- core.hit_test_title_height = title_height
+  else
+    system.set_window_hit_test()
+  end
+end
+
+function TitleView:on_scale_change()
+  self:configure_hit_test(self.visible)
+end
+
+function TitleView:update()
+  self.size.y = self.visible and title_view_height() or 0
+  title_commands[2] = core.window_mode == "maximized" and restore_command or maximize_command
+  TitleView.super.update(self)
+end
+
+
+function TitleView:draw_window_title()
+  local h = style.font:get_height()
+  local ox, oy = self:get_content_offset()
+  local color = style.text
+  local x, y = ox + style.padding.x, oy + style.padding.y
+  common.draw_text(style.icon_font, icon_colors.bg, "5", nil, x, y, 0, h)
+  common.draw_text(style.icon_font, icon_colors.color6, "6", nil, x, y, 0, h)
+  common.draw_text(style.icon_font, icon_colors.color7, "7", nil, x, y, 0, h)
+  common.draw_text(style.icon_font, icon_colors.color8, "8", nil, x, y, 0, h)
+  x = common.draw_text(style.icon_font, icon_colors.color9, "9 ", nil, x, y, 0, h)
+  local title = core.compose_window_title(core.window_title)
+  common.draw_text(style.font, color, title, nil, x, y, 0, h)
+end
+
+function TitleView:each_control_item()
+  local icon_h, icon_w = style.icon_font:get_height(), style.icon_font:get_width("_")
+  local icon_spacing = icon_w
+  local ox, oy = self:get_content_offset()
+  ox = ox + self.size.x
+  local i, n = 0, #title_commands
+  local iter = function()
+    i = i + 1
+    if i <= n then
+      local dx = - (icon_w + icon_spacing) * (n - i + 1)
+      local dy = style.padding.y
+      return title_commands[i], ox + dx, oy + dy, icon_w, icon_h
+    end
+  end
+  return iter
+end
+
+
+function TitleView:draw_window_controls()
+  for item, x, y, w, h in self:each_control_item() do
+    local color = item == self.hovered_item and style.text or style.dim
+    common.draw_text(style.icon_font, color, item.symbol, nil, x, y, 0, h)
+  end
+end
+
+
+function TitleView:on_mouse_pressed(button, x, y, clicks)
+  local caught = TitleView.super.on_mouse_pressed(self, button, x, y, clicks)
+  if caught then return end
+  core.set_active_view(core.last_active_view)
+  if self.hovered_item then
+    self.hovered_item.action()
+  end
+end
+
+
+function TitleView:on_mouse_moved(px, py, ...)
+  if self.size.y == 0 then return end
+  TitleView.super.on_mouse_moved(self, px, py, ...)
+  self.hovered_item = nil
+  local x_min, x_max, y_min, y_max = self.size.x, 0, self.size.y, 0
+  for item, x, y, w, h in self:each_control_item() do
+    x_min, x_max = math.min(x, x_min), math.max(x + w, x_max)
+    y_min, y_max = y, y + h
+    if px > x and py > y and px <= x + w and py <= y + h then
+      self.hovered_item = item
+      return
+    end
+  end
+end
+
+
+function TitleView:draw()
+  self:draw_background(style.background2)
+  self:draw_window_title()
+  self:draw_window_controls()
+end
+
+return TitleView

data/core/tokenizer.lua

@@ -1,10 +1,15 @@
-local tokenizer = {}
+local core = require "core"
+local syntax = require "core.syntax"
+local config = require "core.config"
 
+local tokenizer = {}
+local bad_patterns = {}
 
 local function push_token(t, type, text)
+  type = type or "normal"
   local prev_type = t[#t-1]
   local prev_text = t[#t]
-  if prev_type and (prev_type == type or prev_text:find("^%s*$")) then
+  if prev_type and (prev_type == type or (prev_text:ufind("^%s*$") and type ~= "incomplete")) then
     t[#t-1] = type
     t[#t] = prev_text .. text
   else
@@ -14,80 +19,372 @@ local function push_token(t, type, text)
 end
 
 
-local function is_escaped(text, idx, esc)
-  local byte = esc:byte()
-  local count = 0
-  for i = idx - 1, 1, -1 do
-    if text:byte(i) ~= byte then break end
-    count = count + 1
+local function push_tokens(t, syn, pattern, full_text, find_results)
+  if #find_results > 2 then
+    -- We do some manipulation with find_results so that it's arranged
+    -- like this:
+    -- { start, end, i_1, i_2, i_3, …, i_last }
+    -- Each position spans characters from i_n to ((i_n+1) - 1), to form
+    -- consecutive spans of text.
+    --
+    -- If i_1 is not equal to start, start is automatically inserted at
+    -- that index.
+    if find_results[3] ~= find_results[1] then
+      table.insert(find_results, 3, find_results[1])
+    end
+    -- Copy the ending index to the end of the table, so that an ending index
+    -- always follows a starting index after position 3 in the table.
+    table.insert(find_results, find_results[2] + 1)
+    -- Then, we just iterate over our modified table.
+    for i = 3, #find_results - 1 do
+      local start = find_results[i]
+      local fin = find_results[i + 1] - 1
+      local type = pattern.type[i - 2]
+        -- ↑ (i - 2) to convert from [3; n] to [1; n]
+      local text = full_text:usub(start, fin)
+      push_token(t, syn.symbols[text] or type, text)
+    end
+  else
+    local start, fin = find_results[1], find_results[2]
+    local text = full_text:usub(start, fin)
+    push_token(t, syn.symbols[text] or pattern.type, text)
   end
-  return count % 2 == 1
 end
 
+-- State is a string of bytes, where the count of bytes represents the depth
+-- of the subsyntax we are currently in. Each individual byte represents the
+-- index of the pattern for the current subsyntax in relation to its parent
+-- syntax. Using a string of bytes allows us to have as many subsyntaxes as
+-- bytes can be stored on a string while keeping some level of performance in
+-- comparison to a Lua table. The only limitation is that a syntax would not
+-- be able to contain more than 255 patterns.
+--
+-- Lets say a state contains 2 bytes byte #1 with value `3` and byte #2 with
+-- a value of `5`. This would mean that on the parent syntax at index `3` a
+-- pattern subsyntax that matched current text was found, then inside that
+-- subsyntax another subsyntax pattern at index `5` that matched current text
+-- was also found.
 
-local function find_non_escaped(text, pattern, offset, esc)
-  while true do
-    local s, e = text:find(pattern, offset)
-    if not s then break end
-    if esc and is_escaped(text, s, esc) then
-      offset = e + 1
-    else
-      return s, e
+-- Calling `push_subsyntax` appends the current subsyntax pattern index to the
+-- state and increases the stack depth. Calling `pop_subsyntax` clears the
+-- last appended subsyntax and decreases the stack.
+
+local function retrieve_syntax_state(incoming_syntax, state)
+  local current_syntax, subsyntax_info, current_pattern_idx, current_level =
+    incoming_syntax, nil, state:byte(1) or 0, 1
+  if
+    current_pattern_idx > 0
+    and
+    current_syntax.patterns[current_pattern_idx]
+  then
+    -- If the state is not empty we iterate over each byte, and find which
+    -- syntax we're using. Rather than walking the bytes, and calling into
+    -- `syntax` each time, we could probably cache this in a single table.
+    for i = 1, #state do
+      local target = state:byte(i)
+      if target ~= 0 then
+        if current_syntax.patterns[target].syntax then
+          subsyntax_info = current_syntax.patterns[target]
+          current_syntax = type(subsyntax_info.syntax) == "table" and
+            subsyntax_info.syntax or syntax.get(subsyntax_info.syntax)
+          current_pattern_idx = 0
+          current_level = i+1
+        else
+          current_pattern_idx = target
+          break
+        end
+      else
+        break
+      end
     end
   end
+  return current_syntax, subsyntax_info, current_pattern_idx, current_level
 end
 
+---Return the list of syntaxes used in the specified state.
+---@param base_syntax table @The initial base syntax (the syntax of the file)
+---@param state string @The state of the tokenizer to extract from
+---@return table @Array of syntaxes starting from the innermost one
+function tokenizer.extract_subsyntaxes(base_syntax, state)
+  local current_syntax
+  local t = {}
+  repeat
+    current_syntax = retrieve_syntax_state(base_syntax, state)
+    table.insert(t, current_syntax)
+    state = string.sub(state, 2)
+  until #state == 0
+  return t
+end
 
-function tokenizer.tokenize(syntax, text, state)
-  local res = {}
+local function report_bad_pattern(log_fn, syntax, pattern_idx, msg, ...)
+  if not bad_patterns[syntax] then
+    bad_patterns[syntax] = { }
+  end
+  if bad_patterns[syntax][pattern_idx] then return end
+  bad_patterns[syntax][pattern_idx] = true
+  log_fn("Malformed pattern #%d <%s> in %s language plugin.\n" .. msg,
+            pattern_idx,
+            syntax.patterns[pattern_idx].pattern or syntax.patterns[pattern_idx].regex,
+            syntax.name or "unnamed", ...)
+end
+
+---@param incoming_syntax table
+---@param text string
+---@param state string
+function tokenizer.tokenize(incoming_syntax, text, state, resume)
+  local res
   local i = 1
 
-  if #syntax.patterns == 0 then
-    return { "normal", text }
+  state = state or string.char(0)
+
+  if #incoming_syntax.patterns == 0 then
+    return { "normal", text }, state
   end
 
-  while i <= #text do
-    -- continue trying to match the end pattern of a pair if we have a state set
-    if state then
-      local p = syntax.patterns[state]
-      local s, e = find_non_escaped(text, p.pattern[2], i, p.pattern[3])
+  if resume then
+    res = resume.res
+    -- Remove "incomplete" tokens
+    while res[#res-1] == "incomplete" do
+      table.remove(res, #res)
+      table.remove(res, #res)
+    end
+    i = resume.i
+    state = resume.state
+  end
 
+  res = res or {}
+
+  -- incoming_syntax    : the parent syntax of the file.
+  -- state              : a string of bytes representing syntax state (see above)
+
+  -- current_syntax     : the syntax we're currently in.
+  -- subsyntax_info     : info about the delimiters of this subsyntax.
+  -- current_pattern_idx: the index of the pattern we're on for this syntax.
+  -- current_level      : how many subsyntaxes deep we are.
+  local current_syntax, subsyntax_info, current_pattern_idx, current_level =
+    retrieve_syntax_state(incoming_syntax, state)
+
+  -- Should be used to set the state variable. Don't modify it directly.
+  local function set_subsyntax_pattern_idx(pattern_idx)
+    current_pattern_idx = pattern_idx
+    local state_len = #state
+    if current_level > state_len then
+      state = state .. string.char(pattern_idx)
+    elseif state_len == 1 then
+      state = string.char(pattern_idx)
+    else
+      state = ("%s%s%s"):format(
+        state:sub(1,current_level-1),
+        string.char(pattern_idx),
+        state:sub(current_level+1)
+      )
+    end
+  end
+
+
+  local function push_subsyntax(entering_syntax, pattern_idx)
+    set_subsyntax_pattern_idx(pattern_idx)
+    current_level = current_level + 1
+    subsyntax_info = entering_syntax
+    current_syntax = type(entering_syntax.syntax) == "table" and
+      entering_syntax.syntax or syntax.get(entering_syntax.syntax)
+    current_pattern_idx = 0
+  end
+
+  local function pop_subsyntax()
+    current_level = current_level - 1
+    state = string.sub(state, 1, current_level)
+    set_subsyntax_pattern_idx(0)
+    current_syntax, subsyntax_info, current_pattern_idx, current_level =
+      retrieve_syntax_state(incoming_syntax, state)
+  end
+
+  local function find_text(text, p, offset, at_start, close)
+    local target, res = p.pattern or p.regex, { 1, offset - 1 }
+    local p_idx = close and 2 or 1
+    local code = type(target) == "table" and target[p_idx] or target
+    if p.disabled then return end
+
+    if p.whole_line == nil then p.whole_line = { } end
+    if p.whole_line[p_idx] == nil then
+      -- Match patterns that start with '^'
+      p.whole_line[p_idx] = code:umatch("^%^") and true or false
+      if p.whole_line[p_idx] then
+        -- Remove '^' from the beginning of the pattern
+        if type(target) == "table" then
+          target[p_idx] = code:usub(2)
+          code = target[p_idx]
+        else
+          p.pattern = p.pattern and code:usub(2)
+          p.regex = p.regex and code:usub(2)
+          code = p.pattern or p.regex
+        end
+      end
+    end
+
+    if p.regex and type(p.regex) ~= "table" then
+      p._regex = p._regex or regex.compile(p.regex)
+      code = p._regex
+    end
+
+    repeat
+      local next = res[2] + 1
+      -- If the pattern contained '^', allow matching only the whole line
+      if p.whole_line[p_idx] and next > 1 then
+        return
+      end
+      res = p.pattern and { text:ufind((at_start or p.whole_line[p_idx]) and "^" .. code or code, next) }
+        or { regex.find(code, text, text:ucharpos(next), (at_start or p.whole_line[p_idx]) and regex.ANCHORED or 0) }
+      if p.regex and #res > 0 then -- set correct utf8 len for regex result
+        local char_pos_1 = res[1] > next and string.ulen(text:sub(1, res[1])) or next
+        local char_pos_2 = string.ulen(text:sub(1, res[2]))
+        for i=3,#res do
+          res[i] = string.ulen(text:sub(1, res[i] - 1)) + 1
+        end
+        res[1] = char_pos_1
+        res[2] = char_pos_2
+      end
+      if res[1] and target[3] then
+        -- Check to see if the escaped character is there,
+        -- and if it is not itself escaped.
+        local count = 0
+        for i = res[1] - 1, 1, -1 do
+          if text:ubyte(i) ~= target[3]:ubyte() then break end
+          count = count + 1
+        end
+        if count % 2 == 0 then
+          -- The match is not escaped, so confirm it
+          break
+        elseif not close then
+          -- The *open* match is escaped, so avoid it
+          return
+        end
+      end
+    until not res[1] or not close or not target[3]
+    return table.unpack(res)
+  end
+
+  local text_len = text:ulen()
+  local start_time = system.get_time()
+  local starting_i = i
+  while i <= text_len do
+    -- Every 200 chars, check if we're out of time
+    if i - starting_i > 200 then
+      starting_i = i
+      if system.get_time() - start_time > 0.5 / config.fps then
+        -- We're out of time
+        push_token(res, "incomplete", string.usub(text, i))
+        return res, string.char(0), {
+          res = res,
+          i = i,
+          state = state
+        }
+      end
+    end
+    -- continue trying to match the end pattern of a pair if we have a state set
+    if current_pattern_idx > 0 then
+      local p = current_syntax.patterns[current_pattern_idx]
+      local find_results = { find_text(text, p, i, false, true) }
+      local s, e = find_results[1], find_results[2]
+
+      local cont = true
+      -- If we're in subsyntax mode, always check to see if we end our syntax
+      -- first, before the found delimeter, as ending the subsyntax takes
+      -- precedence over ending the delimiter in the subsyntax.
+      if subsyntax_info then
+        local ss, se = find_text(text, subsyntax_info, i, false, true)
+        -- If we find that we end the subsyntax before the
+        -- delimiter, push the token, and signal we shouldn't
+        -- treat the bit after as a token to be normally parsed
+        -- (as it's the syntax delimiter).
+        if ss and (s == nil or ss < s) then
+          push_token(res, p.type, text:usub(i, ss - 1))
+          i = ss
+          cont = false
+        end
+      end
+      -- If we don't have any concerns about syntax delimiters,
+      -- continue on as normal.
+      if cont then
+        if s then
+          -- Push remaining token before the end delimiter
+          if s > i then
+            push_token(res, p.type, text:usub(i, s - 1))
+          end
+          -- Push the end delimiter
+          push_tokens(res, current_syntax, p, text, find_results)
+          set_subsyntax_pattern_idx(0)
+          i = e + 1
+        else
+          push_token(res, p.type, text:usub(i))
+          break
+        end
+      end
+    end
+    -- General end of syntax check. Applies in the case where
+    -- we're ending early in the middle of a delimiter, or
+    -- just normally, upon finding a token.
+    while subsyntax_info do
+      local s, e = find_text(text, subsyntax_info, i, true, true)
       if s then
-        push_token(res, p.type, text:sub(i, e))
-        state = nil
+        push_token(res, subsyntax_info.type, text:usub(i, e))
+        -- On finding unescaped delimiter, pop it.
+        pop_subsyntax()
         i = e + 1
       else
-        push_token(res, p.type, text:sub(i))
         break
       end
     end
 
     -- find matching pattern
     local matched = false
-    for n, p in ipairs(syntax.patterns) do
-      local pattern = (type(p.pattern) == "table") and p.pattern[1] or p.pattern
-      local s, e = text:find("^" .. pattern, i)
-
-      if s then
-        -- matched pattern; make and add token
-        local t = text:sub(s, e)
-        push_token(res, syntax.symbols[t] or p.type, t)
-
-        -- update state if this was a start|end pattern pair
-        if type(p.pattern) == "table" then
-          state = n
+    for n, p in ipairs(current_syntax.patterns) do
+      local find_results = { find_text(text, p, i, true, false) }
+      if find_results[1] then
+        -- Check for patterns successfully matching nothing
+        if find_results[1] > find_results[2] then
+          report_bad_pattern(core.warn, current_syntax, n,
+              "Pattern successfully matched, but nothing was captured.")
+          goto continue
         end
 
+        -- Check for patterns with mismatching number of `types`
+        local type_is_table = type(p.type) == "table"
+        local n_types = type_is_table and #p.type or 1
+        if #find_results == 2 and type_is_table then
+          report_bad_pattern(core.warn, current_syntax, n,
+            "Token type is a table, but a string was expected.")
+          p.type = p.type[1]
+        elseif #find_results - 1 > n_types then
+          report_bad_pattern(core.error, current_syntax, n,
+            "Not enough token types: got %d needed %d.", n_types, #find_results - 1)
+        elseif #find_results - 1 < n_types then
+          report_bad_pattern(core.warn, current_syntax, n,
+            "Too many token types: got %d needed %d.", n_types, #find_results - 1)
+        end
+
+        -- matched pattern; make and add tokens
+        push_tokens(res, current_syntax, p, text, find_results)
+        -- update state if this was a start|end pattern pair
+        if type(p.pattern or p.regex) == "table" then
+          -- If we have a subsyntax, push that onto the subsyntax stack.
+          if p.syntax then
+            push_subsyntax(p, n)
+          else
+            set_subsyntax_pattern_idx(n)
+          end
+        end
         -- move cursor past this token
-        i = e + 1
+        i = find_results[2] + 1
         matched = true
         break
+        ::continue::
       end
     end
 
     -- consume character if we didn't match
     if not matched then
-      push_token(res, "normal", text:sub(i, i))
+      push_token(res, "normal", text:usub(i, i))
       i = i + 1
     end
   end

data/core/utf8string.lua

@@ -0,0 +1,32 @@
+--------------------------------------------------------------------------------
+-- inject utf8 functions to strings
+--------------------------------------------------------------------------------
+
+local utf8 = require "utf8extra"
+
+string.ubyte = utf8.byte
+string.uchar = utf8.char
+string.ufind = utf8.find
+string.ugmatch = utf8.gmatch
+string.ugsub = utf8.gsub
+string.ulen = utf8.len
+string.ulower = utf8.lower
+string.umatch = utf8.match
+string.ureverse = utf8.reverse
+string.usub = utf8.sub
+string.uupper = utf8.upper
+
+string.uescape = utf8.escape
+string.ucharpos = utf8.charpos
+string.unext = utf8.next
+string.uinsert = utf8.insert
+string.uremove = utf8.remove
+string.uwidth = utf8.width
+string.uwidthindex = utf8.widthindex
+string.utitle = utf8.title
+string.ufold = utf8.fold
+string.uncasecmp = utf8.ncasecmp
+
+string.uoffset = utf8.offset
+string.ucodepoint = utf8.codepoint
+string.ucodes = utf8.codes

data/core/view.lua

@@ -1,12 +1,59 @@
 local core = require "core"
 local config = require "core.config"
-local style = require "core.style"
 local common = require "core.common"
 local Object = require "core.object"
+local Scrollbar = require "core.scrollbar"
 
+---@class core.view.position
+---@field x number
+---@field y number
 
+---@class core.view.scroll
+---@field x number
+---@field y number
+---@field to core.view.position
+
+---@class core.view.thumbtrack
+---@field thumb number
+---@field track number
+
+---@class core.view.thumbtrackwidth
+---@field thumb number
+---@field track number
+---@field to core.view.thumbtrack
+
+---@class core.view.scrollbar
+---@field x core.view.thumbtrack
+---@field y core.view.thumbtrack
+---@field w core.view.thumbtrackwidth
+---@field h core.view.thumbtrack
+
+---@alias core.view.cursor "'arrow'" | "'ibeam'" | "'sizeh'" | "'sizev'" | "'hand'"
+
+---@alias core.view.mousebutton "'left'" | "'right'"
+
+---@alias core.view.context "'application'" | "'session'"
+
+---Base view.
+---@class core.view : core.object
+---@field context core.view.context
+---@field super core.object
+---@field position core.view.position
+---@field size core.view.position
+---@field scroll core.view.scroll
+---@field cursor core.view.cursor
+---@field scrollable boolean
+---@field v_scrollbar core.scrollbar
+---@field h_scrollbar core.scrollbar
+---@field current_scale number
 local View = Object:extend()
 
+function View:__tostring() return "View" end
+
+-- context can be "application" or "session". The instance of objects
+-- with context "session" will be closed when a project session is
+-- terminated. The context "application" is for functional UI elements.
+View.context = "application"
 
 function View:new()
   self.position = { x = 0, y = 0 }
@@ -14,20 +61,28 @@ function View:new()
   self.scroll = { x = 0, y = 0, to = { x = 0, y = 0 } }
   self.cursor = "arrow"
   self.scrollable = false
+  self.v_scrollbar = Scrollbar({direction = "v", alignment = "e"})
+  self.h_scrollbar = Scrollbar({direction = "h", alignment = "e"})
+  self.current_scale = SCALE
 end
 
-
-function View:move_towards(t, k, dest, rate)
+function View:move_towards(t, k, dest, rate, name)
   if type(t) ~= "table" then
-    return self:move_towards(self, t, k, dest, rate)
+    return self:move_towards(self, t, k, dest, rate, name)
   end
   local val = t[k]
-  if math.abs(val - dest) < 0.5 then
+  local diff = math.abs(val - dest)
+  if not config.transitions or diff < 0.5 or config.disabled_transitions[name] then
     t[k] = dest
   else
-    t[k] = common.lerp(val, dest, rate or 0.5)
+    rate = rate or 0.5
+    if config.fps ~= 60 or config.animation_rate ~= 1 then
+      local dt = 60 / config.fps
+      rate = 1 - common.clamp(1 - rate, 1e-8, 1 - 1e-8)^(config.animation_rate * dt)
+    end
+    t[k] = common.lerp(val, dest, rate)
   end
-  if val ~= dest then
+  if diff > 1e-8 then
     core.redraw = true
   end
 end
@@ -38,70 +93,153 @@ function View:try_close(do_close)
 end
 
 
+---@return string
 function View:get_name()
   return "---"
 end
 
 
+---@return number
 function View:get_scrollable_size()
   return math.huge
 end
 
-
-function View:get_scrollbar_rect()
-  local sz = self:get_scrollable_size()
-  if sz <= self.size.y or sz == math.huge then
-    return 0, 0, 0, 0
-  end
-  local h = math.max(20, self.size.y * self.size.y / sz)
-  return
-    self.position.x + self.size.x - style.scrollbar_size,
-    self.position.y + self.scroll.y * (self.size.y - h) / (sz - self.size.y),
-    style.scrollbar_size,
-    h
+---@return number
+function View:get_h_scrollable_size()
+  return 0
 end
 
 
+---@param x number
+---@param y number
+---@return boolean
 function View:scrollbar_overlaps_point(x, y)
-  local sx, sy, sw, sh = self:get_scrollbar_rect()
-  return x >= sx - sw * 3 and x < sx + sw and y >= sy and y < sy + sh
+  return not (not (self.v_scrollbar:overlaps(x, y) or self.h_scrollbar:overlaps(x, y)))
 end
 
 
+---@return boolean
+function View:scrollbar_dragging()
+  return self.v_scrollbar.dragging or self.h_scrollbar.dragging
+end
+
+
+---@return boolean
+function View:scrollbar_hovering()
+  return self.v_scrollbar.hovering.track or self.h_scrollbar.hovering.track
+end
+
+
+---@param button core.view.mousebutton
+---@param x number
+---@param y number
+---@param clicks integer
+---return boolean
 function View:on_mouse_pressed(button, x, y, clicks)
-  if self:scrollbar_overlaps_point(x, y) then
-    self.dragging_scrollbar = true
+  if not self.scrollable then return end
+  local result = self.v_scrollbar:on_mouse_pressed(button, x, y, clicks)
+  if result then
+    if result ~= true then
+      self.scroll.to.y = result * self:get_scrollable_size()
+    end
+    return true
+  end
+  result = self.h_scrollbar:on_mouse_pressed(button, x, y, clicks)
+  if result then
+    if result ~= true then
+      self.scroll.to.x = result * self:get_h_scrollable_size()
+    end
     return true
   end
 end
 
 
+---@param button core.view.mousebutton
+---@param x number
+---@param y number
 function View:on_mouse_released(button, x, y)
-  self.dragging_scrollbar = false
+  if not self.scrollable then return end
+  self.v_scrollbar:on_mouse_released(button, x, y)
+  self.h_scrollbar:on_mouse_released(button, x, y)
 end
 
 
+---@param x number
+---@param y number
+---@param dx number
+---@param dy number
 function View:on_mouse_moved(x, y, dx, dy)
-  if self.dragging_scrollbar then
-    local delta = self:get_scrollable_size() / self.size.y * dy
-    self.scroll.to.y = self.scroll.to.y + delta
+  if not self.scrollable then return end
+  local result
+  if self.h_scrollbar.dragging then goto skip_v_scrollbar end
+  result = self.v_scrollbar:on_mouse_moved(x, y, dx, dy)
+  if result then
+    if result ~= true then
+      self.scroll.to.y = result * self:get_scrollable_size()
+      if not config.animate_drag_scroll then
+        self:clamp_scroll_position()
+        self.scroll.y = self.scroll.to.y
+      end
+    end
+    -- hide horizontal scrollbar
+    self.h_scrollbar:on_mouse_left()
+    return true
+  end
+  ::skip_v_scrollbar::
+  result = self.h_scrollbar:on_mouse_moved(x, y, dx, dy)
+  if result then
+    if result ~= true then
+      self.scroll.to.x = result * self:get_h_scrollable_size()
+      if not config.animate_drag_scroll then
+        self:clamp_scroll_position()
+        self.scroll.x = self.scroll.to.x
+      end
+    end
+    return true
   end
-  self.hovered_scrollbar = self:scrollbar_overlaps_point(x, y)
 end
 
 
+function View:on_mouse_left()
+  if not self.scrollable then return end
+  self.v_scrollbar:on_mouse_left()
+  self.h_scrollbar:on_mouse_left()
+end
+
+
+---@param filename string
+---@param x number
+---@param y number
+---@return boolean
+function View:on_file_dropped(filename, x, y)
+  return false
+end
+
+
+---@param text string
 function View:on_text_input(text)
   -- no-op
 end
 
 
-function View:on_mouse_wheel(y)
-  if self.scrollable then
-    self.scroll.to.y = self.scroll.to.y + y * -config.mouse_wheel_scroll
-  end
+function View:on_ime_text_editing(text, start, length)
+  -- no-op
 end
 
 
+---@param y number @Vertical scroll delta; positive is "up"
+---@param x number @Horizontal scroll delta; positive is "left"
+---@return boolean @Capture event
+function View:on_mouse_wheel(y, x)
+  -- no-op
+end
+
+---Can be overriden to listen for scale change events to apply
+---any neccesary changes in sizes, padding, etc...
+---@param new_scale number
+---@param prev_scale number
+function View:on_scale_change(new_scale, prev_scale) end
+
 function View:get_content_bounds()
   local x = self.scroll.x
   local y = self.scroll.y
@@ -109,6 +247,8 @@ function View:get_content_bounds()
 end
 
 
+---@return number x
+---@return number y
 function View:get_content_offset()
   local x = common.round(self.position.x - self.scroll.x)
   local y = common.round(self.position.y - self.scroll.y)
@@ -119,33 +259,54 @@ end
 function View:clamp_scroll_position()
   local max = self:get_scrollable_size() - self.size.y
   self.scroll.to.y = common.clamp(self.scroll.to.y, 0, max)
+
+  max = self:get_h_scrollable_size() - self.size.x
+  self.scroll.to.x = common.clamp(self.scroll.to.x, 0, max)
+end
+
+
+function View:update_scrollbar()
+  local v_scrollable = self:get_scrollable_size()
+  self.v_scrollbar:set_size(self.position.x, self.position.y, self.size.x, self.size.y, v_scrollable)
+  self.v_scrollbar:set_percent(self.scroll.y/v_scrollable)
+  self.v_scrollbar:update()
+
+  local h_scrollable = self:get_h_scrollable_size()
+  self.h_scrollbar:set_size(self.position.x, self.position.y, self.size.x, self.size.y, h_scrollable)
+  self.h_scrollbar:set_percent(self.scroll.x/h_scrollable)
+  self.h_scrollbar:update()
 end
 
 
 function View:update()
+  if self.current_scale ~= SCALE then
+    self:on_scale_change(SCALE, self.current_scale)
+    self.current_scale = SCALE
+  end
+
   self:clamp_scroll_position()
-  self:move_towards(self.scroll, "x", self.scroll.to.x, 0.3)
-  self:move_towards(self.scroll, "y", self.scroll.to.y, 0.3)
+  self:move_towards(self.scroll, "x", self.scroll.to.x, 0.3, "scroll")
+  self:move_towards(self.scroll, "y", self.scroll.to.y, 0.3, "scroll")
+  if not self.scrollable then return end
+  self:update_scrollbar()
 end
 
 
+---@param color renderer.color
 function View:draw_background(color)
   local x, y = self.position.x, self.position.y
   local w, h = self.size.x, self.size.y
-  renderer.draw_rect(x, y, w + x % 1, h + y % 1, color)
+  renderer.draw_rect(x, y, w, h, color)
 end
 
 
 function View:draw_scrollbar()
-  local x, y, w, h = self:get_scrollbar_rect()
-  local highlight = self.hovered_scrollbar or self.dragging_scrollbar
-  local color = highlight and style.scrollbar2 or style.scrollbar
-  renderer.draw_rect(x, y, w, h, color)
+  self.v_scrollbar:draw()
+  self.h_scrollbar:draw()
 end
 
 
 function View:draw()
 end
 
-
 return View

data/plugins/autocomplete.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local common = require "core.common"
 local config = require "core.config"
@@ -7,44 +8,154 @@ local keymap = require "core.keymap"
 local translate = require "core.doc.translate"
 local RootView = require "core.rootview"
 local DocView = require "core.docview"
+local Doc = require "core.doc"
 
-config.autocomplete_max_suggestions = 6
+config.plugins.autocomplete = common.merge({
+  -- Amount of characters that need to be written for autocomplete
+  min_len = 3,
+  -- The max amount of visible items
+  max_height = 6,
+  -- The max amount of scrollable items
+  max_suggestions = 100,
+  -- Maximum amount of symbols to cache per document
+  max_symbols = 4000,
+  -- Font size of the description box
+  desc_font_size = 12,
+  -- The config specification used by gui generators
+  config_spec = {
+    name = "Autocomplete",
+    {
+      label = "Minimum Length",
+      description = "Amount of characters that need to be written for autocomplete to popup.",
+      path = "min_len",
+      type = "number",
+      default = 3,
+      min = 1,
+      max = 5
+    },
+    {
+      label = "Maximum Height",
+      description = "The maximum amount of visible items.",
+      path = "max_height",
+      type = "number",
+      default = 6,
+      min = 1,
+      max = 20
+    },
+    {
+      label = "Maximum Suggestions",
+      description = "The maximum amount of scrollable items.",
+      path = "max_suggestions",
+      type = "number",
+      default = 100,
+      min = 10,
+      max = 10000
+    },
+    {
+      label = "Maximum Symbols",
+      description = "Maximum amount of symbols to cache per document.",
+      path = "max_symbols",
+      type = "number",
+      default = 4000,
+      min = 1000,
+      max = 10000
+    },
+    {
+      label = "Description Font Size",
+      description = "Font size of the description box.",
+      path = "desc_font_size",
+      type = "number",
+      default = 12,
+      min = 8
+    }
+  }
+}, config.plugins.autocomplete)
 
 local autocomplete = {}
-autocomplete.map = {}
 
+autocomplete.map = {}
+autocomplete.map_manually = {}
+autocomplete.on_close = nil
+
+-- Flag that indicates if the autocomplete box was manually triggered
+-- with the autocomplete.complete() function to prevent the suggestions
+-- from getting cluttered with arbitrary document symbols by using the
+-- autocomplete.map_manually table.
+local triggered_manually = false
 
 local mt = { __tostring = function(t) return t.text end }
 
-function autocomplete.add(t)
+function autocomplete.add(t, manually_triggered)
   local items = {}
   for text, info in pairs(t.items) do
-    info = (type(info) == "string") and info
-    table.insert(items, setmetatable({ text = text, info = info }, mt))
+    if type(info) == "table" then
+      table.insert(
+        items,
+        setmetatable(
+          {
+            text = text,
+            info = info.info,
+            desc = info.desc,          -- Description shown on item selected
+            onhover = info.onhover,    -- A callback called once when item is hovered
+            onselect = info.onselect,  -- A callback called when item is selected
+            data = info.data           -- Optional data that can be used on cb
+          },
+          mt
+        )
+      )
+    else
+      info = (type(info) == "string") and info
+      table.insert(items, setmetatable({ text = text, info = info }, mt))
+    end
+  end
+
+  if not manually_triggered then
+    autocomplete.map[t.name] =  { files = t.files or ".*", items = items }
+  else
+    autocomplete.map_manually[t.name] =  { files = t.files or ".*", items = items }
   end
-  autocomplete.map[t.name] =  { files = t.files or ".*", items = items }
 end
 
-local max_symbols = config.max_symbols or 2000
+--
+-- Thread that scans open document symbols and cache them
+--
+local max_symbols = config.plugins.autocomplete.max_symbols
 
 core.add_thread(function()
   local cache = setmetatable({}, { __mode = "k" })
 
+  local function get_syntax_symbols(symbols, doc)
+    if doc.syntax then
+      for sym in pairs(doc.syntax.symbols) do
+        symbols[sym] = true
+      end
+    end
+  end
+
   local function get_symbols(doc)
-    if doc.disable_symbols then return {} end
-    local i = 1
     local s = {}
+    get_syntax_symbols(s, doc)
+    if doc.disable_symbols then return s end
+    local i = 1
     local symbols_count = 0
-    while i < #doc.lines do
+    while i <= #doc.lines do
       for sym in doc.lines[i]:gmatch(config.symbol_pattern) do
         if not s[sym] then
           symbols_count = symbols_count + 1
           if symbols_count > max_symbols then
             s = nil
             doc.disable_symbols = true
+            local filename_message
+            if doc.filename then
+              filename_message = "document " .. doc.filename
+            else
+              filename_message = "unnamed document"
+            end
             core.status_view:show_message("!", style.accent,
-              "Too many symbols in document "..doc.filename..
-              ": stopping auto-complete for this document according to config.max_symbols.")
+              "Too many symbols in "..filename_message..
+              ": stopping auto-complete for this document according to "..
+              "config.plugins.autocomplete.max_symbols."
+            )
             collectgarbage('collect')
             return {}
           end
@@ -91,6 +202,7 @@ core.add_thread(function()
       for _, doc in ipairs(core.docs) do
         if not cache_is_valid(doc) then
           valid = false
+          break
         end
       end
     end
@@ -100,24 +212,39 @@ end)
 
 
 local partial = ""
+local suggestions_offset = 1
 local suggestions_idx = 1
 local suggestions = {}
 local last_line, last_col
 
 
 local function reset_suggestions()
+  suggestions_offset = 1
   suggestions_idx = 1
   suggestions = {}
-end
 
+  triggered_manually = false
+
+  local doc = core.active_view.doc
+  if autocomplete.on_close then
+    autocomplete.on_close(doc, suggestions[suggestions_idx])
+    autocomplete.on_close = nil
+  end
+end
 
 local function update_suggestions()
   local doc = core.active_view.doc
   local filename = doc and doc.filename or ""
 
+  local map = autocomplete.map
+
+  if triggered_manually then
+    map = autocomplete.map_manually
+  end
+
   -- get all relevant suggestions for given filename
   local items = {}
-  for _, v in pairs(autocomplete.map) do
+  for _, v in pairs(map) do
     if common.match_pattern(filename, v.files) then
       for _, item in pairs(v.items) do
         table.insert(items, item)
@@ -128,16 +255,17 @@ local function update_suggestions()
   -- fuzzy match, remove duplicates and store
   items = common.fuzzy_match(items, partial)
   local j = 1
-  for i = 1, config.autocomplete_max_suggestions do
+  for i = 1, config.plugins.autocomplete.max_suggestions do
     suggestions[i] = items[j]
     while items[j] and items[i].text == items[j].text do
       items[i].info = items[i].info or items[j].info
       j = j + 1
     end
   end
+  suggestions_idx = 1
+  suggestions_offset = 1
 end
 
-
 local function get_partial_symbol()
   local doc = core.active_view.doc
   local line2, col2 = doc:get_selection()
@@ -145,44 +273,185 @@ local function get_partial_symbol()
   return doc:get_text(line1, col1, line2, col2)
 end
 
-
 local function get_active_view()
-  if getmetatable(core.active_view) == DocView then
+  if core.active_view:is(DocView) then
     return core.active_view
   end
 end
 
-
+local last_max_width = 0
 local function get_suggestions_rect(av)
   if #suggestions == 0 then
+    last_max_width = 0
     return 0, 0, 0, 0
   end
 
   local line, col = av.doc:get_selection()
-  local x, y = av:get_line_screen_position(line)
-  x = x + av:get_col_x_offset(line, col - #partial)
+  local x, y = av:get_line_screen_position(line, col - #partial)
   y = y + av:get_line_height() + style.padding.y
   local font = av:get_font()
   local th = font:get_height()
 
+  local ah = config.plugins.autocomplete.max_height
+
+  local max_items = math.min(ah, #suggestions)
+
+  local show_count = math.min(#suggestions, ah)
+  local start_index = math.max(suggestions_idx-(ah-1), 1)
+
   local max_width = 0
-  for _, s in ipairs(suggestions) do
+  for i = start_index, start_index + show_count - 1 do
+    local s = suggestions[i]
     local w = font:get_width(s.text)
     if s.info then
       w = w + style.font:get_width(s.info) + style.padding.x
     end
     max_width = math.max(max_width, w)
   end
+  max_width = math.max(last_max_width, max_width)
+  last_max_width = max_width
+
+  max_width = max_width + style.padding.x * 2
+  x = x - style.padding.x
+
+  -- additional line to display total items
+  max_items = max_items + 1
+
+  if max_width > core.root_view.size.x then
+    max_width = core.root_view.size.x
+  end
+  if max_width < 150 * SCALE then
+    max_width = 150 * SCALE
+  end
+
+  -- if portion not visiable to right, reposition to DocView right margin
+  if x + max_width > core.root_view.size.x then
+    x = (av.size.x + av.position.x) - max_width
+  end
 
   return
-    x - style.padding.x,
+    x,
     y - style.padding.y,
-    max_width + style.padding.x * 2,
-    #suggestions * (th + style.padding.y) + style.padding.y
+    max_width,
+    max_items * (th + style.padding.y) + style.padding.y
 end
 
+local function wrap_line(line, max_chars)
+  if #line > max_chars then
+    local lines = {}
+    local line_len = #line
+    local new_line = ""
+    local prev_char = ""
+    local position = 0
+    local indent = line:match("^%s+")
+    for char in line:gmatch(".") do
+      position = position + 1
+      if #new_line < max_chars then
+        new_line = new_line .. char
+        prev_char = char
+        if position >= line_len then
+          table.insert(lines, new_line)
+        end
+      else
+        if
+          not prev_char:match("%s")
+          and
+          not string.sub(line, position+1, 1):match("%s")
+          and
+          position < line_len
+        then
+          new_line = new_line .. "-"
+        end
+        table.insert(lines, new_line)
+        if indent then
+          new_line = indent .. char
+        else
+          new_line = char
+        end
+      end
+    end
+    return lines
+  end
+  return line
+end
+
+local previous_scale = SCALE
+local desc_font = style.code_font:copy(
+  config.plugins.autocomplete.desc_font_size * SCALE
+)
+local function draw_description_box(text, av, sx, sy, sw, sh)
+  if previous_scale ~= SCALE then
+    desc_font = style.code_font:copy(
+      config.plugins.autocomplete.desc_font_size * SCALE
+    )
+    previous_scale = SCALE
+  end
+
+  local font = desc_font
+  local lh = font:get_height()
+  local y = sy + style.padding.y
+  local x = sx + sw + style.padding.x / 4
+  local width = 0
+  local char_width = font:get_width(" ")
+  local draw_left = false;
+
+  local max_chars = 0
+  if sx - av.position.x < av.size.x - (sx - av.position.x) - sw then
+    max_chars = (((av.size.x+av.position.x) - x) / char_width) - 5
+  else
+    draw_left = true;
+    max_chars = (
+      (sx - av.position.x - (style.padding.x / 4) - style.scrollbar_size)
+      / char_width
+    ) - 5
+  end
+
+  local lines = {}
+  for line in string.gmatch(text.."\n", "(.-)\n") do
+    local wrapper_lines = wrap_line(line, max_chars)
+    if type(wrapper_lines) == "table" then
+      for _, wrapped_line in pairs(wrapper_lines) do
+        width = math.max(width, font:get_width(wrapped_line))
+        table.insert(lines, wrapped_line)
+      end
+    else
+      width = math.max(width, font:get_width(line))
+      table.insert(lines, line)
+    end
+  end
+
+  if draw_left then
+    x = sx - (style.padding.x / 4) - width - (style.padding.x * 2)
+  end
+
+  local height = #lines * font:get_height()
+
+  -- draw background rect
+  renderer.draw_rect(
+    x,
+    sy,
+    width + style.padding.x * 2,
+    height + style.padding.y * 2,
+    style.background3
+  )
+
+  -- draw text
+  for _, line in pairs(lines) do
+    common.draw_text(
+      font, style.text, line, "left",
+      x + style.padding.x, y, width, lh
+    )
+    y = y + lh
+  end
+end
 
 local function draw_suggestions_box(av)
+  if #suggestions <= 0 then
+    return
+  end
+
+  local ah = config.plugins.autocomplete.max_height
+
   -- draw background rect
   local rx, ry, rw, rh = get_suggestions_rect(av)
   renderer.draw_rect(rx, ry, rw, rh, style.background3)
@@ -191,34 +460,82 @@ local function draw_suggestions_box(av)
   local font = av:get_font()
   local lh = font:get_height() + style.padding.y
   local y = ry + style.padding.y / 2
-  for i, s in ipairs(suggestions) do
+  local show_count = math.min(#suggestions, ah)
+  local start_index = suggestions_offset
+
+  for i=start_index, start_index+show_count-1, 1 do
+    if not suggestions[i] then
+      break
+    end
+    local s = suggestions[i]
+
+    local info_size = s.info and (style.font:get_width(s.info) + style.padding.x) or style.padding.x
+
     local color = (i == suggestions_idx) and style.accent or style.text
-    common.draw_text(font, color, s.text, "left", rx + style.padding.x, y, rw, lh)
+    -- Push clip to avoid that the suggestion text gets drawn over suggestion type/icon
+    core.push_clip_rect(rx + style.padding.x, y, rw - info_size - style.padding.x, lh)
+    local x_adv = common.draw_text(font, color, s.text, "left", rx + style.padding.x, y, rw, lh)
+    core.pop_clip_rect()
+    -- If the text wasn't fully visible, draw an ellipsis
+    if x_adv > rx + rw - info_size then
+      local ellipsis_size = font:get_width("…")
+      local ell_x = rx + rw - info_size - ellipsis_size
+      renderer.draw_rect(ell_x, y, ellipsis_size, lh, style.background3)
+      common.draw_text(font, color, "…", "left", ell_x, y, ellipsis_size, lh)
+    end
     if s.info then
       color = (i == suggestions_idx) and style.text or style.dim
       common.draw_text(style.font, color, s.info, "right", rx, y, rw - style.padding.x, lh)
     end
     y = y + lh
+    if suggestions_idx == i then
+      if s.onhover then
+        s.onhover(suggestions_idx, s)
+        s.onhover = nil
+      end
+      if s.desc and #s.desc > 0 then
+        draw_description_box(s.desc, av, rx, ry, rw, rh)
+      end
+    end
   end
+
+  renderer.draw_rect(rx, y, rw, 2, style.caret)
+  renderer.draw_rect(rx, y+2, rw, lh, style.background)
+  common.draw_text(
+    style.font,
+    style.accent,
+    "Items",
+    "left",
+    rx + style.padding.x, y, rw, lh
+  )
+  common.draw_text(
+    style.font,
+    style.accent,
+    tostring(suggestions_idx) .. "/" .. tostring(#suggestions),
+    "right",
+    rx, y, rw - style.padding.x, lh
+  )
 end
 
-
--- patch event logic into RootView
-local on_text_input = RootView.on_text_input
-local update = RootView.update
-local draw = RootView.draw
-
-
-RootView.on_text_input = function(...)
-  on_text_input(...)
-
+local function show_autocomplete()
   local av = get_active_view()
   if av then
     -- update partial symbol and suggestions
     partial = get_partial_symbol()
-    if #partial >= 3 then
+
+    if #partial >= config.plugins.autocomplete.min_len or triggered_manually then
       update_suggestions()
-      last_line, last_col = av.doc:get_selection()
+
+      if not triggered_manually then
+        last_line, last_col = av.doc:get_selection()
+      else
+        local line, col = av.doc:get_selection()
+        local char = av.doc:get_char(line, col-1, line, col-1)
+
+        if char:match("%s") or (char:match("%p") and col ~= last_col) then
+          reset_suggestions()
+        end
+      end
     else
       reset_suggestions()
     end
@@ -232,6 +549,30 @@ RootView.on_text_input = function(...)
   end
 end
 
+--
+-- Patch event logic into RootView and Doc
+--
+local on_text_input = RootView.on_text_input
+local on_text_remove = Doc.remove
+local update = RootView.update
+local draw = RootView.draw
+
+RootView.on_text_input = function(...)
+  on_text_input(...)
+  show_autocomplete()
+end
+
+Doc.remove = function(self, line1, col1, line2, col2)
+  on_text_remove(self, line1, col1, line2, col2)
+
+  if triggered_manually and line1 == line2 then
+    if last_col >= col1 then
+      reset_suggestions()
+    else
+      show_autocomplete()
+    end
+  end
+end
 
 RootView.update = function(...)
   update(...)
@@ -240,13 +581,19 @@ RootView.update = function(...)
   if av then
     -- reset suggestions if caret was moved
     local line, col = av.doc:get_selection()
-    if line ~= last_line or col ~= last_col then
-      reset_suggestions()
+
+    if not triggered_manually then
+      if line ~= last_line or col ~= last_col then
+        reset_suggestions()
+      end
+    else
+      if line ~= last_line or col < last_col then
+        reset_suggestions()
+      end
     end
   end
 end
 
-
 RootView.draw = function(...)
   draw(...)
 
@@ -257,29 +604,114 @@ RootView.draw = function(...)
   end
 end
 
+--
+-- Public functions
+--
+function autocomplete.open(on_close)
+  triggered_manually = true
 
-local function predicate()
-  return get_active_view() and #suggestions > 0
+  if on_close then
+    autocomplete.on_close = on_close
+  end
+
+  local av = get_active_view()
+  if av then
+    partial = get_partial_symbol()
+    last_line, last_col = av.doc:get_selection()
+    update_suggestions()
+  end
+end
+
+function autocomplete.close()
+  reset_suggestions()
+end
+
+function autocomplete.is_open()
+  return #suggestions > 0
+end
+
+function autocomplete.complete(completions, on_close)
+  reset_suggestions()
+
+  autocomplete.map_manually = {}
+  autocomplete.add(completions, true)
+
+  autocomplete.open(on_close)
+end
+
+function autocomplete.can_complete()
+  if #partial >= config.plugins.autocomplete.min_len then
+    return true
+  end
+  return false
 end
 
 
+--
+-- Commands
+--
+local function predicate()
+  local active_docview = get_active_view()
+  return active_docview and #suggestions > 0, active_docview
+end
+
 command.add(predicate, {
-  ["autocomplete:complete"] = function()
-    local doc = core.active_view.doc
-    local line, col = doc:get_selection()
-    local text = suggestions[suggestions_idx].text
-    doc:insert(line, col, text)
-    doc:remove(line, col, line, col - #partial)
-    doc:set_selection(line, col + #text - #partial)
+  ["autocomplete:complete"] = function(dv)
+    local doc = dv.doc
+    local item = suggestions[suggestions_idx]
+    local text = item.text
+    local inserted = false
+    if item.onselect then
+      inserted = item.onselect(suggestions_idx, item)
+    end
+    if not inserted then
+      local current_partial = get_partial_symbol()
+      local sz = #current_partial
+
+      for _, line1, col1, line2, _ in doc:get_selections(true) do
+        local n = col1 - 1
+        local line = doc.lines[line1]
+        for i = 1, sz + 1 do
+          local j = sz - i
+          local subline = line:sub(n - j, n)
+          local subpartial = current_partial:sub(i, -1)
+          if subpartial == subline then
+            doc:remove(line1, col1, line2, n - j)
+            break
+          end
+        end
+      end
+
+      doc:text_input(item.text)
+    end
     reset_suggestions()
   end,
 
   ["autocomplete:previous"] = function()
-    suggestions_idx = math.max(suggestions_idx - 1, 1)
+    suggestions_idx = (suggestions_idx - 2) % #suggestions + 1
+
+    local ah = math.min(config.plugins.autocomplete.max_height, #suggestions)
+    if suggestions_offset > suggestions_idx then
+      suggestions_offset = suggestions_idx
+    elseif suggestions_offset + ah < suggestions_idx + 1 then
+      suggestions_offset = suggestions_idx - ah + 1
+    end
   end,
 
   ["autocomplete:next"] = function()
-    suggestions_idx = math.min(suggestions_idx + 1, #suggestions)
+    suggestions_idx = (suggestions_idx % #suggestions) + 1
+
+    local ah = math.min(config.plugins.autocomplete.max_height, #suggestions)
+    if suggestions_offset + ah < suggestions_idx + 1 then
+      suggestions_offset = suggestions_idx - ah + 1
+    elseif suggestions_offset > suggestions_idx then
+      suggestions_offset = suggestions_idx
+    end
+  end,
+
+  ["autocomplete:cycle"] = function()
+    local newidx = suggestions_idx + 1
+    suggestions_idx = newidx > #suggestions and 1 or newidx
   end,
 
   ["autocomplete:cancel"] = function()
@@ -287,7 +719,9 @@ command.add(predicate, {
   end,
 })
 
-
+--
+-- Keymaps
+--
 keymap.add {
   ["tab"]    = "autocomplete:complete",
   ["up"]     = "autocomplete:previous",

data/plugins/autoreload.lua

@@ -1,49 +1,137 @@
+-- mod-version:3
 local core = require "core"
 local config = require "core.config"
 local Doc = require "core.doc"
+local Node = require "core.node"
+local common = require "core.common"
+local dirwatch = require "core.dirwatch"
 
+config.plugins.autoreload = common.merge({
+  always_show_nagview = false,
+  config_spec = {
+    name = "Autoreload",
+    {
+      label = "Always Show Nagview",
+      description = "Alerts you if an opened file changes externally even if you haven't modified it.",
+      path = "always_show_nagview",
+      type = "toggle",
+      default = false
+    }
+  }
+}, config.plugins.autoreload)
 
+local watch = dirwatch.new()
 local times = setmetatable({}, { __mode = "k" })
+local visible = setmetatable({}, { __mode = "k" })
 
-local function update_time(doc)
-  local info = system.get_file_info(doc.filename)
-  times[doc] = info.modified
+local function get_project_doc_watch(doc)
+  for _, v in ipairs(core.project_directories) do
+    if doc.abs_filename:find(v.name, 1, true) == 1 then return v.watch end
+  end
+  return watch
 end
 
+local function update_time(doc)
+  times[doc] = system.get_file_info(doc.filename).modified
+end
 
 local function reload_doc(doc)
-  local fp = io.open(doc.filename, "r")
-  local text = fp:read("*a")
-  fp:close()
-
-  local sel = { doc:get_selection() }
-  doc:remove(1, 1, math.huge, math.huge)
-  doc:insert(1, 1, text:gsub("\r", ""):gsub("\n$", ""))
-  doc:set_selection(table.unpack(sel))
-
+  doc:reload()
   update_time(doc)
-  doc:clean()
+  core.redraw = true
   core.log_quiet("Auto-reloaded doc \"%s\"", doc.filename)
 end
 
 
+local timers = setmetatable({}, { __mode = "k" })
+
+local function delayed_reload(doc, mtime)
+  if timers[doc] then
+    -- If mtime remains the same, there's no need to restart the timer
+    -- as we're waiting a full second anyways.
+    if not mtime or timers[doc].mtime ~= mtime then
+      timers[doc] = { last_trigger = system.get_time(), mtime = mtime }
+    end
+    return
+  end
+
+  timers[doc] = { last_trigger = system.get_time(), mtime = mtime }
+  core.add_thread(function()
+    local diff = system.get_time() - timers[doc].last_trigger
+    -- Wait a second before triggering a reload because we're using mtime
+    -- to determine if a file has changed, and on many systems it has a
+    -- resolution of 1 second.
+    while diff < 1 do
+      coroutine.yield(diff)
+      diff = system.get_time() - timers[doc].last_trigger
+    end
+    timers[doc] = nil
+    reload_doc(doc)
+  end)
+end
+
+local function check_prompt_reload(doc)
+  if doc and doc.deferred_reload then
+    core.nag_view:show("File Changed", doc.filename .. " has changed. Reload this file?", {
+      { text = "Yes", default_yes = true },
+      { text = "No", default_no = true }
+    }, function(item)
+      if item.text == "Yes" then reload_doc(doc) end
+      doc.deferred_reload = false
+    end)
+  end
+end
+
+local function doc_changes_visiblity(doc, visibility)
+  if doc and visible[doc] ~= visibility and doc.abs_filename then
+    visible[doc] = visibility
+    if visibility then check_prompt_reload(doc) end
+    get_project_doc_watch(doc):watch(doc.abs_filename, visibility)
+  end
+end
+
+local on_check = dirwatch.check
+function dirwatch:check(change_callback, ...)
+  on_check(self, function(dir)
+    for _, doc in ipairs(core.docs) do
+      if doc.abs_filename and (dir == common.dirname(doc.abs_filename) or dir == doc.abs_filename) then
+        local info = system.get_file_info(doc.filename or "")
+        if info and info.type == "file" and times[doc] ~= info.modified then
+          if not doc:is_dirty() and not config.plugins.autoreload.always_show_nagview then
+            delayed_reload(doc, info.modified)
+          else
+            doc.deferred_reload = true
+            if doc == core.active_view.doc then check_prompt_reload(doc) end
+          end
+        end
+      end
+    end
+    change_callback(dir)
+  end, ...)
+end
+
+local core_set_active_view = core.set_active_view
+function core.set_active_view(view)
+  core_set_active_view(view)
+  doc_changes_visiblity(view.doc, true)
+end
+
+local node_set_active_view = Node.set_active_view
+function Node:set_active_view(view)
+  if self.active_view then doc_changes_visiblity(self.active_view.doc, false) end
+  node_set_active_view(self, view)
+  doc_changes_visiblity(self.active_view.doc, true)
+end
+
 core.add_thread(function()
   while true do
-    -- check all doc modified times
-    for _, doc in ipairs(core.docs) do
-      local info = system.get_file_info(doc.filename or "")
-      if info and times[doc] ~= info.modified then
-        reload_doc(doc)
-      end
-      coroutine.yield()
-    end
-
-    -- wait for next scan
-    coroutine.yield(config.project_scan_rate)
+    -- because we already hook this function above; we only
+    -- need to check the file.
+    watch:check(function() end)
+    coroutine.yield(0.05)
   end
 end)
 
-
 -- patch `Doc.save|load` to store modified time
 local load = Doc.load
 local save = Doc.save
@@ -56,6 +144,8 @@ end
 
 Doc.save = function(self, ...)
   local res = save(self, ...)
+  -- if starting with an unsaved document with a filename.
+  if not times[self] then get_project_doc_watch(self):watch(self.abs_filename, true) end
   update_time(self)
   return res
 end

data/plugins/contextmenu.lua

@@ -0,0 +1,85 @@
+-- mod-version:3
+local core = require "core"
+local command = require "core.command"
+local keymap = require "core.keymap"
+local ContextMenu = require "core.contextmenu"
+local RootView = require "core.rootview"
+local config = require "core.config"
+
+local menu = ContextMenu()
+local on_view_mouse_pressed = RootView.on_view_mouse_pressed
+local on_mouse_moved = RootView.on_mouse_moved
+local root_view_update = RootView.update
+local root_view_draw = RootView.draw
+
+function RootView:on_mouse_moved(...)
+  if menu:on_mouse_moved(...) then return end
+  on_mouse_moved(self, ...)
+end
+
+function RootView.on_view_mouse_pressed(button, x, y, clicks)
+  -- We give the priority to the menu to process mouse pressed events.
+  local handled = menu:on_mouse_pressed(button, x, y, clicks)
+  return handled or on_view_mouse_pressed(button, x, y, clicks)
+end
+
+function RootView:update(...)
+  root_view_update(self, ...)
+  menu:update()
+end
+
+function RootView:draw(...)
+  root_view_draw(self, ...)
+  menu:draw()
+end
+
+command.add("core.docview!", {
+  ["context:show"] = function(dv)
+    menu:show(dv.position.x, dv.position.y)
+  end
+})
+
+keymap.add {
+  ["menu"] = "context:show"
+}
+
+command.add(function() return menu.show_context_menu == true end, {
+  ["context:focus-previous"] = function()
+    menu:focus_previous()
+  end,
+  ["context:focus-next"] = function()
+    menu:focus_next()
+  end,
+  ["context:hide"] = function()
+    menu:hide()
+  end,
+  ["context:on-selected"] = function()
+    menu:call_selected_item()
+  end,
+})
+keymap.add { ["return"] = "context:on-selected" }
+keymap.add { ["up"] = "context:focus-previous" }
+keymap.add { ["down"] = "context:focus-next" }
+keymap.add { ["escape"] = "context:hide" }
+
+
+local cmds = {
+  { text = "Cut",     command = "doc:cut" },
+  { text = "Copy",    command = "doc:copy" },
+  { text = "Paste",   command = "doc:paste" },
+  ContextMenu.DIVIDER,
+  { text = "Find",    command = "find-replace:find"    },
+  { text = "Replace", command = "find-replace:replace" }
+}
+
+if config.plugins.scale ~= false and require("plugins.scale") then
+  table.move(cmds, 4, 6, 7)
+  cmds[4] = { text = "Font +",     command = "scale:increase" }
+  cmds[5] = { text = "Font -",     command = "scale:decrease" }
+  cmds[6] = { text = "Font Reset", command = "scale:reset"    }
+end
+
+menu:register("core.docview", cmds)
+
+
+return menu

data/plugins/detectindent.lua

@@ -0,0 +1,372 @@
+-- mod-version:3
+local core = require "core"
+local command = require "core.command"
+local common = require "core.common"
+local config = require "core.config"
+local core_syntax = require "core.syntax"
+local DocView = require "core.docview"
+local Doc = require "core.doc"
+
+local cache = setmetatable({}, { __mode = "k" })
+local comments_cache = {}
+local auto_detect_max_lines = 150
+
+
+local function indent_occurrences_more_than_once(stat, idx)
+  if stat[idx-1] and stat[idx-1] == stat[idx] then
+    return true
+  elseif stat[idx+1] and stat[idx+1] == stat[idx] then
+    return true
+  end
+  return false
+end
+
+
+local function optimal_indent_from_stat(stat)
+  if #stat == 0 then return nil, 0 end
+  table.sort(stat, function(a, b) return a > b end)
+  local best_indent = 0
+  local best_score = 0
+  local count = #stat
+  for x=1, count do
+    local indent = stat[x]
+    local score = 0
+    for y=1, count do
+      if y ~= x and stat[y] % indent == 0 then
+        score = score + 1
+      elseif
+        indent > stat[y]
+        and
+        indent_occurrences_more_than_once(stat, y)
+      then
+        score = 0
+        break
+      end
+    end
+    if score > best_score then
+      best_indent = indent
+      best_score = score
+    end
+    if score > 0 then
+      break
+    end
+  end
+  return best_score > 0 and best_indent or nil, best_score
+end
+
+
+local function escape_comment_tokens(token)
+  local special_chars = "*-%[].()+?^$"
+  local escaped = ""
+  for x=1, token:len() do
+    local found = false
+    for y=1, special_chars:len() do
+      if token:sub(x, x) == special_chars:sub(y, y) then
+        escaped = escaped .. "%" .. token:sub(x, x)
+        found = true
+        break
+      end
+    end
+    if not found then
+      escaped = escaped .. token:sub(x, x)
+    end
+  end
+  return escaped
+end
+
+
+local function get_comment_patterns(syntax, _loop)
+  _loop = _loop or 1
+  if _loop > 5 then return end
+  if comments_cache[syntax] then
+    if #comments_cache[syntax] > 0 then
+      return comments_cache[syntax]
+    else
+      return nil
+    end
+  end
+  local comments = {}
+  for idx=1, #syntax.patterns do
+    local pattern = syntax.patterns[idx]
+    local startp = ""
+    if
+      type(pattern.type) == "string"
+      and
+      (pattern.type == "comment" or pattern.type == "string")
+    then
+      local not_is_string = pattern.type ~= "string"
+      if pattern.pattern then
+        startp = type(pattern.pattern) == "table"
+          and pattern.pattern[1] or pattern.pattern
+        if not_is_string and startp:sub(1, 1) ~= "^" then
+          startp = "^%s*" .. startp
+        elseif not_is_string then
+          startp = "^%s*" .. startp:sub(2, startp:len())
+        end
+        if type(pattern.pattern) == "table" then
+          table.insert(comments, {"p", startp, pattern.pattern[2]})
+        elseif not_is_string then
+          table.insert(comments, {"p", startp})
+        end
+      elseif pattern.regex then
+        startp = type(pattern.regex) == "table"
+          and pattern.regex[1] or pattern.regex
+        if not_is_string and startp:sub(1, 1) ~= "^" then
+          startp = "^\\s*" .. startp
+        elseif not_is_string then
+          startp = "^\\s*" .. startp:sub(2, startp:len())
+        end
+        if type(pattern.regex) == "table" then
+          table.insert(comments, {
+            "r", regex.compile(startp), regex.compile(pattern.regex[2])
+          })
+        elseif not_is_string then
+          table.insert(comments, {"r", regex.compile(startp)})
+        end
+      end
+    elseif pattern.syntax then
+      local subsyntax = type(pattern.syntax) == 'table' and pattern.syntax
+        or core_syntax.get("file"..pattern.syntax, "")
+      local sub_comments = get_comment_patterns(subsyntax, _loop + 1)
+      if sub_comments then
+        for s=1, #sub_comments do
+          table.insert(comments, sub_comments[s])
+        end
+      end
+    end
+  end
+  if #comments == 0 then
+    local single_line_comment = syntax.comment
+      and escape_comment_tokens(syntax.comment) or nil
+    local block_comment = nil
+    if syntax.block_comment then
+      block_comment = {
+        escape_comment_tokens(syntax.block_comment[1]),
+        escape_comment_tokens(syntax.block_comment[2])
+      }
+    end
+    if single_line_comment then
+      table.insert(comments, {"p", "^%s*" .. single_line_comment})
+    end
+    if block_comment then
+      table.insert(comments, {"p", "^%s*" .. block_comment[1], block_comment[2]})
+    end
+  end
+  comments_cache[syntax] = comments
+  if #comments > 0 then
+    return comments
+  end
+  return nil
+end
+
+
+local function get_non_empty_lines(syntax, lines)
+  return coroutine.wrap(function()
+    local comments = get_comment_patterns(syntax)
+
+    local i = 0
+    local end_regex = nil
+    local end_pattern = nil
+    local inside_comment = false
+    for _, line in ipairs(lines) do
+      if line:gsub("^%s+", "") ~= "" then
+        local is_comment = false
+        if comments then
+          if not inside_comment then
+            for c=1, #comments do
+              local comment = comments[c]
+              if comment[1] == "p" then
+                if comment[3] then
+                  local start, ending = line:find(comment[2])
+                  if start then
+                    if not line:find(comment[3], ending+1) then
+                      is_comment = true
+                      inside_comment = true
+                      end_pattern = comment[3]
+                    end
+                    break
+                  end
+                elseif line:find(comment[2]) then
+                  is_comment = true
+                  break
+                end
+              else
+                if comment[3] then
+                  local start, ending = regex.find_offsets(
+                    comment[2], line, 1, regex.ANCHORED
+                  )
+                  if start then
+                    if not regex.find_offsets(
+                        comment[3], line, ending+1, regex.ANCHORED
+                      )
+                    then
+                      is_comment = true
+                      inside_comment = true
+                      end_regex = comment[3]
+                    end
+                    break
+                  end
+                elseif regex.find_offsets(comment[2], line, 1, regex.ANCHORED) then
+                  is_comment = true
+                  break
+                end
+              end
+            end
+          elseif end_pattern and line:find(end_pattern) then
+            is_comment = true
+            inside_comment = false
+            end_pattern = nil
+          elseif end_regex and regex.find_offsets(end_regex, line) then
+            is_comment = true
+            inside_comment = false
+            end_regex = nil
+          end
+        end
+        if
+          not is_comment
+          and
+          not inside_comment
+        then
+          i = i + 1
+          coroutine.yield(i, line)
+        end
+      end
+    end
+  end)
+end
+
+
+local function detect_indent_stat(doc)
+  local stat = {}
+  local tab_count = 0
+  local runs = 1
+  local max_lines = auto_detect_max_lines
+  for i, text in get_non_empty_lines(doc.syntax, doc.lines) do
+    local spaces = text:match("^ +")
+    if spaces and #spaces > 1 then table.insert(stat, #spaces) end
+    local tabs = text:match("^\t+")
+    if tabs then tab_count = tab_count + 1 end
+    -- if nothing found for first lines try at least 4 more times
+    if i == max_lines and runs < 5 and #stat == 0 and tab_count == 0 then
+      max_lines = max_lines + auto_detect_max_lines
+      runs = runs + 1
+    -- Stop parsing when files is very long. Not needed for euristic determination.
+    elseif i > max_lines then break end
+  end
+  local indent, score = optimal_indent_from_stat(stat)
+  if tab_count > score then
+    return "hard", config.indent_size, tab_count
+  else
+    return "soft", indent or config.indent_size, score or 0
+  end
+end
+
+
+local function update_cache(doc)
+  local type, size, score = detect_indent_stat(doc)
+  local score_threshold = 2
+  if score < score_threshold then
+    -- use default values
+    type = config.tab_type
+    size = config.indent_size
+  end
+  cache[doc] = { type = type, size = size, confirmed = (score >= score_threshold) }
+  doc.indent_info = cache[doc]
+end
+
+
+local new = Doc.new
+function Doc:new(...)
+  new(self, ...)
+  update_cache(self)
+end
+
+local clean = Doc.clean
+function Doc:clean(...)
+  clean(self, ...)
+  local _, _, confirmed = self:get_indent_info()
+  if not confirmed then
+    update_cache(self)
+  end
+end
+
+
+local function set_indent_type(doc, type)
+  local _, indent_size = doc:get_indent_info()
+  cache[doc] = {
+    type = type,
+    size = indent_size,
+    confirmed = true
+  }
+  doc.indent_info = cache[doc]
+end
+
+local function set_indent_type_command(dv)
+  core.command_view:enter("Specify indent style for this file", {
+    submit = function(value)
+      local doc = dv.doc
+      value = value:lower()
+      set_indent_type(doc, value == "tabs" and "hard" or "soft")
+    end,
+    suggest = function(text)
+      return common.fuzzy_match({"tabs", "spaces"}, text)
+    end,
+    validate = function(text)
+      local t = text:lower()
+      return t == "tabs" or t == "spaces"
+    end
+  })
+end
+
+
+local function set_indent_size(doc, size)
+  local indent_type = doc:get_indent_info()
+  cache[doc] = {
+    type = indent_type,
+    size = size,
+    confirmed = true
+  }
+  doc.indent_info = cache[doc]
+end
+
+local function set_indent_size_command(dv)
+  core.command_view:enter("Specify indent size for current file", {
+    submit = function(value)
+      value = math.floor(tonumber(value))
+      local doc = dv.doc
+      set_indent_size(doc, value)
+    end,
+    validate = function(value)
+      value = tonumber(value)
+      return value ~= nil and value >= 1
+    end
+  })
+end
+
+
+command.add("core.docview", {
+  ["indent:set-file-indent-type"] = set_indent_type_command,
+  ["indent:set-file-indent-size"] = set_indent_size_command
+})
+
+command.add(
+  function()
+    return core.active_view:is(DocView)
+      and cache[core.active_view.doc]
+      and cache[core.active_view.doc].type == "soft"
+  end, {
+  ["indent:switch-file-to-tabs-indentation"] = function()
+    set_indent_type(core.active_view.doc, "hard")
+  end
+})
+
+command.add(
+  function()
+    return core.active_view:is(DocView)
+      and cache[core.active_view.doc]
+      and cache[core.active_view.doc].type == "hard"
+  end, {
+  ["indent:switch-file-to-spaces-indentation"] = function()
+    set_indent_type(core.active_view.doc, "soft")
+  end
+})

data/plugins/drawwhitespace.lua

@@ -0,0 +1,321 @@
+-- mod-version:3
+
+local style = require "core.style"
+local DocView = require "core.docview"
+local common = require "core.common"
+local command = require "core.command"
+local config = require "core.config"
+local Highlighter = require "core.doc.highlighter"
+
+config.plugins.drawwhitespace = common.merge({
+  enabled = false,
+  show_leading = true,
+  show_trailing = true,
+  show_middle = true,
+
+  show_middle_min = 1,
+
+  color = style.syntax.whitespace or style.syntax.comment,
+  leading_color = nil,
+  middle_color = nil,
+  trailing_color = nil,
+
+  substitutions = {
+    {
+      char = " ",
+      sub = "·",
+      -- You can put any of the previous options here too.
+      -- For example:
+      -- show_middle_min = 2,
+      -- show_leading = false,
+    },
+    {
+      char = "\t",
+      sub = "»",
+    },
+  },
+
+  config_spec = {
+    name = "Draw Whitespace",
+    {
+      label = "Enabled",
+      description = "Disable or enable the drawing of white spaces.",
+      path = "enabled",
+      type = "toggle",
+      default = false
+    },
+    {
+      label = "Show Leading",
+      description = "Draw whitespaces starting at the beginning of a line.",
+      path = "show_leading",
+      type = "toggle",
+      default = true,
+    },
+    {
+      label = "Show Middle",
+      description = "Draw whitespaces on the middle of a line.",
+      path = "show_middle",
+      type = "toggle",
+      default = true,
+    },
+    {
+      label = "Show Trailing",
+      description = "Draw whitespaces on the end of a line.",
+      path = "show_trailing",
+      type = "toggle",
+      default = true,
+    },
+    {
+      label = "Show Trailing as Error",
+      description = "Uses an error square to spot them easily, requires 'Show Trailing' enabled.",
+      path = "show_trailing_error",
+      type = "toggle",
+      default = false,
+      on_apply = function(enabled)
+        local found = nil
+        local substitutions = config.plugins.drawwhitespace.substitutions
+        for i, sub in ipairs(substitutions) do
+          if sub.trailing_error then
+            found = i
+          end
+        end
+        if found == nil and enabled then
+          table.insert(substitutions, {
+            char = " ",
+            sub = "█",
+            show_leading = false,
+            show_middle = false,
+            show_trailing = true,
+            trailing_color = style.error,
+            trailing_error = true
+          })
+        elseif found ~= nil and not enabled then
+          table.remove(substitutions, found)
+        end
+      end
+    }
+  }
+}, config.plugins.drawwhitespace)
+
+
+local ws_cache
+local cached_settings
+local function reset_cache()
+  ws_cache = setmetatable({}, { __mode = "k" })
+  local settings = config.plugins.drawwhitespace
+  cached_settings = {
+    show_leading = settings.show_leading,
+    show_trailing = settings.show_trailing,
+    show_middle = settings.show_middle,
+    show_middle_min = settings.show_middle_min,
+    color = settings.color,
+    leading_color = settings.leading_color,
+    middle_color = settings.middle_color,
+    trailing_color = settings.trailing_color,
+    substitutions = settings.substitutions,
+  }
+end
+reset_cache()
+
+local function reset_cache_if_needed()
+  local settings = config.plugins.drawwhitespace
+  if
+    not ws_cache or
+    cached_settings.show_leading       ~= settings.show_leading
+    or cached_settings.show_trailing   ~= settings.show_trailing
+    or cached_settings.show_middle     ~= settings.show_middle
+    or cached_settings.show_middle_min ~= settings.show_middle_min
+    or cached_settings.color           ~= settings.color
+    or cached_settings.leading_color   ~= settings.leading_color
+    or cached_settings.middle_color    ~= settings.middle_color
+    or cached_settings.trailing_color  ~= settings.trailing_color
+    -- we assume that the entire table changes
+    or cached_settings.substitutions   ~= settings.substitutions
+  then
+    reset_cache()
+  end
+end
+
+-- Move cache to make space for new lines
+local prev_insert_notify = Highlighter.insert_notify
+function Highlighter:insert_notify(line, n, ...)
+  prev_insert_notify(self, line, n, ...)
+  if not ws_cache[self] then
+    ws_cache[self] = {}
+  end
+  local to = math.min(line + n, #self.doc.lines)
+  for i=#self.doc.lines+n,to,-1 do
+    ws_cache[self][i] = ws_cache[self][i - n]
+  end
+  for i=line,to do
+    ws_cache[self][i] = nil
+  end
+end
+
+-- Close the cache gap created by removed lines
+local prev_remove_notify = Highlighter.remove_notify
+function Highlighter:remove_notify(line, n, ...)
+  prev_remove_notify(self, line, n, ...)
+  if not ws_cache[self] then
+    ws_cache[self] = {}
+  end
+  local to = math.max(line + n, #self.doc.lines)
+  for i=line,to do
+    ws_cache[self][i] = ws_cache[self][i + n]
+  end
+end
+
+-- Remove changed lines from the cache
+local prev_update_notify = Highlighter.update_notify
+function Highlighter:update_notify(line, n, ...)
+  prev_update_notify(self, line, n, ...)
+  if not ws_cache[self] then
+    ws_cache[self] = {}
+  end
+  for i=line,line+n do
+    ws_cache[self][i] = nil
+  end
+end
+
+
+local function get_option(substitution, option)
+  if substitution[option] == nil then
+    return config.plugins.drawwhitespace[option]
+  end
+  return substitution[option]
+end
+
+local draw_line_text = DocView.draw_line_text
+function DocView:draw_line_text(idx, x, y)
+  if
+    not config.plugins.drawwhitespace.enabled
+    or
+    getmetatable(self) ~= DocView
+  then
+    return draw_line_text(self, idx, x, y)
+  end
+
+  local font = (self:get_font() or style.syntax_fonts["whitespace"] or style.syntax_fonts["comment"])
+  local font_size = font:get_size()
+  local _, indent_size = self.doc:get_indent_info()
+
+  reset_cache_if_needed()
+  if
+    not ws_cache[self.doc.highlighter]
+    or ws_cache[self.doc.highlighter].font ~= font
+    or ws_cache[self.doc.highlighter].font_size ~= font_size
+    or ws_cache[self.doc.highlighter].indent_size ~= indent_size
+  then
+    ws_cache[self.doc.highlighter] =
+      setmetatable(
+        { font = font, font_size = font_size, indent_size = indent_size },
+        { __mode = "k" }
+      )
+  end
+
+  if not ws_cache[self.doc.highlighter][idx] then -- need to cache line
+    local cache = {}
+
+    local tx
+    local text = self.doc.lines[idx]
+
+    for _, substitution in pairs(config.plugins.drawwhitespace.substitutions) do
+      local char = substitution.char
+      local sub = substitution.sub
+      local offset = 1
+
+      local show_leading = get_option(substitution, "show_leading")
+      local show_middle = get_option(substitution, "show_middle")
+      local show_trailing = get_option(substitution, "show_trailing")
+
+      local show_middle_min = get_option(substitution, "show_middle_min")
+
+      local base_color = get_option(substitution, "color")
+      local leading_color = get_option(substitution, "leading_color") or base_color
+      local middle_color = get_option(substitution, "middle_color") or base_color
+      local trailing_color = get_option(substitution, "trailing_color") or base_color
+
+      local pattern = char.."+"
+      while true do
+        local s, e = text:find(pattern, offset)
+        if not s then break end
+
+        tx = self:get_col_x_offset(idx, s)
+
+        local color = base_color
+        local draw = false
+
+        if e >= #text - 1 then
+          draw = show_trailing
+          color = trailing_color
+        elseif s == 1 then
+          draw = show_leading
+          color = leading_color
+        else
+          draw = show_middle and (e - s + 1 >= show_middle_min)
+          color = middle_color
+        end
+
+        if draw then
+          local last_cache_idx = #cache
+          -- We need to draw tabs one at a time because they might have a
+          -- different size than the substituting character.
+          -- This also applies to any other char if we use non-monospace fonts
+          -- but we ignore this case for now.
+          if char == "\t" then
+            for i = s,e do
+              tx = self:get_col_x_offset(idx, i)
+              cache[last_cache_idx + 1] = sub
+              cache[last_cache_idx + 2] = tx
+              cache[last_cache_idx + 3] = font:get_width(sub)
+              cache[last_cache_idx + 4] = color
+              last_cache_idx = last_cache_idx + 4
+            end
+          else
+            cache[last_cache_idx + 1] = string.rep(sub, e - s + 1)
+            cache[last_cache_idx + 2] = tx
+            cache[last_cache_idx + 3] = font:get_width(cache[last_cache_idx + 1])
+            cache[last_cache_idx + 4] = color
+          end
+        end
+        offset = e + 1
+      end
+    end
+    ws_cache[self.doc.highlighter][idx] = cache
+  end
+
+  -- draw from cache
+  local x1, _, x2, _ = self:get_content_bounds()
+  x1 = x1 + x
+  x2 = x2 + x
+  local ty = y + self:get_line_text_y_offset()
+  local cache = ws_cache[self.doc.highlighter][idx]
+  for i=1,#cache,4 do
+    local tx = cache[i + 1] + x
+    local tw = cache[i + 2]
+    if tx <= x2 then
+      local sub = cache[i]
+      local color = cache[i + 3]
+      if tx + tw >= x1 then
+        tx = renderer.draw_text(font, sub, tx, ty, color)
+      end
+    end
+  end
+
+  return draw_line_text(self, idx, x, y)
+end
+
+
+command.add(nil, {
+  ["draw-whitespace:toggle"]  = function()
+    config.plugins.drawwhitespace.enabled = not config.plugins.drawwhitespace.enabled
+  end,
+
+  ["draw-whitespace:disable"] = function()
+    config.plugins.drawwhitespace.enabled = false
+  end,
+
+  ["draw-whitespace:enable"]  = function()
+    config.plugins.drawwhitespace.enabled = true
+  end,
+})

data/plugins/language_c.lua

@@ -1,20 +1,86 @@
+-- mod-version:3
 local syntax = require "core.syntax"
 
+-- integer suffix combinations as a regex
+local isuf = [[(?:[lL][uU]|ll[uU]|LL[uU]|[uU][lL]\b|[uU]ll|[uU]LL|[uU]|[lL]\b|ll|LL)?]]
+-- float suffix combinations as a Lua pattern / regex
+local fsuf = "[fFlL]?"
+-- number with digit separator as a regex non-capturing group
+local digitsep = [[(?:\d[\d']*)]]
+
 syntax.add {
-  files = { "%.c$", "%.h$", "%.inl$", "%.cpp$", "%.hpp$" },
+  name = "C",
+  files = { "%.c$" },
   comment = "//",
+  block_comment = { "/*", "*/" },
   patterns = {
-    { pattern = "//.-\n",               type = "comment"  },
-    { pattern = { "/%*", "%*/" },       type = "comment"  },
-    { pattern = { "#", "[^\\]\n" },     type = "comment"  },
-    { pattern = { '"', '"', '\\' },     type = "string"   },
-    { pattern = { "'", "'", '\\' },     type = "string"   },
-    { pattern = "-?0x%x+",              type = "number"   },
-    { pattern = "-?%d+[%d%.eE]*f?",     type = "number"   },
-    { pattern = "-?%.?%d+f?",           type = "number"   },
-    { pattern = "[%+%-=/%*%^%%<>!~|&]", type = "operator" },
-    { pattern = "[%a_][%w_]*%f[(]",     type = "function" },
-    { pattern = "[%a_][%w_]*",          type = "symbol"   },
+    { pattern = "//.*",                                                            type = "comment" },
+    { pattern = { "/%*", "%*/" },                                                  type = "comment" },
+    { pattern = { '"', '"', '\\' },                                                type = "string"  },
+    { pattern = { "'", "'", '\\' },                                                type = "string"  },
+    { regex   = "0x[0-9a-fA-F][0-9a-fA-F']*"..isuf,                                type = "number"  },
+    { regex   = "0()[0-7][0-7']*"..isuf,                                           type = { "keyword", "number" } },
+    { regex   = digitsep.."\\.?"..digitsep.."?(?:[Ee][-+]?"..digitsep..")?"..fsuf, type = "number" },
+    { regex   = "\\."..digitsep.."(?:[Ee][-+]?"..digitsep..")?"..fsuf,             type = "number" },
+    { pattern = "[%+%-=/%*%^%%<>!~|&]",                                            type = "operator" },
+    { pattern = "##",                                                              type = "operator" },
+    { pattern = "struct%s()[%a_][%w_]*",                                           type = {"keyword", "keyword2"} },
+    { pattern = "union%s()[%a_][%w_]*",                                            type = {"keyword", "keyword2"} },
+    -- static declarations
+    { pattern = "static()%s+()inline",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()const",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()[%a_][%w_]*",
+      type = { "keyword", "normal", "literal" }
+    },
+    -- match function type declarations
+    { pattern = "[%a_][%w_]*()%*+()%s+()[%a_][%w_]*%f[%(]",
+      type = { "literal", "operator", "normal", "function" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()%*+()[%a_][%w_]*%f[%(]",
+      type = { "literal", "normal", "operator", "function" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()[%a_][%w_]*%f[%(]",
+      type = { "literal", "normal", "function" }
+    },
+    -- match variable type declarations
+    { pattern = "[%a_][%w_]*()%*+()%s+()[%a_][%w_]*",
+      type = { "literal", "operator", "normal", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()%*+()[%a_][%w_]*",
+      type = { "literal", "normal", "operator", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()[%a_][%w_]*()%s*()[;,%[%)]",
+      type = { "literal", "normal", "normal", "normal", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()[%a_][%w_]*()%s*()=",
+      type = { "literal", "normal", "normal", "normal", "operator" }
+    },
+    { pattern = "[%a_][%w_]*()&()%s+()[%a_][%w_]*",
+      type = { "literal", "operator", "normal", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()&()[%a_][%w_]*",
+      type = { "literal", "normal", "operator", "normal" }
+    },
+    -- Uppercase constants of at least 2 chars in len
+    { pattern = "_?%u[%u_][%u%d_]*%f[%s%+%*%-%.%)%]}%?%^%%=/<>~|&;:,!]",
+      type = "number"
+    },
+    -- Magic constants
+    { pattern = "__[%u%l]+__",           type = "number"   },
+    -- all other functions
+    { pattern = "[%a_][%w_]*%f[(]",      type = "function" },
+    -- Macros
+    { pattern = "^%s*#%s*define%s+()[%a_][%a%d_]*",
+      type = { "keyword", "symbol" }
+    },
+    { pattern = "#%s*include%s()<.->",   type = {"keyword", "string"} },
+    { pattern = "%f[#]#%s*[%a_][%w_]*",  type = "keyword"   },
+    -- Everything else to make the tokenizer work properly
+    { pattern = "[%a_][%w_]*",           type = "symbol" },
   },
   symbols = {
     ["if"]       = "keyword",
@@ -28,8 +94,6 @@ syntax.add {
     ["continue"] = "keyword",
     ["return"]   = "keyword",
     ["goto"]     = "keyword",
-    ["struct"]   = "keyword",
-    ["union"]    = "keyword",
     ["typedef"]  = "keyword",
     ["enum"]     = "keyword",
     ["extern"]   = "keyword",
@@ -41,8 +105,9 @@ syntax.add {
     ["case"]     = "keyword",
     ["default"]  = "keyword",
     ["auto"]     = "keyword",
-    ["const"]    = "keyword",
-    ["void"]     = "keyword",
+    ["struct"]   = "keyword",
+    ["union"]    = "keyword",
+    ["void"]     = "keyword2",
     ["int"]      = "keyword2",
     ["short"]    = "keyword2",
     ["long"]     = "keyword2",
@@ -54,6 +119,18 @@ syntax.add {
     ["true"]     = "literal",
     ["false"]    = "literal",
     ["NULL"]     = "literal",
+    ["#include"] = "keyword",
+    ["#if"] = "keyword",
+    ["#ifdef"] = "keyword",
+    ["#ifndef"] = "keyword",
+    ["#elif"]    = "keyword",
+    ["#else"] = "keyword",
+    ["#elseif"] = "keyword",
+    ["#endif"] = "keyword",
+    ["#define"] = "keyword",
+    ["#warning"] = "keyword",
+    ["#error"] = "keyword",
+    ["#pragma"] = "keyword",
   },
 }
 

data/plugins/language_cpp.lua

@@ -0,0 +1,222 @@
+-- mod-version:3
+local syntax = require "core.syntax"
+
+-- integer suffix combinations as a regex
+local isuf = [[(?:[lL][uU]|ll[uU]|LL[uU]|[uU][lL]\b|[uU]ll|[uU]LL|[uU]|[lL]\b|ll|LL)?]]
+-- float suffix combinations as a Lua pattern / regex
+local fsuf = "[fFlL]?"
+-- number with digit separator as a regex non-capturing group
+local digitsep = [[(?:\d[\d']*)]]
+
+syntax.add {
+  name = "C++",
+  files = {
+    "%.h$", "%.inl$", "%.cpp$", "%.cc$", "%.C$", "%.cxx$",
+    "%.c++$", "%.hh$", "%.H$", "%.hxx$", "%.hpp$", "%.h++$",
+    "%.ino$", "%.cu$", "%.cuh$"
+  },
+  comment = "//",
+  block_comment = { "/*", "*/" },
+  patterns = {
+    { pattern = "//.*",                                                            type = "comment"  },
+    { pattern = { "/%*", "%*/" },                                                  type = "comment"  },
+    { pattern = { '"', '"', '\\' },                                                type = "string"   },
+    { pattern = { "'", "'", '\\' },                                                type = "string"   },
+    { regex   = "0x[0-9a-fA-F][0-9a-fA-F']*"..isuf,                                type = "number"   },
+    { regex   = "0b[01][01']*"..isuf,                                              type = "number"   },
+    { regex   = "0()[0-7][0-7']*"..isuf,                                           type = { "keyword", "number" } },
+    { regex   = digitsep.."\\.?"..digitsep.."?(?:[Ee][-+]?"..digitsep..")?"..fsuf, type = "number" },
+    { regex   = "\\."..digitsep.."(?:[Ee][-+]?"..digitsep..")?"..fsuf,             type = "number" },
+    { pattern = "[%+%-=/%*%^%%<>!~|:&]",                                           type = "operator" },
+    { pattern = "##",                                                              type = "operator" },
+    { pattern = "struct%s()[%a_][%w_]*",                                           type = {"keyword", "keyword2"} },
+    { pattern = "class%s()[%a_][%w_]*",                                            type = {"keyword", "keyword2"} },
+    { pattern = "union%s()[%a_][%w_]*",                                            type = {"keyword", "keyword2"} },
+    { pattern = "namespace%s()[%a_][%w_]*",                                        type = {"keyword", "keyword2"} },
+    -- static declarations
+    { pattern = "static()%s+()inline",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()constexpr",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()constinit",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()consteval",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()const",
+      type = { "keyword", "normal", "keyword" }
+    },
+    { pattern = "static()%s+()[%a_][%w_]*",
+      type = { "keyword", "normal", "literal" }
+    },
+    -- match method type declarations
+    { pattern = "[%a_][%w_]*()%s*()%**()%s*()[%a_][%w_]*()%s*()::",
+      type = {
+        "literal", "normal", "operator", "normal",
+        "literal", "normal", "operator"
+      }
+    },
+    -- match function type declarations
+    { pattern = "[%a_][%w_]*()%*+()%s+()[%a_][%w_]*%f[%(]",
+      type = { "literal", "operator", "normal", "function" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()%*+()[%a_][%w_]*%f[%(]",
+      type = { "literal", "normal", "operator", "function" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()[%a_][%w_]*%f[%(]",
+      type = { "literal", "normal", "function" }
+    },
+    -- match variable type declarations
+    { pattern = "[%a_][%w_]*()%*+()%s+()[%a_][%w_]*",
+      type = { "literal", "operator", "normal", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()%*+()[%a_][%w_]*",
+      type = { "literal", "normal", "operator", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()[%a_][%w_]*()%s*()[;,%[%)]",
+      type = { "literal", "normal", "normal", "normal", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()[%a_][%w_]*()%s*()=",
+      type = { "literal", "normal", "normal", "normal", "operator" }
+    },
+    { pattern = "[%a_][%w_]*()&()%s+()[%a_][%w_]*",
+      type = { "literal", "operator", "normal", "normal" }
+    },
+    { pattern = "[%a_][%w_]*()%s+()&()[%a_][%w_]*",
+      type = { "literal", "normal", "operator", "normal" }
+    },
+    -- Match scope operator element access
+    { pattern = "[%a_][%w_]*()%s*()::",
+      type = { "literal", "normal", "operator" }
+    },
+    -- Uppercase constants of at least 2 chars in len
+    { pattern = "_?%u[%u_][%u%d_]*%f[%s%+%*%-%.%)%]}%?%^%%=/<>~|&;:,!]",
+      type = "number"
+    },
+    -- Magic constants
+    { pattern = "__[%u%l]+__",              type = "number"   },
+    -- all other functions
+    { pattern = "[%a_][%w_]*%f[(]",         type = "function" },
+    -- Macros
+    { pattern = "^%s*#%s*define%s+()[%a_][%a%d_]*",
+      type = { "keyword", "symbol" }
+    },
+    { pattern = "#%s*include%s+()<.->",
+      type = { "keyword", "string" }
+    },
+    { pattern = "%f[#]#%s*[%a_][%w_]*",     type = "keyword"   },
+    -- Everything else to make the tokenizer work properly
+    { pattern = "[%a_][%w_]*",              type = "symbol"   },
+  },
+  symbols = {
+    ["alignof"]  = "keyword",
+    ["alignas"]  = "keyword",
+    ["and"]      = "keyword",
+    ["and_eq"]   = "keyword",
+    ["not"]      = "keyword",
+    ["not_eq"]   = "keyword",
+    ["or"]       = "keyword",
+    ["or_eq"]    = "keyword",
+    ["xor"]      = "keyword",
+    ["xor_eq"]   = "keyword",
+    ["private"]  = "keyword",
+    ["protected"] = "keyword",
+    ["public"]   = "keyword",
+    ["register"] = "keyword",
+    ["nullptr"]  = "keyword",
+    ["operator"] = "keyword",
+    ["asm"]      = "keyword",
+    ["bitand"]   = "keyword",
+    ["bitor"]    = "keyword",
+    ["catch"]    = "keyword",
+    ["throw"]    = "keyword",
+    ["try"]      = "keyword",
+    ["class"]    = "keyword",
+    ["compl"]    = "keyword",
+    ["explicit"] = "keyword",
+    ["export"]   = "keyword",
+    ["concept"]  = "keyword",
+    ["consteval"] = "keyword",
+    ["constexpr"] = "keyword",
+    ["constinit"] = "keyword",
+    ["const_cast"] = "keyword",
+    ["dynamic_cast"] = "keyword",
+    ["reinterpret_cast"]   = "keyword",
+    ["static_cast"]   = "keyword",
+    ["static_assert"] = "keyword",
+    ["template"]  = "keyword",
+    ["this"]      = "keyword",
+    ["thread_local"] = "keyword",
+    ["requires"]  = "keyword",
+    ["co_await"]   = "keyword",
+    ["co_return"] = "keyword",
+    ["co_yield"]  = "keyword",
+    ["decltype"] = "keyword",
+    ["delete"]   = "keyword",
+    ["friend"]   = "keyword",
+    ["typeid"]   = "keyword",
+    ["typename"] = "keyword",
+    ["mutable"]  = "keyword",
+    ["override"] = "keyword",
+    ["virtual"]  = "keyword",
+    ["using"]    = "keyword",
+    ["namespace"] = "keyword",
+    ["new"]      = "keyword",
+    ["noexcept"] = "keyword",
+    ["if"]       = "keyword",
+    ["then"]     = "keyword",
+    ["else"]     = "keyword",
+    ["elseif"]   = "keyword",
+    ["do"]       = "keyword",
+    ["while"]    = "keyword",
+    ["for"]      = "keyword",
+    ["break"]    = "keyword",
+    ["continue"] = "keyword",
+    ["return"]   = "keyword",
+    ["goto"]     = "keyword",
+    ["struct"]   = "keyword",
+    ["union"]    = "keyword",
+    ["typedef"]  = "keyword",
+    ["enum"]     = "keyword",
+    ["extern"]   = "keyword",
+    ["static"]   = "keyword",
+    ["volatile"] = "keyword",
+    ["const"]    = "keyword",
+    ["inline"]   = "keyword",
+    ["switch"]   = "keyword",
+    ["case"]     = "keyword",
+    ["default"]  = "keyword",
+    ["auto"]     = "keyword",
+    ["void"]     = "keyword2",
+    ["int"]      = "keyword2",
+    ["short"]    = "keyword2",
+    ["long"]     = "keyword2",
+    ["float"]    = "keyword2",
+    ["double"]   = "keyword2",
+    ["char"]     = "keyword2",
+    ["unsigned"] = "keyword2",
+    ["bool"]     = "keyword2",
+    ["true"]     = "literal",
+    ["false"]    = "literal",
+    ["NULL"]     = "literal",
+    ["wchar_t"]  = "keyword2",
+    ["char8_t"]  = "keyword2",
+    ["char16_t"] = "keyword2",
+    ["char32_t"] = "keyword2",
+    ["#include"] = "keyword",
+    ["#if"]      = "keyword",
+    ["#ifdef"]   = "keyword",
+    ["#ifndef"]  = "keyword",
+    ["#elif"]    = "keyword",
+    ["#else"]    = "keyword",
+    ["#elseif"]  = "keyword",
+    ["#endif"]   = "keyword",
+    ["#define"]  = "keyword",
+    ["#warning"] = "keyword",
+    ["#error"]   = "keyword",
+    ["#pragma"]  = "keyword",
+  },
+}

data/plugins/language_css.lua

@@ -1,17 +1,46 @@
+-- mod-version:3
 local syntax = require "core.syntax"
 
 syntax.add {
+  name = "CSS",
   files = { "%.css$" },
+  block_comment = { "/*", "*/" },
   patterns = {
     { pattern = "\\.",                type = "normal"   },
-    { pattern = "//.-\n",             type = "comment"  },
     { pattern = { "/%*", "%*/" },     type = "comment"  },
     { pattern = { '"', '"', '\\' },   type = "string"   },
     { pattern = { "'", "'", '\\' },   type = "string"   },
     { pattern = "[%a][%w-]*%s*%f[:]", type = "keyword"  },
-    { pattern = "#%x+",               type = "string"   },
-    { pattern = "-?%d+[%d%.]*p[xt]",  type = "number"   },
+    { pattern = "#%x%x%x%x%x%x%f[%W]",type = "string"   },
+    { pattern = "#%x%x%x%f[%W]",      type = "string"   },
+    { pattern = "-?%d+[%d%.]*p[xtc]", type = "number"   },
     { pattern = "-?%d+[%d%.]*deg",    type = "number"   },
+    { pattern = "-?%d+[%d%.]*cm",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*mm",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*in",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*r?ic",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*r?cap",  type = "number"   },
+    { pattern = "-?%d+[%d%.]*r?em",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*r?lh",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*r?ch",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*r?ex",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*m?s",    type = "number"   },
+    { pattern = "-?%d+[%d%.]*hz",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*Hz",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*vw",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*vh",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*vmin",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*vmax",   type = "number"   },
+    { pattern = "-?%d+[%d%.]*vb",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*vi",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*%%",     type = "number"   },
+    { pattern = "-?%d+[%d%.]*Q",      type = "number"   },
+    { pattern = "-?%d+[%d%.]*cqw",    type = "number"   },
+    { pattern = "-?%d+[%d%.]*cqh",    type = "number"   },
+    { pattern = "-?%d+[%d%.]*cqi",    type = "number"   },
+    { pattern = "-?%d+[%d%.]*cqb",    type = "number"   },
+    { pattern = "-?%d+[%d%.]*cqmin",  type = "number"   },
+    { pattern = "-?%d+[%d%.]*cqmax",  type = "number"   },
     { pattern = "-?%d+[%d%.]*",       type = "number"   },
     { pattern = "[%a_][%w_]*",        type = "symbol"   },
     { pattern = "#[%a][%w_-]*",       type = "keyword2" },

data/plugins/language_html.lua

@@ -0,0 +1,39 @@
+-- mod-version:3
+local syntax = require "core.syntax"
+
+syntax.add {
+  name = "HTML",
+  files = { "%.html?$" },
+  block_comment = { "<!--", "-->" },
+  patterns = {
+    {
+      pattern = {
+        "<%s*[sS][cC][rR][iI][pP][tT]%f[%s>].->",
+        "<%s*/%s*[sS][cC][rR][iI][pP][tT]%s*>"
+      },
+      syntax = ".js",
+      type = "function"
+    },
+    {
+      pattern = {
+        "<%s*[sS][tT][yY][lL][eE]%f[%s>].->",
+        "<%s*/%s*[sS][tT][yY][lL][eE]%s*>"
+      },
+      syntax = ".css",
+      type = "function"
+    },
+    { pattern = { "<!%-%-", "%-%->" },     type = "comment"  },
+    { pattern = { '%f[^>][^<]', '%f[<]' }, type = "normal"   },
+    { pattern = { '"', '"', '\\' },        type = "string"   },
+    { pattern = { "'", "'", '\\' },        type = "string"   },
+    { pattern = "0x[%da-fA-F]+",           type = "number"   },
+    { pattern = "-?%d+[%d%.]*f?",          type = "number"   },
+    { pattern = "-?%.?%d+f?",              type = "number"   },
+    { pattern = "%f[^<]![%a_][%w_]*",      type = "keyword2" },
+    { pattern = "%f[^<][%a_][%w_]*",       type = "function" },
+    { pattern = "%f[^<]/[%a_][%w_]*",      type = "function" },
+    { pattern = "[%a_][%w_]*",             type = "keyword"  },
+    { pattern = "[/<>=]",                  type = "operator" },
+  },
+  symbols = {},
+}

data/plugins/language_js.lua

@@ -1,20 +1,75 @@
+-- mod-version:3
 local syntax = require "core.syntax"
 
-syntax.add {
-  files = { "%.js$", "%.json$", "%.cson$" },
-  comment = "//",
+-- Regex pattern explanation:
+-- This will match / and will look ahead for something that looks like a regex.
+--
+-- (?!/) Don't match empty regexes.
+--
+-- (?>...) this is using an atomic group to minimize backtracking, as that'd
+--         cause "Catastrophic Backtracking" in some cases.
+--
+-- [^\\[\/]++ will match anything that's isn't an escape, a start of character
+--           class or an end of pattern, without backtracking (the second +).
+--
+-- \\. will match anything that's escaped.
+--
+-- \[(?:[^\\\]++]|\\.)*+\] will match character classes.
+--
+-- /[gmiyuvsd]*\s*[\n,;\)\]\}\.]) will match the end of pattern delimiter, optionally
+--                                followed by pattern options, and anything that can
+--                                be after a pattern.
+--
+-- Demo with some unit tests (click on the Unit Tests entry): https://regex101.com/r/Vx5L5V/1
+-- Note that it has a couple of changes to make it work on that platform.
+local regex_pattern = {
+  [=[\/(?=(?!\/)(?:(?>[^\\[\/]++|\\.|\[(?:[^\\\]]++|\\.)*+\])*+)++\/[gmiyuvsd]*\s*(?:[\n,;\)\]\}\.]|\/[\/*]))()]=],
+  "/()[gmiyuvsd]*", "\\"
+}
+
+-- For the moment let's not actually differentiate the insides of the regex,
+-- as this will need new token types...
+local inner_regex_syntax = {
   patterns = {
-    { pattern = "//.-\n",               type = "comment"  },
-    { pattern = { "/%*", "%*/" },       type = "comment"  },
-    { pattern = { '"', '"', '\\' },     type = "string"   },
-    { pattern = { "'", "'", '\\' },     type = "string"   },
-    { pattern = { "`", "`", '\\' },     type = "string"   },
-    { pattern = "0x[%da-fA-F]+",        type = "number"   },
-    { pattern = "-?%d+[%d%.eE]*",       type = "number"   },
-    { pattern = "-?%.?%d+",             type = "number"   },
-    { pattern = "[%+%-=/%*%^%%<>!~|&]", type = "operator" },
-    { pattern = "[%a_][%w_]*%f[(]",     type = "function" },
-    { pattern = "[%a_][%w_]*",          type = "symbol"   },
+    { pattern = "%(()%?[:!=><]", type = { "string", "string" } },
+    { pattern = "[.?+*%(%)|]", type = "string" },
+    { pattern = "{%d*,?%d*}", type = "string" },
+    { regex = { [=[\[()\^?]=], [=[(?:\]|(?=\n))()]=], "\\" },
+      type = { "string", "string" },
+      syntax = { -- Inside character class
+        patterns = {
+          { pattern = "\\\\", type = "string" },
+          { pattern = "\\%]", type = "string" },
+          { pattern = "[^%]\n]", type = "string" }
+        },
+        symbols = {}
+      }
+    },
+    { regex = "\\/", type = "string" },
+    { regex = "[^/\n]", type = "string" },
+  },
+  symbols = {}
+}
+
+syntax.add {
+  name = "JavaScript",
+  files = { "%.js$", "%.json$", "%.cson$", "%.mjs$", "%.cjs$" },
+  comment = "//",
+  block_comment = { "/*", "*/" },
+  patterns = {
+    { pattern = "//.*",                                               type = "comment"  },
+    { pattern = { "/%*", "%*/" },                                     type = "comment"  },
+    { regex = regex_pattern, syntax = inner_regex_syntax,             type = {"string", "string"}  },
+    { pattern = { '"', '"', '\\' },                                   type = "string"   },
+    { pattern = { "'", "'", '\\' },                                   type = "string"   },
+    { pattern = { "`", "`", '\\' },                                   type = "string"   },
+    -- Use (?:\/(?!\/|\*))? to avoid that a regex can start after a number, while also allowing // and /* comments
+    { regex   = [[-?0[xXbBoO][\da-fA-F_]+n?()\s*()(?:\/(?!\/|\*))?]], type = {"number", "normal", "operator"}   },
+    { regex   = [[-?\d+[0-9.eE_n]*()\s*()(?:\/(?!\/|\*))?]],          type = {"number", "normal", "operator"}   },
+    { regex   = [[-?\.?\d+()\s*()(?:\/(?!\/|\*))?]],                  type = {"number", "normal", "operator"}   },
+    { pattern = "[%+%-=/%*%^%%<>!~|&]",                               type = "operator" },
+    { pattern = "[%a_][%w_]*%f[(]",                                   type = "function" },
+    { pattern = "[%a_][%w_]*",                                        type = "symbol"   },
   },
   symbols = {
     ["async"]      = "keyword",
@@ -38,7 +93,9 @@ syntax.add {
     ["get"]        = "keyword",
     ["if"]         = "keyword",
     ["import"]     = "keyword",
+    ["from"]       = "keyword",    
     ["in"]         = "keyword",
+    ["of"]         = "keyword",
     ["instanceof"] = "keyword",
     ["let"]        = "keyword",
     ["new"]        = "keyword",

data/plugins/language_lua.lua

@@ -1,25 +1,35 @@
+-- mod-version:3
 local syntax = require "core.syntax"
 
 syntax.add {
-  files = "%.lua$",
+  name = "Lua",
+  files = { "%.lua$", "%.rockspec$" },
   headers = "^#!.*[ /]lua",
   comment = "--",
+  block_comment = { "--[[", "]]" },
   patterns = {
-    { pattern = { '"', '"', '\\' },       type = "string"   },
-    { pattern = { "'", "'", '\\' },       type = "string"   },
-    { pattern = { "%[%[", "%]%]" },       type = "string"   },
-    { pattern = { "%-%-%[%[", "%]%]"},    type = "comment"  },
-    { pattern = "%-%-.-\n",               type = "comment"  },
-    { pattern = "-?0x%x+",                type = "number"   },
-    { pattern = "-?%d+[%d%.eE]*",         type = "number"   },
-    { pattern = "-?%.?%d+",               type = "number"   },
-    { pattern = "<%a+>",                  type = "keyword2" },
-    { pattern = "%.%.%.?",                type = "operator" },
-    { pattern = "[<>~=]=",                type = "operator" },
-    { pattern = "[%+%-=/%*%^%%#<>]",      type = "operator" },
-    { pattern = "[%a_][%w_]*%s*%f[(\"{]", type = "function" },
-    { pattern = "[%a_][%w_]*",            type = "symbol"   },
-    { pattern = "::[%a_][%w_]*::",        type = "function" },
+    { pattern = { '"', '"', '\\' },          type = "string" },
+    { pattern = { "'", "'", '\\' },          type = "string" },
+    { pattern = { "%[%[", "%]%]" },          type = "string" },
+    { pattern = { "%-%-%[%[", "%]%]"},       type = "comment" },
+    { pattern = "%-%-.*",                    type = "comment" },
+    { pattern = "0x%x+%.%x*[pP][-+]?%d+",    type = "number" },
+    { pattern = "0x%x+%.%x*",                type = "number" },
+    { pattern = "0x%.%x+[pP][-+]?%d+",       type = "number" },
+    { pattern = "0x%.%x+",                   type = "number" },
+    { pattern = "0x%x+[pP][-+]?%d+",         type = "number" },
+    { pattern = "0x%x+",                     type = "number" },
+    { pattern = "%d%.%d*[eE][-+]?%d+",       type = "number" },
+    { pattern = "%d%.%d*",                   type = "number" },
+    { pattern = "%.?%d*[eE][-+]?%d+",        type = "number" },
+    { pattern = "%.?%d+",                    type = "number" },
+    { pattern = "<%a+>",                     type = "keyword2" },
+    { pattern = "%.%.%.?",                   type = "operator" },
+    { pattern = "[<>~=]=",                   type = "operator" },
+    { pattern = "[%+%-=/%*%^%%#<>]",         type = "operator" },
+    { pattern = "[%a_][%w_]*()%s*%f[(\"'{]", type = {"function", "normal"} },
+    { pattern = "[%a_][%w_]*",               type = "symbol" },
+    { pattern = "::[%a_][%w_]*::",           type = "function" },
   },
   symbols = {
     ["if"]       = "keyword",

data/plugins/language_md.lua

@@ -1,21 +1,268 @@
+-- mod-version:3
 local syntax = require "core.syntax"
+local style = require "core.style"
+local core = require "core"
+
+local in_squares_match = "^%[%]"
+local in_parenthesis_match = "^%(%)"
 
 syntax.add {
+  name = "Markdown",
   files = { "%.md$", "%.markdown$" },
+  block_comment = { "<!--", "-->" },
+  space_handling = false, -- turn off this feature to handle it our selfs
   patterns = {
-    { pattern = "\\.",                    type = "normal"   },
-    { pattern = { "<!%-%-", "%-%->" },    type = "comment"  },
-    { pattern = { "```", "```" },         type = "string"   },
-    { pattern = { "``", "``", "\\" },     type = "string"   },
-    { pattern = { "`", "`", "\\" },       type = "string"   },
-    { pattern = { "~~", "~~", "\\" },     type = "keyword2" },
-    { pattern = "%-%-%-+",                type = "comment" },
-    { pattern = "%*%s+",                  type = "operator" },
-    { pattern = { "%*", "[%*\n]", "\\" }, type = "operator" },
-    { pattern = { "%_", "[%_\n]", "\\" }, type = "keyword2" },
-    { pattern = "#.-\n",                  type = "keyword"  },
-    { pattern = "!?%[.-%]%(.-%)",         type = "function" },
-    { pattern = "https?://%S+",           type = "function" },
+  ---- Place patterns that require spaces at start to optimize matching speed
+  ---- and apply the %s+ optimization immediately afterwards
+    -- bullets
+    { pattern = "^%s*%*%s",                 type = "number" },
+    { pattern = "^%s*%-%s",                 type = "number" },
+    { pattern = "^%s*%+%s",                 type = "number" },
+    -- numbered bullet
+    { pattern = "^%s*[0-9]+[%.%)]%s",       type = "number" },
+    -- blockquote
+    { pattern = "^%s*>+%s",                 type = "string" },
+    -- alternative bold italic formats
+    { pattern = { "%s___", "___" },         type = "markdown_bold_italic" },
+    { pattern = { "%s__", "__" },           type = "markdown_bold" },
+    { pattern = { "%s_[%S]", "_" },         type = "markdown_italic" },
+    -- reference links
+    {
+      pattern = "^%s*%[%^()["..in_squares_match.."]+()%]: ",
+      type = { "function", "number", "function" }
+    },
+    {
+      pattern = "^%s*%[%^?()["..in_squares_match.."]+()%]:%s+.*",
+      type = { "function", "number", "function" }
+    },
+    -- optimization
+    { pattern = "%s+",                      type = "normal" },
+
+  ---- HTML rules imported and adapted from language_html
+  ---- to not conflict with markdown rules
+    -- Inline JS and CSS
+    {
+      pattern = {
+      "<%s*[sS][cC][rR][iI][pP][tT]%s+[tT][yY][pP][eE]%s*=%s*" ..
+        "['\"]%a+/[jJ][aA][vV][aA][sS][cC][rR][iI][pP][tT]['\"]%s*>",
+      "<%s*/[sS][cC][rR][iI][pP][tT]>"
+      },
+      syntax = ".js",
+      type = "function"
+    },
+    {
+      pattern = {
+      "<%s*[sS][cC][rR][iI][pP][tT]%s*>",
+      "<%s*/%s*[sS][cC][rR][iI][pP][tT]>"
+      },
+      syntax = ".js",
+      type = "function"
+    },
+    {
+      pattern = {
+      "<%s*[sS][tT][yY][lL][eE][^>]*>",
+      "<%s*/%s*[sS][tT][yY][lL][eE]%s*>"
+      },
+      syntax = ".css",
+      type = "function"
+    },
+    -- Comments
+    { pattern = { "<!%-%-", "%-%->" },   type = "comment" },
+    -- Tags
+    { pattern = "%f[^<]![%a_][%w_]*",    type = "keyword2" },
+    { pattern = "%f[^<][%a_][%w_]*",     type = "function" },
+    { pattern = "%f[^<]/[%a_][%w_]*",    type = "function" },
+    -- Attributes
+    {
+      pattern = "[a-z%-]+%s*()=%s*()\".-\"",
+      type = { "keyword", "operator", "string" }
+    },
+    {
+      pattern = "[a-z%-]+%s*()=%s*()'.-'",
+      type = { "keyword", "operator", "string" }
+    },
+    {
+      pattern = "[a-z%-]+%s*()=%s*()%-?%d[%d%.]*",
+      type = { "keyword", "operator", "number" }
+    },
+    -- Entities
+    { pattern = "&#?[a-zA-Z0-9]+;",         type = "keyword2" },
+
+  ---- Markdown rules
+    -- math
+    { pattern = { "%$%$", "%$%$", "\\"  },  type = "string", syntax = ".tex"},
+    { regex   = { "\\$", [[\$|(?=\\*\n)]], "\\" },  type = "string", syntax = ".tex"},
+    -- code blocks
+    { pattern = { "```caddyfile", "```" },  type = "string", syntax = "Caddyfile" },
+    { pattern = { "```c++", "```" },        type = "string", syntax = ".cpp" },
+    { pattern = { "```cpp", "```" },        type = "string", syntax = ".cpp" },
+    { pattern = { "```python", "```" },     type = "string", syntax = ".py" },
+    { pattern = { "```ruby", "```" },       type = "string", syntax = ".rb" },
+    { pattern = { "```perl", "```" },       type = "string", syntax = ".pl" },
+    { pattern = { "```php", "```" },        type = "string", syntax = ".php" },
+    { pattern = { "```javascript", "```" }, type = "string", syntax = ".js" },
+    { pattern = { "```json", "```" },       type = "string", syntax = ".js" },
+    { pattern = { "```html", "```" },       type = "string", syntax = ".html" },
+    { pattern = { "```ini", "```" },        type = "string", syntax = ".ini" },
+    { pattern = { "```xml", "```" },        type = "string", syntax = ".xml" },
+    { pattern = { "```css", "```" },        type = "string", syntax = ".css" },
+    { pattern = { "```lua", "```" },        type = "string", syntax = ".lua" },
+    { pattern = { "```bash", "```" },       type = "string", syntax = ".sh" },
+    { pattern = { "```sh", "```" },         type = "string", syntax = ".sh" },
+    { pattern = { "```java", "```" },       type = "string", syntax = ".java" },
+    { pattern = { "```c#", "```" },         type = "string", syntax = ".cs" },
+    { pattern = { "```cmake", "```" },      type = "string", syntax = ".cmake" },
+    { pattern = { "```d", "```" },          type = "string", syntax = ".d" },
+    { pattern = { "```glsl", "```" },       type = "string", syntax = ".glsl" },
+    { pattern = { "```c", "```" },          type = "string", syntax = ".c" },
+    { pattern = { "```julia", "```" },      type = "string", syntax = ".jl" },
+    { pattern = { "```rust", "```" },       type = "string", syntax = ".rs" },
+    { pattern = { "```dart", "```" },       type = "string", syntax = ".dart" },
+    { pattern = { "```v", "```" },          type = "string", syntax = ".v" },
+    { pattern = { "```toml", "```" },       type = "string", syntax = ".toml" },
+    { pattern = { "```yaml", "```" },       type = "string", syntax = ".yaml" },
+    { pattern = { "```nim", "```" },        type = "string", syntax = ".nim" },
+    { pattern = { "```typescript", "```" }, type = "string", syntax = ".ts" },
+    { pattern = { "```rescript", "```" },   type = "string", syntax = ".res" },
+    { pattern = { "```moon", "```" },       type = "string", syntax = ".moon" },
+    { pattern = { "```go", "```" },         type = "string", syntax = ".go" },
+    { pattern = { "```lobster", "```" },    type = "string", syntax = ".lobster" },
+    { pattern = { "```liquid", "```" },     type = "string", syntax = ".liquid" },
+    { pattern = { "```", "```" },           type = "string" },
+    { pattern = { "``", "``" },             type = "string" },
+    { pattern = { "%f[\\`]%`[%S]", "`" },   type = "string" },
+    -- lines
+    { pattern = "^%-%-%-+\n" ,              type = "comment" },
+    { pattern = "^%*%*%*+\n",               type = "comment" },
+    { pattern = "^___+\n",                  type = "comment" },
+    { pattern = "^===+\n",                  type = "comment" },
+    -- strike
+    { pattern = { "~~", "~~" },             type = "keyword2" },
+    -- highlight
+    { pattern = { "==", "==" },             type = "literal" },
+    -- bold and italic
+    { pattern = { "%*%*%*%S", "%*%*%*" },   type = "markdown_bold_italic" },
+    { pattern = { "%*%*%S", "%*%*" },       type = "markdown_bold" },
+    -- handle edge case where asterisk can be at end of line and not close
+    {
+      pattern = { "%f[\\%*]%*[%S]", "%*%f[^%*]" },
+      type = "markdown_italic"
+    },
+    -- alternative bold italic formats
+    { pattern = "^___[%s%p%w]+___" ,        type = "markdown_bold_italic" },
+    { pattern = "^__[%s%p%w]+__" ,          type = "markdown_bold" },
+    { pattern = "^_[%s%p%w]+_" ,            type = "markdown_italic" },
+    -- heading with custom id
+    {
+      pattern = "^#+%s[%w%s%p]+(){()#[%w%-]+()}",
+      type = { "keyword", "function", "string", "function" }
+    },
+    -- headings
+    { pattern = "^#+%s.+\n",                type = "keyword" },
+    -- superscript and subscript
+    {
+      pattern = "%^()%d+()%^",
+      type = { "function", "number", "function" }
+    },
+    {
+      pattern = "%~()%d+()%~",
+      type = { "function", "number", "function" }
+    },
+    -- definitions
+    { pattern = "^:%s.+",                   type = "function" },
+    -- emoji
+    { pattern = ":[a-zA-Z0-9_%-]+:",        type = "literal" },
+    -- images and link
+    {
+      pattern = "!?%[!?%[()["..in_squares_match.."]+()%]%(()["..in_parenthesis_match.."]+()%)%]%(()["..in_parenthesis_match.."]+()%)",
+      type = { "function", "string", "function", "number", "function", "number", "function" }
+    },
+    {
+      pattern = "!?%[!?%[?()["..in_squares_match.."]+()%]?%]%(()["..in_parenthesis_match.."]+()%)",
+      type = { "function", "string", "function", "number", "function" }
+    },
+    -- reference links
+    {
+      pattern = "%[()["..in_squares_match.."]+()%] *()%[()["..in_squares_match.."]+()%]",
+      type = { "function", "string", "function", "function", "number", "function" }
+    },
+    {
+      pattern = "!?%[%^?()["..in_squares_match.."]+()%]",
+      type = { "function", "number", "function" }
+    },
+    -- url's and email
+    {
+      pattern = "<[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+%.[a-zA-Z0-9-.]+>",
+      type = "function"
+    },
+    { pattern = "<https?://%S+>",           type = "function" },
+    { pattern = "https?://%S+",             type = "function" },
+    -- optimize consecutive dashes used in tables
+    { pattern = "%-+",                      type = "normal" },
   },
   symbols = { },
 }
+
+-- Adjust the color on theme changes
+core.add_thread(function()
+  local custom_fonts = { bold = {font = nil, color = nil}, italic = {}, bold_italic = {} }
+  local initial_color
+  local last_code_font
+
+  local function set_font(attr)
+    local attributes = {}
+    if attr ~= "bold_italic" then
+      attributes[attr] = true
+    else
+      attributes["bold"] = true
+      attributes["italic"] = true
+    end
+    local font = style.code_font:copy(
+      style.code_font:get_size(),
+      attributes
+    )
+    custom_fonts[attr].font = font
+    style.syntax_fonts["markdown_"..attr] = font
+  end
+
+  local function set_color(attr)
+    custom_fonts[attr].color = style.syntax["keyword2"]
+    style.syntax["markdown_"..attr] = style.syntax["keyword2"]
+  end
+
+  -- Add 3 type of font styles for use on markdown files
+  for attr, _ in pairs(custom_fonts) do
+    -- Only set it if the font wasn't manually customized
+    if not style.syntax_fonts["markdown_"..attr] then
+      set_font(attr)
+    end
+
+    -- Only set it if the color wasn't manually customized
+    if not style.syntax["markdown_"..attr] then
+      set_color(attr)
+    end
+  end
+
+  while true do
+    if last_code_font ~= style.code_font then
+      last_code_font = style.code_font
+      for attr, _ in pairs(custom_fonts) do
+        -- Only set it if the font wasn't manually customized
+        if style.syntax_fonts["markdown_"..attr] == custom_fonts[attr].font then
+          set_font(attr)
+        end
+      end
+    end
+
+    if initial_color ~= style.syntax["keyword2"] then
+      initial_color = style.syntax["keyword2"]
+      for attr, _ in pairs(custom_fonts) do
+        -- Only set it if the color wasn't manually customized
+        if style.syntax["markdown_"..attr] == custom_fonts[attr].color then
+          set_color(attr)
+        end
+      end
+    end
+    coroutine.yield(1)
+  end
+end)

data/plugins/language_python.lua

@@ -1,55 +1,188 @@
+-- mod-version:3
 local syntax = require "core.syntax"
 
-syntax.add {
-  files = "%.py$",
-  headers = "^#!.*[ /]python",
-  comment = "#",
+local function table_merge(a, b)
+    local t = {}
+    for _, v in pairs(a) do table.insert(t, v) end
+    for _, v in pairs(b) do table.insert(t, v) end
+
+    return t
+end
+
+
+local python_symbols = {
+
+  ["class"]    = "keyword",
+  ["finally"]  = "keyword",
+  ["is"]       = "keyword",
+  ["return"]   = "keyword",
+  ["continue"] = "keyword",
+  ["for"]      = "keyword",
+  ["lambda"]   = "keyword",
+  ["try"]      = "keyword",
+  ["except"]   = "keyword",
+  ["def"]      = "keyword",
+  ["async"]    = "keyword",
+  ["await"]    = "keyword",
+  ["from"]     = "keyword",
+  ["nonlocal"] = "keyword",
+  ["while"]    = "keyword",
+  ["and"]      = "keyword",
+  ["global"]   = "keyword",
+  ["not"]      = "keyword",
+  ["with"]     = "keyword",
+  ["as"]       = "keyword",
+  ["elif"]     = "keyword",
+  ["if"]       = "keyword",
+  ["or"]       = "keyword",
+  ["else"]     = "keyword",
+  ["match"]    = "keyword",
+  ["case"]     = "keyword",
+  ["import"]   = "keyword",
+  ["pass"]     = "keyword",
+  ["break"]    = "keyword",
+  ["in"]       = "keyword",
+  ["del"]      = "keyword",
+  ["raise"]    = "keyword",
+  ["yield"]    = "keyword",
+  ["assert"]   = "keyword",
+
+  ["self"]     = "keyword2",
+
+  ["None"]     = "literal",
+  ["True"]     = "literal",
+  ["False"]    = "literal",
+
+}
+
+
+
+local python_fstring = {
+
   patterns = {
-    { pattern = { "#", "\n" },            type = "comment"  },
-    { pattern = { '[ruU]?"', '"', '\\' }, type = "string"   },
-    { pattern = { "[ruU]?'", "'", '\\' }, type = "string"   },
-    { pattern = { '"""', '"""' },         type = "string"   },
-    { pattern = "0x[%da-fA-F]+",          type = "number"   },
-    { pattern = "-?%d+[%d%.eE]*",         type = "number"   },
-    { pattern = "-?%.?%d+",               type = "number"   },
-    { pattern = "[%+%-=/%*%^%%<>!~|&]",   type = "operator" },
-    { pattern = "[%a_][%w_]*%f[(]",       type = "function" },
-    { pattern = "[%a_][%w_]*",            type = "symbol"   },
+    { pattern = "\\.",         type = "string" },
+    { pattern = '[^"\\{}\']+', type = "string" }
+
   },
+
+  symbols = {}
+}
+
+
+
+local python_patterns = {
+
+  { pattern = '[uUrR]%f["]',                 type = "keyword"                         },
+
+  { pattern = { '[ruU]?"""', '"""', '\\' },  type = "string"                          },
+  { pattern = { "[ruU]?'''", "'''", '\\' },  type = "string"                          },
+  { pattern = { '[ruU]?"',   '"',   '\\' },  type = "string"                          },
+  { pattern = { "[ruU]?'",   "'",   '\\' },  type = "string"                          },
+  { pattern = { 'f"',        '"',   "\\" },  type = "string", syntax = python_fstring },
+  { pattern = { "f'",        "'",   "\\" },  type = "string", syntax = python_fstring },
+
+  { pattern = "%d+[%d%.eE_]*",               type = "number"                          },
+  { pattern = "0[xboXBO][%da-fA-F_]+",       type = "number"                          },
+  { pattern = "%.?%d+",                      type = "number"                          },
+  { pattern = "%f[-%w_]-%f[%d%.]",           type = "number"                          },
+
+  { pattern = "[%+%-=/%*%^%%<>!~|&]",        type = "operator"                        },
+  { pattern = "[%a_][%w_]*%f[(]",            type = "function"                        },
+
+  { pattern = "[%a_][%w_]+",                 type = "symbol"                          },
+
+}
+
+
+
+local python_type = {
+
+  patterns = {
+    { pattern = "|",            type = "operator"  },
+    { pattern = "[%w_]+",       type = "keyword2"  },
+    { pattern = "[%a_][%w_]+",  type = "symbol"    },
+  },
+
   symbols = {
-    ["class"]    = "keyword",
-    ["finally"]  = "keyword",
-    ["is"]       = "keyword",
-    ["return"]   = "keyword",
-    ["continue"] = "keyword",
-    ["for"]      = "keyword",
-    ["lambda"]   = "keyword",
-    ["try"]      = "keyword",
-    ["def"]      = "keyword",
-    ["from"]     = "keyword",
-    ["nonlocal"] = "keyword",
-    ["while"]    = "keyword",
-    ["and"]      = "keyword",
-    ["global"]   = "keyword",
-    ["not"]      = "keyword",
-    ["with"]     = "keyword",
-    ["as"]       = "keyword",
-    ["elif"]     = "keyword",
-    ["if"]       = "keyword",
-    ["or"]       = "keyword",
-    ["else"]     = "keyword",
-    ["import"]   = "keyword",
-    ["pass"]     = "keyword",
-    ["break"]    = "keyword",
-    ["except"]   = "keyword",
-    ["in"]       = "keyword",
-    ["del"]      = "keyword",
-    ["raise"]    = "keyword",
-    ["yield"]    = "keyword",
-    ["assert"]   = "keyword",
-    ["self"]     = "keyword2",
-    ["None"]     = "literal",
-    ["True"]     = "literal",
-    ["False"]    = "literal",
+    ["None"] = "literal"
   }
 }
+-- Add this line after in order for the recursion to work.
+-- Makes sure that the square brackets are well balanced when capturing the syntax
+-- (in order to make something like this work: Tuple[Tuple[int, str], float])
+table.insert(python_type.patterns, 1, { pattern = { "%[", "%]" }, syntax = python_type })
+
+
+
+-- For things like this_list = other_list[a:b:c]
+local not_python_type = {
+
+  patterns = python_patterns,
+
+  symbols = python_symbols
+
+}
+
+table.insert(not_python_type.patterns, 1, { pattern = { "%[", "%]" }, syntax = not_python_type })
+table.insert(not_python_type.patterns, 1, { pattern = { "{",  "}"  }, syntax = not_python_type })
+
+table.insert(python_fstring.patterns,  1, { pattern = { "{",  "}"  }, syntax = not_python_type })
+
+
+
+local python_func = {
+
+  patterns = table_merge({
+
+    { pattern = { "->",   "%f[:]"        }, type = "operator", syntax = python_type  },
+    { pattern = { ":%s*", "%f[^%[%]%w_]" },                    syntax = python_type  },
+
+  }, python_patterns),
+
+  symbols = python_symbols
+}
+
+table.insert(python_func.patterns, 1, { pattern = { "%(", "%)" }, syntax = python_func })
+
+
+
+syntax.add {
+  name = "Python",
+  files = { "%.py$", "%.pyw$", "%.rpy$", "%.pyi$" },
+  headers = "^#!.*[ /]python",
+  comment = "#",
+  block_comment = { '"""', '"""' },
+
+  patterns = table_merge({
+
+    { pattern = "#.*",                         type = "comment"                                         },
+    { pattern = { '^%s*"""', '"""' },          type = "comment"                                         },
+
+    { pattern = { "%[", "%]" },                                                syntax = not_python_type },
+    { pattern = { "{",  "}"  },                                                syntax = not_python_type },
+
+    { pattern = { "^%s*()def%f[%s]",    ":" }, type = { "normal", "keyword" }, syntax = python_func     }, -- this and the following prevent one-liner highlight bugs
+
+    { pattern = { "^%s*()for%f[%s]",    ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+    { pattern = { "^%s*()if%f[%s]",     ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+    { pattern = { "^%s*()elif%f[%s]",   ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+    { pattern = { "^%s*()while%f[%s]",  ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+    { pattern = { "^%s*()match%f[%s]",  ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+    { pattern = { "^%s*()case%f[%s]",   ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+    { pattern = { "^%s*()except%f[%s]", ":" }, type = { "normal", "keyword" }, syntax = not_python_type },
+
+    { pattern =  "else():",                    type = { "keyword", "normal" }                           },
+    { pattern =  "try():",                     type = { "keyword", "normal" }                           },
+
+    { pattern = "lambda()%s.+:",               type = { "keyword", "normal" }                           },
+    { pattern = "class%s+()[%a_][%w_]+().*:",  type = { "keyword", "keyword2", "normal" }               },
+
+
+    { pattern = { ":%s*", "%f[^%[%]%w_]"},                                     syntax = python_type     },
+
+  }, python_patterns),
+
+  symbols = python_symbols
+
+}
+

data/plugins/language_xml.lua

@@ -1,8 +1,11 @@
+-- mod-version:3
 local syntax = require "core.syntax"
 
 syntax.add {
-  files = { "%.xml$", "%.html?$" },
+  name = "XML",
+  files = { "%.xml$" },
   headers = "<%?xml",
+  block_comment = { "<!--", "-->" },
   patterns = {
     { pattern = { "<!%-%-", "%-%->" },     type = "comment"  },
     { pattern = { '%f[^>][^<]', '%f[<]' }, type = "normal"   },

data/plugins/lineguide.lua

@@ -0,0 +1,115 @@
+-- mod-version:3
+local common = require "core.common"
+local command = require "core.command"
+local config = require "core.config"
+local style = require "core.style"
+local DocView = require "core.docview"
+local CommandView = require "core.commandview"
+
+config.plugins.lineguide = common.merge({
+  enabled = false,
+  width = 2,
+  rulers = {
+    -- 80,
+    -- 100,
+    -- 120,
+    config.line_limit
+  },
+  -- The config specification used by gui generators
+  config_spec = {
+    name = "Line Guide",
+    {
+      label = "Enabled",
+      description = "Disable or enable drawing of the line guide.",
+      path = "enabled",
+      type = "toggle",
+      default = true
+    },
+    {
+      label = "Width",
+      description = "Width in pixels of the line guide.",
+      path = "width",
+      type = "number",
+      default = 2,
+      min = 1
+    },
+    {
+      label = "Ruler Positions",
+      description = "The different column numbers for the line guides to draw.",
+      path = "rulers",
+      type = "list_strings",
+      default = { tostring(config.line_limit) or "80" },
+      get_value = function(rulers)
+        if type(rulers) == "table" then
+          local new_rulers = {}
+          for _, ruler in ipairs(rulers) do
+            table.insert(new_rulers, tostring(ruler))
+          end
+          return new_rulers
+        else
+          return { tostring(config.line_limit) }
+        end
+      end,
+      set_value = function(rulers)
+        local new_rulers = {}
+        for _, ruler in ipairs(rulers) do
+          local number = tonumber(ruler)
+          if number then
+            table.insert(new_rulers, number)
+          end
+        end
+        if #new_rulers == 0 then
+          table.insert(new_rulers, config.line_limit)
+        end
+        return new_rulers
+      end
+    }
+  }
+}, config.plugins.lineguide)
+
+local function get_ruler(v)
+  local result = nil
+  if type(v) == 'number' then
+    result = { columns = v }
+  elseif type(v) == 'table' then
+    result = v
+  end
+  return result
+end
+
+local draw_overlay = DocView.draw_overlay
+function DocView:draw_overlay(...)
+  if
+    type(config.plugins.lineguide) == "table"
+    and
+    config.plugins.lineguide.enabled
+    and
+    self:is(DocView)
+  then
+    local line_x = self:get_line_screen_position(1)
+    local character_width = self:get_font():get_width("n")
+    local ruler_width = config.plugins.lineguide.width
+    local ruler_color = style.guide or style.selection
+
+    for k,v in ipairs(config.plugins.lineguide.rulers) do
+      local ruler = get_ruler(v)
+
+      if ruler then
+        local x = line_x + (character_width * ruler.columns)
+        local y = self.position.y
+        local w = ruler_width
+        local h = self.size.y
+
+        renderer.draw_rect(x, y, w, h, ruler.color or ruler_color)
+      end
+    end
+  end
+  -- everything else like the cursor above the line guides
+  draw_overlay(self, ...)
+end
+
+command.add(nil, {
+  ["lineguide:toggle"] = function()
+    config.plugins.lineguide.enabled = not config.plugins.lineguide.enabled
+  end
+})

data/plugins/linewrapping.lua

@@ -0,0 +1,600 @@
+-- mod-version:3 --priority:10
+local core = require "core"
+local common = require "core.common"
+local DocView = require "core.docview"
+local Doc = require "core.doc"
+local style = require "core.style"
+local config = require "core.config"
+local command = require "core.command"
+local keymap = require "core.keymap"
+local translate = require "core.doc.translate"
+
+
+config.plugins.linewrapping = common.merge({
+	-- The type of wrapping to perform. Can be "letter" or "word".
+  mode = "letter",
+	-- If nil, uses the DocView's size, otherwise, uses this exact width. Can be a function.
+  width_override = nil,
+	-- Whether or not to draw a guide
+  guide = true,
+  -- Whether or not we should indent ourselves like the first line of a wrapped block.
+  indent = true,
+  -- Whether or not to enable wrapping by default when opening files.
+  enable_by_default = false,
+  -- Requires tokenization
+  require_tokenization = false,
+  -- The config specification used by gui generators
+  config_spec = {
+    name = "Line Wrapping",
+    {
+      label = "Mode",
+      description = "The type of wrapping to perform.",
+      path = "mode",
+      type = "selection",
+      default = "letter",
+      values = {
+        {"Letters", "letter"},
+        {"Words", "word"}
+      }
+    },
+    {
+      label = "Guide",
+      description = "Whether or not to draw a guide.",
+      path = "guide",
+      type = "toggle",
+      default = true
+    },
+    {
+      label = "Indent",
+      description = "Whether or not to follow the indentation of wrapped line.",
+      path = "indent",
+      type = "toggle",
+      default = true
+    },
+    {
+      label = "Enable by Default",
+      description = "Whether or not to enable wrapping by default when opening files.",
+      path = "enable_by_default",
+      type = "toggle",
+      default = false
+    },
+    {
+      label = "Require Tokenization",
+      description = "Use tokenization when applying wrapping.",
+      path = "require_tokenization",
+      type = "toggle",
+      default = false
+    }
+  }
+}, config.plugins.linewrapping)
+
+local LineWrapping = {}
+
+-- Optimzation function. The tokenizer is relatively slow (at present), and
+-- so if we don't need to run it, should be run sparingly.
+local function spew_tokens(doc, line) if line < math.huge then return math.huge, "normal", doc.lines[line] end end
+local function get_tokens(doc, line)
+  if config.plugins.linewrapping.require_tokenization then
+    return doc.highlighter:each_token(line)
+  end
+  return spew_tokens, doc, line
+end
+
+-- Computes the breaks for a given line, width and mode. Returns a list of columns
+-- at which the line should be broken.
+function LineWrapping.compute_line_breaks(doc, default_font, line, width, mode)
+  local xoffset, last_i, i, last_space, last_width, begin_width = 0, 1, 1, nil, 0, 0
+  local splits = { 1 }
+  for idx, type, text in get_tokens(doc, line) do
+    local font = style.syntax_fonts[type] or default_font
+    if idx == 1 or idx == math.huge and config.plugins.linewrapping.indent then
+      local _, indent_end = text:find("^%s+")
+      if indent_end then begin_width = font:get_width(text:sub(1, indent_end)) end
+    end
+    local w = font:get_width(text)
+    if xoffset + w > width then
+      for char in common.utf8_chars(text) do
+        w = font:get_width(char)
+        xoffset = xoffset + w
+        if xoffset > width then
+          if mode == "word" and last_space then
+            table.insert(splits, last_space + 1)
+            xoffset = w + begin_width + (xoffset - last_width)
+          else
+            table.insert(splits, i)
+            xoffset = w + begin_width
+          end
+          last_space = nil
+        elseif char == ' ' then
+          last_space = i
+          last_width = xoffset
+        end
+        i = i + #char
+      end
+    else
+      xoffset = xoffset + w
+      i = i + #text
+    end
+  end
+  return splits, begin_width
+end
+
+-- breaks are held in a single table that contains n*2 elements, where n is the amount of line breaks.
+-- each element represents line and column of the break. line_offset will check from the specified line
+-- if the first line has not changed breaks, it will stop there.
+function LineWrapping.reconstruct_breaks(docview, default_font, width, line_offset)
+  if width ~= math.huge then
+    local doc = docview.doc
+    -- two elements per wrapped line; first maps to original line number, second to column number.
+    docview.wrapped_lines = { }
+    -- one element per actual line; maps to the first index of in wrapped_lines for this line
+    docview.wrapped_line_to_idx = { }
+    -- one element per actual line; gives the indent width for the acutal line
+    docview.wrapped_line_offsets = { }
+    docview.wrapped_settings = { ["width"] = width, ["font"] = default_font }
+    for i = line_offset or 1, #doc.lines do
+      local breaks, offset = LineWrapping.compute_line_breaks(doc, default_font, i, width, config.plugins.linewrapping.mode)
+      table.insert(docview.wrapped_line_offsets, offset)
+      for k, col in ipairs(breaks) do
+        table.insert(docview.wrapped_lines, i)
+        table.insert(docview.wrapped_lines, col)
+      end
+    end
+    -- list of indices for wrapped_lines, that are based on original line number
+    -- holds the index to the first in the wrapped_lines list.
+    local last_wrap = nil
+    for i = 1, #docview.wrapped_lines, 2 do
+      if not last_wrap or last_wrap ~= docview.wrapped_lines[i] then
+        table.insert(docview.wrapped_line_to_idx, (i + 1) / 2)
+        last_wrap = docview.wrapped_lines[i]
+      end
+    end
+  else
+    docview.wrapped_lines = nil
+    docview.wrapped_line_to_idx = nil
+    docview.wrapped_line_offsets = nil
+    docview.wrapped_settings = nil
+  end
+end
+
+-- When we have an insertion or deletion, we have four sections of text.
+-- 1. The unaffected section, located prior to the cursor. This is completely ignored.
+-- 2. The beginning of the affected line prior to the insertion or deletion. Begins on column 1 of the selection.
+-- 3. The removed/pasted lines.
+-- 4. Every line after the modification, begins one line after the selection in the initial document.
+function LineWrapping.update_breaks(docview, old_line1, old_line2, net_lines)
+  -- Step 1: Determine the index for the line for #2.
+  local old_idx1 = docview.wrapped_line_to_idx[old_line1] or 1
+  -- Step 2: Determine the index of the line for #4.
+  local old_idx2 = (docview.wrapped_line_to_idx[old_line2 + 1] or ((#docview.wrapped_lines / 2) + 1)) - 1
+  -- Step 3: Remove all old breaks for the old lines from the table, and all old widths from wrapped_line_offsets.
+  local offset = (old_idx1  - 1) * 2 + 1
+  for i = old_idx1, old_idx2 do
+    table.remove(docview.wrapped_lines, offset)
+    table.remove(docview.wrapped_lines, offset)
+  end
+  for i = old_line1, old_line2 do
+    table.remove(docview.wrapped_line_offsets, old_line1)
+  end
+  -- Step 4: Shift the line number of wrapped_lines past #4 by the amount of inserted/deleted lines.
+  if net_lines ~= 0 then
+    for i = offset, #docview.wrapped_lines, 2 do
+      docview.wrapped_lines[i] = docview.wrapped_lines[i] + net_lines
+    end
+  end
+  -- Step 5: Compute the breaks and offsets for the lines for #2 and #3. Insert them into the table.
+  local new_line1 = old_line1
+  local new_line2 = old_line2 + net_lines
+  for line = new_line1, new_line2 do
+    local breaks, begin_width = LineWrapping.compute_line_breaks(docview.doc, docview.wrapped_settings.font, line, docview.wrapped_settings.width, config.plugins.linewrapping.mode)
+    table.insert(docview.wrapped_line_offsets, line, begin_width)
+    for i,b in ipairs(breaks) do
+      table.insert(docview.wrapped_lines, offset, b)
+      table.insert(docview.wrapped_lines, offset, line)
+      offset = offset + 2
+    end
+  end
+  -- Step 6: Recompute the wrapped_line_to_idx cache from #2.
+  local line = old_line1
+  offset = (old_idx1  - 1) * 2 + 1
+  while offset < #docview.wrapped_lines do
+    if docview.wrapped_lines[offset + 1] == 1 then
+      docview.wrapped_line_to_idx[line] = ((offset - 1) / 2) + 1
+      line = line + 1
+    end
+    offset = offset + 2
+  end
+  while line <= #docview.wrapped_line_to_idx do
+    table.remove(docview.wrapped_line_to_idx)
+  end
+end
+
+-- Draws a guide if applicable to show where wrapping is occurring.
+function LineWrapping.draw_guide(docview)
+  if config.plugins.linewrapping.guide and docview.wrapped_settings.width ~= math.huge then
+    local x, y = docview:get_content_offset()
+    local gw = docview:get_gutter_width()
+    renderer.draw_rect(x + gw + docview.wrapped_settings.width, y, 1, core.root_view.size.y, style.selection)
+  end
+end
+
+function LineWrapping.update_docview_breaks(docview)
+  local w = docview.v_scrollbar.expanded_size or style.expanded_scrollbar_size
+  local width = (type(config.plugins.linewrapping.width_override) == "function" and config.plugins.linewrapping.width_override(docview))
+    or config.plugins.linewrapping.width_override or (docview.size.x - docview:get_gutter_width() - w)
+  if (not docview.wrapped_settings or docview.wrapped_settings.width == nil or width ~= docview.wrapped_settings.width) then
+    docview.scroll.to.x = 0
+    LineWrapping.reconstruct_breaks(docview, docview:get_font(), width)
+  end
+end
+
+local function get_idx_line_col(docview, idx)
+  local doc = docview.doc
+  if not docview.wrapped_settings then
+    if idx > #doc.lines then return #doc.lines, #doc.lines[#doc.lines] + 1 end
+    return idx, 1
+  end
+  if idx < 1 then return 1, 1 end
+  local offset = (idx - 1) * 2 + 1
+  if offset > #docview.wrapped_lines then return #doc.lines, #doc.lines[#doc.lines] + 1 end
+  return docview.wrapped_lines[offset], docview.wrapped_lines[offset + 1]
+end
+
+local function get_idx_line_length(docview, idx)
+  local doc = docview.doc
+  if not docview.wrapped_settings then
+    if idx > #doc.lines then return #doc.lines[#doc.lines] + 1 end
+    return #doc.lines[idx]
+  end
+  local offset = (idx - 1) * 2 + 1
+  local start = docview.wrapped_lines[offset + 1]
+  if docview.wrapped_lines[offset + 2] and docview.wrapped_lines[offset + 2] == docview.wrapped_lines[offset] then
+    return docview.wrapped_lines[offset + 3] - docview.wrapped_lines[offset + 1]
+  else
+    return #doc.lines[docview.wrapped_lines[offset]] - docview.wrapped_lines[offset + 1] + 1
+  end
+end
+
+local function get_total_wrapped_lines(docview)
+  if not docview.wrapped_settings then return docview.doc and #docview.doc.lines end
+  return #docview.wrapped_lines / 2
+end
+
+-- If line end, gives the end of an index line, rather than the first character of the next line.
+local function get_line_idx_col_count(docview, line, col, line_end, ndoc)
+  local doc = docview.doc
+  if not docview.wrapped_settings then return common.clamp(line, 1, #doc.lines), col, 1, 1 end
+  if line > #doc.lines then return get_line_idx_col_count(docview, #doc.lines, #doc.lines[#doc.lines] + 1) end
+  line = math.max(line, 1)
+  local idx = docview.wrapped_line_to_idx[line] or 1
+  local ncol, scol = 1, 1
+  if col then
+    local i = idx + 1
+    while line == docview.wrapped_lines[(i - 1) * 2 + 1] and col >= docview.wrapped_lines[(i - 1) * 2 + 2] do
+      local nscol = docview.wrapped_lines[(i - 1) * 2 + 2]
+      if line_end and col == nscol then
+        break
+      end
+      scol = nscol
+      i = i + 1
+      idx = idx + 1
+    end
+    ncol = (col - scol) + 1
+  end
+  local count = (docview.wrapped_line_to_idx[line + 1] or (get_total_wrapped_lines(docview) + 1)) - (docview.wrapped_line_to_idx[line] or get_total_wrapped_lines(docview))
+  return idx, ncol, count, scol
+end
+
+local function get_line_col_from_index_and_x(docview, idx, x)
+  local doc = docview.doc
+  local line, col = get_idx_line_col(docview, idx)
+  if idx < 1 then return 1, 1 end
+  local xoffset, last_i, i = (col ~= 1 and docview.wrapped_line_offsets[line] or 0), col, 1
+  if x < xoffset then return line, col end
+  local default_font = docview:get_font()
+  for _, type, text in doc.highlighter:each_token(line) do
+    local font, w = style.syntax_fonts[type] or default_font, 0
+    for char in common.utf8_chars(text) do
+      if i >= col then
+        if xoffset >= x then
+          return line, (xoffset - x > (w / 2) and last_i or i)
+        end
+        w = font:get_width(char)
+        xoffset = xoffset + w
+      end
+      last_i = i
+      i = i + #char
+    end
+  end
+  return line, #doc.lines[line]
+end
+
+
+local open_files = setmetatable({ }, { __mode = "k" })
+
+local old_doc_insert = Doc.raw_insert
+function Doc:raw_insert(line, col, text, undo_stack, time)
+  local old_lines = #self.lines
+  old_doc_insert(self, line, col, text, undo_stack, time)
+  if open_files[self] then
+    for i,docview in ipairs(open_files[self]) do
+      if docview.wrapped_settings then
+        local lines = #self.lines - old_lines
+        LineWrapping.update_breaks(docview, line, line, lines)
+      end
+    end
+  end
+end
+
+local old_doc_remove = Doc.raw_remove
+function Doc:raw_remove(line1, col1, line2, col2, undo_stack, time)
+  local old_lines = #self.lines
+  old_doc_remove(self, line1, col1, line2, col2, undo_stack, time)
+  if open_files[self] then
+    for i,docview in ipairs(open_files[self]) do
+      if docview.wrapped_settings then
+        local lines = #self.lines - old_lines
+        LineWrapping.update_breaks(docview, line1, line2, lines)
+      end
+    end
+  end
+end
+
+local old_doc_update = DocView.update
+function DocView:update()
+  old_doc_update(self)
+  if self.wrapped_settings and self.size.x > 0 then
+    LineWrapping.update_docview_breaks(self)
+  end
+end
+
+function DocView:get_scrollable_size()
+  if not config.scroll_past_end then
+    return self:get_line_height() * get_total_wrapped_lines(self) + style.padding.y * 2
+  end
+  return self:get_line_height() * (get_total_wrapped_lines(self) - 1) + self.size.y
+end
+
+local old_get_h_scrollable_size = DocView.get_h_scrollable_size
+function DocView:get_h_scrollable_size(...)
+  if self.wrapping_enabled then return 0 end
+  return old_get_h_scrollable_size(self, ...)
+end
+
+local old_new = DocView.new
+function DocView:new(doc)
+  old_new(self, doc)
+  if not open_files[doc] then open_files[doc] = {} end
+  table.insert(open_files[doc], self)
+  if config.plugins.linewrapping.enable_by_default then
+    self.wrapping_enabled = true
+    LineWrapping.update_docview_breaks(self)
+  else
+    self.wrapping_enabled = false
+  end
+end
+
+local old_scroll_to_line = DocView.scroll_to_line
+function DocView:scroll_to_line(...)
+  if self.wrapping_enabled then LineWrapping.update_docview_breaks(self) end
+  old_scroll_to_line(self, ...)
+end
+
+local old_scroll_to_make_visible = DocView.scroll_to_make_visible
+function DocView:scroll_to_make_visible(line, col)
+  if self.wrapping_enabled then LineWrapping.update_docview_breaks(self) end
+  old_scroll_to_make_visible(self, line, col)
+  if self.wrapped_settings then self.scroll.to.x = 0 end
+end
+
+local old_get_visible_line_range = DocView.get_visible_line_range
+function DocView:get_visible_line_range()
+  if not self.wrapped_settings then return old_get_visible_line_range(self) end
+  local x, y, x2, y2 = self:get_content_bounds()
+  local lh = self:get_line_height()
+  local minline = get_idx_line_col(self, math.max(1, math.floor(y / lh)))
+  local maxline = get_idx_line_col(self, math.min(get_total_wrapped_lines(self), math.floor(y2 / lh) + 1))
+  return minline, maxline
+end
+
+local old_get_x_offset_col = DocView.get_x_offset_col
+function DocView:get_x_offset_col(line, x)
+  if not self.wrapped_settings then return old_get_x_offset_col(self, line, x) end
+  local idx = get_line_idx_col_count(self, line)
+  return get_line_col_from_index_and_x(self, idx, x)
+end
+
+-- If line end is true, returns the end of the previous line, in a multi-line break.
+local old_get_col_x_offset = DocView.get_col_x_offset
+function DocView:get_col_x_offset(line, col, line_end)
+  if not self.wrapped_settings then return old_get_col_x_offset(self, line, col) end
+  local idx, ncol, count, scol = get_line_idx_col_count(self, line, col, line_end)
+  local xoffset, i = (scol ~= 1 and self.wrapped_line_offsets[line] or 0), 1
+  local default_font = self:get_font()
+  for _, type, text in self.doc.highlighter:each_token(line) do
+    if i + #text >= scol then
+      if i < scol then
+        text = text:sub(scol - i + 1)
+        i = scol
+      end
+      local font = style.syntax_fonts[type] or default_font
+      for char in common.utf8_chars(text) do
+        if i >= col then
+          return xoffset
+        end
+        xoffset = xoffset + font:get_width(char)
+        i = i + #char
+      end
+    else
+     i = i + #text
+    end
+  end
+  return xoffset
+end
+
+local old_get_line_screen_position = DocView.get_line_screen_position
+function DocView:get_line_screen_position(line, col)
+  if not self.wrapped_settings then return old_get_line_screen_position(self, line, col) end
+  local idx, ncol, count = get_line_idx_col_count(self, line, col)
+  local x, y = self:get_content_offset()
+  local lh = self:get_line_height()
+  local gw = self:get_gutter_width()
+  return x + gw + (col and self:get_col_x_offset(line, col) or 0), y + (idx-1) * lh + style.padding.y
+end
+
+local old_resolve_screen_position = DocView.resolve_screen_position
+function DocView:resolve_screen_position(x, y)
+  if not self.wrapped_settings then return old_resolve_screen_position(self, x, y) end
+  local ox, oy = self:get_line_screen_position(1)
+  local idx = common.clamp(math.floor((y - oy) / self:get_line_height()) + 1, 1, get_total_wrapped_lines(self))
+  return get_line_col_from_index_and_x(self, idx, x - ox)
+end
+
+local old_draw_line_text = DocView.draw_line_text
+function DocView:draw_line_text(line, x, y)
+  if not self.wrapped_settings then return old_draw_line_text(self, line, x, y) end
+  local default_font = self:get_font()
+  local tx, ty, begin_width = x, y + self:get_line_text_y_offset(), self.wrapped_line_offsets[line]
+  local lh = self:get_line_height()
+  local idx, _, count = get_line_idx_col_count(self, line)
+  local total_offset = 1
+  for _, type, text in self.doc.highlighter:each_token(line) do
+    local color = style.syntax[type]
+    local font = style.syntax_fonts[type] or default_font
+    local token_offset = 1
+    -- Split tokens if we're at the end of the document.
+    while text ~= nil and token_offset <= #text do
+      local next_line, next_line_start_col = get_idx_line_col(self, idx + 1)
+      if next_line ~= line then
+        next_line_start_col = #self.doc.lines[line]
+      end
+      local max_length = next_line_start_col - total_offset
+      local rendered_text = text:sub(token_offset, token_offset + max_length - 1)
+      tx = renderer.draw_text(font, rendered_text, tx, ty, color)
+      total_offset = total_offset + #rendered_text
+      if total_offset ~= next_line_start_col or max_length == 0 then break end
+      token_offset = token_offset + #rendered_text
+      idx = idx + 1
+      tx, ty = x + begin_width, ty + lh
+    end
+  end
+  return lh * count
+end
+
+local old_draw_line_body = DocView.draw_line_body
+function DocView:draw_line_body(line, x, y)
+  if not self.wrapped_settings then return old_draw_line_body(self, line, x, y) end
+  local lh = self:get_line_height()
+  local idx0, _, count = get_line_idx_col_count(self, line)
+  for lidx, line1, col1, line2, col2 in self.doc:get_selections(true) do
+    if line >= line1 and line <= line2 then
+      if line1 ~= line then col1 = 1 end
+      if line2 ~= line then col2 = #self.doc.lines[line] + 1 end
+      if col1 ~= col2 then
+        local idx1, ncol1 = get_line_idx_col_count(self, line, col1)
+        local idx2, ncol2 = get_line_idx_col_count(self, line, col2)
+        local start = 0
+        for i = idx1, idx2 do
+          local x1, x2 = x + (idx1 == i and self:get_col_x_offset(line1, col1) or 0)
+          if idx2 == i then
+            x2 = x + self:get_col_x_offset(line, col2)
+          else
+            start = start + get_idx_line_length(self, i, line)
+            x2 = x + self:get_col_x_offset(line, start + 1, true)
+          end
+          renderer.draw_rect(x1, y + (i - idx0) * lh, x2 - x1, lh, style.selection)
+        end
+      end
+    end
+  end
+  local draw_highlight = nil
+  for lidx, line1, col1, line2, col2 in self.doc:get_selections(true) do
+    -- draw line highlight if caret is on this line
+    if draw_highlight ~= false and config.highlight_current_line
+    and line1 == line and core.active_view == self then
+      draw_highlight = (line1 == line2 and col1 == col2)
+    end
+  end
+  if draw_highlight then
+    for i=1,count do
+      self:draw_line_highlight(x + self.scroll.x, y + lh * (i - 1))
+    end
+  end
+  -- draw line's text
+  return self:draw_line_text(line, x, y)
+end
+
+local old_draw = DocView.draw
+function DocView:draw()
+  old_draw(self)
+  if self.wrapped_settings then
+    LineWrapping.draw_guide(self)
+  end
+end
+
+local old_draw_line_gutter = DocView.draw_line_gutter
+function DocView:draw_line_gutter(line, x, y, width)
+  local lh = self:get_line_height()
+  local _, _, count = get_line_idx_col_count(self, line)
+  return (old_draw_line_gutter(self, line, x, y, width) or lh) * count
+end
+
+local old_translate_end_of_line = translate.end_of_line
+function translate.end_of_line(doc, line, col)
+  if not core.active_view or core.active_view.doc ~= doc or not core.active_view.wrapped_settings then old_translate_end_of_line(doc, line, col) end
+  local idx, ncol = get_line_idx_col_count(core.active_view, line, col)
+  local nline, ncol2 = get_idx_line_col(core.active_view, idx + 1)
+  if nline ~= line then return line, math.huge end
+  return line, ncol2 - 1
+end
+
+local old_translate_start_of_line = translate.start_of_line
+function translate.start_of_line(doc, line, col)
+  if not core.active_view or core.active_view.doc ~= doc or not core.active_view.wrapped_settings then old_translate_start_of_line(doc, line, col) end
+  local idx, ncol = get_line_idx_col_count(core.active_view, line, col)
+  local nline, ncol2 = get_idx_line_col(core.active_view, idx - 1)
+  if nline ~= line then return line, 1 end
+  return line, ncol2 + 1
+end
+
+local old_previous_line = DocView.translate.previous_line
+function DocView.translate.previous_line(doc, line, col, dv)
+  if not dv.wrapped_settings then return old_previous_line(doc, line, col, dv) end
+  local idx, ncol = get_line_idx_col_count(dv, line, col)
+  return get_line_col_from_index_and_x(dv, idx - 1, dv:get_col_x_offset(line, col))
+end
+
+local old_next_line = DocView.translate.next_line
+function DocView.translate.next_line(doc, line, col, dv)
+  if not dv.wrapped_settings then return old_next_line(doc, line, col, dv) end
+  local idx, ncol = get_line_idx_col_count(dv, line, col)
+  return get_line_col_from_index_and_x(dv, idx + 1, dv:get_col_x_offset(line, col))
+end
+
+command.add(nil, {
+  ["line-wrapping:enable"] = function()
+    if core.active_view and core.active_view.doc then
+      core.active_view.wrapping_enabled = true
+      LineWrapping.update_docview_breaks(core.active_view)
+    end
+  end,
+  ["line-wrapping:disable"] = function()
+    if core.active_view and core.active_view.doc then
+      core.active_view.wrapping_enabled = false
+      LineWrapping.reconstruct_breaks(core.active_view, core.active_view:get_font(), math.huge)
+    end
+  end,
+  ["line-wrapping:toggle"] = function()
+    if core.active_view and core.active_view.doc and core.active_view.wrapped_settings then
+      command.perform("line-wrapping:disable")
+    else
+      command.perform("line-wrapping:enable")
+    end
+  end
+})
+
+keymap.add {
+  ["f10"] = "line-wrapping:toggle",
+}
+
+return LineWrapping

data/plugins/macro.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local command = require "core.command"
 local keymap = require "core.keymap"

data/plugins/projectsearch.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local common = require "core.common"
 local keymap = require "core.keymap"
@@ -5,15 +6,19 @@ local command = require "core.command"
 local style = require "core.style"
 local View = require "core.view"
 
-
+---@class plugins.projectsearch.resultsview : core.view
 local ResultsView = View:extend()
 
+function ResultsView:__tostring() return "ResultsView" end
 
-function ResultsView:new(text, fn)
+ResultsView.context = "session"
+
+function ResultsView:new(path, text, fn)
   ResultsView.super.new(self)
   self.scrollable = true
   self.brightness = 0
-  self:begin_search(text, fn)
+  self.max_h_scroll = 0
+  self:begin_search(path, text, fn)
 end
 
 
@@ -29,7 +34,12 @@ local function find_all_matches_in_file(t, filename, fn)
   for line in fp:lines() do
     local s = fn(line)
     if s then
-      table.insert(t, { file = filename, text = line, line = n, col = s })
+      -- Insert maximum 256 characters. If we insert more, for compiled files, which can have very long lines
+      -- things tend to get sluggish. If our line is longer than 80 characters, begin to truncate the thing.
+      local start_index = math.max(s - 80, 1)
+      local text = (start_index > 1 and "..." or "") .. line:sub(start_index, 256 + start_index)
+      if #line > 256 + start_index then text = text .. "..." end
+      table.insert(t, { file = filename, text = text, line = n, col = s })
       core.redraw = true
     end
     if n % 100 == 0 then coroutine.yield() end
@@ -40,8 +50,8 @@ local function find_all_matches_in_file(t, filename, fn)
 end
 
 
-function ResultsView:begin_search(text, fn)
-  self.search_args = { text, fn }
+function ResultsView:begin_search(path, text, fn)
+  self.search_args = { path, text, fn }
   self.results = {}
   self.last_file_idx = 1
   self.query = text
@@ -49,11 +59,14 @@ function ResultsView:begin_search(text, fn)
   self.selected_idx = 0
 
   core.add_thread(function()
-    for i, file in ipairs(core.project_files) do
-      if file.type == "file" then
-        find_all_matches_in_file(self.results, file.filename, fn)
+    local i = 1
+    for dir_name, file in core.get_project_files() do
+      if file.type == "file" and (not path or (dir_name .. "/" .. file.filename):find(path, 1, true) == 1) then
+        local truncated_path = (dir_name == core.project_dir and "" or (dir_name .. PATHSEP))
+        find_all_matches_in_file(self.results, truncated_path .. file.filename, fn)
       end
       self.last_file_idx = i
+      i = i + 1
     end
     self.searching = false
     self.brightness = 100
@@ -84,7 +97,7 @@ end
 function ResultsView:on_mouse_pressed(...)
   local caught = ResultsView.super.on_mouse_pressed(self, ...)
   if not caught then
-    self:open_selected_result()
+    return self:open_selected_result()
   end
 end
 
@@ -100,6 +113,7 @@ function ResultsView:open_selected_result()
     dv.doc:set_selection(res.line, res.col)
     dv:scroll_to_line(res.line, false, true)
   end)
+  return true
 end
 
 
@@ -124,10 +138,16 @@ function ResultsView:get_scrollable_size()
 end
 
 
+function ResultsView:get_h_scrollable_size()
+  return self.max_h_scroll
+end
+
+
 function ResultsView:get_visible_results_range()
   local lh = self:get_line_height()
   local oy = self:get_results_yoffset()
-  local min = math.max(1, math.floor((self.scroll.y - oy) / lh))
+  local min = self.scroll.y+oy-style.font:get_height()
+  min = math.max(1, math.floor(min / lh))
   return min, min + math.floor(self.size.y / lh) + 1
 end
 
@@ -141,7 +161,8 @@ function ResultsView:each_visible_result()
     for i = min, max do
       local item = self.results[i]
       if not item then break end
-      coroutine.yield(i, item, x, y, self.size.x, lh)
+      local _, _, w = self:get_content_bounds()
+      coroutine.yield(i, item, x, y, w, lh)
       y = y + lh
     end
   end)
@@ -150,9 +171,9 @@ end
 
 function ResultsView:scroll_to_make_selected_visible()
   local h = self:get_line_height()
-  local y = self:get_results_yoffset() + h * (self.selected_idx - 1)
+  local y = h * (self.selected_idx - 1)
   self.scroll.to.y = math.min(self.scroll.to.y, y)
-  self.scroll.to.y = math.max(self.scroll.to.y, y + h - self.size.y)
+  self.scroll.to.y = math.max(self.scroll.to.y, y + h - self.size.y + self:get_results_yoffset())
 end
 
 
@@ -160,14 +181,26 @@ function ResultsView:draw()
   self:draw_background(style.background)
 
   -- status
-  local ox, oy = self:get_content_offset()
+  local ox, oy = self.position.x, self.position.y
+  local yoffset = self:get_results_yoffset()
+  renderer.draw_rect(self.position.x, self.position.y, self.size.x, yoffset, style.background)
+  if self.scroll.y ~= 0 then
+    renderer.draw_rect(self.position.x, self.position.y+yoffset, self.size.x, style.divider_size, style.divider)
+  end
+
   local x, y = ox + style.padding.x, oy + style.padding.y
-  local per = self.last_file_idx / #core.project_files
+  local files_number = core.project_files_number()
+  local per = common.clamp(files_number and self.last_file_idx / files_number or 1, 0, 1)
   local text
   if self.searching then
-    text = string.format("Searching %d%% (%d of %d files, %d matches) for %q...",
-      per * 100, self.last_file_idx, #core.project_files,
-      #self.results, self.query)
+    if files_number then
+      text = string.format("Searching %.f%% (%d of %d files, %d matches) for %q...",
+        per * 100, self.last_file_idx, files_number,
+        #self.results, self.query)
+    else
+      text = string.format("Searching (%d files, %d matches) for %q...",
+        self.last_file_idx, #self.results, self.query)
+    end
   else
     text = string.format("Found %d matches for %q",
       #self.results, self.query)
@@ -176,7 +209,6 @@ function ResultsView:draw()
   renderer.draw_text(style.font, text, x, y, color)
 
   -- horizontal line
-  local yoffset = self:get_results_yoffset()
   local x = ox + style.padding.x
   local w = self.size.x - style.padding.x * 2
   local h = style.divider_size
@@ -187,6 +219,8 @@ function ResultsView:draw()
   end
 
   -- results
+  local _, _, bw = self:get_content_bounds()
+  core.push_clip_rect(ox, oy+yoffset + style.divider_size, bw, self.size.y-yoffset)
   local y1, y2 = self.position.y, self.position.y + self.size.y
   for i, item, x,y,w,h in self:each_visible_result() do
     local color = style.text
@@ -198,44 +232,129 @@ function ResultsView:draw()
     local text = string.format("%s at line %d (col %d): ", item.file, item.line, item.col)
     x = common.draw_text(style.font, style.dim, text, "left", x, y, w, h)
     x = common.draw_text(style.code_font, color, item.text, "left", x, y, w, h)
+    self.max_h_scroll = math.max(self.max_h_scroll, x)
   end
+  core.pop_clip_rect()
 
   self:draw_scrollbar()
 end
 
-
-local function begin_search(text, fn)
+---@param path string
+---@param text string
+---@param fn fun(line_text:string):...
+---@return plugins.projectsearch.resultsview?
+local function begin_search(path, text, fn)
   if text == "" then
     core.error("Expected non-empty string")
     return
   end
-  local rv = ResultsView(text, fn)
-  core.root_view:get_active_node():add_view(rv)
+  local rv = ResultsView(path, text, fn)
+  core.root_view:get_active_node_default():add_view(rv)
+  return rv
+end
+
+
+local function get_selected_text()
+  local view = core.active_view
+  local doc = (view and view.doc) and view.doc or nil
+  if doc then
+    return doc:get_text(table.unpack({ doc:get_selection() }))
+  end
+end
+
+
+local function normalize_path(path)
+  if not path then return nil end
+  path = common.normalize_path(path)
+  for i, project_dir in ipairs(core.project_directories) do
+    if common.path_belongs_to(path, project_dir.name) then
+      return project_dir.item.filename .. PATHSEP .. common.relative_path(project_dir.name, path)
+    end
+  end
+  return path
+end
+
+---@class plugins.projectsearch
+local projectsearch = {}
+
+---@type plugins.projectsearch.resultsview
+projectsearch.ResultsView = ResultsView
+
+---@param text string
+---@param path string
+---@param insensitive? boolean
+---@return plugins.projectsearch.resultsview?
+function projectsearch.search_plain(text, path, insensitive)
+  if insensitive then text = text:lower() end
+  return begin_search(path, text, function(line_text)
+    if insensitive then
+      return line_text:lower():find(text, nil, true)
+    else
+      return line_text:find(text, nil, true)
+    end
+  end)
+end
+
+---@param text string
+---@param path string
+---@param insensitive? boolean
+---@return plugins.projectsearch.resultsview?
+function projectsearch.search_regex(text, path, insensitive)
+  local re, errmsg
+  if insensitive then
+    re, errmsg = regex.compile(text, "i")
+  else
+    re, errmsg = regex.compile(text)
+  end
+  if not re then core.log("%s", errmsg) return end
+  return begin_search(path, text, function(line_text)
+    return regex.cmatch(re, line_text)
+  end)
+end
+
+---@param text string
+---@param path string
+---@param insensitive? boolean
+---@return plugins.projectsearch.resultsview?
+function projectsearch.search_fuzzy(text, path, insensitive)
+  if insensitive then text = text:lower() end
+  return begin_search(path, text, function(line_text)
+    if insensitive then
+      return common.fuzzy_match(line_text:lower(), text) and 1
+    else
+      return common.fuzzy_match(line_text, text) and 1
+    end
+  end)
 end
 
 
 command.add(nil, {
-  ["project-search:find"] = function()
-    core.command_view:enter("Find Text In Project", function(text)
-      text = text:lower()
-      begin_search(text, function(line_text)
-        return line_text:lower():find(text, nil, true)
-      end)
-    end)
+  ["project-search:find"] = function(path)
+    core.command_view:enter("Find Text In " .. (normalize_path(path) or "Project"), {
+      text = get_selected_text(),
+      select_text = true,
+      submit = function(text)
+        projectsearch.search_plain(text, path, true)
+      end
+    })
   end,
 
-  ["project-search:find-pattern"] = function()
-    core.command_view:enter("Find Pattern In Project", function(text)
-      begin_search(text, function(line_text) return line_text:find(text) end)
-    end)
+  ["project-search:find-regex"] = function(path)
+    core.command_view:enter("Find Regex In " .. (normalize_path(path) or "Project"), {
+      submit = function(text)
+        projectsearch.search_regex(text, path, true)
+      end
+    })
   end,
 
-  ["project-search:fuzzy-find"] = function()
-    core.command_view:enter("Fuzzy Find Text In Project", function(text)
-      begin_search(text, function(line_text)
-        return common.fuzzy_match(line_text, text) and 1
-      end)
-    end)
+  ["project-search:fuzzy-find"] = function(path)
+    core.command_view:enter("Fuzzy Find Text In " .. (normalize_path(path) or "Project"), {
+      text = get_selected_text(),
+      select_text = true,
+      submit = function(text)
+        projectsearch.search_fuzzy(text, path, true)
+      end
+    })
   end,
 })
 
@@ -260,12 +379,41 @@ command.add(ResultsView, {
   ["project-search:refresh"] = function()
     core.active_view:refresh()
   end,
+
+  ["project-search:move-to-previous-page"] = function()
+    local view = core.active_view
+    view.scroll.to.y = view.scroll.to.y - view.size.y
+  end,
+
+  ["project-search:move-to-next-page"] = function()
+    local view = core.active_view
+    view.scroll.to.y = view.scroll.to.y + view.size.y
+  end,
+
+  ["project-search:move-to-start-of-doc"] = function()
+    local view = core.active_view
+    view.scroll.to.y = 0
+  end,
+
+  ["project-search:move-to-end-of-doc"] = function()
+    local view = core.active_view
+    view.scroll.to.y = view:get_scrollable_size()
+  end
 })
 
 keymap.add {
-  ["f5"]           = "project-search:refresh",
-  ["ctrl+shift+f"] = "project-search:find",
-  ["up"]           = "project-search:select-previous",
-  ["down"]         = "project-search:select-next",
-  ["return"]       = "project-search:open-selected",
+  ["f5"]                 = "project-search:refresh",
+  ["ctrl+shift+f"]       = "project-search:find",
+  ["up"]                 = "project-search:select-previous",
+  ["down"]               = "project-search:select-next",
+  ["return"]             = "project-search:open-selected",
+  ["pageup"]             = "project-search:move-to-previous-page",
+  ["pagedown"]           = "project-search:move-to-next-page",
+  ["ctrl+home"]          = "project-search:move-to-start-of-doc",
+  ["ctrl+end"]           = "project-search:move-to-end-of-doc",
+  ["home"]               = "project-search:move-to-start-of-doc",
+  ["end"]                = "project-search:move-to-end-of-doc"
 }
+
+
+return projectsearch

data/plugins/quote.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local command = require "core.command"
 local keymap = require "core.keymap"
@@ -18,8 +19,8 @@ end
 
 
 command.add("core.docview", {
-  ["quote:quote"] = function()
-    core.active_view.doc:replace(function(text)
+  ["quote:quote"] = function(dv)
+    dv.doc:replace(function(text)
       return '"' .. text:gsub("[\0-\31\\\"]", replace) .. '"'
     end)
   end,

data/plugins/reflow.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local config = require "core.config"
 local command = require "core.command"
@@ -24,8 +25,8 @@ end
 
 
 command.add("core.docview", {
-  ["reflow:reflow"] = function()
-    local doc = core.active_view.doc
+  ["reflow:reflow"] = function(dv)
+    local doc = dv.doc
     doc:replace(function(text)
       local prefix_set = "[^%w\n%[%](){}`'\"]*"
 
@@ -58,6 +59,6 @@ command.add("core.docview", {
 })
 
 
-keymap.add {
+keymap.add_direct {
   ["ctrl+shift+q"] = "reflow:reflow"
 }

data/plugins/scale.lua

@@ -0,0 +1,190 @@
+-- mod-version:3
+local core = require "core"
+local common = require "core.common"
+local command = require "core.command"
+local config = require "core.config"
+local keymap = require "core.keymap"
+local style = require "core.style"
+local CommandView = require "core.commandview"
+
+config.plugins.scale = common.merge({
+  -- The method used to apply the scaling: "code", "ui"
+  mode = "code",
+  -- Default scale applied at startup.
+  default_scale = "autodetect",
+  -- Allow using CTRL + MouseWheel for changing the scale.
+  use_mousewheel = true
+}, config.plugins.scale)
+
+local scale_steps = 0.05
+
+local current_scale = SCALE
+local default_scale = SCALE
+
+local function set_scale(scale)
+  scale = common.clamp(scale, 0.2, 6)
+
+  -- save scroll positions
+  local v_scrolls = {}
+  local h_scrolls = {}
+  for _, view in ipairs(core.root_view.root_node:get_children()) do
+    local n = view:get_scrollable_size()
+    if n ~= math.huge and n > view.size.y then
+      v_scrolls[view] = view.scroll.y / (n - view.size.y)
+    end
+    local hn = view:get_h_scrollable_size()
+    if hn ~= math.huge and hn > view.size.x then
+      h_scrolls[view] = view.scroll.x / (hn - view.size.x)
+    end
+  end
+
+  local s = scale / current_scale
+  current_scale = scale
+
+  if config.plugins.scale.mode == "ui" then
+    SCALE = scale
+
+    style.padding.x               = style.padding.x               * s
+    style.padding.y               = style.padding.y               * s
+    style.divider_size            = style.divider_size            * s
+    style.scrollbar_size          = style.scrollbar_size          * s
+    style.expanded_scrollbar_size = style.expanded_scrollbar_size * s
+    style.caret_width             = style.caret_width             * s
+    style.tab_width               = style.tab_width               * s
+
+    for _, name in ipairs {"font", "big_font", "icon_font", "icon_big_font", "code_font"} do
+      style[name]:set_size(s * style[name]:get_size())
+    end
+  else
+    style.code_font:set_size(s * style.code_font:get_size())
+  end
+
+  for name, font in pairs(style.syntax_fonts) do
+    style.syntax_fonts[name]:set_size(s * font:get_size())
+  end
+
+  -- restore scroll positions
+  for view, n in pairs(v_scrolls) do
+    view.scroll.y = n * (view:get_scrollable_size() - view.size.y)
+    view.scroll.to.y = view.scroll.y
+  end
+  for view, hn in pairs(h_scrolls) do
+    view.scroll.x = hn * (view:get_h_scrollable_size() - view.size.x)
+    view.scroll.to.x = view.scroll.x
+  end
+
+  core.redraw = true
+end
+
+local function get_scale()
+  return current_scale
+end
+
+local function res_scale()
+  set_scale(default_scale)
+end
+
+local function inc_scale()
+  set_scale(current_scale + scale_steps)
+end
+
+local function dec_scale()
+  set_scale(current_scale - scale_steps)
+end
+
+if default_scale ~= config.plugins.scale.default_scale then
+  if type(config.plugins.scale.default_scale) == "number" then
+    set_scale(config.plugins.scale.default_scale)
+  end
+end
+
+-- The config specification used by gui generators
+config.plugins.scale.config_spec = {
+  name = "Scale",
+  {
+    label = "Mode",
+    description = "The method used to apply the scaling.",
+    path = "mode",
+    type = "selection",
+    default = "code",
+    values = {
+      {"Everything", "ui"},
+      {"Code Only", "code"}
+    }
+  },
+  {
+    label = "Default Scale",
+    description = "The scaling factor applied to lite-xl.",
+    path = "default_scale",
+    type = "selection",
+    default = "autodetect",
+    values = {
+      {"Autodetect", "autodetect"},
+      {"80%", 0.80},
+      {"90%", 0.90},
+      {"100%", 1.00},
+      {"110%", 1.10},
+      {"120%", 1.20},
+      {"125%", 1.25},
+      {"130%", 1.30},
+      {"140%", 1.40},
+      {"150%", 1.50},
+      {"175%", 1.75},
+      {"200%", 2.00},
+      {"250%", 2.50},
+      {"300%", 3.00}
+    },
+    on_apply = function(value)
+      if type(value) == "string" then value = default_scale end
+      if value ~= current_scale then
+        set_scale(value)
+      end
+    end
+  },
+  {
+    label = "Use MouseWheel",
+    description = "Allow using CTRL + MouseWheel for changing the scale.",
+    path = "use_mousewheel",
+    type = "toggle",
+    default = true,
+    on_apply = function(enabled)
+      if enabled then
+        keymap.add {
+          ["ctrl+wheelup"] = "scale:increase",
+          ["ctrl+wheeldown"] = "scale:decrease"
+        }
+      else
+        keymap.unbind("ctrl+wheelup", "scale:increase")
+        keymap.unbind("ctrl+wheeldown", "scale:decrease")
+      end
+    end
+  }
+}
+
+
+command.add(nil, {
+  ["scale:reset"   ] = function() res_scale() end,
+  ["scale:decrease"] = function() dec_scale() end,
+  ["scale:increase"] = function() inc_scale() end,
+})
+
+keymap.add {
+  ["ctrl+0"] = "scale:reset",
+  ["ctrl+-"] = "scale:decrease",
+  ["ctrl+="] = "scale:increase"
+}
+
+if config.plugins.scale.use_mousewheel then
+  keymap.add {
+    ["ctrl+wheelup"] = "scale:increase",
+    ["ctrl+wheeldown"] = "scale:decrease"
+  }
+end
+
+return {
+  ["set"] = set_scale,
+  ["get"] = get_scale,
+  ["increase"] = inc_scale,
+  ["decrease"] = dec_scale,
+  ["reset"] = res_scale
+}

data/plugins/tabularize.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local command = require "core.command"
 local translate = require "core.doc.translate"
@@ -40,21 +41,23 @@ end
 
 
 command.add("core.docview", {
-  ["tabularize:tabularize"] = function()
-    core.command_view:enter("Tabularize On Delimiter", function(delim)
-      if delim == "" then delim = " " end
+  ["tabularize:tabularize"] = function(dv)
+    core.command_view:enter("Tabularize On Delimiter", {
+      submit = function(delim)
+        if delim == "" then delim = " " end
 
-      local doc = core.active_view.doc
-      local line1, col1, line2, col2, swap = doc:get_selection(true)
-      line1, col1 = doc:position_offset(line1, col1, translate.start_of_line)
-      line2, col2 = doc:position_offset(line2, col2, translate.end_of_line)
-      doc:set_selection(line1, col1, line2, col2, swap)
+        local doc = dv.doc
+        local line1, col1, line2, col2, swap = doc:get_selection(true)
+        line1, col1 = doc:position_offset(line1, col1, translate.start_of_line)
+        line2, col2 = doc:position_offset(line2, col2, translate.end_of_line)
+        doc:set_selection(line1, col1, line2, col2, swap)
 
-      doc:replace(function(text)
-        local lines = gmatch_to_array(text, "[^\n]*\n?")
-        tabularize_lines(lines, delim)
-        return table.concat(lines)
-      end)
-    end)
+        doc:replace(function(text)
+          local lines = gmatch_to_array(text, "[^\n]*\n?")
+          tabularize_lines(lines, delim)
+          return table.concat(lines)
+        end)
+      end
+    })
   end,
 })

data/plugins/toolbarview.lua

@@ -0,0 +1,131 @@
+-- mod-version:3
+local core = require "core"
+local common = require "core.common"
+local command = require "core.command"
+local style = require "core.style"
+local keymap = require "core.keymap"
+local View = require "core.view"
+
+local ToolbarView = View:extend()
+
+function ToolbarView:__tostring() return "ToolbarView" end
+
+function ToolbarView:new()
+  ToolbarView.super.new(self)
+  self.visible = true
+  self.init_size = true
+  self.tooltip = false
+  self.toolbar_font = style.icon_big_font
+  self.toolbar_commands = {
+    {symbol = "f", command = "core:new-doc"},
+    {symbol = "D", command = "core:open-file"},
+    {symbol = "S", command = "doc:save"},
+    {symbol = "L", command = "core:find-file"},
+    {symbol = "B", command = "core:find-command"},
+    {symbol = "P", command = "core:open-user-module"},
+  }
+end
+
+
+function ToolbarView:update()
+  local dest_size = self.visible and (self.toolbar_font:get_height() + style.padding.y * 2) or 0
+  if self.init_size then
+    self.size.y = dest_size
+    self.init_size = nil
+  else
+    self:move_towards(self.size, "y", dest_size)
+  end
+  ToolbarView.super.update(self)
+end
+
+
+function ToolbarView:toggle_visible()
+  self.visible = not self.visible
+  if self.tooltip then
+    core.status_view:remove_tooltip()
+    self.tooltip = false
+  end
+  self.hovered_item = nil
+end
+
+function ToolbarView:get_icon_width()
+  local max_width = 0
+  for i,v in ipairs(self.toolbar_commands) do max_width = math.max(max_width, self.toolbar_font:get_width(v.symbol)) end
+  return max_width
+end
+
+function ToolbarView:each_item()
+  local icon_h, icon_w = self.toolbar_font:get_height(), self:get_icon_width()
+  local toolbar_spacing = icon_w / 2
+  local ox, oy = self:get_content_offset()
+  local index = 0
+  local iter = function()
+    index = index + 1
+    if index <= #self.toolbar_commands then
+      local dx = style.padding.x + (icon_w + toolbar_spacing) * (index - 1)
+      local dy = style.padding.y
+      if dx + icon_w > self.size.x then return end
+      return self.toolbar_commands[index], ox + dx, oy + dy, icon_w, icon_h
+    end
+  end
+  return iter
+end
+
+
+function ToolbarView:get_min_width()
+  local icon_w = self:get_icon_width()
+  local space = icon_w / 2
+  return 2 * style.padding.x + (icon_w + space) * #self.toolbar_commands - space
+end
+
+
+function ToolbarView:draw()
+  if not self.visible then return end
+  self:draw_background(style.background2)
+
+  for item, x, y, w, h in self:each_item() do
+    local color = item == self.hovered_item and command.is_valid(item.command) and style.text or style.dim
+    common.draw_text(self.toolbar_font, color, item.symbol, nil, x, y, 0, h)
+  end
+end
+
+
+function ToolbarView:on_mouse_pressed(button, x, y, clicks)
+  if not self.visible then return end
+  local caught = ToolbarView.super.on_mouse_pressed(self, button, x, y, clicks)
+  if caught then return caught end
+  core.set_active_view(core.last_active_view)
+  if self.hovered_item and command.is_valid(self.hovered_item.command) then
+    command.perform(self.hovered_item.command)
+  end
+  return true
+end
+
+
+function ToolbarView:on_mouse_moved(px, py, ...)
+  if not self.visible then return end
+  ToolbarView.super.on_mouse_moved(self, px, py, ...)
+  self.hovered_item = nil
+  local x_min, x_max, y_min, y_max = self.size.x, 0, self.size.y, 0
+  for item, x, y, w, h in self:each_item() do
+    x_min, x_max = math.min(x, x_min), math.max(x + w, x_max)
+    y_min, y_max = y, y + h
+    if px > x and py > y and px <= x + w and py <= y + h then
+      self.hovered_item = item
+      local binding = keymap.get_binding(item.command)
+      local name = command.prettify_name(item.command)
+      core.status_view:show_tooltip(binding and { name, style.dim, "  ", binding } or { name })
+      self.tooltip = true
+      return
+    end
+  end
+  if self.tooltip and not (px > x_min and px <= x_max and py > y_min and py <= y_max) then
+    core.status_view:remove_tooltip()
+    self.tooltip = false
+  end
+end
+
+-- The toolbarview pane is not plugged here but it is added in the
+-- treeview plugin.
+
+return ToolbarView

data/plugins/treeview.lua

@@ -1,3 +1,4 @@
+-- mod-version:3
 local core = require "core"
 local common = require "core.common"
 local command = require "core.command"
@@ -5,46 +6,98 @@ local config = require "core.config"
 local keymap = require "core.keymap"
 local style = require "core.style"
 local View = require "core.view"
+local ContextMenu = require "core.contextmenu"
+local RootView = require "core.rootview"
+local CommandView = require "core.commandview"
+
+config.plugins.treeview = common.merge({
+  -- Default treeview width
+  size = 200 * SCALE
+}, config.plugins.treeview)
+
+local tooltip_offset = style.font:get_height()
+local tooltip_border = 1
+local tooltip_delay = 0.5
+local tooltip_alpha = 255
+local tooltip_alpha_rate = 1
 
-config.treeview_size = 200 * SCALE
 
 local function get_depth(filename)
-  local n = 0
-  for sep in filename:gmatch("[\\/]") do
+  local n = 1
+  for _ in filename:gmatch(PATHSEP) do
     n = n + 1
   end
   return n
 end
 
+local function replace_alpha(color, alpha)
+  local r, g, b = table.unpack(color)
+  return { r, g, b, alpha }
+end
+
 
 local TreeView = View:extend()
 
+function TreeView:__tostring() return "TreeView" end
+
 function TreeView:new()
   TreeView.super.new(self)
   self.scrollable = true
   self.visible = true
   self.init_size = true
+  self.target_size = config.plugins.treeview.size
   self.cache = {}
+  self.tooltip = { x = 0, y = 0, begin = 0, alpha = 0 }
+  self.cursor_pos = { x = 0, y = 0 }
+
+  self.item_icon_width = 0
+  self.item_text_spacing = 0
 end
 
 
-function TreeView:get_cached(item)
-  local t = self.cache[item.filename]
-  if not t then
+function TreeView:set_target_size(axis, value)
+  if axis == "x" then
+    self.target_size = value
+    return true
+  end
+end
+
+
+function TreeView:get_cached(dir, item, dirname)
+  local dir_cache = self.cache[dirname]
+  if not dir_cache then
+    dir_cache = {}
+    self.cache[dirname] = dir_cache
+  end
+  -- to discriminate top directories from regular files or subdirectories
+  -- we add ':' at the end of the top directories' filename. it will be
+  -- used only to identify the entry into the cache.
+  local cache_name = item.filename .. (item.topdir and ":" or "")
+  local t = dir_cache[cache_name]
+  if not t or t.type ~= item.type then
     t = {}
-    t.filename = item.filename
-    t.abs_filename = system.absolute_path(item.filename)
-    t.name = t.filename:match("[^\\/]+$")
-    t.depth = get_depth(t.filename)
+    local basename = common.basename(item.filename)
+    if item.topdir then
+      t.filename = basename
+      t.expanded = true
+      t.depth = 0
+      t.abs_filename = dirname
+    else
+      t.filename = item.filename
+      t.depth = get_depth(item.filename)
+      t.abs_filename = dirname .. PATHSEP .. item.filename
+    end
+    t.name = basename
     t.type = item.type
-    self.cache[t.filename] = t
+    t.dir_name = dir.name -- points to top level "dir" item
+    dir_cache[cache_name] = t
   end
   return t
 end
 
 
 function TreeView:get_name()
-  return "Project"
+  return nil
 end
 
 
@@ -53,13 +106,21 @@ function TreeView:get_item_height()
 end
 
 
+function TreeView:invalidate_cache(dirname)
+  for _, v in pairs(self.cache[dirname]) do
+    v.skip = nil
+  end
+end
+
+
 function TreeView:check_cache()
-  -- invalidate cache's skip values if project_files has changed
-  if core.project_files ~= self.last_project_files then
-    for _, v in pairs(self.cache) do
-      v.skip = nil
+  for i = 1, #core.project_directories do
+    local dir = core.project_directories[i]
+    -- invalidate cache's skip values if directory is declared dirty
+    if dir.is_dirty and self.cache[dir.name] then
+      self:invalidate_cache(dir.name)
     end
-    self.last_project_files = core.project_files
+    dir.is_dirty = false
   end
 end
 
@@ -67,117 +128,314 @@ end
 function TreeView:each_item()
   return coroutine.wrap(function()
     self:check_cache()
+    local count_lines = 0
     local ox, oy = self:get_content_offset()
     local y = oy + style.padding.y
     local w = self.size.x
     local h = self:get_item_height()
 
-    local i = 1
-    while i <= #core.project_files do
-      local item = core.project_files[i]
-      local cached = self:get_cached(item)
-
-      coroutine.yield(cached, ox, y, w, h)
+    for k = 1, #core.project_directories do
+      local dir = core.project_directories[k]
+      local dir_cached = self:get_cached(dir, dir.item, dir.name)
+      coroutine.yield(dir_cached, ox, y, w, h)
+      count_lines = count_lines + 1
       y = y + h
-      i = i + 1
+      local i = 1
+      if dir.files then -- if consumed max sys file descriptors this can be nil
+        while i <= #dir.files and dir_cached.expanded do
+          local item = dir.files[i]
+          local cached = self:get_cached(dir, item, dir.name)
 
-      if not cached.expanded then
-        if cached.skip then
-          i = cached.skip
-        else
-          local depth = cached.depth
-          while i <= #core.project_files do
-            local filename = core.project_files[i].filename
-            if get_depth(filename) <= depth then break end
-            i = i + 1
+          coroutine.yield(cached, ox, y, w, h)
+          count_lines = count_lines + 1
+          y = y + h
+          i = i + 1
+
+          if not cached.expanded then
+            if cached.skip then
+              i = cached.skip
+            else
+              local depth = cached.depth
+              while i <= #dir.files do
+                if get_depth(dir.files[i].filename) <= depth then break end
+                i = i + 1
+              end
+              cached.skip = i
+            end
           end
-          cached.skip = i
-        end
+        end -- while files
       end
-    end
+    end -- for directories
+    self.count_lines = count_lines
   end)
 end
 
 
-function TreeView:on_mouse_moved(px, py)
-  self.hovered_item = nil
-  for item, x,y,w,h in self:each_item() do
-    if px > x and py > y and px <= x + w and py <= y + h then
-      self.hovered_item = item
-      break
+function TreeView:set_selection(selection, selection_y)
+  self.selected_item = selection
+  if selection and selection_y
+      and (selection_y <= 0 or selection_y >= self.size.y) then
+
+    local lh = self:get_item_height()
+    if selection_y >= self.size.y - lh then
+      selection_y = selection_y - self.size.y + lh
     end
+    local _, y = self:get_content_offset()
+    self.scroll.to.y = selection and (selection_y - y)
   end
 end
 
 
-function TreeView:on_mouse_pressed(button, x, y)
-  if not self.hovered_item then
+function TreeView:get_text_bounding_box(item, x, y, w, h)
+  local icon_width = style.icon_font:get_width("D")
+  local xoffset = item.depth * style.padding.x + style.padding.x + icon_width
+  x = x + xoffset
+  w = style.font:get_width(item.name) + 2 * style.padding.x
+  return x, y, w, h
+end
+
+
+function TreeView:on_mouse_moved(px, py, ...)
+  if not self.visible then return end
+  self.cursor_pos.x = px
+  self.cursor_pos.y = py
+  if TreeView.super.on_mouse_moved(self, px, py, ...) then
+    -- mouse movement handled by the View (scrollbar)
+    self.hovered_item = nil
     return
-  elseif self.hovered_item.type == "dir" then
-    self.hovered_item.expanded = not self.hovered_item.expanded
-  else
-    core.try(function()
-      core.root_view:open_doc(core.open_doc(self.hovered_item.filename))
-    end)
   end
+
+  local item_changed, tooltip_changed
+  for item, x,y,w,h in self:each_item() do
+    if px > x and py > y and px <= x + w and py <= y + h then
+      item_changed = true
+      self.hovered_item = item
+
+      x,y,w,h = self:get_text_bounding_box(item, x,y,w,h)
+      if px > x and py > y and px <= x + w and py <= y + h then
+        tooltip_changed = true
+        self.tooltip.x, self.tooltip.y = px, py
+        self.tooltip.begin = system.get_time()
+      end
+      break
+    end
+  end
+  if not item_changed then self.hovered_item = nil end
+  if not tooltip_changed then self.tooltip.x, self.tooltip.y = nil, nil end
 end
 
 
 function TreeView:update()
   -- update width
-  local dest = self.visible and config.treeview_size or 0
+  local dest = self.visible and self.target_size or 0
   if self.init_size then
     self.size.x = dest
     self.init_size = false
   else
-    self:move_towards(self.size, "x", dest)
+    self:move_towards(self.size, "x", dest, nil, "treeview")
+  end
+
+  if not self.visible then return end
+
+  local duration = system.get_time() - self.tooltip.begin
+  if self.hovered_item and self.tooltip.x and duration > tooltip_delay then
+    self:move_towards(self.tooltip, "alpha", tooltip_alpha, tooltip_alpha_rate, "treeview")
+  else
+    self.tooltip.alpha = 0
+  end
+
+  self.item_icon_width = style.icon_font:get_width("D")
+  self.item_text_spacing = style.icon_font:get_width("f") / 2
+
+  -- this will make sure hovered_item is updated
+  -- we don't want events when the thing is scrolling fast
+  local dy = math.abs(self.scroll.to.y - self.scroll.y)
+  if self.scroll.to.y ~= 0 and dy < self:get_item_height() then
+    self:on_mouse_moved(self.cursor_pos.x, self.cursor_pos.y, 0, 0)
   end
 
   TreeView.super.update(self)
 end
 
 
+function TreeView:get_scrollable_size()
+  return self.count_lines and self:get_item_height() * (self.count_lines + 1) or math.huge
+end
+
+
+function TreeView:draw_tooltip()
+  local text = common.home_encode(self.hovered_item.abs_filename)
+  local w, h = style.font:get_width(text), style.font:get_height(text)
+
+  local x, y = self.tooltip.x + tooltip_offset, self.tooltip.y + tooltip_offset
+  w, h = w + style.padding.x, h + style.padding.y
+
+  if x + w > core.root_view.root_node.size.x then -- check if we can span right
+    x = x - w -- span left instead
+  end
+
+  local bx, by = x - tooltip_border, y - tooltip_border
+  local bw, bh = w + 2 * tooltip_border, h + 2 * tooltip_border
+  renderer.draw_rect(bx, by, bw, bh, replace_alpha(style.text, self.tooltip.alpha))
+  renderer.draw_rect(x, y, w, h, replace_alpha(style.background2, self.tooltip.alpha))
+  common.draw_text(style.font, replace_alpha(style.text, self.tooltip.alpha), text, "center", x, y, w, h)
+end
+
+
+function TreeView:get_item_icon(item, active, hovered)
+  local character = "f"
+  if item.type == "dir" then
+    character = item.expanded and "D" or "d"
+  end
+  local font = style.icon_font
+  local color = style.text
+  if active or hovered then
+    color = style.accent
+  end
+  return character, font, color
+end
+
+function TreeView:get_item_text(item, active, hovered)
+  local text = item.name
+  local font = style.font
+  local color = style.text
+  if active or hovered then
+    color = style.accent
+  end
+  return text, font, color
+end
+
+
+function TreeView:draw_item_text(item, active, hovered, x, y, w, h)
+  local item_text, item_font, item_color = self:get_item_text(item, active, hovered)
+  common.draw_text(item_font, item_color, item_text, nil, x, y, 0, h)
+end
+
+
+function TreeView:draw_item_icon(item, active, hovered, x, y, w, h)
+  local icon_char, icon_font, icon_color = self:get_item_icon(item, active, hovered)
+  common.draw_text(icon_font, icon_color, icon_char, nil, x, y, 0, h)
+  return self.item_icon_width + self.item_text_spacing
+end
+
+
+function TreeView:draw_item_body(item, active, hovered, x, y, w, h)
+    x = x + self:draw_item_icon(item, active, hovered, x, y, w, h)
+    self:draw_item_text(item, active, hovered, x, y, w, h)
+end
+
+
+function TreeView:draw_item_chevron(item, active, hovered, x, y, w, h)
+  if item.type == "dir" then
+    local chevron_icon = item.expanded and "-" or "+"
+    local chevron_color = hovered and style.accent or style.text
+    common.draw_text(style.icon_font, chevron_color, chevron_icon, nil, x, y, 0, h)
+  end
+  return style.padding.x
+end
+
+
+function TreeView:draw_item_background(item, active, hovered, x, y, w, h)
+  if hovered then
+    local hover_color = { table.unpack(style.line_highlight) }
+    hover_color[4] = 160
+    renderer.draw_rect(x, y, w, h, hover_color)
+  elseif active then
+    renderer.draw_rect(x, y, w, h, style.line_highlight)
+  end
+end
+
+
+function TreeView:draw_item(item, active, hovered, x, y, w, h)
+  self:draw_item_background(item, active, hovered, x, y, w, h)
+
+  x = x + item.depth * style.padding.x + style.padding.x
+  x = x + self:draw_item_chevron(item, active, hovered, x, y, w, h)
+
+  self:draw_item_body(item, active, hovered, x, y, w, h)
+end
+
+
 function TreeView:draw()
+  if not self.visible then return end
   self:draw_background(style.background2)
-
-  local icon_width = style.icon_font:get_width("D")
-  local spacing = style.font:get_width(" ") * 2
-
-  local doc = core.active_view.doc
-  local active_filename = doc and system.absolute_path(doc.filename or "")
+  local _y, _h = self.position.y, self.size.y
 
   for item, x,y,w,h in self:each_item() do
-    local color = style.text
-
-    -- highlight active_view doc
-    if item.abs_filename == active_filename then
-      color = style.accent
+    if y + h >= _y and y < _y + _h then
+      self:draw_item(item,
+        item == self.selected_item,
+        item == self.hovered_item,
+        x, y, w, h)
     end
+  end
 
-    -- hovered item background
-    if item == self.hovered_item then
-      renderer.draw_rect(x, y, w, h, style.line_highlight)
-      color = style.accent
+  self:draw_scrollbar()
+  if self.hovered_item and self.tooltip.x and self.tooltip.alpha > 0 then
+    core.root_view:defer_draw(self.draw_tooltip, self)
+  end
+end
+
+
+function TreeView:get_parent(item)
+  local parent_path = common.dirname(item.abs_filename)
+  if not parent_path then return end
+  for it, _, y in self:each_item() do
+    if it.abs_filename == parent_path then
+      return it, y
     end
+  end
+end
 
-    -- icons
-    x = x + item.depth * style.padding.x + style.padding.x
-    if item.type == "dir" then
-      local icon1 = item.expanded and "-" or "+"
-      local icon2 = item.expanded and "D" or "d"
-      common.draw_text(style.icon_font, color, icon1, nil, x, y, 0, h)
-      x = x + style.padding.x
-      common.draw_text(style.icon_font, color, icon2, nil, x, y, 0, h)
-      x = x + icon_width
+
+function TreeView:get_item(item, where)
+  local last_item, last_x, last_y, last_w, last_h
+  local stop = false
+
+  for it, x, y, w, h in self:each_item() do
+    if not item and where >= 0 then
+      return it, x, y, w, h
+    end
+    if item == it then
+      if where < 0 and last_item then
+        break
+      elseif where == 0 or (where < 0 and not last_item) then
+        return it, x, y, w, h
+      end
+      stop = true
+    elseif stop then
+      item = it
+      return it, x, y, w, h
+    end
+    last_item, last_x, last_y, last_w, last_h = it, x, y, w, h
+  end
+  return last_item, last_x, last_y, last_w, last_h
+end
+
+function TreeView:get_next(item)
+  return self:get_item(item, 1)
+end
+
+function TreeView:get_previous(item)
+  return self:get_item(item, -1)
+end
+
+
+function TreeView:toggle_expand(toggle)
+  local item = self.selected_item
+
+  if not item then return end
+
+  if item.type == "dir" then
+    if type(toggle) == "boolean" then
+      item.expanded = toggle
     else
-      x = x + style.padding.x
-      common.draw_text(style.icon_font, color, "f", nil, x, y, 0, h)
-      x = x + icon_width
+      item.expanded = not item.expanded
+    end
+    local hovered_dir = core.project_dir_by_name(item.dir_name)
+    if hovered_dir and hovered_dir.files_limit then
+      core.update_project_subdir(hovered_dir, item.depth == 0 and "" or item.filename, item.expanded)
     end
-
-    -- text
-    x = x + spacing
-    x = common.draw_text(style.font, color, item.name, nil, x, y, 0, h)
   end
 end
 
@@ -185,13 +443,452 @@ end
 -- init
 local view = TreeView()
 local node = core.root_view:get_active_node()
-node:split("left", view, true)
+view.node = node:split("left", view, {x = true}, true)
 
--- register commands and keymap
+-- The toolbarview plugin is special because it is plugged inside
+-- a treeview pane which is itelf provided in a plugin.
+-- We therefore break the usual plugin's logic that would require each
+-- plugin to be independent of each other. In addition it is not the
+-- plugin module that plug itself in the active node but it is plugged here
+-- in the treeview node.
+local toolbar_view = nil
+local toolbar_plugin, ToolbarView = pcall(require, "plugins.toolbarview")
+if config.plugins.toolbarview ~= false and toolbar_plugin then
+  toolbar_view = ToolbarView()
+  view.node:split("down", toolbar_view, {y = true})
+  local min_toolbar_width = toolbar_view:get_min_width()
+  view:set_target_size("x", math.max(config.plugins.treeview.size, min_toolbar_width))
+  command.add(nil, {
+    ["toolbar:toggle"] = function()
+      toolbar_view:toggle_visible()
+    end,
+  })
+end
+
+-- Add a context menu to the treeview
+local menu = ContextMenu()
+
+local on_view_mouse_pressed = RootView.on_view_mouse_pressed
+local on_mouse_moved = RootView.on_mouse_moved
+local root_view_update = RootView.update
+local root_view_draw = RootView.draw
+
+function RootView:on_mouse_moved(...)
+  if menu:on_mouse_moved(...) then return end
+  on_mouse_moved(self, ...)
+end
+
+function RootView.on_view_mouse_pressed(button, x, y, clicks)
+  -- We give the priority to the menu to process mouse pressed events.
+  if button == "right" then
+    view.tooltip.alpha = 0
+    view.tooltip.x, view.tooltip.y = nil, nil
+  end
+  local handled = menu:on_mouse_pressed(button, x, y, clicks)
+  return handled or on_view_mouse_pressed(button, x, y, clicks)
+end
+
+function RootView:update(...)
+  root_view_update(self, ...)
+  menu:update()
+end
+
+function RootView:draw(...)
+  root_view_draw(self, ...)
+  menu:draw()
+end
+
+local on_quit_project = core.on_quit_project
+function core.on_quit_project()
+  view.cache = {}
+  on_quit_project()
+end
+
+local function is_project_folder(path)
+  for _,dir in pairs(core.project_directories) do
+    if dir.name == path then
+      return true
+    end
+  end
+  return false
+end
+
+local function is_primary_project_folder(path)
+  return core.project_dir == path
+end
+
+
+local function treeitem() return view.hovered_item or view.selected_item end
+
+
+menu:register(function() return core.active_view:is(TreeView) and treeitem() end, {
+  { text = "Open in System", command = "treeview:open-in-system" },
+  ContextMenu.DIVIDER
+})
+
+menu:register(
+  function()
+    local item = treeitem()
+    return core.active_view:is(TreeView) and item and not is_project_folder(item.abs_filename)
+  end,
+  {
+    { text = "Rename", command = "treeview:rename" },
+    { text = "Delete", command = "treeview:delete" },
+  }
+)
+
+menu:register(
+  function()
+    local item = treeitem()
+    return core.active_view:is(TreeView) and item and item.type == "dir"
+  end,
+  {
+    { text = "New File", command = "treeview:new-file" },
+    { text = "New Folder", command = "treeview:new-folder" },
+  }
+)
+
+menu:register(
+  function()
+    local item = treeitem()
+    return core.active_view:is(TreeView) and item
+      and not is_primary_project_folder(item.abs_filename)
+      and is_project_folder(item.abs_filename)
+  end,
+  {
+    { text = "Remove directory", command = "treeview:remove-project-directory" },
+  }
+)
+
+local previous_view = nil
+
+-- Register the TreeView commands and keymap
 command.add(nil, {
   ["treeview:toggle"] = function()
     view.visible = not view.visible
   end,
+
+  ["treeview:toggle-focus"] = function()
+    if not core.active_view:is(TreeView) then
+      if core.active_view:is(CommandView) then
+        previous_view = core.last_active_view
+      else
+        previous_view = core.active_view
+      end
+      if not previous_view then
+        previous_view = core.root_view:get_primary_node().active_view
+      end
+      core.set_active_view(view)
+      if not view.selected_item then
+        for it, _, y in view:each_item() do
+          view:set_selection(it, y)
+          break
+        end
+      end
+
+    else
+      core.set_active_view(
+        previous_view or core.root_view:get_primary_node().active_view
+      )
+    end
+  end
 })
 
-keymap.add { ["ctrl+\\"] = "treeview:toggle" }
+command.add(
+  function()
+    return not menu.show_context_menu and core.active_view:extends(TreeView), TreeView
+  end, {
+  ["treeview:next"] = function()
+    local item, _, item_y = view:get_next(view.selected_item)
+    view:set_selection(item, item_y)
+  end,
+
+  ["treeview:previous"] = function()
+    local item, _, item_y = view:get_previous(view.selected_item)
+    view:set_selection(item, item_y)
+  end,
+
+  ["treeview:open"] = function()
+    local item = view.selected_item
+    if not item then return end
+    if item.type == "dir" then
+      view:toggle_expand()
+    else
+      core.try(function()
+        if core.last_active_view and core.active_view == view then
+          core.set_active_view(core.last_active_view)
+        end
+        local doc_filename = core.normalize_to_project_dir(item.abs_filename)
+        core.root_view:open_doc(core.open_doc(doc_filename))
+      end)
+    end
+  end,
+
+  ["treeview:deselect"] = function()
+    view.selected_item = nil
+  end,
+
+  ["treeview:select"] = function()
+    view:set_selection(view.hovered_item)
+  end,
+
+  ["treeview:select-and-open"] = function()
+    if view.hovered_item then
+      view:set_selection(view.hovered_item)
+      command.perform "treeview:open"
+    end
+  end,
+
+  ["treeview:collapse"] = function()
+    if view.selected_item then
+      if view.selected_item.type == "dir" and view.selected_item.expanded then
+        view:toggle_expand(false)
+      else
+        local parent_item, y = view:get_parent(view.selected_item)
+        if parent_item then
+          view:set_selection(parent_item, y)
+        end
+      end
+    end
+  end,
+
+  ["treeview:expand"] = function()
+    local item = view.selected_item
+    if not item or item.type ~= "dir" then return end
+
+    if item.expanded then
+      local next_item, _, next_y = view:get_next(item)
+      if next_item.depth > item.depth then
+        view:set_selection(next_item, next_y)
+      end
+    else
+      view:toggle_expand(true)
+    end
+  end,
+})
+
+
+command.add(
+  function()
+    local item = treeitem()
+    return item ~= nil and (core.active_view == view or menu.show_context_menu), item
+  end, {
+  ["treeview:delete"] = function(item)
+    local filename = item.abs_filename
+    local relfilename = item.filename
+    if item.dir_name ~= core.project_dir then
+      -- add secondary project dirs names to the file path to show
+      relfilename = common.basename(item.dir_name) .. PATHSEP .. relfilename
+    end
+    local file_info = system.get_file_info(filename)
+    local file_type = file_info.type == "dir" and "Directory" or "File"
+    -- Ask before deleting
+    local opt = {
+      { text = "Yes", default_yes = true },
+      { text = "No", default_no = true }
+    }
+    core.nag_view:show(
+      string.format("Delete %s", file_type),
+      string.format(
+        "Are you sure you want to delete the %s?\n%s: %s",
+        file_type:lower(), file_type, relfilename
+      ),
+      opt,
+      function(item)
+        if item.text == "Yes" then
+          if file_info.type == "dir" then
+            local deleted, error, path = common.rm(filename, true)
+            if not deleted then
+              core.error("Error: %s - \"%s\" ", error, path)
+              return
+            end
+          else
+            local removed, error = os.remove(filename)
+            if not removed then
+              core.error("Error: %s - \"%s\"", error, filename)
+              return
+            end
+          end
+          core.log("Deleted \"%s\"", filename)
+        end
+      end
+    )
+  end,
+
+  ["treeview:rename"] = function(item)
+    local old_filename = item.filename
+    local old_abs_filename = item.abs_filename
+    core.command_view:enter("Rename", {
+      text = old_filename,
+      submit = function(filename)
+        local abs_filename = filename
+        if not common.is_absolute_path(filename) then
+          abs_filename = item.dir_name .. PATHSEP .. filename
+        end
+        local res, err = os.rename(old_abs_filename, abs_filename)
+        if res then -- successfully renamed
+          for _, doc in ipairs(core.docs) do
+            if doc.abs_filename and old_abs_filename == doc.abs_filename then
+              doc:set_filename(filename, abs_filename) -- make doc point to the new filename
+              doc:reset_syntax()
+              break -- only first needed
+            end
+          end
+          core.log("Renamed \"%s\" to \"%s\"", old_filename, filename)
+        else
+          core.error("Error while renaming \"%s\" to \"%s\": %s", old_abs_filename, abs_filename, err)
+        end
+      end,
+      suggest = function(text)
+        return common.path_suggest(text, item.dir_name)
+      end
+    })
+  end,
+
+  ["treeview:new-file"] = function(item)
+    local text
+    if not is_project_folder(item.abs_filename) then
+      if item.type == "dir" then
+        text = item.filename .. PATHSEP
+      elseif item.type == "file" then
+        local parent_dir = common.dirname(item.filename)
+        text = parent_dir and parent_dir .. PATHSEP
+      end
+    end
+    core.command_view:enter("Filename", {
+      text = text,
+      submit = function(filename)
+        local doc_filename = item.dir_name .. PATHSEP .. filename
+        core.log(doc_filename)
+        local file = io.open(doc_filename, "a+")
+        file:write("")
+        file:close()
+        core.root_view:open_doc(core.open_doc(doc_filename))
+        core.log("Created %s", doc_filename)
+      end,
+      suggest = function(text)
+        return common.path_suggest(text, item.dir_name)
+      end
+    })
+  end,
+
+  ["treeview:new-folder"] = function(item)
+    local text
+    if not is_project_folder(item.abs_filename) then
+      if item.type == "dir" then
+        text = item.filename .. PATHSEP
+      elseif item.type == "file" then
+        local parent_dir = common.dirname(item.filename)
+        text = parent_dir and parent_dir .. PATHSEP
+      end
+    end
+    core.command_view:enter("Folder Name", {
+      text = text,
+      submit = function(filename)
+        local dir_path = item.dir_name .. PATHSEP .. filename
+        common.mkdirp(dir_path)
+        core.log("Created %s", dir_path)
+      end,
+      suggest = function(text)
+        return common.path_suggest(text, item.dir_name)
+      end
+    })
+  end,
+
+  ["treeview:open-in-system"] = function(item)
+    if PLATFORM == "Windows" then
+      system.exec(string.format("start \"\" %q", item.abs_filename))
+    elseif string.find(PLATFORM, "Mac") then
+      system.exec(string.format("open %q", item.abs_filename))
+    elseif PLATFORM == "Linux" or string.find(PLATFORM, "BSD") then
+      system.exec(string.format("xdg-open %q", item.abs_filename))
+    end
+  end
+})
+
+local projectsearch = pcall(require, "plugins.projectsearch")
+if projectsearch then
+  menu:register(function()
+    local item = treeitem()
+    return item and item.type == "dir"
+  end, { 
+    { text = "Find in directory", command = "treeview:search-in-directory" } 
+  })
+  command.add(function()
+    return view.hovered_item and view.hovered_item.type == "dir"
+  end, {
+    ["treeview:search-in-directory"] = function(item)
+      command.perform("project-search:find", view.hovered_item.abs_filename)
+    end
+  })
+end
+
+command.add(function()
+    local item = treeitem()
+    return item
+           and not is_primary_project_folder(item.abs_filename)
+           and is_project_folder(item.abs_filename), item
+  end, {
+  ["treeview:remove-project-directory"] = function(item)
+    core.remove_project_directory(item.dir_name)
+  end,
+})
+
+
+keymap.add {
+  ["ctrl+\\"]     = "treeview:toggle",
+  ["up"]          = "treeview:previous",
+  ["down"]        = "treeview:next",
+  ["left"]        = "treeview:collapse",
+  ["right"]       = "treeview:expand",
+  ["return"]      = "treeview:open",
+  ["escape"]      = "treeview:deselect",
+  ["delete"]      = "treeview:delete",
+  ["ctrl+return"] = "treeview:new-folder",
+  ["lclick"]      = "treeview:select-and-open",
+  ["mclick"]      = "treeview:select",
+  ["ctrl+lclick"] = "treeview:new-folder"
+}
+
+-- The config specification used by gui generators
+config.plugins.treeview.config_spec = {
+  name = "Treeview",
+  {
+    label = "Size",
+    description = "Default treeview width.",
+    path = "size",
+    type = "number",
+    default = toolbar_view and math.ceil(toolbar_view:get_min_width() / SCALE)
+      or 200 * SCALE,
+    min = toolbar_view and toolbar_view:get_min_width() / SCALE
+      or 200 * SCALE,
+    get_value = function(value)
+      return value / SCALE
+    end,
+    set_value = function(value)
+      return value * SCALE
+    end,
+    on_apply = function(value)
+      view:set_target_size("x", math.max(
+        value, toolbar_view and toolbar_view:get_min_width() or 200 * SCALE
+      ))
+    end
+  },
+  {
+    label = "Hide on Startup",
+    description = "Show or hide the treeview on startup.",
+    path = "visible",
+    type = "toggle",
+    default = false,
+    on_apply = function(value)
+      view.visible = not value
+    end
+  }
+}
+
+-- Return the treeview with toolbar and contextmenu to allow
+-- user or plugin modifications
+view.toolbar = toolbar_view
+view.contextmenu = menu
+
+return view

data/plugins/trimwhitespace.lua

@@ -1,9 +1,53 @@
-local core = require "core"
+-- mod-version:3
+local common = require "core.common"
+local config = require "core.config"
 local command = require "core.command"
 local Doc = require "core.doc"
 
+---@class config.plugins.trimwhitespace
+---@field enabled boolean
+---@field trim_empty_end_lines boolean
+config.plugins.trimwhitespace = common.merge({
+  enabled = false,
+  trim_empty_end_lines = false,
+  config_spec = {
+    name = "Trim Whitespace",
+    {
+      label = "Enabled",
+      description = "Disable or enable the trimming of white spaces by default.",
+      path = "enabled",
+      type = "toggle",
+      default = false
+    },
+    {
+      label = "Trim Empty End Lines",
+      description = "Remove any empty new lines at the end of documents.",
+      path = "trim_empty_end_lines",
+      type = "toggle",
+      default = false
+    }
+  }
+}, config.plugins.trimwhitespace)
 
-local function trim_trailing_whitespace(doc)
+---@class plugins.trimwhitespace
+local trimwhitespace = {}
+
+---Disable whitespace trimming for a specific document.
+---@param doc core.doc
+function trimwhitespace.disable(doc)
+  doc.disable_trim_whitespace = true
+end
+
+---Re-enable whitespace trimming if previously disabled.
+---@param doc core.doc
+function trimwhitespace.enable(doc)
+  doc.disable_trim_whitespace = nil
+end
+
+---Perform whitespace trimming in all lines of a document except the
+---line where the caret is currently positioned.
+---@param doc core.doc
+function trimwhitespace.trim(doc)
   local cline, ccol = doc:get_selection()
   for i = 1, #doc.lines do
     local old_text = doc:get_text(i, 1, i, math.huge)
@@ -21,16 +65,54 @@ local function trim_trailing_whitespace(doc)
   end
 end
 
+---Removes all empty new lines at the end of the document.
+---@param doc core.doc
+---@param raw_remove? boolean Perform the removal not registering to undo stack
+function trimwhitespace.trim_empty_end_lines(doc, raw_remove)
+  for _=#doc.lines, 1, -1 do
+    local l = #doc.lines
+    if l > 1 and doc.lines[l] == "\n" then
+      local current_line = doc:get_selection()
+      if current_line == l then
+        doc:set_selection(l-1, math.huge, l-1, math.huge)
+      end
+      if not raw_remove then
+        doc:remove(l-1, math.huge, l, math.huge)
+      else
+        table.remove(doc.lines, l)
+      end
+    else
+      break
+    end
+  end
+end
+
 
 command.add("core.docview", {
-  ["trim-whitespace:trim-trailing-whitespace"] = function()
-    trim_trailing_whitespace(core.active_view.doc)
+  ["trim-whitespace:trim-trailing-whitespace"] = function(dv)
+    trimwhitespace.trim(dv.doc)
+  end,
+
+  ["trim-whitespace:trim-empty-end-lines"] = function(dv)
+    trimwhitespace.trim_empty_end_lines(dv.doc)
   end,
 })
 
 
-local save = Doc.save
+local doc_save = Doc.save
 Doc.save = function(self, ...)
-  trim_trailing_whitespace(self)
-  save(self, ...)
+  if
+    config.plugins.trimwhitespace.enabled
+    and
+    not self.disable_trim_whitespace
+  then
+    trimwhitespace.trim(self)
+    if config.plugins.trimwhitespace.trim_empty_end_lines then
+      trimwhitespace.trim_empty_end_lines(self)
+    end
+  end
+  doc_save(self, ...)
 end
+
+
+return trimwhitespace

data/plugins/workspace.lua

@@ -0,0 +1,246 @@
+-- mod-version:3
+local core = require "core"
+local common = require "core.common"
+local DocView = require "core.docview"
+local LogView = require "core.logview"
+
+
+local function workspace_files_for(project_dir)
+  local basename = common.basename(project_dir)
+  local workspace_dir = USERDIR .. PATHSEP .. "ws"
+  local info_wsdir = system.get_file_info(workspace_dir)
+  if not info_wsdir then
+    local ok, err = system.mkdir(workspace_dir)
+    if not ok then
+      error("cannot create workspace directory: \"" .. err .. "\"")
+    end
+  end
+  return coroutine.wrap(function()
+    local files = system.list_dir(workspace_dir) or {}
+    local n = #basename
+    for _, file in ipairs(files) do
+      if file:sub(1, n) == basename then
+        local id = tonumber(file:sub(n + 1):match("^-(%d+)$"))
+        if id then
+          coroutine.yield(workspace_dir .. PATHSEP .. file, id)
+        end
+      end
+    end
+  end)
+end
+
+
+local function consume_workspace_file(project_dir)
+  for filename, id in workspace_files_for(project_dir) do
+    local load_f = loadfile(filename)
+    local workspace = load_f and load_f()
+    if workspace and workspace.path == project_dir then
+      os.remove(filename)
+      return workspace
+    end
+  end
+end
+
+
+local function get_workspace_filename(project_dir)
+  local id_list = {}
+  for filename, id in workspace_files_for(project_dir) do
+    id_list[id] = true
+  end
+  local id = 1
+  while id_list[id] do
+    id = id + 1
+  end
+  local basename = common.basename(project_dir)
+  return USERDIR .. PATHSEP .. "ws" .. PATHSEP .. basename .. "-" .. tostring(id)
+end
+
+
+local function has_no_locked_children(node)
+  if node.locked then return false end
+  if node.type == "leaf" then return true end
+  return has_no_locked_children(node.a) and has_no_locked_children(node.b)
+end
+
+
+local function get_unlocked_root(node)
+  if node.type == "leaf" then
+    return not node.locked and node
+  end
+  if has_no_locked_children(node) then
+    return node
+  end
+  return get_unlocked_root(node.a) or get_unlocked_root(node.b)
+end
+
+
+local function save_view(view)
+  local mt = getmetatable(view)
+  if mt == DocView then
+    return {
+      type = "doc",
+      active = (core.active_view == view),
+      filename = view.doc.filename,
+      selection = { view.doc:get_selection() },
+      scroll = { x = view.scroll.to.x, y = view.scroll.to.y },
+      crlf = view.doc.crlf,
+      text = view.doc.new_file and view.doc:get_text(1, 1, math.huge, math.huge)
+    }
+  end
+  if mt == LogView then return end
+  for name, mod in pairs(package.loaded) do
+    if mod == mt then
+      return {
+        type = "view",
+        active = (core.active_view == view),
+        module = name,
+        scroll = { x = view.scroll.to.x, y = view.scroll.to.y, to = { x = view.scroll.to.x, y = view.scroll.to.y } },
+      }
+    end
+  end
+end
+
+
+local function load_view(t)
+  if t.type == "doc" then
+    local dv
+    if not t.filename then
+      -- document not associated to a file
+      dv = DocView(core.open_doc())
+    else
+      -- we have a filename, try to read the file
+      local ok, doc = pcall(core.open_doc, t.filename)
+      if ok then
+        dv = DocView(doc)
+      end
+    end
+    if dv and dv.doc then
+      if dv.doc.new_file and t.text then
+        dv.doc:insert(1, 1, t.text)
+        dv.doc.crlf = t.crlf
+      end
+      dv.doc:set_selection(table.unpack(t.selection))
+      dv.last_line1, dv.last_col1, dv.last_line2, dv.last_col2 = dv.doc:get_selection()
+      dv.scroll.x, dv.scroll.to.x = t.scroll.x, t.scroll.x
+      dv.scroll.y, dv.scroll.to.y = t.scroll.y, t.scroll.y
+    end
+    return dv
+  end
+  return require(t.module)()
+end
+
+
+local function save_node(node)
+  local res = {}
+  res.type = node.type
+  if node.type == "leaf" then
+    res.views = {}
+    for _, view in ipairs(node.views) do
+      local t = save_view(view)
+      if t then
+        table.insert(res.views, t)
+        if node.active_view == view then
+          res.active_view = #res.views
+        end
+      end
+    end
+  else
+    res.divider = node.divider
+    res.a = save_node(node.a)
+    res.b = save_node(node.b)
+  end
+  return res
+end
+
+
+local function load_node(node, t)
+  if t.type == "leaf" then
+    local res
+    local active_view
+    for i, v in ipairs(t.views) do
+      local view = load_view(v)
+      if view then
+        if v.active then res = view end
+        node:add_view(view)
+        if t.active_view == i then
+          active_view = view
+        end
+        if not view:is(DocView) then
+          view.scroll = v.scroll	
+        end
+      end
+    end
+    if active_view then
+      node:set_active_view(active_view)
+    end
+    return res
+  else
+    node:split(t.type == "hsplit" and "right" or "down")
+    node.divider = t.divider
+    local res1 = load_node(node.a, t.a)
+    local res2 = load_node(node.b, t.b)
+    return res1 or res2
+  end
+end
+
+
+local function save_directories()
+  local project_dir = core.project_dir
+  local dir_list = {}
+  for i = 2, #core.project_directories do
+    dir_list[#dir_list + 1] = common.relative_path(project_dir, core.project_directories[i].name)
+  end
+  return dir_list
+end
+
+
+local function save_workspace()
+  local root = get_unlocked_root(core.root_view.root_node)
+  local workspace_filename = get_workspace_filename(core.project_dir)
+  local fp = io.open(workspace_filename, "w")
+  if fp then
+    local node_text = common.serialize(save_node(root))
+    local dir_text = common.serialize(save_directories())
+    fp:write(string.format("return { path = %q, documents = %s, directories = %s }\n", core.project_dir, node_text, dir_text))
+    fp:close()
+  end
+end
+
+
+local function load_workspace()
+  local workspace = consume_workspace_file(core.project_dir)
+  if workspace then
+    local root = get_unlocked_root(core.root_view.root_node)
+    local active_view = load_node(root, workspace.documents)
+    if active_view then
+      core.set_active_view(active_view)
+    end
+    for i, dir_name in ipairs(workspace.directories) do
+      core.add_project_directory(system.absolute_path(dir_name))
+    end
+  end
+end
+
+
+local run = core.run
+
+function core.run(...)
+  if #core.docs == 0 then
+    core.try(load_workspace)
+
+    local on_quit_project = core.on_quit_project
+    function core.on_quit_project()
+      core.try(save_workspace)
+      on_quit_project()
+    end
+
+    local on_enter_project = core.on_enter_project
+    function core.on_enter_project(new_dir)
+      on_enter_project(new_dir)
+      core.try(load_workspace)
+    end
+  end
+
+  core.run = run
+  return core.run(...)
+end

data/user/init.lua

@@ -1,13 +0,0 @@
--- put user settings here
--- this module will be loaded after everything else when the application starts
-
-local keymap = require "core.keymap"
-local config = require "core.config"
-local style = require "core.style"
-
--- light theme:
--- require "user.colors.summer"
-
--- key binding:
--- keymap.add { ["ctrl+escape"] = "core:quit" }
-

debian/.gitignore

@@ -0,0 +1,6 @@
+debian/files
+debian/.debhelper/
+debian/*.log
+debian/lite-xl/
+debian/debhelper-build-stamp
+debian/*.substvars

debian/changelog

@@ -0,0 +1,75 @@
+lite-xl (2.1.8-7) stonking; urgency=medium
+
+  * Vendor five more plugins from lite-xl-plugins @ 31eef29:
+    - selectionhighlight: highlights other occurrences of the selected word
+    - bracketmatch: highlights the bracket matching the one under the cursor
+    - colorpreview: draws inline swatches for #hex/rgb()/hsl() color literals
+    - navigate: Go Back / Go Forward cursor history (alt+left/right)
+    - editorconfig: applies .editorconfig files (ships its parser and test
+      harness; uses the bundled trimwhitespace plugin)
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Thu, 17 Sep 2026 11:30:00 +0200
+
+lite-xl (2.1.8-6) stonking; urgency=medium
+
+  * Vendor ephemeral_tabs (lite-xl-plugins @ 31eef29): files opened from the
+    treeview with a single click open in a preview tab (titled "~ name ~")
+    that is reused for the next file and becomes a permanent tab as soon as
+    it is edited, double-clicked or dragged - matching VSCode's preview
+    editor behavior. Disable with config.plugins.ephemeral_tabs = false.
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Thu, 17 Sep 2026 10:45:00 +0200
+
+lite-xl (2.1.8-5) stonking; urgency=medium
+
+  * Vendor gitpanel 0.3.0 (own plugin, lite-xl-gitpanel @ 0731a63): a git
+    panel integrated into the treeview pane - uncommitted changes with
+    diff stats, staging, commits and history - toggled from a git-branch
+    button in the treeview toolbar or the status bar branch indicator.
+    History is pinned to the bottom half of the panel; clicking a commit
+    opens its patch with syntax highlighting via the already bundled
+    language_diff.
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Wed, 17 Sep 2026 01:55:00 +0200
+
+lite-xl (2.1.8-4) stonking; urgency=medium
+
+  * Bundle a curated set of community plugins (vendored, pinned in
+    debian/extra/README.source):
+    - gitstatus, gitopen, fontconfig, open_ext, select_colorscheme,
+      smoothcaret, nerdicons (+ Symbols Nerd Font Mono, font path patched
+      to DATADIR)
+    - lite-xl-lsp (full LSP client; activates when a language server is
+      configured) with the lite-xl-widgets library it requires
+    - 104 additional language syntax plugins (none duplicate the nine
+      already bundled with core)
+  * settings GUI plugin left out: its hard dependency on a widget that is
+    missing from lite-xl-widgets@master makes it fail to load upstream.
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Wed, 16 Sep 2026 22:10:00 +0200
+
+lite-xl (2.1.8-3) stonking; urgency=medium
+
+  * Ship a VSCode-style dark theme and out-of-the-box config:
+    - first-run template writes a tuned default init.lua (quilt patch)
+    - theme module in /usr/share/lite-xl/colors, default config in /etc/skel
+    - default config uses JetBrains Mono (new fonts-jetbrains-mono dependency)
+  * desktop: launch with SDL software rendering and LITE_SCALE=1.5 so text is
+    sharp on fractional-scaled Wayland panels and avoids panfrost artifacts.
+  * vendored nerdicons ships with the tuned icon rendering (whole-pixel size,
+    hinting off) instead of the pristine upstream copy.
+  * default config keeps the status bar always visible.
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Wed, 16 Sep 2026 21:50:00 +0200
+
+lite-xl (2.1.8-2) stonking; urgency=medium
+
+  * Drop the ":native" qualifiers on the meson/ninja-build Build-Depends.
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Wed, 16 Sep 2026 16:40:00 +0200
+
+lite-xl (2.1.8-1) stonking; urgency=medium
+
+  * Initial release.
+
+ -- Valentin Haudiquet <valentin.haudiquet@canonical.com>  Wed, 16 Sep 2026 13:56:53 +0200

debian/control

@@ -0,0 +1,22 @@
+Source: lite-xl
+Section: utils
+Priority: optional
+Maintainer: Valentin Haudiquet <valentin.haudiquet@canonical.com>
+Rules-Requires-Root: no
+Standards-Version: 4.7.2
+Build-Depends: debhelper-compat (= 13),
+ meson,
+ ninja-build,
+ libsdl3-dev,
+ libfreetype-dev,
+ libpcre2-dev,
+ liblua5.4-dev
+Homepage: https://lite-xl.com/
+
+Package: lite-xl
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}, fonts-jetbrains-mono
+Description: A lightweight text editor written in Lua
+ A lightweight, fast and extensible text editor written in Lua, designed to be
+ highly customizable and to have a small footprint. It is written in C and Lua
+ and uses the SDL library for cross-platform rendering.

debian/copyright

@@ -0,0 +1,11 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: lite-xl
+Source: https://lite-xl.com/
+
+Files: *
+Copyright: 2026 Valentin Haudiquet <valentin.haudiquet@canonical.com>
+License: MIT
+ The package is distributed under the terms of the MIT license. The full license text is available at <https://spdx.org/licenses/MIT.html>.
+
+License: MIT
+ The package is distributed under the terms of the MIT license. The full license text is available at <https://spdx.org/licenses/MIT.html>.

debian/extra/README.source

@@ -0,0 +1,27 @@
+Vendored from upstream, pinned by commit:
+
+- lite-xl-plugins   https://github.com/lite-xl/lite-xl-plugins   @ 31eef29 (master, 2026-09)
+    plugins/: ephemeral_tabs (VSCode-style preview tabs), selectionhighlight,
+    bracketmatch, colorpreview, navigate, editorconfig (whole directory,
+    incl. its test harness), gitstatus, gitopen, fontconfig, open_ext,
+    select_colorscheme, smoothcaret, nerdicons, language_* (all 104; none
+    overlap the ones bundled in the core data/ directory)
+- lite-xl-gitpanel  (own plugin, source tree lite-xl-gitpanel)  @ 0731a63 (main, 2026-09)
+    plugins/: gitpanel -- git panel integrated into the treeview pane
+    (changes, staging, commits, history) with a toolbar toggle button;
+    uses the bundled language_diff for commit diff highlighting
+
+- lite-xl-lsp       https://github.com/lite-xl/lite-xl-lsp       @ d1432ae (master, 2026-09)
+    vendored whole as plugins/lsp/ (screenshots removed)
+- lite-xl-widgets   https://github.com/lite-xl/lite-xl-widgets   @ dcf1c8c
+    NOT vendored: only the settings plugin needs it, and settings@master
+    requires libraries.widget.fonts which does not exist in the widgets
+    repository at any revision, so settings cannot load. Revisit when
+    upstream publishes the missing widget.
+- nerdicons font mapping: plugins/font_symbols_nerdfont_mono_regular.lua
+    shipped as usr/share/lite-xl/libraries/font_symbols_nerdfont_mono_regular.lua
+    with the font path patched from USERDIR to DATADIR, plus the
+    Symbols Nerd Font Mono TTF (SIL OFL 1.1) next to it.
+
+Refresh by re-cloning the sources at a new commit and re-applying the single
+sed patch to the font mapping path.