uniline.info

This is uniline.info, produced by makeinfo version 6.8 from
uniline.texi.


INFO-DIR-SECTION Emacs
START-INFO-DIR-ENTRY
* Uniline: (uniline).     Draw UNICODE diagrams
END-INFO-DIR-ENTRY


File: uniline.info,  Node: Top,  Next: Getting started in 10 seconds,  Up: (dir)

Uniline
*******

*New*: fine tweak at the quarter character scale

* Menu:

* Getting started in 10 seconds::
* Pure UNICODE text diagrams in Emacs::
* Minor mode::
* Drawing lines::
* Brush style::
* The <insert> key::
* Arrows glyphs ▷ ▶ → ▹ ▸ ↔::
* Intersection glyphs ■ ◆ ●::
* Drawing rectangles::
* Moving rectangles::
* Tracing a contour::
* Flood-fill::
* Text direction::
* Macros::
* Fine tweaking::
* Which fonts?::
* Text menus (Hydra)::
* Line spacing::
* How Uniline behaves with its environment?::
* Lisp API::
* Installation::
* Related packages::
* Author, contributors: Author contributors.
* License::

— The Detailed Node Listing —

How ‘Uniline’ behaves with its environment?

* Compatibility with Picture-mode::
* Compatibility with Artist-mode::
* Compatibility with Whitespace-mode::
* Compatibility with Org Mode::
* Org Mode and LaTex::
* What about \t tabs?::
* What about ^L page separation?::
* Emacs on the Linux console::
* Emacs on a graphical terminal emulator::
* Emacs on Windows::



File: uniline.info,  Node: Getting started in 10 seconds,  Next: Pure UNICODE text diagrams in Emacs,  Prev: Top,  Up: Top

1 Getting started in 10 seconds
*******************************

   • Type ‘M-x uniline-mode’
   • Move cursor with the arrow-keys on the keyboard ‘→ ↑ ↓ ←’
   • Quit ‘C-c C-c’


File: uniline.info,  Node: Pure UNICODE text diagrams in Emacs,  Next: Minor mode,  Prev: Getting started in 10 seconds,  Up: Top

2 Pure UNICODE text diagrams in Emacs
*************************************

Draw diagrams like those:

   Document a command:



        pdfjam source.pdf 3-5,9
             ▲    ▲        ▲  ▲
     command╶╯    │        │  │
     input file╶──╯        │  │
     select pages 3,4,5╶───╯  │
     and page 9╶──────────────╯

   Connect boxes with arrows:



                 ╭───────────────────────╮
       ╷123╭────▶┤ hundred and something │
       ╰───╯     ╰───────────────────────╯
                                  ╭────▶──╮A╷
         ╭───╮    ┏━━━┓    ╔═══╗  │       ╰─╯
     0╶─→┤ 1 ┝━━━▶┫ 2 ┣═══▷╣ 3 ╟──●────▶──╮B╷
         ╰───╯    ┗━┯━┛    ╚═╤═╝  │       ╰─╯
                    ╰────←───╯    ╰────▶──╮C╷
                                          ╰─╯
        ╔══════════╗
        ║ 1        ║          ▐▀▀▀▀▀▀▀▀▜
        ║    ╭─────╫───╮ ◁──▷ ▐ 3      ▐
        ╚════╪═════╝ 2 │      ▐▄▄▄▄▄▄▄▄▟
             ╰─────────╯

   Explain decisions trees:



     ┏━━━━━━━━━━━━┓
     ┃which color?┃
     ┗━┯━━━━━━━━━━┛
       │     ╭──────╮
       │  ╭──┤yellow├─▷╮good─choice╭□
       ▽  │  ╰──────╯  ╰═══════════╯
       ╰──●  ╭───╮    ┏━━━━━┓
          ├──┤red├───▷┨dark?┠──╮
          │  ╰───╯    ┗━━━━━┛  │
          │ ╭───◁──────────────╯
          │ │   ╭───╮
          │ ╰─●─┤yes├▷╮regular─red╭─□
          │   │ ╰───╯ ╰═══════════╯
          │   │ ╭──╮
          │   ╰─┤no├─▷╮pink╭────────□
          │     ╰──╯  ╰════╯
          │  ╭────╮
          ├──┤blue├───▷╮next week╭──□
          │  ╰────╯    ╰═════════╯
          │  ╭─────╮
          ╰──┤white├──▷╮available╭──□
             ╰─────╯   ╰═════════╯

   Draw lines or blocks:



                                   ╭─╮←─╮
                              ╭╮   │ │  ╰──╴max 235
                            ╭╮││  ╭╯ │
                            │╰╯│╭─╯  │
           ╭╮               │  ││    │
        ╭─╮││╭╮   ╭──╮╭╮    │  ╰╯    ╰╮
       ╭╯ ╰╯╰╯│  ╭╯  ╰╯╰─╮  │         │ ╭╮
     ◁─╯      ╰──╯       ╰──╯         ╰─╯╰────▷
     ◀════════════════════════════════════════▶
                            ╭────────╮
        ▲                   │all time│
        ┃       ▄     ▗▟█ ←─┤highest │
       Qdx      █▌   ████   ╰────────╯
        ┃     ▗▄█▌   █████▙
        ┃   ▟███████▄█████████▄▄▄     ▗▄
        ┃▐▄▄████████████████████████████▄▄▖
         ╺━━━━━━━━━━╸time╺━━━━━━━━━━━━━━━━▶


   Explain Lisp lists:



       '(a b c)
          ┏━━━┳━━━┓   ┏━━━┳━━━┓   ┏━━━┳━━━┓
     ●━━━▶┫ ● ┃ ●─╂──▷┨ ● ┃ ●─╂──▷┨ ● ┃nil┃
          ┗━┿━┻━━━┛   ┗━┿━┻━━━┛   ┗━┿━┻━━━┛
            │           ╰──────────╮╰╮
            │  ╭─────┬───────────╮ │ │
            ╰─▷┤"a\0"│properties │ │ │
               ├─────┼───────────┤ │ │
               │"b\0"│properties ├◁╯ │
               ├─────┼───────────┤   │
               │"c\0"│properties ├◁──╯
               ├─────┼───────────┤
               │...  │...        │
               ╵     ╵           ╵

   Draw sketched objects:




      ◀─(-)────────(+)──▶    ~╭──────╮~
       ▗──────────────╮     ~~│ ╭~~╮ │~~
       ▐              ╰╮     ~│ ╵  ╵ │~
     ╭□▐   1.5 volts  ╭╯□╮    ╰─╖  ╓─╯
     │ ▝▀▀▀▀▀▀▀▀▀▀▀▀▀▀▘  │      ╠━━╣
     │                   ╰──────╯  │
     ╰─────────────────────────────╯



      ╶╮       ╭╴
     ┏┳┥▒▒▒▒▒▒▒┝╸
     ┃┃│▒▒eau▒▒│
     ┃┃│▒▒▒▒▒▒▒│ ╔═════╗
     ┃┃╰──╮▒╭──╯ ║ ╶╮  ▽           ╭╴
     ┃┃    ▒     ║  │  ░           │
     ┃┃    ▒     ║  │░░░░░░░░░░░░░░│
     ┃┃    ╚═════╝  │░░░░░░░░░░░░░░╞════▷▒▒
     ┃┃             │░░░░░akvo░░░░░│    ╶╮ ▒         ╭╴
     ┃┃             │░░░░░░░░░░░░░░│     │  ▒        │
     ┃┃             ╰─┲┳━━━━━━━━┳┱─╯     │▒▒▒▒▒▒▒▒▒▒▒│
     ┃┃               ┃┃        ┃┃       │▒▒▒water▒▒▒│
     ┃┃               ┃┃        ┃┃       │▒▒▒▒▒▒▒▒▒▒▒│
     ┃┃               ┃┃        ┃┃       ╰───────────╯
     ▝▀▀▀▀▀▀▘        ▝▀▘        ▝▀▘      ▀▀▀▀▀▀▀▀▀▀▀▀▀

   Those diagrams are pure text.  There is nothing graphic.  They are
achieved using UNICODE characters.  Most often, the text file will be
encoded as UTF-8.

   Creating such diagrams by hand is painfully slow.  Use ‘Uniline’ to
draw lines while you move the cursor with keyboard arrows.

   *Beware!*

   If you see those diagrams miss-aligned, most likely the font used to
display them does not support UNICODE block characters.  See bellow the
paragraph "Which fonts?".


File: uniline.info,  Node: Minor mode,  Next: Drawing lines,  Prev: Pure UNICODE text diagrams in Emacs,  Up: Top

3 Minor mode
************

‘Uniline’ is a minor mode.  Activate it temporarily:

   ‘M-x uniline-mode’

   Exit it with:

   ‘C-c C-c’

   The current major mode is still active underneath ‘uniline-mode’.

   While in ‘uniline-mode’, overwriting is active, as well as long lines
truncation.  Also, a hollow cursor is provided.  Those settings are
reset to their previous state when exiting ‘uniline-mode’.


File: uniline.info,  Node: Drawing lines,  Next: Brush style,  Prev: Minor mode,  Up: Top

4 Drawing lines
***************

Use keyboard arrows to draw lines.

   By default, drawing lines only happens over empty space or over other
lines.  If there is already text, it will not be erased.  However, by
hitting the control-key while moving, lines overwrite whatever there is.

   The buffer is "infinite" in bottom and right directions.  Which means
that when the cursor ends up outside the buffer, white space characters
are automatically added.

   The usual numeric prefix is available.  For instance, to draw a line
12 characters wide downward, type: ‘M-12 <down>’


File: uniline.info,  Node: Brush style,  Next: The <insert> key,  Prev: Drawing lines,  Up: Top

5 Brush style
*************

Set the current brush with:

   • ‘-’ single thin line ‘╭─┬─╮’

   • ‘+’ single thick line ‘┏━┳━┓’

   • ‘=’ double line ‘╔═╦═╗’

   • ‘#’ quarter block ‘▙▄▟▀’

   • ‘<delete>’ eraser

   • ‘<return>’ move without drawing anything

   The current bush and the current text direction (see below) are
reflected in the mode-line (at the bottom of the Emacs screen).  It
looks like this:

             ╭─current brush
             ▽
     →Uniline┼
     △
     ╰──current text direction



File: uniline.info,  Node: The <insert> key,  Next: Arrows glyphs ▷ ▶ → ▹ ▸ ↔,  Prev: Brush style,  Up: Top

6 The ‘<insert>’ key
********************

The ‘<insert>’ key is a prefix for other keys:
   • for drawing arrows, squares, crosses, o-shapes glyphs,
   • for handling rectangles,
   • for inserting ‘# = - +’ which otherwise change the brush style,
   • for trying a choice of mono-spaced fonts.

   Why ‘<insert>’?  Because:
   • ‘Uniline’ tries to leave their original meaning to as much keys as
     possible,
   • the standard meaning of ‘<insert>’ is to toggle the
     ‘overwrite-mode’; but ‘Uniline’ is already in ‘overwrite-mode’, and
     de-activating overwrite would break ‘Uniline’.

   So preempting ‘<insert>’ does not sacrifices anything.


File: uniline.info,  Node: Arrows glyphs ▷ ▶ → ▹ ▸ ↔,  Next: Intersection glyphs ■ ◆ ●,  Prev: The <insert> key,  Up: Top

7 Arrows glyphs ‘▷ ▶ → ▹ ▸ ↔’
*****************************

At any time, an arrow may be drawn.  The arrow points in the direction
that the line drawing follows.

   ‘Uniline’ supports 6 arrows types: ‘▷ ▶ → ▹ ▸ ↔’




      △    ▵    ↑    ▲    ▴
     ◁ ▷  ◃ ▹  ← →  ◀ ▶  ◂ ▸
      ▽    ▿    ↓    ▼    ▾


   Actually, there are tons of arrows of all styles in the UNICODE
standard.  Unfortunately, the support by fonts is weak.  So ‘Uniline’
restrains itself to those six safe arrows.

   To insert an arrow, type: ‘<insert> a’ or ‘<insert> a a’ or ‘<insert>
a a a’.  (‘a’ cycles through the 5 styles, ‘A’ cycles backward).

   ‘<insert> 4 a’ is equivalent to ‘<insert> a a a a’, which is also
equivalent to ‘<insert> A A A’.  Those 3 shortcuts insert an arrow of
this style: ‘▵▹▿◃’.  The actual direction where the arrow points follows
the last movement of the cursor.

   To change the direction of the arrow, use shift-arrow, for example:
‘S-<up>’ will change from ‘→’ to ‘↑’.


File: uniline.info,  Node: Intersection glyphs ■ ◆ ●,  Next: Drawing rectangles,  Prev: Arrows glyphs ▷ ▶ → ▹ ▸ ↔,  Up: Top

8 Intersection glyphs ‘■ ◆ ●’
*****************************

There are a few other UNICODE characters which are mono-space and
symmetric in the 4 directions.  They are great at line intersections:

   To insert a square ‘□ ■ ▫ ▪ ◇ ◆ ◊’ type: ‘<insert> s s s...’ (‘s’
cycles, ‘S’ cycles backward).

   To insert a circular shape ‘· ∙ • ● ◦ Ø ø’ type: ‘<insert> o o o...’
(‘o’ cycles, ‘O’ cycles backward).

   To insert a cross shape ‘╳ ÷ × ± ¤’ type: ‘<insert> x x x...’ (‘x’
cycles, ‘X’ cycles backward).

   To insert a usual ASCII letter or symbol, just type it.

   As the keys ‘- + = #’ are preempted by ‘Uniline’ mode, to type them,
prefix them with ‘<insert>’.  Example: ‘<insert> -’ inserts a ‘-’ and
‘<insert> +’ inserts a ‘+’.




     <insert>
         │
         ▼
        ╭┴╮   ╭───────╮  ╭─────────────────────╮
        │s├─▶─┤squares├──┤ □  ■  ▫  ▪  ◇  ◆  ◊ │
        ╰┬╯   ╰───────╯  ╰─────────────────────╯
        ╭┴╮   ╭───────╮  ╭─────────────────────╮
        │o├─▶─┼circles┼──┤ ·  ∙  •  ●  ◦  Ø  ø │
        ╰┬╯   ╰───────╯  ╰─────────────────────╯
        ╭┴╮   ╭───────╮  ╭───────────────╮
        │x├─▶─┼crosses┼──┤ ╳  ÷  ×  ±  ¤ │
        ╰┬╯   ╰───────╯  ╰───────────────╯
        ╭┴╮              ╭───╮
        │+├─▶────────────┤ + │
        ╰┬╯              ╰───╯
        ╭┴╮              ╭───╮
        │-├─▶────────────┤ - │
        ╰┬╯              ╰───╯
        ╭┴╮              ╭───╮
        │=├─▶────────────┤ = │
        ╰┬╯              ╰───╯
        ╭┴╮              ╭───╮
        │#├─▶────────────┤ # │
        ╰─╯              ╰───╯



File: uniline.info,  Node: Drawing rectangles,  Next: Moving rectangles,  Prev: Intersection glyphs ■ ◆ ●,  Up: Top

9 Drawing rectangles
********************

To draw a rectangle in one shot, select a rectangular region with
‘C-SPC’ or ‘C-x SPC’ and move the cursor.

   You may also use ‘S-<arrow>’ (‘<arrow>’ being any of the 4
directions) to extend the selection.  The buffer grows as needed with
white spaces to accommodate the selection.  Selection extension mode is
active when ‘shift-select-mode’ is non-nil.

   If needed, change the brush with any of ‘- + = # <delete>’

   then hit
   • ‘r’ to draw a rectangle inside the selection
   • ‘S-R’ to draw a rectangle outside the selection
   • ‘C-r’ to overwrite a rectangle inside the selection
   • ‘C-S-R’ to overwrite a rectangle outside the selection



     ╭───────╮          r: inside╮╭───────╮
     │ one   │          ▗▄▄▄▄▄▄▖╭┤│▛▀▀▀▀▀▜│
     │  ┏━━━━┿━━━━━━┓   ▐╭────╮▌│╰┼▌     ▐│
     ╰──╂────╯ two  ┃   ▐│    │▌│ │▙▄▄▄▄▄▟│
        ┃   ╔═══════╋═╗ ▐│    ├▌╯ ╰─────┬─╯
        ┗━━━╋━━━━━━━┛ ║ ▐╰────╯▌────────┴───╮
            ║  three  ║ ▝▀▀▀▀▀▀▘  R: outside╯
            ╚═════════╝

                            ╭─────────╮
     my text I              │my text I│
     want to  ╶─<insert>R─▷ │want to  │
     box                    │box      │
                            ╰─────────╯

   The usual ‘C-_’ or ‘C-/’ keys may be hit to undo, even with the
region still active visually.


File: uniline.info,  Node: Moving rectangles,  Next: Tracing a contour,  Prev: Drawing rectangles,  Up: Top

10 Moving rectangles
********************

Select a region, then press ‘<insert>’.  The selection becomes
rectangular if it was not.

   Use arrow keys to move the rectangle around.  A numeric prefix may be
used to move the rectangle that many characters.  Be sure to specify the
numeric prefix with just digits, without the ‘Alt’ key.  Typing ‘15
<left>’ moves the rectangle 15 characters to the left.  ‘M-15 <left>’
does not work.

   Press ‘q’, ‘<return>’, or ‘C-g’ to stop moving the rectangle.

   The ‘C-_’ key may also be used to undo the previous movements, even
though the selection is still active.



                     ▲
                     │
                    <up>
               ╭─────┴──────╮
               │this is     │
               │my rectangle│
     ◀─<left>──┤I want to   ├─<right>─▶
               │move        │
               ╰─────┬──────╯
                   <down>
                     │
                     ▼

   A rectangle can be copied or killed, then yanked somewhere else.
Press:
   • ‘c’ to copy
   • ‘k’ to kill
   • ‘y’ to yank (aka paste)

   This is similar to the Emacs standard rectangle handling:
   • ‘C-x r r’ copy rectangle to register
   • ‘C-x r k’ kill rectangle
   • ‘C-x r y’ yank killed rectangle

   The difference is that ‘Uniline’ rectangles when killed and yanked,
do not move surrounding characters.

   ‘Uniline’ and Emacs standard rectangle share the same storage for
copied and killed rectangles, ‘killed-rectangle’.  So, a rectangle can
be killed one way, and yanked another way.


File: uniline.info,  Node: Tracing a contour,  Next: Flood-fill,  Prev: Moving rectangles,  Up: Top

11 Tracing a contour
********************



       ╭──────────────╮
     ╭─╯A.written.text╰────────╮
     │outlined by the.`contour'│
     ╰─╮function.gets╶┬────────╯
       ╰╮a.surrounding╰───────╮
        ╰─╮line.in.the.current│
          ╰─╮brush.style╭─────╯
            ╰───────────╯

   Choose or change the brush style with any of ‘-,+,=_,#,<delete>’.
Put the cursor anywhere on the shape or outside but touching it.  Then
type:

   ‘<insert> c’

   A contour line is traced (or erased if brush style is ‘<delete>’)
around the contiguous shape close to the cursor.

   When hitting capital letter: ‘<insert> C’ the contour is overwritten.
This means that if there was already a different style of line on the
contour path, it is overwritten.

   The shape is distinguished because it floats in a blank characters
ocean.  For the shake of the contour function, blank characters are
those containing lines as drawn by ‘Uniline’ (including true blank
characters).  Locations outside the buffer are also considered blank.

   The algorithm has an upper limit of 10000 steps.  This avoids an
infinite loop in which the algorithm may end up in some rare cases.  One
of those cases is when the contour crosses a new-page character,
displayed by Emacs as ‘^L’.  10000 steps require a fraction of a second
to run.  For shapes really huge, you may launch the contour command once
again, at the point where the previous run ended.


File: uniline.info,  Node: Flood-fill,  Next: Text direction,  Prev: Tracing a contour,  Up: Top

12 Flood-fill
*************




     this.text.surrounds      this.text.surrounds
     .                 /      .▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒/
     .                //╶───▷╴.▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒//
     ...            ////      ...▒▒▒▒▒▒▒▒▒▒▒▒////
       ...a.hole/////           ...a.hole/////


   A hollow shape is a contiguous region of identical characters (not
necessarily blank), surrounded by a boundary of different characters.
The end of the buffer in any direction is also considered a boundary.

   Put the cursor anywhere in the hole.  Then type:

   ‘<insert> i’

   Answer by giving a character to fill the hole.

   If instead of a character, ‘SPC’ or ‘DEL’ is typed, then a shade of
grey character is picked.  ‘SPC’ selects a darker grey than the one the
point is on, while ‘DEL’ selects a lighter.  There are 5 shades of grey
in the UNICODE standard: ‘" ░▒▓█"’.  Those grey characters are well
supported by the suggested fonts.

   ‘C-y’ is also an option.  The first character in the top of the kill
ring will be chosen as the filling character.  The kill ring is filled
by functions like ‘C-k’ or ‘M-w’, which remove text from the buffer.

   Typing ‘<return>’ aborts the filling operation.

   A rectangular shape may also be filled.
   • Mark a region
   • ‘<insert> i’
   • answer which character should be used to fill.

   There is no limit on the area to fill.  Therefore, the filling
operation may flood the entire buffer (but no more).


File: uniline.info,  Node: Text direction,  Next: Macros,  Prev: Flood-fill,  Up: Top

13 Text direction
*****************

Usually, inserting text in a buffer moves the cursor to the right.  (And
sometimes to the left for some locales).  Any of the 4 directions can be
selected under ‘Uniline’.  Just type any of:

   • ‘<insert> C-<up>’
   • ‘<insert> C-<right>’
   • ‘<insert> C-<down>’
   • ‘<insert> C-<left>’

   The current direction is reflected in the mode-line, just before the
word ‘"uniline"’.


File: uniline.info,  Node: Macros,  Next: Fine tweaking,  Prev: Text direction,  Up: Top

14 Macros
*********

‘Uniline’ adds directional macros to the Emacs standard macros.

   Record a macro as usual with ‘C-x (’ … ‘C-x )’.

   Then call it with the usual ‘C-x e’.  But then, instead of executing
the macro, a menu is offered to execute it in any of the 4 directions.

   When a macro is executed in a direction other than the one it was
recorded, it is twisted in that direction.  This means that recorded
hits on the 4 keyboard arrows are rotated.  It happens also for shift
and control variations of those keys.  Direction of text insertion is
also rotated.

   There is still the classical ‘e’ option to call the last recorded
macro.  So instead of the usual ‘C-x e’, type ‘C-x e e’.  And of course,
the usual repetition typing repeatedly ‘e’ is available.

   Why are directional macros useful?  To create fancy lines.  For
instance, if we want a doted line instead of the continuous one, we
record a macro for one step:

     C-x (             ;; begin recording
     INS o             ;; insert a small dot
     <right> <right>   ;; draw a line over 2 characters
     C-x )             ;; stop recording

   Then we call this macro repeatedly in any of the 4 directions:




     ·─·─·─·─·  ╷     ·──·
             │  │     │  │
             ·  ·     ·  ·
             │  │     │  │
             ·  ·─·─·─·  ·
             │           │
             ·─·─·─·─·─·─·


   We can draw complex shapes by just drawing one step.  Hereafter, we
call a macro in 4 directions, closing a square:




       ╭╮╭╮╭╮╭╮╭╮╭╮     △ △ △ △ △ △       ╭─╮ ╭─╮ ╭─╮ ╭─╮     ╭─╮ ╭─╮ ╭─╮ ╭─╮
     ╭─╯╰╯╰╯╰╯╰╯╰╯│    ╶╯╶╯╶╯╶╯╶╯╶╯╷   ╭──╯∙╰─╯∙╰─╯∙╰─╯∙│    ▷┤□├▷┤□├▷┤□├▷┤□├▽
     ╰╮           ╰╮  ◁╮           ╰▷  │∙               │   ╭┴┼─╯ ╰─╯ ╰─╯ ╰─┼┴╮
     ╭╯           ╭╯   ╵           ╷   ╰╮               ╰╮  │□│             │□│
     ╰╮           ╰╮  ◁╮           ╰▷   │               ∙│  ╰┬╯             ╰┬╯
     ╭╯           ╭╯   ╵           ╷   ╭╯               ╭╯   △               ▽
     ╰╮           ╰╮  ◁╮           ╰▷  │∙               │   ╭┴╮             ╭┴╮
     ╭╯           ╭╯   ╵           ╷   ╰╮               ╰╮  │□│             │□│
     ╰╮           ╰╮  ◁╮           ╰▷   │               ∙│  ╰┬┼─╮ ╭─╮ ╭─╮ ╭─┼┬╯
      │╭╮╭╮╭╮╭╮╭╮╭─╯   ╵╭╴╭╴╭╴╭╴╭╴╭╴    │∙╭─╮∙╭─╮∙╭─╮∙╭──╯   △┤□├◁┤□├◁┤□├◁┤□├◁
      ╰╯╰╯╰╯╰╯╰╯╰╯      ▽ ▽ ▽ ▽ ▽ ▽     ╰─╯ ╰─╯ ╰─╯ ╰─╯       ╰─╯ ╰─╯ ╰─╯ ╰─╯



File: uniline.info,  Node: Fine tweaking,  Next: Which fonts?,  Prev: Macros,  Up: Top

15 Fine tweaking
****************




      convert this  ═══▶   into that
     ╭───────────╮        ╭───────────╮
     │╶───┬────▷ │        │╶───╮────▷ │
     │    │      │        │    │      │
     │           │        │           │
     │    ▀▀▀    │        │    ▀▟▀    │
     ╰───────────╯        ╰───────────╯


   At the crossing of lines, it may be appealing to do small
adjustments.  In the above example, we removed a segment of line which
occupies 1/4 of a character.  This cannot be achieve with line tracing
alone.  We also modified a quarter-block line in a non-obvious way.

   • Put the point (the cursor) on the character where lines cross each
     other.
   • type ‘INS S-<right> S-<right>’

   ‘<right>’ here refers to the right part of the character under the
point.  The 1/4 line segment will cycle through all displayable forms.
On the second stroke, no segment will be displayed, which is what we
want.

   Caveat!  The UNICODE standard does not define all possible
combinations including double line segments.  (It does for all
combinations of thin and tick lines).  So sometimes, when working with
double lines, the process may be frustrating.

   This works also for lines made of quarter-blocks.  There are 4
quarter-blocks in a character, either on or off.  Each of the 4 shifted
keyboard arrows flips a quarter-block on-and-off.

   In the above example, the effect was achieved with: ‘INS S-<up>
S-<down> S-<left>’


File: uniline.info,  Node: Which fonts?,  Next: Text menus (Hydra),  Prev: Fine tweaking,  Up: Top

16 Which fonts?
***************

A mono-space character font must be used.  It must also support UNICODE.

   Not all fonts are born equal.

   • ‘(set-frame-font "DejaVu Sans Mono" )’
   • ‘(set-frame-font "Unifont" )’
   • ‘(set-frame-font "Hack" )’
   • ‘(set-frame-font "JetBrains Mono" )’
   • ‘(set-frame-font "Cascadia Mono" )’
   • ‘(set-frame-font "Agave" )’
   • ‘(set-frame-font "JuliaMono" )’
   • ‘(set-frame-font "FreeMono" )’
   • ‘(set-frame-font "Iosevka Comfy Fixed")’
   • ‘(set-frame-font "Source Code Pro" )’

   Those fonts are known to support the required UNICODE characters, AND
display them as mono-space.  There are fonts advertised as mono-space
which give arbitrary widths to non-ASCII characters.  That is bad for
the kind of drawings done by ‘Uniline’.

   You may want to try any of the 10 suggested fonts.  Just hit the
corresponding entry in the ‘Uniline’ menu, or type ‘<insert> f’.  You
may also execute the above Lisp commands like that:

   ‘M-: (set-frame-font "DejaVu Sans Mono")’

   This setting is for the current session only.  If you want to make it
permanent, you may use the Emacs customization:

   ‘<insert> f *’

   or

   ‘M-x customize-face default’

   Beware that Emacs tries to compensate for missing UNICODE support by
the current font.  Emacs substitutes one font for another, character per
character.  The user may not notice until the drawings done under Emacs
are displayed on another text editor or on the Web.

   To know which font Emacs has chosen for a given character, type:

   ‘C-u C-x =’

   Note that none of those commands downloads a font from the Web.  The
font should already be available.


File: uniline.info,  Node: Text menus (Hydra),  Next: Line spacing,  Prev: Which fonts?,  Up: Top

17 Text menus (Hydra)
*********************

Casual usage of ‘Uniline’ should be easy: just move the point, and lines
are traced.

   More complex actions are summoned by the ‘<insert>’ key, with or
without selection.  This is a single key to remember.  Then a textual
menu is displayed, giving the possible keys continuations and their
meaning.  All that is achieved by the ‘Hydra’ library, which is now part
of Emacs (thanks!).

   For seasoned users, those multi-lines textual menus may distract them
from their workflow.  Beside, they disturb the layout of windows.

   It is now possible to switch to less distracting textual menus.  They
are displayed in the echo-area on a single line.

   To do so, type:
   • ‘TAB’ within a sub-mode (glyph insertion mode, rectangle handling,
     etc.)
   • ‘C-h TAB’ at the top-level

   This will flip between the two sizes of textual menus.  It also
affects the welcome message, the one displayed when entering the
‘Uniline’ minor mode.

   The current size is controlled by the ‘uniline-hint-style’ variable:
   • ‘t’ for full fledged messages over several lines
   • ‘1’ for one-liner messages
   • ‘0’ for no message at all

   The variable is "buffer-local", which means that it can take distinct
values on distinct buffers.

   There are no customizable ‘Uniline’ variables (not yet).  This does
not prevent customizing ‘uniline-hint-style’ for future sessions.  For
instance, in the ‘~/.emacs’ file, there might be:

     (use-package uniline
       :config (set-default 'uniline-hint-style 1))

   This setting gives one-liner messages.  It can be changed later on a
buffer per buffer basis with the ‘TAB’ key.  Note the use of
‘set-default’.  Using ‘setq’ instead would assign the value ‘1’ only in
the ‘~/.emacs’ buffer.


File: uniline.info,  Node: Line spacing,  Next: How Uniline behaves with its environment?,  Prev: Text menus (Hydra),  Up: Top

18 Line spacing
***************

The ‘line-spacing’ setting in Emacs can change the display of a sketch.

   The best looking effect is given by:
     (setq line-spacing nil)

   You may want to change your current setting.  ‘Uniline’ may handle
this variable some day.  Right now, ‘line-spacing’ is left as a matter
of choice for everyone.




     ╭────┬────────┬────╮   ╺┯━━━━┯┯━━┯┯━┯┯━━━━━━━━┯┯━━━━━━━┯┯━━━━━━┯╸
     │▒▒▒▒╰────────╯▒▒▒▒│    │    │╰is╯╰a╯│        ││       │╰around╯
     │▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒│    ╰this╯       ╰sentence╯╰hanging╯
     │▒▒▒╭─╮▒▒▒▒▒▒╭─╮▒▒▒│            △
     │▒▒▒╰─╯▒▒▒▒▒▒╰─╯▒▒▒│            │                  △
     │▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒│            ╰─────────┬────────╯
     ╰──────────────────╯                    verbs
                  (setq line-spacing nil)



File: uniline.info,  Node: How Uniline behaves with its environment?,  Next: Lisp API,  Prev: Line spacing,  Up: Top

19 How ‘Uniline’ behaves with its environment?
**********************************************

* Menu:

* Compatibility with Picture-mode::
* Compatibility with Artist-mode::
* Compatibility with Whitespace-mode::
* Compatibility with Org Mode::
* Org Mode and LaTex::
* What about \t tabs?::
* What about ^L page separation?::
* Emacs on the Linux console::
* Emacs on a graphical terminal emulator::
* Emacs on Windows::


File: uniline.info,  Node: Compatibility with Picture-mode,  Next: Compatibility with Artist-mode,  Up: How Uniline behaves with its environment?

19.1 Compatibility with Picture-mode
====================================

‘Picture-mode’ and ‘uniline-mode’ are compatible.  Their features
overlap somehow:
   • Both implement an unlimited buffer in east and south directions.
   • Both visually truncate long lines (actual text is not truncated).
   • Both set the overwrite mode (‘uniline-mode’ activates
     ‘overwrite-mode’, while ‘picture-mode’ re-implements it)
   • Both are able to draw rectangles (‘uniline-mode’ in UNICODE,
     ‘picture-mode’ in ASCII), copy and yank them.

   They also have features unique to each:
   • ‘Picture-mode’ writes in 8 possible directions
   • ‘Picture-mode’ handles TAB stops
   • ‘Uniline-mode’ draws lines and arrows


File: uniline.info,  Node: Compatibility with Artist-mode,  Next: Compatibility with Whitespace-mode,  Prev: Compatibility with Picture-mode,  Up: How Uniline behaves with its environment?

19.2 Compatibility with Artist-mode
===================================

‘Artist-mode’ and ‘uniline-mode’ are mostly incompatible.  This is
because ‘artist-mode’ preempts the arrow keys, which give access to a
large part of ‘uniline-mode’ features.

   However, it is possible to use both one after the other.


File: uniline.info,  Node: Compatibility with Whitespace-mode,  Next: Compatibility with Org Mode,  Prev: Compatibility with Artist-mode,  Up: How Uniline behaves with its environment?

19.3 Compatibility with Whitespace-mode
=======================================

‘Whitespace-mode’ and ‘uniline-mode’ are mostly compatible.

   Why activate ‘whitespace-mode’ while in ‘uniline-mode’?  Because
‘Uniline’ creates a lot of white-spaces to implement an infinite buffer.
And it is funny to look at this activity.

   To make ‘uniline-mode’ and ‘whitespace-mode’ fully compatible,
disable the newline visualization:

   • ‘M-x customize-variable whitespace-style’
   • uncheck ‘(Mark) NEWLINEs’

   This is due to a glitch in ‘move-to-column’ when a visual property is
attached to newlines.  And ‘uniline-mode’ makes heavy use of
‘move-to-column’.


File: uniline.info,  Node: Compatibility with Org Mode,  Next: Org Mode and LaTex,  Prev: Compatibility with Whitespace-mode,  Up: How Uniline behaves with its environment?

19.4 Compatibility with Org Mode
================================

You may want to customize the shift extension mode in ‘Org Mode’.  This
is because ‘Org Mode’ preempts ‘shift-select-mode’ for other useful
purposes.  Just type:

     M-x customize-variable org-support-shift-select

   and choose "when outside special context", which sets it to ‘t’.

   You then get the shift-selection from ‘Org Mode’, not from ‘Uniline’.
The difference is that the ‘Uniline’’s one handles the infinite-ness of
the buffer.

   Other than that, ‘Uniline’ is compatible with ‘Org Mode’


File: uniline.info,  Node: Org Mode and LaTex,  Next: What about \t tabs?,  Prev: Compatibility with Org Mode,  Up: How Uniline behaves with its environment?

19.5 Org Mode and LaTex
=======================

Use the ‘pmboxdraw’ LaTex module.  This gives limited support for "box
drawing" characters in LaTex documents.

   Example:


     #+LATEX_HEADER: \usepackage{pmboxdraw}

     #+begin_src text

     this works:
     ┌─────┐       ┌────────────┐
     │     ├───────┤            │
     └─────┘       │            │
     ┌─────┐  ┌────┤            │
     │     ├──┘    │            │
     └─────┘  ┌────┤            │
     ┌─────┐  │    │            │
     │     ├──┘    └────────────┘
     └─────┘

     this does not quite work:
        ┏━━━┓  ┏━━┓     ┏━━━━━┓
        ┃   ┃  ┃  ┣━━━━━┫     ┃
        ┃   ┗━━┛  ┃    ┏┛     ┃
        ┗━━━━━━━━━┛    ┗━━━━━━┛

     but that is OK:
          ┏━━━┓
          ┃   ┃
          ┗━━━┛

     that is OK too:
     ╺════╦══╗  ╔════╗
          ║ A║  ║ B  ╚══╗
          ╚══╝  ╚═══════╝

     this works:

     ├── dev
     └┬┬ release
      │├── new
      │└── old
      ├── graph
      └── non-graph

     #+end_src


   Note that corners of thin lines should be sharp.  There is no support
for rounded corners.  ‘Uniline’ does not (yet) draw sharp thin corners.
But it can recognize them.

   To export this Org Mode example to PDF through LaTex, type:

   ‘C-c C-E l o’


File: uniline.info,  Node: What about \t tabs?,  Next: What about ^L page separation?,  Prev: Org Mode and LaTex,  Up: How Uniline behaves with its environment?

19.6 What about ‘\t’ tabs?
==========================

Some files may contain tabs (the character ‘\t’).  Those include
programming code (Python, Perl, C++, D, Rust, JavaScript and so on).

   When ‘Uniline’ draws something in the middle of a tab, it first
converts it to spaces, then proceeds as usual.  This process is
invisible.  So be cautious if tabs have a special meaning in the file.

   One way to see what is going on, is to activate the
‘whitespace-mode’.


File: uniline.info,  Node: What about ^L page separation?,  Next: Emacs on the Linux console,  Prev: What about \t tabs?,  Up: How Uniline behaves with its environment?

19.7 What about ‘^L’ page separation?
=====================================

‘Uniline’ does not work well with ‘^L’ (page separation) character.
Nore with similar characters, like ‘^T’.  When trying to draw a line
over such a character, the cursor may get stuck.  This is because those
characters occupy twice the width of a normal character.

   Just try to get away from ‘^L’, ‘^T’ and such when drawing with
‘Uniline’.


File: uniline.info,  Node: Emacs on the Linux console,  Next: Emacs on a graphical terminal emulator,  Prev: What about ^L page separation?,  Up: How Uniline behaves with its environment?

19.8 Emacs on the Linux console
===============================

Linux consoles are the 7 non-graphic screens which can be accessed
usually typing ‘C-M-F1’, ‘C-M-F2’, and so on.  Such a screen is also
presented when connecting through ‘ssh’ or ‘tls’ into a non-graphical
server.

   By default they use a font named "Fixed" with poor support for
Unicode.  However, it supports lines of the 3 types, mixing all of them
in thin lines though.

   Another problem is that by default ‘S-<left>’ and ‘C-<left>’ are
indistinguishable from ‘<left>’.  Same problem with ‘<right>’, ‘<up>’,
‘<down>’ and ‘<insert>’.  This has nothing to do with Emacs.  A solution
can be found here: <https://www.emacswiki.org/emacs/MissingKeys>


File: uniline.info,  Node: Emacs on a graphical terminal emulator,  Next: Emacs on Windows,  Prev: Emacs on the Linux console,  Up: How Uniline behaves with its environment?

19.9 Emacs on a graphical terminal emulator
===========================================

This is the Emacs launched from a terminal typing ‘emacs -nw’.  In this
environment, ‘<insert>’ does not exists.  It is replaced by
‘<insertchar>’.  This has already been taken into account by ‘Uniline’
by duplicating the key-bindings for the two flavors of this key.

   If you decide to bind globally ‘C-<insert>’ to the toggling of
‘Uniline’ minor mode as suggested, then you will have to do the same for
‘C-<insertchar>’, for example with ‘use-package’ in your ‘~/.emacs’
file:

     (use-package uniline
       :defer t
       :bind ("C-<insert>"     . uniline-mode)
       :bind ("C-<insertchar>" . uniline-mode))


File: uniline.info,  Node: Emacs on Windows,  Prev: Emacs on a graphical terminal emulator,  Up: How Uniline behaves with its environment?

19.10 Emacs on Windows
======================

On Windows the only native mono-spaced fonts are ‘Lucida Console’ and
‘Courier New’.  They are not mono-spaced for the Unicodes used by
‘Uniline’.

   Often, the ‘Consolas’ font is present on Windows.  It supports quite
well the required Unicodes to draw lines.  A few glyphs produce
unaligned result though.  They should be avoided under ‘Consolas’:
‘△▶▹◇◆’

   Of course, other fonts may be installed.  It is quite easy.


File: uniline.info,  Node: Lisp API,  Next: Installation,  Prev: How Uniline behaves with its environment?,  Up: Top

20 Lisp API
***********

Could Uniline be programmed (versus used interactively)?  Yes!

   The API is usable programatically:

   Move cursor while drawing lines by calling any of the 4 directions
functions:
   • ‘uniline-write-up↑’
   • ‘uniline-write-ri→’
   • ‘uniline-write-dw↓’
   • ‘uniline-write-lf←’

   They expect a repeat ‘count’ (usually 1) and optionally ‘force=t’ to
overwrite the buffer

   Set the current brush by calling any of the following:

   • ‘uniline--set-brush-nil ;; write nothing’
   • ‘uniline--set-brush-0 ;; eraser’
   • ‘uniline--set-brush-1 ;; single thin line╶─╴’
   • ‘uniline--set-brush-2 ;; single thick line╺━╸’
   • ‘uniline--set-brush-3 ;; double line╺═╸’
   • ‘uniline--set-brush-block ;; blocks ▙▄▟▀’

   Those functions are equivalent to:

   • ‘(setq uniline--brush nil)’
   • ‘(setq uniline--brush 0)’
   • ‘(setq uniline--brush 1)’
   • ‘(setq uniline--brush 2)’
   • ‘(setq uniline--brush 3)’
   • ‘(setq uniline--brush :block)’

   except the functions also update the mode-line.

   For instance, if we want to create a function to draw a "plus" sign,
we can code it as follows:

     (defun uniline-draw-plus ()
       (interactive)
       (uniline-write-ri→ 1)
       (uniline-write-dw↓ 1)
       (uniline-write-ri→ 1)
       (uniline-write-dw↓ 1)
       (uniline-write-lf← 1)
       (uniline-write-dw↓ 1)
       (uniline-write-lf← 1)
       (uniline-write-up↑ 1)
       (uniline-write-lf← 1)
       (uniline-write-up↑ 1)
       (uniline-write-ri→ 1)
       (uniline-write-up↑ 1))

   Calling ‘M-x uniline-draw-plus’ will result in this nice little
plus-shape:



      ╭╮
     ╭╯╰╮
     ╰╮╭╯
      ╰╯
     generated by
     M-x uniline-draw-plus

   We may modify the function to accept the size of the shape as a
parameter:

     (defun uniline-draw-plus (size)
       (interactive "Nsize? ")
       (uniline-write-ri→ size)
       (uniline-write-dw↓ size)
       (uniline-write-ri→ size)
       (uniline-write-dw↓ size)
       (uniline-write-lf← size)
       (uniline-write-dw↓ size)
       (uniline-write-lf← size)
       (uniline-write-up↑ size)
       (uniline-write-lf← size)
       (uniline-write-up↑ size)
       (uniline-write-ri→ size)
       (uniline-write-up↑ size))

   The ‘(interactive "Nsize? ")’ form prompt user for the size of the
shape if not given as a parameter.

   This API works in any mode, not only in Uniline minor mode.  They
take care of the infiniteness of the buffer in the right and down
directions.

   Other useful functions are:

   Drawing and moving many characters at once:

   • ‘uniline-contour’
   • ‘uniline-fill’
   • ‘uniline-draw-inner-rectangle’
   • ‘uniline-draw-outer-rectangle’
   • ‘uniline-copy-rectangle’
   • ‘uniline-kill-rectangle’
   • ‘uniline-yank-rectangle’
   • ‘uniline-fill-rectangle’
   • ‘uniline-move-rect-up↑’
   • ‘uniline-move-rect-ri→’
   • ‘uniline-move-rect-dw↓’
   • ‘uniline-move-rect-lf←’

   Constants for the 4 directions:

   • ‘uniline-direction-up↑ ;; constant 0’
   • ‘uniline-direction-ri→ ;; constant 1’
   • ‘uniline-direction-dw↓ ;; constant 2’
   • ‘uniline-direction-lf← ;; constant 3’

   Changing text direction:

   • ‘uniline-text-direction-up↑’
   • ‘uniline-text-direction-ri→’
   • ‘uniline-text-direction-dw↓’
   • ‘uniline-text-direction-lf←’

   or (in this case the mode-line is not updated):

   • ‘(setq uniline-text-direction uniline-direction-up↑)’
   • ‘(setq uniline-text-direction uniline-direction-ri→)’
   • ‘(setq uniline-text-direction uniline-direction-dw↓)’
   • ‘(setq uniline-text-direction uniline-direction-lf←)’

   Call macro in any direction:

   • ‘uniline-call-macro-in-direction-up↑’
   • ‘uniline-call-macro-in-direction-ri→’
   • ‘uniline-call-macro-in-direction-dw↓’
   • ‘uniline-call-macro-in-direction-lf←’

   Insert glyphs:

   • ‘uniline-insert-fw-arrow’
   • ‘uniline-insert-fw-square’
   • ‘uniline-insert-fw-oshape’
   • ‘uniline-insert-fw-cross’
   • ‘uniline-insert-bw-arrow’
   • ‘uniline-insert-bw-square’
   • ‘uniline-insert-bw-oshape’
   • ‘uniline-insert-bw-cross’

   Rotate arrow or tweak 4-half-lines or 4-block characters:

   • ‘uniline-rotate-up↑’
   • ‘uniline-rotate-ri→’
   • ‘uniline-rotate-dw↓’
   • ‘uniline-rotate-lf←’

   Move point, possibly extending the buffer in right and bottom
directions:

   • ‘uniline-move-to-column’
   • ‘uniline-move-to-line’
   • ‘uniline-move-to-lin-col’
   • ‘uniline-move-to-delta-column’
   • ‘uniline-move-to-delta-line’


File: uniline.info,  Node: Installation,  Next: Related packages,  Prev: Lisp API,  Up: Top

21 Installation
***************

Add the following lines to your ‘.emacs’ file, and reload it, if not
already done:

     (add-to-list 'package-archives
                  '("melpa" . "http://melpa.org/packages/")
                  t)
     (package-initialize)

   Alternately you may customize this variable:

     M-x customize-variable package-archives

   Then download the package:

     (package-install "uniline")

   Alternately, you can download the Lisp file, and load it:

     (load-file "uniline.el")

   You may want to give ‘uniline-mode’ a key-binding.  ‘use-package’ in
your ‘$HOME/.emacs’ file is great for that:

     (use-package uniline
       :defer t
       :bind ("C-<insert>" . uniline-mode))

   In this example, ‘C-<insert>’ was chosen.  You can use whatever keys
combination you want.  ‘<insert>’ happens to also be the key used inside
‘Uniline’.


File: uniline.info,  Node: Related packages,  Next: Author contributors,  Prev: Installation,  Up: Top

22 Related packages
*******************

   • ‘artist-mode’: the ASCII art mode built into Emacs.

   • ‘ascii-art-to-unicode’: as the name suggest, converts ASCII
     drawings to UNICODE, giving results similar to those of ‘Uniline’.

   • ‘picture-mode’: as in ‘Uniline’, the buffer is infinite in east &
     south directions.

   • ‘org-pretty-table’: Org Mode tables _appear_ to be drawn in UNICODE
     characters (actually they are still in ASCII).

   • ‘boxes’: draws artistic boxes around text, with nice looking
     unicorns, flowers, parchments, all in ASCII art.

   • ‘org-drawio’: a bridge between the Draw.Io editor and Emacs,
     producing drawing similar to those of ‘Uniline’, but in ‘.svg’.

   • ‘syntree’: draws ASCII trees on-the-fly from description.

   • ‘unicode-enbox’: create a UNICODE box around a text; input and
     output are strings.

   • ‘unicode-fonts’: in Emacs, helps alleviate the lack of full UNICODE
     coverage of most fonts.

   • ‘org-superstar’: prettify headings and plain lists in Org Mode,
     using UNICODE glyphs.

   • ‘charmap’: UNICODE table viewer for Emacs.

   • ‘insert-char-preview’: insert UNICODEs with character preview in
     completion prompt.

   • ‘list-unicode-display’: list all UNICODE characters, or a selection
     of them.

   • ‘show-font’: show font features in a buffer.

   • ‘ob-svgbob’: convert your ascii diagram scribbles into happy little
     SVG

   • ‘el-easydraw’: a full featured SVG editor right inside your Emacs

   • ‘asciiflow’: (not Emacs) draw on the web, then copy-paste your
     UNICODE text

   • ‘dot-to-ascii.ggerganov.com:’ (not Emacs) describe your schema in
     the Graphviz language, and copy-past your UNICODE text.

   • ‘monosketch’: (not Emacs) draw on the web, then copy-paste your
     UNICODE text

   • ‘ibm-box-drawing-hydra.el’: keyboard interface to insert UNICODE
     box-drawing characters one at a time

   • ‘org-excalidraw’: integrate SVG images generated by excalidraw into
     Org Mode

   • ‘rcd-box’: create tables surrounded by box-drawing characters from
     Lisp descriptions

   • ‘ob-diagram’: generate various diagrams using diagrams backend

   • ‘ob-mermaid’: generate Mermaid diagrams within org-mode babel

   • ‘quail-boxdrawing.el’: input method for box drawing characters

   • ‘make-box.el’: box around part of a buffer

   • ‘vim drawit ascii diagrams’: in Vin, in ASCII


File: uniline.info,  Node: Author contributors,  Next: License,  Prev: Related packages,  Up: Top

23 Author, contributors
***********************

   • Thierry Banel, author

   Feedback:

   • Joost Kremers <https://github.com/joostkremers> found a bug in the
     minor-mode key-binding definitions, and incompatibility with
   • DogLooksGood <https://github.com/DogLooksGood> gave feedback on
     inserting usual characters not moving the cursor


File: uniline.info,  Node: License,  Prev: Author contributors,  Up: Top

24 License
**********

Copyright (C) 2024-2025 Thierry Banel

   Uniline is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.

   Uniline is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

   You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.



Tag Table:
Node: Top75
Node: Getting started in 10 seconds1204
Node: Pure UNICODE text diagrams in Emacs1534
Node: Minor mode9152
Node: Drawing lines9700
Node: Brush style10376
Node: The <insert> key11096
Node: Arrows glyphs ▷ ▶ → ▹ ▸ ↔11930
Node: Intersection glyphs ■ ◆ ●13238
Node: Drawing rectangles15886
Node: Moving rectangles17860
Node: Tracing a contour19737
Node: Flood-fill21504
Node: Text direction23253
Node: Macros23794
Node: Fine tweaking27155
Node: Which fonts?28950
Node: Text menus (Hydra)30805
Node: Line spacing32765
Node: How Uniline behaves with its environment?34193
Node: Compatibility with Picture-mode34741
Node: Compatibility with Artist-mode35659
Node: Compatibility with Whitespace-mode36178
Node: Compatibility with Org Mode37078
Node: Org Mode and LaTex37864
Node: What about \t tabs?39765
Node: What about ^L page separation?40413
Node: Emacs on the Linux console41036
Node: Emacs on a graphical terminal emulator41990
Node: Emacs on Windows42913
Node: Lisp API43560
Node: Installation48722
Node: Related packages49720
Node: Author contributors52427
Node: License52887

End Tag Table


Local Variables:
coding: utf-8
End: