├── LICENSE
├── README.md
├── TODO.md
├── bindata.go
├── complete.go
├── display.go
├── editutil.go
├── event.go
├── exec.go
├── fervor.desktop
├── fervor.ini
├── fervor.svg
├── gc.go
├── history.go
├── main.go
├── prompt.go
└── syntax.go


/LICENSE:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2015 Casey Mulcahy (jangler)
 2 | 
 3 | Permission is hereby granted, free of charge, to any person obtaining a copy of
 4 | this software and associated documentation files (the "Software"), to deal in
 5 | the Software without restriction, including without limitation the rights to
 6 | use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 7 | of the Software, and to permit persons to whom the Software is furnished to do
 8 | so, subject to the following conditions:
 9 | 
10 | The above copyright notice and this permission notice shall be included in all
11 | copies or substantial portions of the Software.
12 | 
13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
16 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
19 | SOFTWARE.
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Fervor
  2 | ======
  3 | 
  4 | **Disclaimer: Changes to the veandco/go-sdl2 packages since the development of
  5 | this software may have created problematic incompatibilities, which I do not
  6 | plan to investigate anytime soon. If you would like to try Fervor, I recommend
  7 | compiling against a veandco/go-sdl2 commit from September 2015.**
  8 | 
  9 | ![screenshot](http://jangler.info/dl/fervor-screenshot-0.3.0.png 'screenshot')
 10 | 
 11 | A graphical, modeless, cross-platform text editor influenced by Acme, vi, and
 12 | even Notepad. Features include:
 13 | 
 14 | - Infinite undo
 15 | - Unicode (UTF-8) support
 16 | - Regular expression search
 17 | - Acme-like right-click find
 18 | - No GUI toolkit dependencies
 19 | - Quick startup and low memory footprint
 20 | - Asynchronous shell command execution and selection filtering
 21 | - Basic syntax highlighting (currently for: Bash, C, CSS, Go, HTML, INI,
 22 |   JavaScript, JSON, Lua, Make, Python, Ruby, and SVG)
 23 | 
 24 | Not included:
 25 | 
 26 | - A scrollbar.
 27 | - Tabs or panes. Use a good window manager instead!
 28 | 
 29 | See also: [TODO.md](https://github.com/jangler/fervor/blob/master/TODO.md).
 30 | 
 31 | Installation
 32 | ------------
 33 | Install or update via the [go command](http://golang.org/cmd/go/):
 34 | 
 35 | 	go get -u github.com/jangler/{edit,fervor}
 36 | 
 37 | Alternatively, download a binary distribution from
 38 | <https://github.com/jangler/fervor/releases>.
 39 | 
 40 | In either case, the SDL2 and SDL2\_ttf libraries are required.
 41 | 
 42 | Usage
 43 | -----
 44 | 	Usage: fervor [<option> ...] [<file> ...]
 45 | 
 46 | 	Options:
 47 | 	  -dark
 48 | 			use dark color scheme
 49 | 	  -expandtab
 50 | 			insert spaces using the Tab key
 51 | 	  -font string
 52 | 			use the font at the given path
 53 | 	  -ptsize int
 54 | 			set point size of font (default 12)
 55 | 	  -tabstop int
 56 | 			set width of tab stops, in columns (default 8)
 57 | 	  -version
 58 | 			print version information and exit
 59 | 
 60 | 	Global and file-specific default options can be specified in either
 61 | 	~/fervor.ini or ~/.config/fervor.ini.
 62 | 
 63 | See [fervor.ini](https://github.com/jangler/fervor/blob/master/fervor.ini) for
 64 | an example configuration.
 65 | 
 66 | Key bindings
 67 | ------------
 68 | 	Ctrl+A           Move cursor to beginning of line
 69 | 	Ctrl+C           Copy (in buffer), cancel (in prompt)
 70 | 	Ctrl+D           Change directory...
 71 | 	Ctrl+E           Move cursor to end of line
 72 | 	Ctrl+F           Find regexp forward...
 73 | 	Ctrl+Shift+F     Find regexp backward...
 74 | 	Ctrl+G           Go to line...
 75 | 	Ctrl+H           Delete character backward
 76 | 	Ctrl+I           Insert tab
 77 | 	Ctrl+L           Toggle Unix/DOS line endings
 78 | 	Ctrl+N           Next match
 79 | 	Ctrl+Shift+N     Previous match
 80 | 	Ctrl+O           Open...
 81 | 	Ctrl+Shift+O     Open in new window...
 82 | 	Ctrl+P           Pipe selection through command...
 83 | 	Ctrl+Q           Quit
 84 | 	Ctrl+Shift+Q     Quit without confirmation
 85 | 	Ctrl+R           Run command...
 86 | 	Ctrl+Shift+R     Reload font (fixes missing glyphs)
 87 | 	Ctrl+S           Save
 88 | 	Ctrl+Shift+S     Save as...
 89 | 	Ctrl+U           Delete line backward
 90 | 	Ctrl+V           Paste
 91 | 	Ctrl+W           Delete word backward
 92 | 	Ctrl+X           Cut
 93 | 	Ctrl+Y           Redo
 94 | 	Ctrl+Z           Undo
 95 | 	Tab              Indent selection, complete word (searching backward)
 96 | 	Shift+Tab        Unindent selection, complete word (searching forward)
 97 | 
 98 | Holding Shift makes a cursor motion select text from the previous cursor
 99 | position to the resulting position. Enter, Backspace, Delete, Home, End, PgUp,
100 | PgDn, Up, Down, Left, Right, Esc, Ctrl+Backspace, Ctrl+Delete, Ctrl+Home,
101 | Ctrl+End, Ctrl+Left, and Ctrl+Right should also work as expected.
102 | 
103 | Mouse bindings
104 | --------------
105 | 	Left click   Position cursor
106 | 	Left drag    Select text
107 | 	Right click  Find next instance of clicked word or selection
108 | 	Right drag   Find next instance of selection
109 | 
110 | Holding Shift makes a left click select text from the previous cursor position
111 | to the clicked position, and makes a right click or drag search backward
112 | instead of forward.
113 | 


--------------------------------------------------------------------------------
/TODO.md:
--------------------------------------------------------------------------------
 1 | TODO
 2 | ====
 3 | 
 4 | 0.4.0
 5 | -----
 6 | - Make in-buffer tab completion work as expected w/r/t current line
 7 | - Fix the window expose issue
 8 | - Look into pipe command text not coming through
 9 | - Repeat last edit sequence (like . in Vim)
10 | - Use as filter (-filter flag?)
11 | - In-editor help?
12 | - Set options dynamically?
13 | 
14 | 0.5.0
15 | -----
16 | - Terminal-ish support (interact with launched processes)
17 | - Edit remote files
18 | - Custom color schemes?
19 | 
20 | ?.?.?
21 | -----
22 | - Syntax highlighting
23 | 	- Tcl
24 | 	- Markdown
25 | 	- ReStructured Text
26 | 


--------------------------------------------------------------------------------
/complete.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"os"
  5 | 	"os/user"
  6 | 	"path/filepath"
  7 | 	"regexp"
  8 | 	"strings"
  9 | 	"unicode/utf8"
 10 | 
 11 | 	"github.com/jangler/edit"
 12 | )
 13 | 
 14 | var nonWordRegexp = regexp.MustCompile(`\W`)
 15 | 
 16 | // commonPrefix returns the longest common prefix of two strings.
 17 | func commonPrefix(a, b string) string {
 18 | 	var prefix string
 19 | 	if len(b) < len(a) {
 20 | 		a, b = b, a
 21 | 	}
 22 | 	for i := len(a); i >= 0; i-- {
 23 | 		if a[:i] == b[:i] {
 24 | 			prefix = a[:i]
 25 | 			break
 26 | 		}
 27 | 	}
 28 | 	return prefix
 29 | }
 30 | 
 31 | // completeCmd completes the typed command name to the longest common prefix of
 32 | // matches in $PATH.
 33 | func completeCmd(cmd string) string {
 34 | 	paths := strings.Split(os.Getenv("PATH"), string(os.PathListSeparator))
 35 | 	var prefix string
 36 | 	for _, path := range paths {
 37 | 		if f, err := os.Open(path); err == nil {
 38 | 			if names, err := f.Readdirnames(0); err == nil {
 39 | 				for _, name := range names {
 40 | 					if strings.HasPrefix(name, cmd) {
 41 | 						if prefix == "" {
 42 | 							prefix = name
 43 | 						} else {
 44 | 							prefix = commonPrefix(prefix, name)
 45 | 							if prefix == "" {
 46 | 								return cmd
 47 | 							}
 48 | 						}
 49 | 					}
 50 | 				}
 51 | 			}
 52 | 			f.Close()
 53 | 		}
 54 | 	}
 55 | 	if prefix == "" {
 56 | 		return cmd
 57 | 	}
 58 | 	return prefix
 59 | }
 60 | 
 61 | // completePath completes the typed path to the longest common prefix of paths
 62 | // in the directory.
 63 | func completePath(path string, dirsOnly bool) string {
 64 | 	// read filenames from dir
 65 | 	absPath, err := filepath.Abs(path)
 66 | 	if err != nil {
 67 | 		return path
 68 | 	}
 69 | 	var dir, file string
 70 | 	if strings.HasSuffix(path, "/") {
 71 | 		dir = absPath
 72 | 	} else {
 73 | 		dir, file = filepath.Split(absPath)
 74 | 	}
 75 | 	f, err := os.Open(dir)
 76 | 	if err != nil {
 77 | 		return path
 78 | 	}
 79 | 	names, err := f.Readdirnames(0)
 80 | 	f.Close()
 81 | 	if err != nil {
 82 | 		return path
 83 | 	}
 84 | 
 85 | 	// return a match if there is exactly one
 86 | 	var prefix string
 87 | 	for _, name := range names {
 88 | 		if strings.HasPrefix(name, file) &&
 89 | 			(!dirsOnly || isDir(filepath.Join(dir, name))) {
 90 | 			if prefix == "" {
 91 | 				prefix = name
 92 | 			} else {
 93 | 				if prefix = commonPrefix(prefix, name); prefix == "" {
 94 | 					break
 95 | 				}
 96 | 			}
 97 | 		}
 98 | 	}
 99 | 	if prefix != "" {
100 | 		path = filepath.Join(dir, prefix)
101 | 	}
102 | 	if fi, err := os.Stat(path); err == nil && fi.IsDir() {
103 | 		return minPath(path) + "/"
104 | 	}
105 | 	return minPath(path)
106 | }
107 | 
108 | // completeWord completes the typed word to the first match in the buffer.
109 | func completeWord(b *edit.Buffer, prefix string, forward bool) string {
110 | 	endLine := b.End().Line
111 | 	startLine := b.IndexFromMark(insMark).Line
112 | 	line := startLine
113 | 	for {
114 | 		// search for completion in line
115 | 		s := b.Get(edit.Index{line, 0}, edit.Index{line, 1 << 30})
116 | 		words := nonWordRegexp.Split(s, -1)
117 | 		if forward {
118 | 			for _, word := range words {
119 | 				if strings.HasPrefix(word, prefix) && word != prefix {
120 | 					return word
121 | 				}
122 | 			}
123 | 		} else {
124 | 			for i := len(words) - 1; i >= 0; i-- {
125 | 				if strings.HasPrefix(words[i], prefix) && words[i] != prefix {
126 | 					return words[i]
127 | 				}
128 | 			}
129 | 		}
130 | 
131 | 		// go to next line
132 | 		if forward {
133 | 			line++
134 | 			if line > endLine {
135 | 				line = 0
136 | 			}
137 | 		} else {
138 | 			line--
139 | 			if line < 1 {
140 | 				line = endLine
141 | 			}
142 | 		}
143 | 		if line == startLine { // search failed
144 | 			break
145 | 		}
146 | 	}
147 | 	return ""
148 | }
149 | 
150 | // expandVars returns a version of path with environment variables and ~/
151 | // expanded.
152 | func expandVars(path string) string {
153 | 	path = os.ExpandEnv(path)
154 | 	if curUser, err := user.Current(); err == nil {
155 | 		path = strings.Replace(path, "~/", curUser.HomeDir+"/", -1)
156 | 	}
157 | 	return path
158 | }
159 | 
160 | // isDir returns true if and only if the given path represents a directory.
161 | func isDir(path string) bool {
162 | 	if fi, err := os.Stat(path); err == nil {
163 | 		return fi.IsDir()
164 | 	}
165 | 	return false
166 | }
167 | 
168 | // minPath returns the shortest valid representation of the given file path.
169 | func minPath(path string) string {
170 | 	// try absolute path
171 | 	abs, err := filepath.Abs(path)
172 | 	if err != nil {
173 | 		return path
174 | 	}
175 | 
176 | 	// try path relative to working directory
177 | 	if wd, err := os.Getwd(); err == nil {
178 | 		if relWd, err := filepath.Rel(wd, abs); err == nil {
179 | 			if utf8.RuneCountInString(relWd) < utf8.RuneCountInString(path) {
180 | 				path = relWd
181 | 			}
182 | 		}
183 | 	}
184 | 
185 | 	// try path relative to home directory
186 | 	if curUser, err := user.Current(); err == nil {
187 | 		if relHome, err := filepath.Rel(curUser.HomeDir, abs); err == nil {
188 | 			relHome = "~/" + relHome
189 | 			if utf8.RuneCountInString(relHome) < utf8.RuneCountInString(path) {
190 | 				path = relHome
191 | 			}
192 | 		}
193 | 	}
194 | 
195 | 	return filepath.Clean(path)
196 | }
197 | 


--------------------------------------------------------------------------------
/display.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"log"
  6 | 	"os"
  7 | 	"regexp"
  8 | 	"unicode/utf8"
  9 | 	"unsafe"
 10 | 
 11 | 	"github.com/jangler/edit"
 12 | 	"github.com/veandco/go-sdl2/sdl"
 13 | 	"github.com/veandco/go-sdl2/sdl_ttf"
 14 | )
 15 | 
 16 | const padPx = 2 // number of pixels used to pad UI elements
 17 | 
 18 | var (
 19 | 	lightBgColor      = sdl.Color{0xff, 0xff, 0xff, 0xff}
 20 | 	lightFgColor      = sdl.Color{0x2f, 0x2f, 0x2f, 0xff}
 21 | 	lightStatusColor  = sdl.Color{0xe8, 0xe8, 0xe8, 0xff}
 22 | 	lightCommentColor = sdl.Color{0x3f, 0x5a, 0x8d, 0xff}
 23 | 	lightKeywordColor = sdl.Color{0x3a, 0x63, 0x41, 0xff}
 24 | 	lightLiteralColor = sdl.Color{0x8e, 0x4a, 0x43, 0xff}
 25 | 
 26 | 	darkBgColor      = sdl.Color{0x25, 0x25, 0x25, 0xff}
 27 | 	darkFgColor      = sdl.Color{0xe2, 0xe2, 0xe2, 0xff}
 28 | 	darkStatusColor  = sdl.Color{0x40, 0x40, 0x40, 0xff}
 29 | 	darkCommentColor = sdl.Color{0xa0, 0xb6, 0xdf, 0xff}
 30 | 	darkKeywordColor = sdl.Color{0x99, 0xbe, 0x9f, 0xff}
 31 | 	darkLiteralColor = sdl.Color{0xda, 0xaa, 0xa5, 0xff}
 32 | 
 33 | 	bgColor, fgColor, statusColor            sdl.Color
 34 | 	commentColor, keywordColor, literalColor sdl.Color
 35 | )
 36 | 
 37 | func setColorScheme() {
 38 | 	if darkFlag {
 39 | 		bgColor = darkBgColor
 40 | 		fgColor = darkFgColor
 41 | 		statusColor = darkStatusColor
 42 | 		commentColor = darkCommentColor
 43 | 		keywordColor = darkKeywordColor
 44 | 		literalColor = darkLiteralColor
 45 | 	} else {
 46 | 		bgColor = lightBgColor
 47 | 		fgColor = lightFgColor
 48 | 		statusColor = lightStatusColor
 49 | 		commentColor = lightCommentColor
 50 | 		keywordColor = lightKeywordColor
 51 | 		literalColor = lightLiteralColor
 52 | 	}
 53 | }
 54 | 
 55 | var fontHeight, fontWidth int
 56 | 
 57 | // Pane is a buffer with associated metadata.
 58 | type Pane struct {
 59 | 	*edit.Buffer
 60 | 	Title      string
 61 | 	TabWidth   int
 62 | 	Cols, Rows int
 63 | 	LineEnding string
 64 | }
 65 | 
 66 | // getFont loads the default TTF from memory and returns it.
 67 | func getFont() *ttf.Font {
 68 | 	var font *ttf.Font
 69 | 	var err error
 70 | 	// if font flag is specified, try loading that font
 71 | 	if fontFlag != "" {
 72 | 		font, err = ttf.OpenFont(fontFlag, ptsizeFlag)
 73 | 		if err != nil {
 74 | 			fmt.Fprintln(os.Stderr, err)
 75 | 		} else if !font.FaceIsFixedWidth() {
 76 | 			fmt.Fprintf(os.Stderr, "%s is not fixed-width\n", fontFlag)
 77 | 			font = nil
 78 | 		}
 79 | 	}
 80 | 	if font == nil {
 81 | 		// fall back to loading built-in font
 82 | 		data, err := Asset("data/font.ttf")
 83 | 		if err != nil {
 84 | 			log.Fatal(err)
 85 | 		}
 86 | 		rw := sdl.RWFromMem(unsafe.Pointer(&data[0]), len(data))
 87 | 		font, err = ttf.OpenFontRW(rw, 1, ptsizeFlag)
 88 | 		if err != nil {
 89 | 			log.Fatal(err)
 90 | 		}
 91 | 	}
 92 | 
 93 | 	// set globally accessible font dimensions
 94 | 	if fontWidth, _, err = font.SizeUTF8("0"); err != nil {
 95 | 		log.Fatal(err)
 96 | 	}
 97 | 	fontHeight = font.Height()
 98 | 
 99 | 	return font
100 | }
101 | 
102 | // getIcon loads the window icon from memory and returns it as a surface.
103 | func getIcon() *sdl.Surface {
104 | 	data, err := Asset("data/icon.bmp")
105 | 	if err != nil {
106 | 		log.Fatal(err)
107 | 	}
108 | 	rw := sdl.RWFromMem(unsafe.Pointer(&data[0]), len(data))
109 | 	surf, err := sdl.LoadBMP_RW(rw, 1)
110 | 	if err != nil {
111 | 		log.Fatal(err)
112 | 	}
113 | 	return surf
114 | }
115 | 
116 | // createWindow returns a new SDL window of appropriate size given font, and
117 | // titled title.
118 | func createWindow(title string, font *ttf.Font) *sdl.Window {
119 | 	width, height := fontWidth*80+padPx*2, fontHeight*25+padPx*6
120 | 	win, err := sdl.CreateWindow(title, sdl.WINDOWPOS_UNDEFINED,
121 | 		sdl.WINDOWPOS_UNDEFINED, width, height, sdl.WINDOW_RESIZABLE)
122 | 	if err != nil {
123 | 		log.Fatal(err)
124 | 	}
125 | 	win.SetIcon(getIcon())
126 | 	return win
127 | }
128 | 
129 | // drawBuffer draws the displayed contents of b to dst using font.
130 | func drawBuffer(b *edit.Buffer, font *ttf.Font, dst *sdl.Surface,
131 | 	focused bool) {
132 | 	x, y := padPx, padPx
133 | 
134 | 	// get cursor position
135 | 	ins := b.IndexFromMark(insMark)
136 | 	col, row := b.CoordsFromIndex(ins)
137 | 
138 | 	// get selection start and end positions
139 | 	sel := b.IndexFromMark(selMark)
140 | 	selStart, selEnd := order(sel, ins)
141 | 	startCol, startRow := b.CoordsFromIndex(selStart)
142 | 	endCol, endRow := b.CoordsFromIndex(selEnd)
143 | 
144 | 	// draw each line in display
145 | 	for i, line := range b.DisplayLines() {
146 | 		c := 0
147 | 
148 | 		// draw each syntax-highlighted fragment
149 | 		for e := line.Front(); e != nil; e = e.Next() {
150 | 			text := e.Value.(edit.Fragment).Text
151 | 			fg := fgColor
152 | 			switch e.Value.(edit.Fragment).Tag {
153 | 			case commentID:
154 | 				fg = commentColor
155 | 			case keywordID:
156 | 				fg = keywordColor
157 | 			case literalID:
158 | 				fg = literalColor
159 | 			}
160 | 
161 | 			if sel != ins && i >= startRow && i <= endRow {
162 | 				// text might be in selection range, so it needs to be split
163 | 				// and drawn piecewise
164 | 				pre, mid, post := []rune(""), []rune(""), []rune("")
165 | 				runes := []rune(text)
166 | 				if i == startRow && c < startCol {
167 | 					if startCol-c < len(runes) {
168 | 						pre = runes[:startCol-c]
169 | 					} else {
170 | 						pre = runes
171 | 					}
172 | 				}
173 | 				if i == endRow && c+len(runes) > endCol {
174 | 					if c < endCol {
175 | 						post = runes[endCol-c:]
176 | 					} else {
177 | 						post = runes
178 | 					}
179 | 				}
180 | 				mid = runes[len(pre) : len(runes)-len(post)]
181 | 
182 | 				drawString(font, string(pre), fg, bgColor, dst, x, y)
183 | 				x += len(pre) * fontWidth
184 | 				drawString(font, string(mid), fg, statusColor, dst, x, y)
185 | 				x += len(mid) * fontWidth
186 | 				drawString(font, string(post), fg, bgColor, dst, x, y)
187 | 				x += len(post) * fontWidth
188 | 
189 | 				c += len(runes)
190 | 			} else {
191 | 				drawString(font, text, fg, bgColor, dst, x, y)
192 | 				x += utf8.RuneCountInString(text) * fontWidth
193 | 			}
194 | 		}
195 | 
196 | 		if focused && i == row {
197 | 			// draw cursor
198 | 			dst.FillRect(&sdl.Rect{int32(padPx + fontWidth*col), int32(y),
199 | 				1 + int32(ptsizeFlag)/18, int32(fontHeight)}, fgColor.Uint32())
200 | 		}
201 | 
202 | 		y += fontHeight
203 | 		x = padPx
204 | 	}
205 | }
206 | 
207 | // drawString draws s to dst at (x, y) using font.
208 | func drawString(font *ttf.Font, s string, fg, bg sdl.Color, dst *sdl.Surface,
209 | 	x, y int) {
210 | 	if s != "" {
211 | 		surf, err := font.RenderUTF8_Shaded(s, fg, bg)
212 | 		if err != nil {
213 | 			panic(err)
214 | 		}
215 | 		defer surf.Free()
216 | 		err = surf.Blit(&sdl.Rect{0, 0, surf.W, surf.H}, dst,
217 | 			&sdl.Rect{int32(x), int32(y), 0, 0})
218 | 		if err != nil {
219 | 			log.Fatal(err)
220 | 		}
221 | 
222 | 		// check surface size to make sure we're not missing glyphs.
223 | 		// this will probably be an issue with zero-width runes--let's hope we
224 | 		// don't encounter any of those.
225 | 		delta := fontWidth*utf8.RuneCountInString(s) - int(surf.W)
226 | 		if delta > fontWidth/2 {
227 | 			panic(fmt.Errorf("Rendered surface has incorrect size"))
228 | 		}
229 | 	}
230 | }
231 | 
232 | // drawStatusLine draws s at the bottom of dst using font.
233 | func drawStatusLine(dst *sdl.Surface, font *ttf.Font, s string,
234 | 	input *edit.Buffer, pane *Pane, focused bool) {
235 | 	// draw background
236 | 	bgRect := sdl.Rect{
237 | 		0,
238 | 		dst.H - int32(fontHeight) - padPx*2,
239 | 		dst.W,
240 | 		int32(fontHeight) + padPx*2,
241 | 	}
242 | 	dst.FillRect(&bgRect, statusColor.Uint32())
243 | 
244 | 	// draw status text
245 | 	x, y := padPx, int(dst.H)-fontHeight-padPx
246 | 	drawString(font, s, fgColor, statusColor, dst, x, y)
247 | 	x += utf8.RuneCountInString(s) * fontWidth
248 | 
249 | 	if focused {
250 | 		// draw input text and cursor
251 | 		drawString(font, input.Get(edit.Index{1, 0}, input.End()), fgColor,
252 | 			statusColor, dst, x, y)
253 | 		index := input.IndexFromMark(insMark)
254 | 		dst.FillRect(&sdl.Rect{int32(x + fontWidth*index.Char), int32(y),
255 | 			1 + int32(ptsizeFlag)/18, int32(fontHeight)}, fgColor.Uint32())
256 | 	} else if s == pane.Title {
257 | 		// draw cursor pos
258 | 		index := pane.IndexFromMark(insMark)
259 | 		line := pane.Get(edit.Index{index.Line, 0}, index)
260 | 		col := 0
261 | 		for _, ch := range line {
262 | 			if ch == '\t' {
263 | 				col += pane.TabWidth - col%pane.TabWidth
264 | 			} else {
265 | 				col++
266 | 			}
267 | 		}
268 | 		cursorPos := fmt.Sprintf("%d,%d", index.Line, index.Char)
269 | 		if col != index.Char {
270 | 			cursorPos += fmt.Sprintf("-%d", col)
271 | 		}
272 | 		drawString(font, cursorPos, fgColor, statusColor, dst,
273 | 			int(dst.W)-padPx-fontWidth*17, int(dst.H)-fontHeight-padPx)
274 | 
275 | 		// draw scroll percent
276 | 		f := pane.ScrollFraction()
277 | 		scrollStr := fmt.Sprintf("%d%%", int(f*100))
278 | 		if f < 0 {
279 | 			scrollStr = "All"
280 | 		}
281 | 		drawString(font, scrollStr, fgColor, statusColor, dst,
282 | 			int(dst.W)-padPx-fontWidth*4, int(dst.H)-fontHeight-padPx)
283 | 	}
284 | }
285 | 
286 | // paneSpace returns the number of vertical pixels available to a pane.
287 | func paneSpace(height int) int {
288 | 	return height - fontHeight - padPx*2
289 | }
290 | 
291 | // bufSize returns the number of rows and columns available to a pane.
292 | func bufSize(width, height int) (cols, rows int) {
293 | 	cols = (width - padPx*2) / fontWidth
294 | 	rows = paneSpace(height) / fontHeight
295 | 	return
296 | }
297 | 
298 | // RenderContext contains information needed to update the display.
299 | type RenderContext struct {
300 | 	Pane   *Pane
301 | 	Input  *edit.Buffer
302 | 	Focus  *edit.Buffer
303 | 	Status string
304 | 	Font   *ttf.Font
305 | 	Window *sdl.Window
306 | 	Regexp *regexp.Regexp
307 | }
308 | 
309 | // render redraws and updates the display.
310 | func render(rc *RenderContext) {
311 | 	surf, err := rc.Window.GetSurface()
312 | 	if err != nil {
313 | 		log.Fatal(err)
314 | 	}
315 | 	surf.FillRect(&sdl.Rect{0, 0, surf.W, surf.H}, bgColor.Uint32())
316 | 	defer func() {
317 | 		if err := recover(); err != nil {
318 | 			log.Print(err)
319 | 			rc.Font = getFont()
320 | 			render(rc)
321 | 		}
322 | 	}()
323 | 	paneFocused := rc.Focus == rc.Pane.Buffer
324 | 	drawBuffer(rc.Pane.Buffer, rc.Font, surf, paneFocused)
325 | 	drawStatusLine(surf, rc.Font, rc.Status, rc.Input, rc.Pane, !paneFocused)
326 | 	rc.Window.UpdateSurface()
327 | }
328 | 


--------------------------------------------------------------------------------
/editutil.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"regexp"
  5 | 
  6 | 	"github.com/jangler/edit"
  7 | )
  8 | 
  9 | var (
 10 | 	spaceRegexp = regexp.MustCompile(`\s`)
 11 | 	wordRegexp  = regexp.MustCompile(`\w`)
 12 | )
 13 | 
 14 | // find attempts a regexp search in the buffer and returns a status message.
 15 | func find(b *edit.Buffer, re *regexp.Regexp, forward bool,
 16 | 	defaultStatus string) string {
 17 | 	if re == nil {
 18 | 		return "No pattern to find."
 19 | 	}
 20 | 
 21 | 	sel, ins := b.IndexFromMark(selMark), b.IndexFromMark(insMark)
 22 | 	if forward {
 23 | 		_, index := order(sel, ins)
 24 | 		text := b.Get(index, b.End())
 25 | 		if loc := re.FindStringIndex(text); loc != nil {
 26 | 			b.Mark(b.ShiftIndex(index, loc[0]), selMark)
 27 | 			b.Mark(b.ShiftIndex(index, loc[1]), insMark)
 28 | 			b.Separate()
 29 | 		} else {
 30 | 			return "No forward match."
 31 | 		}
 32 | 	} else {
 33 | 		index, _ := order(sel, ins)
 34 | 		text := b.Get(edit.Index{1, 0}, index)
 35 | 		if locs := re.FindAllStringIndex(text, -1); locs != nil {
 36 | 			loc := locs[len(locs)-1]
 37 | 			b.Mark(b.ShiftIndex(edit.Index{1, 0}, loc[0]), selMark)
 38 | 			b.Mark(b.ShiftIndex(edit.Index{1, 0}, loc[1]), insMark)
 39 | 			b.Separate()
 40 | 		} else {
 41 | 			return "No backward match."
 42 | 		}
 43 | 	}
 44 | 
 45 | 	return defaultStatus
 46 | }
 47 | 
 48 | // getSelection returns the selected text in the buffer.
 49 | func getSelection(b *edit.Buffer) string {
 50 | 	return b.Get(order(b.IndexFromMark(selMark), b.IndexFromMark(insMark)))
 51 | }
 52 | 
 53 | // indent changes the indentation of the given lines in the buffer.
 54 | func indent(b *edit.Buffer, startLine, endLine int, unindent bool) {
 55 | 	for line := startLine; line <= endLine; line++ {
 56 | 		if expandtabFlag {
 57 | 			for i := 0; i < int(tabstopFlag); i++ {
 58 | 				char := b.Get(edit.Index{line, 0}, edit.Index{line, 1})
 59 | 				if unindent {
 60 | 					if char == " " {
 61 | 						b.Delete(edit.Index{line, 0}, edit.Index{line, 1})
 62 | 					}
 63 | 				} else if char != "" { // don't indent blank lines
 64 | 					b.Insert(edit.Index{line, 0}, " ")
 65 | 				}
 66 | 			}
 67 | 		} else {
 68 | 			char := b.Get(edit.Index{line, 0}, edit.Index{line, 1})
 69 | 			if unindent {
 70 | 				if char == "\t" {
 71 | 					b.Delete(edit.Index{line, 0}, edit.Index{line, 1})
 72 | 				}
 73 | 			} else if char != "" { // don't indent blank lines
 74 | 				b.Insert(edit.Index{line, 0}, "\t")
 75 | 			}
 76 | 		}
 77 | 	}
 78 | }
 79 | 
 80 | // order returns index1 and index2 in buffer order.
 81 | func order(index1, index2 edit.Index) (first, second edit.Index) {
 82 | 	if index1.Less(index2) {
 83 | 		return index1, index2
 84 | 	}
 85 | 	return index2, index1
 86 | }
 87 | 
 88 | // seeMark ensurees that the mark with ID id is visible on the buffer's screen,
 89 | // which displays numRows rows.
 90 | func seeMark(b *edit.Buffer, id, numRows int) {
 91 | 	_, row := b.CoordsFromIndex(b.IndexFromMark(id))
 92 | 
 93 | 	// If the mark is off-screen by less than a page, scroll so that the mark
 94 | 	// is at the top or bottom edge of the display. Otherwise, scroll so that
 95 | 	// the mark is centered in the display.
 96 | 	if row < -numRows {
 97 | 		b.Scroll(row - numRows/2)
 98 | 	} else if row < 0 {
 99 | 		b.Scroll(row)
100 | 	} else if row >= numRows*2 {
101 | 		b.Scroll(row + 1 - numRows/2)
102 | 	} else if row >= numRows {
103 | 		b.Scroll(row + 1 - numRows)
104 | 	}
105 | }
106 | 
107 | // select line changes the selection to the entirety of a line, sans leading
108 | // whitespace.
109 | func selectLine(b *edit.Buffer, line int) {
110 | 	selIndex := edit.Index{line, 0}
111 | 	for spaceRegexp.MatchString(b.Get(selIndex,
112 | 		edit.Index{line, selIndex.Char + 1})) {
113 | 		selIndex.Char++
114 | 	}
115 | 	b.Mark(selIndex, selMark)
116 | 	b.Mark(edit.Index{line, 1 << 30}, insMark)
117 | }
118 | 
119 | // selectWord selects the word at the given index in the buffer.
120 | func selectWord(b *edit.Buffer, index edit.Index) {
121 | 	selIndex, insIndex := index, index
122 | 	for wordRegexp.MatchString(b.Get(
123 | 		edit.Index{selIndex.Line, selIndex.Char - 1}, selIndex)) {
124 | 		selIndex.Char--
125 | 	}
126 | 	for wordRegexp.MatchString(b.Get(
127 | 		insIndex, edit.Index{insIndex.Line, insIndex.Char + 1})) {
128 | 		insIndex.Char++
129 | 	}
130 | 	b.Mark(selIndex, selMark)
131 | 	b.Mark(insIndex, insMark)
132 | }
133 | 
134 | // shiftIndexByWord returns the given index shifted forward by n words. A
135 | // negative value for n will shift backwards.
136 | func shiftIndexByWord(b *edit.Buffer, index edit.Index, n int) edit.Index {
137 | 	for n > 0 {
138 | 		text := []rune(b.Get(index, edit.Index{index.Line, 1 << 30}))
139 | 		if len(text) == 0 {
140 | 			index = b.ShiftIndex(index, 1)
141 | 		} else {
142 | 			i := 0
143 | 			for i < len(text) && spaceRegexp.MatchString(string(text[i])) {
144 | 				i++
145 | 			}
146 | 			if i < len(text) && wordRegexp.MatchString(string(text[i])) {
147 | 				for i < len(text) && wordRegexp.MatchString(string(text[i])) {
148 | 					i++
149 | 				}
150 | 			} else {
151 | 				for i < len(text) &&
152 | 					!wordRegexp.MatchString(string(text[i])) &&
153 | 					!spaceRegexp.MatchString(string(text[i])) {
154 | 					i++
155 | 				}
156 | 			}
157 | 			index.Char += i
158 | 		}
159 | 		n--
160 | 	}
161 | 	for n < 0 {
162 | 		if index.Char == 0 {
163 | 			index = b.ShiftIndex(index, -1)
164 | 		} else {
165 | 			text := []rune(b.Get(edit.Index{index.Line, 0}, index))
166 | 			i := len(text) - 1
167 | 			for i >= 0 && spaceRegexp.MatchString(string(text[i])) {
168 | 				i--
169 | 			}
170 | 			if i >= 0 && wordRegexp.MatchString(string(text[i])) {
171 | 				for i >= 0 && wordRegexp.MatchString(string(text[i])) {
172 | 					i--
173 | 				}
174 | 			} else {
175 | 				for i >= 0 && !wordRegexp.MatchString(string(text[i])) &&
176 | 					!spaceRegexp.MatchString(string(text[i])) {
177 | 					i--
178 | 				}
179 | 			}
180 | 			index.Char = i + 1
181 | 		}
182 | 		n++
183 | 	}
184 | 	return index
185 | }
186 | 


--------------------------------------------------------------------------------
/event.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"bytes"
  5 | 	"fmt"
  6 | 	"io/ioutil"
  7 | 	"path/filepath"
  8 | 	"strings"
  9 | 	"time"
 10 | 	"unicode/utf8"
 11 | 
 12 | 	"github.com/jangler/edit"
 13 | 	"github.com/veandco/go-sdl2/sdl"
 14 | 	"github.com/veandco/go-sdl2/sdl_ttf"
 15 | )
 16 | 
 17 | // user event types. these are only vars in order to be addressable.
 18 | var (
 19 | 	pipeEvent   = 1
 20 | 	statusEvent = 2
 21 | )
 22 | 
 23 | var userEventType uint32 // set at beginning of event loop
 24 | 
 25 | // colRowFromXY converts (x, y) coordinates in a window to a row and column.
 26 | func colRowFromXY(winHeight, x, y int) (col, row int) {
 27 | 	ps := paneSpace(winHeight)
 28 | 	y = y % ps
 29 | 	x -= padPx - fontWidth/2
 30 | 	y /= fontHeight
 31 | 	x /= fontWidth
 32 | 	return x, y
 33 | }
 34 | 
 35 | // click processes a left mouse click at the given coordinates.
 36 | func click(b *edit.Buffer, winHeight, x, y, times int, shift bool) {
 37 | 	x, y = colRowFromXY(winHeight, x, y)
 38 | 
 39 | 	switch times {
 40 | 	case 1: // place cursor
 41 | 		b.Mark(b.IndexFromCoords(x, y), insMark)
 42 | 		if !shift {
 43 | 			b.Mark(b.IndexFromMark(insMark), selMark)
 44 | 		}
 45 | 	case 2: // select word
 46 | 		selectWord(b, b.IndexFromCoords(x, y))
 47 | 	case 3: // select line
 48 | 		index := b.IndexFromCoords(x, y)
 49 | 		selectLine(b, index.Line)
 50 | 	}
 51 | }
 52 | 
 53 | // clickFind moves the cursor and selection to the next or previous instance of
 54 | // the selected text, and returns a status message,
 55 | func clickFind(b *edit.Buffer, shift bool, winHeight, x, y int,
 56 | 	defaultStatus string) string {
 57 | 	x, y = colRowFromXY(winHeight, x, y)
 58 | 
 59 | 	// get selection
 60 | 	sel, ins := order(b.IndexFromMark(selMark), b.IndexFromMark(insMark))
 61 | 
 62 | 	// reposition cursor if click is outside selection
 63 | 	clickIndex := b.IndexFromCoords(x, y)
 64 | 	if clickIndex.Less(sel) || ins.Less(clickIndex) {
 65 | 		b.Mark(clickIndex, selMark, insMark)
 66 | 		sel, ins = b.IndexFromMark(selMark), b.IndexFromMark(insMark)
 67 | 	}
 68 | 
 69 | 	// select word if selection is nil
 70 | 	if sel == ins {
 71 | 		selectWord(b, sel)
 72 | 		sel, ins = b.IndexFromMark(selMark), b.IndexFromMark(insMark)
 73 | 	}
 74 | 	selection := b.Get(sel, ins)
 75 | 
 76 | 	if shift { // search backwards
 77 | 		index := sel
 78 | 		text := b.Get(edit.Index{1, 0}, index)
 79 | 		if pos := strings.LastIndex(text, selection); pos >= 0 {
 80 | 			b.Mark(b.ShiftIndex(index, pos-utf8.RuneCountInString(text)),
 81 | 				selMark)
 82 | 			b.Mark(b.ShiftIndex(b.IndexFromMark(selMark),
 83 | 				utf8.RuneCountInString(selection)), insMark)
 84 | 		} else {
 85 | 			return "No backward match."
 86 | 		}
 87 | 	} else { // search forwards
 88 | 		index := ins
 89 | 		text := b.Get(index, b.End())
 90 | 		if pos := strings.Index(text, selection); pos >= 0 {
 91 | 			b.Mark(b.ShiftIndex(index, pos), selMark)
 92 | 			b.Mark(b.ShiftIndex(b.IndexFromMark(selMark),
 93 | 				utf8.RuneCountInString(selection)), insMark)
 94 | 		} else {
 95 | 			return "No forward match."
 96 | 		}
 97 | 	}
 98 | 
 99 | 	return defaultStatus
100 | }
101 | 
102 | // deleteCharOrTab deletes a single character, or may delete a tabstop worth of
103 | // spaces if the expandtab flag is set.
104 | func deleteCharOrTab(b *edit.Buffer, index edit.Index, step int) {
105 | 	if expandtabFlag {
106 | 		start, end := order(index, b.ShiftIndex(index, step*int(tabstopFlag)))
107 | 		if strings.Trim(b.Get(start, end), " ") == "" {
108 | 			b.Delete(start, end)
109 | 		} else {
110 | 			b.Delete(order(index, b.ShiftIndex(index, step)))
111 | 		}
112 | 	} else {
113 | 		b.Delete(order(index, b.ShiftIndex(index, step)))
114 | 	}
115 | }
116 | 
117 | // textInput inserts text into the focus, or performs another action depending
118 | // on the contents of the string.
119 | func textInput(buf *edit.Buffer, s string) {
120 | 	index := buf.IndexFromMark(insMark)
121 | 	if sel := buf.IndexFromMark(selMark); sel != index {
122 | 		buf.Delete(order(sel, index))
123 | 		index, _ = order(sel, index)
124 | 	}
125 | 	if s == "\n" {
126 | 		// autoindent
127 | 		indent := buf.Get(edit.Index{index.Line, 0},
128 | 			edit.Index{index.Line, 0xffff})
129 | 		i := 0
130 | 		for i < len(indent) && (indent[i] == ' ' || indent[i] == '\t') {
131 | 			i++
132 | 		}
133 | 		if i <= index.Char {
134 | 			s += indent[:i]
135 | 		}
136 | 	}
137 | 	buf.Insert(index, s)
138 | }
139 | 
140 | // resize resizes the pane in the display.
141 | func resize(pane *Pane, width, height int) {
142 | 	cols, rows := bufSize(width, height)
143 | 	pane.Cols, pane.Rows = cols, rows
144 | 	pane.SetSize(cols, rows)
145 | }
146 | 
147 | // saveFile writes the contents of pane to a file with the name of the pane's
148 | // title.
149 | func saveFile(pane *Pane) error {
150 | 	text := pane.Get(edit.Index{1, 0}, pane.End()) + "\n"
151 | 	if pane.LineEnding != "\n" {
152 | 		text = strings.Replace(text, "\n", pane.LineEnding, -1)
153 | 	}
154 | 	path, err := filepath.Abs(expandVars(pane.Title))
155 | 	if err != nil {
156 | 		return err
157 | 	}
158 | 	err = ioutil.WriteFile(path, []byte(text), 0664)
159 | 	if err == nil {
160 | 		pane.ResetModified()
161 | 	}
162 | 	return err
163 | }
164 | 
165 | // warpMouseToSel warps the mouse to the center of the buffer selection.
166 | func warpMouseToSel(w *sdl.Window, b *edit.Buffer) {
167 | 	sel, ins := b.IndexFromMark(selMark), b.IndexFromMark(insMark)
168 | 	selCol, selRow := b.CoordsFromIndex(sel)
169 | 	insCol, insRow := b.CoordsFromIndex(ins)
170 | 	x := (float64(selCol)+float64(insCol))*float64(fontWidth)/2 + padPx
171 | 	y := (float64(selRow)+float64(insRow)+1)*float64(fontHeight)/2 + padPx
172 | 	w.WarpMouseInWindow(int(x), int(y))
173 | }
174 | 
175 | // getHistory gets the appropriate history for the given prompt.
176 | func getHistory(histories map[string]*history, prompt string) *history {
177 | 	key := strings.Split(prompt, " ")[0]
178 | 	if histories[key] == nil {
179 | 		histories[key] = &history{}
180 | 	}
181 | 	return histories[key]
182 | }
183 | 
184 | // eventLoop handles SDL events until quit is requested.
185 | func eventLoop(pane *Pane, status string, font *ttf.Font, win *sdl.Window) {
186 | 	userEventType = sdl.RegisterEvents(1)
187 | 	rc := &RenderContext{pane, edit.NewBuffer(), pane.Buffer, status, font,
188 | 		win, nil}
189 | 	rc.Input.Mark(edit.Index{1, 0}, selMark, insMark)
190 | 	render(rc)
191 | 	w, h := win.GetSize()
192 | 	win.SetSize(w, h)
193 | 	clickCount := 0
194 | 	lastClick := time.Now()
195 | 	var rightClickIndex edit.Index
196 | 	histories := make(map[string]*history)
197 | 
198 | 	for {
199 | 		// get current marks to see if they change based on the event
200 | 		prevSel := rc.Pane.IndexFromMark(selMark)
201 | 		prevIns := rc.Pane.IndexFromMark(insMark)
202 | 
203 | 		switch event := sdl.WaitEvent().(type) {
204 | 		case *sdl.KeyDownEvent:
205 | 			if rc.Focus == rc.Pane.Buffer {
206 | 				rc.Status = rc.Pane.Title
207 | 			}
208 | 			recognized := true
209 | 			switch event.Keysym.Sym {
210 | 			case sdl.K_BACKSPACE:
211 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
212 | 					end := rc.Focus.IndexFromMark(insMark)
213 | 					begin := shiftIndexByWord(rc.Focus, end, -1)
214 | 					rc.Focus.Delete(begin, end)
215 | 				} else {
216 | 					index := rc.Focus.IndexFromMark(insMark)
217 | 					if sel := rc.Focus.IndexFromMark(selMark); sel != index {
218 | 						rc.Focus.Delete(order(sel, index))
219 | 					} else {
220 | 						deleteCharOrTab(rc.Focus, index, -1)
221 | 					}
222 | 				}
223 | 			case sdl.K_DELETE:
224 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
225 | 					begin := rc.Focus.IndexFromMark(insMark)
226 | 					end := shiftIndexByWord(rc.Focus, begin, 1)
227 | 					rc.Focus.Delete(begin, end)
228 | 				} else {
229 | 					index := rc.Focus.IndexFromMark(insMark)
230 | 					if sel := rc.Focus.IndexFromMark(selMark); sel != index {
231 | 						rc.Focus.Delete(order(sel, index))
232 | 					} else {
233 | 						deleteCharOrTab(rc.Focus, index, 1)
234 | 					}
235 | 				}
236 | 				if rc.Focus == rc.Pane.Buffer {
237 | 					seeMark(rc.Pane.Buffer, insMark, rc.Pane.Rows)
238 | 				}
239 | 			case sdl.K_DOWN:
240 | 				if rc.Focus == rc.Pane.Buffer {
241 | 					index := rc.Focus.IndexFromMark(insMark)
242 | 					col, row := rc.Focus.CoordsFromIndex(index)
243 | 					rc.Focus.Mark(rc.Focus.IndexFromCoords(col, row+1),
244 | 						insMark)
245 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
246 | 						rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
247 | 							selMark)
248 | 					}
249 | 					rc.Pane.Separate()
250 | 				} else {
251 | 					input := getHistory(histories, rc.Status).next()
252 | 					rc.Input.Delete(edit.Index{1, 0}, rc.Input.End())
253 | 					rc.Input.Insert(edit.Index{1, 0}, input)
254 | 				}
255 | 			case sdl.K_ESCAPE:
256 | 				if rc.Focus == rc.Input {
257 | 					rc.Status = rc.Pane.Title
258 | 					rc.Focus = rc.Pane.Buffer
259 | 				}
260 | 			case sdl.K_END:
261 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
262 | 					rc.Focus.Mark(rc.Focus.End(), insMark)
263 | 				} else {
264 | 					index := rc.Focus.IndexFromMark(insMark)
265 | 					rc.Focus.Mark(edit.Index{index.Line, 1 << 30}, insMark)
266 | 				}
267 | 				if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
268 | 					rc.Focus.Mark(rc.Focus.IndexFromMark(insMark), selMark)
269 | 				}
270 | 				if rc.Focus == rc.Pane.Buffer {
271 | 					rc.Pane.Separate()
272 | 				}
273 | 			case sdl.K_LEFT:
274 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
275 | 					index := rc.Focus.IndexFromMark(insMark)
276 | 					index = shiftIndexByWord(rc.Focus, index, -1)
277 | 					rc.Focus.Mark(index, insMark)
278 | 				} else {
279 | 					index := rc.Focus.IndexFromMark(insMark)
280 | 					rc.Focus.Mark(rc.Focus.ShiftIndex(index, -1), insMark)
281 | 				}
282 | 				if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
283 | 					rc.Focus.Mark(rc.Focus.IndexFromMark(insMark), selMark)
284 | 				}
285 | 				if rc.Focus == rc.Pane.Buffer {
286 | 					rc.Pane.Separate()
287 | 				}
288 | 			case sdl.K_HOME:
289 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
290 | 					rc.Focus.Mark(edit.Index{1, 0}, insMark)
291 | 				} else {
292 | 					index := rc.Focus.IndexFromMark(insMark)
293 | 					rc.Focus.Mark(edit.Index{index.Line, 0}, insMark)
294 | 				}
295 | 				if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
296 | 					rc.Focus.Mark(rc.Focus.IndexFromMark(insMark), selMark)
297 | 				}
298 | 				if rc.Focus == rc.Pane.Buffer {
299 | 					rc.Pane.Separate()
300 | 				}
301 | 			case sdl.K_PAGEDOWN:
302 | 				if rc.Focus == rc.Pane.Buffer {
303 | 					index := rc.Pane.IndexFromMark(insMark)
304 | 					col, row := rc.Pane.CoordsFromIndex(index)
305 | 					rc.Pane.Mark(rc.Pane.IndexFromCoords(col,
306 | 						row+rc.Pane.Rows), insMark)
307 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
308 | 						rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
309 | 							selMark)
310 | 					}
311 | 					rc.Pane.Separate()
312 | 				}
313 | 			case sdl.K_PAGEUP:
314 | 				if rc.Focus == rc.Pane.Buffer {
315 | 					index := rc.Pane.IndexFromMark(insMark)
316 | 					col, row := rc.Pane.CoordsFromIndex(index)
317 | 					rc.Pane.Mark(rc.Pane.IndexFromCoords(col,
318 | 						row-rc.Pane.Rows), insMark)
319 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
320 | 						rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
321 | 							selMark)
322 | 					}
323 | 					rc.Pane.Separate()
324 | 				}
325 | 			case sdl.K_RETURN:
326 | 				if rc.Focus == rc.Pane.Buffer {
327 | 					textInput(rc.Focus, "\n")
328 | 				} else {
329 | 					input := rc.Input.Get(edit.Index{1, 0}, rc.Input.End())
330 | 					getHistory(histories, rc.Status).appendString(input)
331 | 					if !rc.EnterInput() {
332 | 						return
333 | 					}
334 | 				}
335 | 			case sdl.K_RIGHT:
336 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
337 | 					index := rc.Focus.IndexFromMark(insMark)
338 | 					index = shiftIndexByWord(rc.Focus, index, 1)
339 | 					rc.Focus.Mark(index, insMark)
340 | 				} else {
341 | 					index := rc.Focus.IndexFromMark(insMark)
342 | 					rc.Focus.Mark(rc.Focus.ShiftIndex(index, 1), insMark)
343 | 				}
344 | 				if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
345 | 					rc.Focus.Mark(rc.Focus.IndexFromMark(insMark), selMark)
346 | 				}
347 | 				if rc.Focus == rc.Pane.Buffer {
348 | 					rc.Pane.Separate()
349 | 				}
350 | 			case sdl.K_TAB:
351 | 				if rc.Focus == rc.Pane.Buffer {
352 | 					sel := rc.Pane.IndexFromMark(selMark)
353 | 					ins := rc.Pane.IndexFromMark(insMark)
354 | 					if sel == ins {
355 | 						char := rc.Pane.Buffer.Get(
356 | 							edit.Index{ins.Line, ins.Char - 1}, ins)
357 | 						if char == "" || char == " " || char == "\t" {
358 | 							// insert tab
359 | 							if expandtabFlag {
360 | 								for i := 0; i < int(tabstopFlag); i++ {
361 | 									textInput(rc.Focus, " ")
362 | 								}
363 | 							} else {
364 | 								textInput(rc.Focus, "\t")
365 | 							}
366 | 						} else {
367 | 							// complete word
368 | 							selectWord(rc.Focus, ins)
369 | 							word := getSelection(rc.Focus)
370 | 							forward := event.Keysym.Mod&sdl.KMOD_SHIFT != 0
371 | 							completion := completeWord(rc.Focus, word, forward)
372 | 							if completion != "" {
373 | 								textInput(rc.Focus, completion)
374 | 							} else {
375 | 								rc.Status = "No completions."
376 | 							}
377 | 							rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
378 | 								selMark)
379 | 						}
380 | 					} else {
381 | 						// indent/unindent selection
382 | 						sel, ins := order(sel, ins)
383 | 						unindent := event.Keysym.Mod&sdl.KMOD_SHIFT != 0
384 | 						indent(rc.Pane.Buffer, sel.Line, ins.Line, unindent)
385 | 					}
386 | 				} else {
387 | 					input := rc.Input.Get(edit.Index{1, 0}, rc.Input.End())
388 | 					input = expandVars(input)
389 | 					switch rc.Status {
390 | 					case cdPrompt:
391 | 						input = completePath(input, true)
392 | 					case openPrompt, openNewPrompt, saveAsPrompt:
393 | 						input = completePath(input, false)
394 | 					case pipePrompt, runPrompt:
395 | 						tokens := strings.Split(input, " ")
396 | 						for i, token := range tokens {
397 | 							if i == 0 {
398 | 								tokens[i] = completeCmd(token)
399 | 							} else {
400 | 								tokens[i] = completePath(token, false)
401 | 							}
402 | 						}
403 | 						input = strings.Join(tokens, " ")
404 | 					}
405 | 					rc.Input.Delete(edit.Index{1, 0}, rc.Input.End())
406 | 					rc.Input.Insert(edit.Index{1, 0}, input)
407 | 				}
408 | 			case sdl.K_UP:
409 | 				if rc.Focus == rc.Pane.Buffer {
410 | 					index := rc.Focus.IndexFromMark(insMark)
411 | 					col, row := rc.Focus.CoordsFromIndex(index)
412 | 					rc.Focus.Mark(rc.Focus.IndexFromCoords(col, row-1),
413 | 						insMark)
414 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
415 | 						rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
416 | 							selMark)
417 | 					}
418 | 					rc.Pane.Separate()
419 | 				} else {
420 | 					input := rc.Input.Get(edit.Index{1, 0}, rc.Input.End())
421 | 					input = getHistory(histories, rc.Status).prev(input)
422 | 					rc.Input.Delete(edit.Index{1, 0}, rc.Input.End())
423 | 					rc.Input.Insert(edit.Index{1, 0}, input)
424 | 				}
425 | 			case sdl.K_a:
426 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
427 | 					index := rc.Focus.IndexFromMark(insMark)
428 | 					rc.Focus.Mark(edit.Index{index.Line, 0}, insMark)
429 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
430 | 						rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
431 | 							selMark)
432 | 					}
433 | 					if rc.Focus == rc.Pane.Buffer {
434 | 						rc.Pane.Separate()
435 | 					}
436 | 				}
437 | 			case sdl.K_c:
438 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
439 | 					if rc.Focus == rc.Input {
440 | 						rc.Status = rc.Pane.Title
441 | 						rc.Focus = rc.Pane.Buffer
442 | 					} else {
443 | 						sdl.SetClipboardText(getSelection(rc.Pane.Buffer))
444 | 						rc.Status = "Copied text."
445 | 					}
446 | 				}
447 | 			case sdl.K_d:
448 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
449 | 					rc.Focus != rc.Input {
450 | 					rc.Prompt(cdPrompt)
451 | 				}
452 | 			case sdl.K_e:
453 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
454 | 					index := rc.Focus.IndexFromMark(insMark)
455 | 					rc.Focus.Mark(edit.Index{index.Line, 1 << 30}, insMark)
456 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 {
457 | 						rc.Focus.Mark(rc.Focus.IndexFromMark(insMark),
458 | 							selMark)
459 | 					}
460 | 					if rc.Focus == rc.Pane.Buffer {
461 | 						rc.Pane.Separate()
462 | 					}
463 | 				}
464 | 			case sdl.K_f:
465 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
466 | 					rc.Focus != rc.Input {
467 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
468 | 						rc.Prompt(findBackwardPrompt)
469 | 					} else {
470 | 						rc.Prompt(findForwardPrompt)
471 | 					}
472 | 				}
473 | 			case sdl.K_g:
474 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
475 | 					rc.Focus != rc.Input {
476 | 					rc.Prompt(goToLinePrompt)
477 | 				}
478 | 			case sdl.K_h:
479 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
480 | 					index := rc.Focus.IndexFromMark(insMark)
481 | 					deleteCharOrTab(rc.Focus, index, -1)
482 | 				}
483 | 			case sdl.K_i:
484 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
485 | 					textInput(rc.Focus, "\t")
486 | 				}
487 | 			case sdl.K_l:
488 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
489 | 					rc.Focus != rc.Input {
490 | 					if rc.Pane.LineEnding == "\n" {
491 | 						rc.Pane.LineEnding = "\r\n"
492 | 						rc.Status = "Using DOS line endings."
493 | 					} else {
494 | 						rc.Pane.LineEnding = "\n"
495 | 						rc.Status = "Using Unix line endings."
496 | 					}
497 | 				}
498 | 			case sdl.K_n:
499 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
500 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
501 | 						rc.Status = find(rc.Pane.Buffer, rc.Regexp, false,
502 | 							rc.Status)
503 | 					} else {
504 | 						rc.Status = find(rc.Pane.Buffer, rc.Regexp, true,
505 | 							rc.Status)
506 | 					}
507 | 				}
508 | 			case sdl.K_o:
509 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
510 | 					rc.Focus != rc.Input {
511 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
512 | 						rc.Prompt(openNewPrompt)
513 | 					} else {
514 | 						if rc.Pane.Modified() {
515 | 							rc.Prompt(reallyOpenPrompt)
516 | 						} else {
517 | 							rc.Prompt(openPrompt)
518 | 						}
519 | 					}
520 | 				}
521 | 			case sdl.K_p:
522 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
523 | 					rc.Focus != rc.Input {
524 | 					rc.Prompt(pipePrompt)
525 | 				}
526 | 			case sdl.K_q:
527 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
528 | 					if rc.Focus == rc.Pane.Buffer {
529 | 						if event.Keysym.Mod&sdl.KMOD_SHIFT == 0 &&
530 | 							rc.Pane.Modified() {
531 | 							rc.Prompt(reallyQuitPrompt)
532 | 						} else {
533 | 							return
534 | 						}
535 | 					} else {
536 | 						rc.Status = rc.Pane.Title
537 | 						rc.Focus = rc.Pane.Buffer
538 | 					}
539 | 				}
540 | 			case sdl.K_r:
541 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
542 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
543 | 						rc.Font = getFont()
544 | 						rc.Status = "Reloaded font."
545 | 					} else if rc.Focus != rc.Input {
546 | 						rc.Prompt(runPrompt)
547 | 					}
548 | 				}
549 | 			case sdl.K_s:
550 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 &&
551 | 					rc.Focus != rc.Input {
552 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
553 | 						rc.Prompt(saveAsPrompt)
554 | 					} else {
555 | 						if err := saveFile(rc.Pane); err == nil {
556 | 							rc.Status = fmt.Sprintf(`Saved "%s".`,
557 | 								rc.Pane.Title)
558 | 							if rc.Pane.LineEnding == "\r\n" {
559 | 								rc.Status += " [DOS]"
560 | 							}
561 | 						} else {
562 | 							rc.Status = err.Error()
563 | 						}
564 | 					}
565 | 				}
566 | 			case sdl.K_u:
567 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
568 | 					index := rc.Focus.IndexFromMark(insMark)
569 | 					rc.Focus.Delete(edit.Index{index.Line, 0}, index)
570 | 				}
571 | 			case sdl.K_v:
572 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
573 | 					text, err := sdl.GetClipboardText()
574 | 					if err != nil {
575 | 						rc.Status = err.Error()
576 | 						break
577 | 					}
578 | 					sel := rc.Focus.IndexFromMark(selMark)
579 | 					insert := rc.Focus.IndexFromMark(insMark)
580 | 					if sel != insert {
581 | 						rc.Focus.Delete(order(sel, insert))
582 | 						insert, _ = order(sel, insert)
583 | 					}
584 | 					rc.Focus.Insert(insert, text)
585 | 				}
586 | 			case sdl.K_w:
587 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
588 | 					end := rc.Focus.IndexFromMark(insMark)
589 | 					begin := shiftIndexByWord(rc.Focus, end, -1)
590 | 					rc.Focus.Delete(begin, end)
591 | 				}
592 | 			case sdl.K_x:
593 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
594 | 					sel := rc.Focus.IndexFromMark(selMark)
595 | 					insert := rc.Focus.IndexFromMark(insMark)
596 | 					sdl.SetClipboardText(rc.Focus.Get(order(sel, insert)))
597 | 					rc.Focus.Delete(order(sel, insert))
598 | 				}
599 | 
600 | 			case sdl.K_y:
601 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
602 | 					if !rc.Pane.Redo(selMark, insMark) {
603 | 						rc.Status = "Nothing to redo."
604 | 					}
605 | 				}
606 | 			case sdl.K_z:
607 | 				if event.Keysym.Mod&sdl.KMOD_CTRL != 0 {
608 | 					if event.Keysym.Mod&sdl.KMOD_SHIFT != 0 {
609 | 						if !rc.Pane.Redo(selMark, insMark) {
610 | 							rc.Status = "Nothing to redo."
611 | 						}
612 | 					} else {
613 | 						if !rc.Pane.Undo(selMark, insMark) {
614 | 							rc.Status = "Nothing to undo."
615 | 						}
616 | 					}
617 | 				}
618 | 			default:
619 | 				recognized = false
620 | 			}
621 | 			if recognized {
622 | 				if prevSel != rc.Pane.IndexFromMark(selMark) ||
623 | 					prevIns != rc.Pane.IndexFromMark(insMark) {
624 | 					seeMark(rc.Pane.Buffer, insMark, rc.Pane.Rows)
625 | 				}
626 | 				render(rc)
627 | 			}
628 | 		case *sdl.MouseButtonEvent:
629 | 			if rc.Focus == rc.Pane.Buffer {
630 | 				rc.Status = rc.Pane.Title
631 | 			}
632 | 			state := sdl.GetKeyboardState()
633 | 			shift := state[sdl.SCANCODE_LSHIFT]|state[sdl.SCANCODE_RSHIFT] != 0
634 | 			if event.Type == sdl.MOUSEBUTTONDOWN {
635 | 				if event.Button == sdl.BUTTON_LEFT {
636 | 					if time.Since(lastClick) < time.Second/4 {
637 | 						clickCount = clickCount%3 + 1
638 | 					} else {
639 | 						clickCount = 1
640 | 					}
641 | 					lastClick = time.Now()
642 | 					_, winHeight := rc.Window.GetSize()
643 | 					click(rc.Pane.Buffer, winHeight, int(event.X),
644 | 						int(event.Y), clickCount, shift)
645 | 					render(rc)
646 | 				} else if event.Button == sdl.BUTTON_RIGHT {
647 | 					_, winHeight := rc.Window.GetSize()
648 | 					x, y := colRowFromXY(winHeight, int(event.X), int(event.Y))
649 | 					rightClickIndex = rc.Pane.IndexFromCoords(x, y)
650 | 				}
651 | 			} else if event.Type == sdl.MOUSEBUTTONUP &&
652 | 				event.Button == sdl.BUTTON_RIGHT {
653 | 				_, winHeight := rc.Window.GetSize()
654 | 				rc.Status = clickFind(rc.Pane.Buffer, shift, winHeight,
655 | 					int(event.X), int(event.Y), rc.Status)
656 | 				seeMark(rc.Pane.Buffer, insMark, rc.Pane.Rows)
657 | 				warpMouseToSel(rc.Window, rc.Pane.Buffer)
658 | 				render(rc)
659 | 			}
660 | 			rc.Pane.Separate()
661 | 		case *sdl.MouseMotionEvent:
662 | 			if event.State&sdl.ButtonLMask() != 0 {
663 | 				_, h := rc.Window.GetSize()
664 | 				click(rc.Pane.Buffer, h, int(event.X), int(event.Y), 1, true)
665 | 				render(rc)
666 | 			} else if event.State&sdl.ButtonRMask() != 0 {
667 | 				_, winHeight := rc.Window.GetSize()
668 | 				x, y := colRowFromXY(winHeight, int(event.X), int(event.Y))
669 | 				index := rc.Pane.IndexFromCoords(x, y)
670 | 				if index != rightClickIndex {
671 | 					rc.Pane.Mark(rightClickIndex, selMark)
672 | 					rc.Pane.Mark(index, insMark)
673 | 					render(rc)
674 | 				}
675 | 			}
676 | 		case *sdl.MouseWheelEvent:
677 | 			rc.Pane.Scroll(int(event.Y) * -3)
678 | 			render(rc)
679 | 		case *sdl.QuitEvent:
680 | 			return
681 | 		case *sdl.TextInputEvent:
682 | 			if n := bytes.Index(event.Text[:], []byte{0}); n > 0 {
683 | 				textInput(rc.Focus, string(event.Text[:n]))
684 | 				if rc.Focus == rc.Pane.Buffer {
685 | 					seeMark(rc.Pane.Buffer, insMark, rc.Pane.Rows)
686 | 				}
687 | 				render(rc)
688 | 			}
689 | 		case *sdl.UserEvent:
690 | 			switch *(*int)(event.Data1) {
691 | 			case pipeEvent:
692 | 				sel := rc.Focus.IndexFromMark(selMark)
693 | 				ins := rc.Focus.IndexFromMark(insMark)
694 | 				rc.Pane.Delete(order(sel, ins))
695 | 				ins, _ = order(sel, ins)
696 | 				rc.Pane.Insert(ins, *(*string)(event.Data2))
697 | 				seeMark(rc.Pane.Buffer, insMark, rc.Pane.Rows)
698 | 				render(rc)
699 | 			case statusEvent:
700 | 				if rc.Focus != rc.Input {
701 | 					rc.Status = *(*string)(event.Data2)
702 | 					render(rc)
703 | 				}
704 | 			}
705 | 			enableGC()
706 | 		case *sdl.WindowEvent:
707 | 			switch event.Event {
708 | 			case sdl.WINDOWEVENT_EXPOSED, sdl.WINDOWEVENT_SHOWN:
709 | 				win.UpdateSurface()
710 | 			case sdl.WINDOWEVENT_RESIZED:
711 | 				resize(rc.Pane, int(event.Data1), int(event.Data2))
712 | 				render(rc)
713 | 			}
714 | 		}
715 | 
716 | 		// delete lines containing only whitespace when moving cursor away
717 | 		if prevIns.Line != rc.Pane.IndexFromMark(insMark).Line {
718 | 			line := rc.Pane.Get(edit.Index{prevIns.Line, 0},
719 | 				edit.Index{prevIns.Line, 1 << 30})
720 | 			if len(strings.TrimSpace(line)) == 0 {
721 | 				rc.Pane.Delete(edit.Index{prevIns.Line, 0},
722 | 					edit.Index{prevIns.Line, 1 << 30})
723 | 			}
724 | 		}
725 | 	}
726 | }
727 | 


--------------------------------------------------------------------------------
/exec.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"encoding/base32"
  5 | 	"flag"
  6 | 	"fmt"
  7 | 	"io"
  8 | 	"io/ioutil"
  9 | 	"log"
 10 | 	"math/rand"
 11 | 	"os"
 12 | 	"os/exec"
 13 | 	"path/filepath"
 14 | 	"runtime"
 15 | 	"strings"
 16 | 	"time"
 17 | 	"unsafe"
 18 | 
 19 | 	"github.com/veandco/go-sdl2/sdl"
 20 | )
 21 | 
 22 | var shellName, shellOpt string // command interpreter invocation
 23 | 
 24 | func init() {
 25 | 	rand.Seed(time.Now().UnixNano())
 26 | 
 27 | 	if runtime.GOOS == "windows" {
 28 | 		shellName, shellOpt = "cmd", "/c"
 29 | 	} else {
 30 | 		shellName, shellOpt = "/bin/sh", "-c"
 31 | 	}
 32 | }
 33 | 
 34 | // flags returns a []string of command line flags that have been set in a form
 35 | // that can be passed as arguments to exec.Command().
 36 | func flags() []string {
 37 | 	args := make([]string, flag.NFlag())
 38 | 	i := 0
 39 | 	flag.Visit(func(f *flag.Flag) {
 40 | 		args[i] = fmt.Sprintf("-%s=%v", f.Name, f.Value)
 41 | 		i++
 42 | 	})
 43 | 	return args
 44 | }
 45 | 
 46 | // newInstance opens a new instane of Fervor editing the given filename and
 47 | // returns a status message.
 48 | func newInstance(filename, defaultStatus string) string {
 49 | 	cmd := exec.Command(os.Args[0], append(flags(), filename)...)
 50 | 	if err := cmd.Start(); err != nil {
 51 | 		return err.Error()
 52 | 	}
 53 | 	return defaultStatus
 54 | }
 55 | 
 56 | // reportExitStatus pushes a status message to the SDL event queue depending
 57 | // on err (which may be nil).
 58 | func reportExitStatus(cmd string, err error) {
 59 | 	var event sdl.UserEvent
 60 | 	var msg string
 61 | 	if err == nil {
 62 | 		msg = fmt.Sprintf(`Command "%s" exited successfully.`, cmd)
 63 | 	} else {
 64 | 		msg = fmt.Sprintf(`Command "%s" exited with error: %v`, cmd, err)
 65 | 	}
 66 | 	event.Type, event.Data1 = userEventType, unsafe.Pointer(&statusEvent)
 67 | 	disableGC()
 68 | 	event.Data2 = unsafe.Pointer(&msg)
 69 | 	sdl.PushEvent(&event)
 70 | }
 71 | 
 72 | // pipeCmd pipes selection through cmdString asynchronously and returns a
 73 | // status message. Results are returned on the SDL event queue.
 74 | func pipeCmd(cmdString, selection, defaultStatus string) string {
 75 | 	// initialize command
 76 | 	cmd := exec.Command(shellName, shellOpt, cmdString)
 77 | 	inPipe, err := cmd.StdinPipe()
 78 | 	if err != nil {
 79 | 		return err.Error()
 80 | 	}
 81 | 	outPipe, err := cmd.StdoutPipe()
 82 | 	if err != nil {
 83 | 		return err.Error()
 84 | 	}
 85 | 	if err := cmd.Start(); err != nil {
 86 | 		return err.Error()
 87 | 	}
 88 | 
 89 | 	go func() {
 90 | 		// write to stdin and read from stdout
 91 | 		go func() {
 92 | 			if _, err := io.WriteString(inPipe, selection); err != nil {
 93 | 				log.Print(err)
 94 | 			}
 95 | 			inPipe.Close()
 96 | 		}()
 97 | 		var outBytes []byte
 98 | 		go func() {
 99 | 			if outBytes, err = ioutil.ReadAll(outPipe); err != nil {
100 | 				log.Print(err)
101 | 			}
102 | 		}()
103 | 
104 | 		reportExitStatus(cmdString, cmd.Wait())
105 | 
106 | 		if outBytes != nil {
107 | 			// strip trailing newline
108 | 			if len(outBytes) > 0 && outBytes[len(outBytes)-1] == '\n' {
109 | 				outBytes = outBytes[:len(outBytes)-1]
110 | 			}
111 | 
112 | 			// push pipe event
113 | 			output := string(outBytes)
114 | 			var event sdl.UserEvent
115 | 			event.Type = userEventType
116 | 			event.Data1 = unsafe.Pointer(&pipeEvent)
117 | 			disableGC()
118 | 			event.Data2 = unsafe.Pointer(&output)
119 | 			sdl.PushEvent(&event)
120 | 		}
121 | 	}()
122 | 
123 | 	return defaultStatus
124 | }
125 | 
126 | // runCmd executes cmdString asynchronously. Results are returned on the SDL
127 | // event queue.
128 | func runCmd(cmdString string) {
129 | 	cmd := exec.Command(shellName, shellOpt, cmdString)
130 | 
131 | 	go func() {
132 | 		output, err := cmd.CombinedOutput()
133 | 		reportExitStatus(cmdString, err)
134 | 
135 | 		if output != nil && len(output) > 0 {
136 | 			// generate a random filename
137 | 			src := make([]byte, 8)
138 | 			for i := range src {
139 | 				src[i] = byte(rand.Intn(256))
140 | 			}
141 | 			name := base32.StdEncoding.EncodeToString(src)
142 | 			name = strings.TrimRight(name, "=")
143 | 
144 | 			// write command output to temp file
145 | 			path := filepath.Join(os.TempDir(), name)
146 | 			file, err := os.Create(path)
147 | 			if err != nil {
148 | 				log.Print(err)
149 | 				return
150 | 			}
151 | 			file.Write(output)
152 | 			file.Close()
153 | 
154 | 			// open temp file in new window, then clean up
155 | 			exec.Command(os.Args[0], append(flags(), path)...).Run()
156 | 			defer os.Remove(path)
157 | 		}
158 | 	}()
159 | }
160 | 


--------------------------------------------------------------------------------
/fervor.desktop:
--------------------------------------------------------------------------------
 1 | [Desktop Entry]
 2 | Type=Application
 3 | Version=1.0
 4 | Name=Fervor
 5 | GenericName=Text editor
 6 | Icon=fervor
 7 | TryExec=fervor
 8 | Exec=fervor %F
 9 | Terminal=false
10 | MimeType=text/plain
11 | Categories=Development;Utility;TextEditor
12 | Keywords=text;editor
13 | 


--------------------------------------------------------------------------------
/fervor.ini:
--------------------------------------------------------------------------------
 1 | ; example fervor.ini file.
 2 | 
 3 | ; command-line flags override these global flags:
 4 | 
 5 | font=/usr/share/fonts/TTF/LiberationMono-Regular.ttf
 6 | ptsize=11
 7 | 
 8 | ; but command-line flags are overridden by these filetype flags:
 9 | 
10 | [bash]
11 | filename=.bash_profile;.bashrc;.xinitrc;*.sh;*.bash
12 | shebang=sh;bash
13 | 
14 | [c]
15 | filename=*.c;*.h
16 | tabstop=8
17 | expandtab=false
18 | 
19 | [css]
20 | filename=*.css
21 | tabstop=2
22 | expandtab=true
23 | 
24 | [go]
25 | filename=*.go
26 | expandtab=false
27 | 
28 | [html]
29 | filename=*.html
30 | tabstop=2
31 | expandtab=true
32 | 
33 | [ini]
34 | filename=*.ini;*.INI;*.desktop
35 | 
36 | [javascript]
37 | filename=*.js
38 | tabstop=4
39 | expandtab=true
40 | 
41 | [json]
42 | filename=*.json
43 | tabstop=2
44 | expandtab=true
45 | 
46 | [lua]
47 | filename=*.lua
48 | shebang=lua
49 | tabstop=2
50 | expandtab=true
51 | 
52 | [make]
53 | filename=Makefile;makefile
54 | expandtab=false
55 | 
56 | [python]
57 | filename=*.py
58 | shebang=python;python2;python3
59 | tabstop=4
60 | expandtab=true
61 | 
62 | [ruby]
63 | filename=*.rb
64 | shebang=ruby
65 | tabstop=2
66 | expandtab=true
67 | 
68 | [svg]
69 | filename=*.svg
70 | tabstop=2
71 | expandtab=true
72 | 
73 | ; the name of a section determines the syntax highlighting rules used.
74 | 


--------------------------------------------------------------------------------
/fervor.svg:
--------------------------------------------------------------------------------
 1 | <svg width="64" height="64">
 2 |   <rect x="0" y="0" width="64" height="64" fill="#ffffff"/>
 3 |   <rect x="0" y="56" width="64" height="8" fill="#c5c5c5"/>
 4 |   <path fill="none" stroke="#4481f5" stroke-width="4"
 5 |    d="M 33 43.5 A 20.8 20.8 0 0 1 32 8 A 20.8 20.8 0 0 1 41.6 28"/>
 6 |   <path fill="none" stroke="#40934f" stroke-width="4"
 7 |    d="M 41.6 28 A 20.8 20.8 0 0 1 11.2 44 A 20.8 20.8 0 0 1 21.5 26.5"/>
 8 |   <path fill="none" stroke="#f05e52" stroke-width="4"
 9 |    d="M 24 26.3 A 20.8 20.8 0 0 1 52.7 44 A 20.8 20.8 0 0 1 33.5 43.6"/>
10 | </svg>
11 | 


--------------------------------------------------------------------------------
/gc.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "runtime/debug"
 4 | 
 5 | // In order to pass data to the main event loop from a goroutine, a pointer to
 6 | // the data is passed through a sdl.UserEvent. Between pushing the event onto
 7 | // the event queue and receiving the event, the memory that is pointed to could
 8 | // be garbage collected, since no references to it exist. Therefore, to avoid
 9 | // segfaults, the sender must call disableGC() before sending, and the receiver
10 | // must call enableGC() after receiving.
11 | 
12 | // gcDisables and initialGCPercent must not be read or written without
13 | // receiving from gcMutex first.
14 | var gcMutex = make(chan int, 1)
15 | var gcDisables, initialGCPercent int
16 | 
17 | func init() {
18 | 	gcMutex <- 1
19 | }
20 | 
21 | // disableGC disables garbage collection until enableGC is called once for each
22 | // call to disableGC.
23 | func disableGC() {
24 | 	<-gcMutex
25 | 	if gcDisables == 0 {
26 | 		initialGCPercent = debug.SetGCPercent(-1)
27 | 	}
28 | 	gcDisables++
29 | 	gcMutex <- 1
30 | }
31 | 
32 | // enableGC negates a call to disableGC, re-enabling garbage collection if all
33 | // calls have been negated.
34 | func enableGC() {
35 | 	<-gcMutex
36 | 	if gcDisables > 0 {
37 | 		gcDisables--
38 | 		if gcDisables == 0 {
39 | 			debug.SetGCPercent(initialGCPercent)
40 | 		}
41 | 	}
42 | 	gcMutex <- 1
43 | }
44 | 


--------------------------------------------------------------------------------
/history.go:
--------------------------------------------------------------------------------
 1 | package main
 2 | 
 3 | import "container/list"
 4 | 
 5 | // history represents a command history.
 6 | type history struct {
 7 | 	entries *list.List // list of string
 8 | 	current *list.Element
 9 | }
10 | 
11 | // appendString adds s to the list of history entries if s is not already the
12 | // last entry.
13 | func (h *history) appendString(s string) {
14 | 	if h.entries == nil {
15 | 		h.entries = list.New()
16 | 	}
17 | 	h.current = nil
18 | 	if e := h.entries.Back(); s == "" || (e != nil && e.Value.(string) == s) {
19 | 		return
20 | 	}
21 | 	h.entries.PushBack(s)
22 | }
23 | 
24 | // prev returns the previous history entry, or s if there is no such entry.
25 | func (h *history) prev(s string) string {
26 | 	if h.entries == nil {
27 | 		h.entries = list.New()
28 | 	}
29 | 	if h.current == nil {
30 | 		current := h.entries.Back()
31 | 		h.appendString(s)
32 | 		h.current = current
33 | 	} else if h.current.Prev() != nil {
34 | 		h.current = h.current.Prev()
35 | 	}
36 | 	if h.current != nil {
37 | 		s = h.current.Value.(string)
38 | 	}
39 | 	return s
40 | }
41 | 
42 | // next returns the next history entry, or an empty string if there is no such
43 | // entry.
44 | func (h *history) next() string {
45 | 	if h.entries == nil {
46 | 		h.entries = list.New()
47 | 	}
48 | 	if h.current == nil {
49 | 		return ""
50 | 	}
51 | 	h.current = h.current.Next()
52 | 	if h.current == nil {
53 | 		return ""
54 | 	}
55 | 	if h.current != nil {
56 | 		return h.current.Value.(string)
57 | 	}
58 | 	return ""
59 | }
60 | 


--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"flag"
  5 | 	"fmt"
  6 | 	"io/ioutil"
  7 | 	"log"
  8 | 	"os"
  9 | 	"os/user"
 10 | 	"path/filepath"
 11 | 	"regexp"
 12 | 	"runtime"
 13 | 	"strings"
 14 | 
 15 | 	"github.com/jangler/edit"
 16 | 	"github.com/veandco/go-sdl2/sdl"
 17 | 	"github.com/veandco/go-sdl2/sdl_ttf"
 18 | )
 19 | 
 20 | const version = "0.3.0"
 21 | 
 22 | const (
 23 | 	insMark = iota // ID of the cursor/insertion mark
 24 | 	selMark        // ID of the selection anchor mark
 25 | )
 26 | 
 27 | var (
 28 | 	darkFlag      = false
 29 | 	expandtabFlag = false
 30 | 	fontFlag      = ""
 31 | 	ptsizeFlag    = 12
 32 | 	tabstopFlag   = 8
 33 | 	versionFlag   = false
 34 | )
 35 | 
 36 | var sectionFlags = make(map[string]map[string]string)
 37 | var shebangRegexp = regexp.MustCompile(`^#!(/usr/bin/env |/.+/)(.+)( |$)`)
 38 | 
 39 | // readIni reads option defaults from the .ini file, if one exists.
 40 | func readIni() {
 41 | 	if curUser, err := user.Current(); err == nil {
 42 | 		paths := []string{
 43 | 			filepath.Join(curUser.HomeDir, "fervor.ini"),
 44 | 			filepath.Join(curUser.HomeDir, ".config", "fervor.ini"),
 45 | 		}
 46 | 		for _, path := range paths {
 47 | 			contents, err := ioutil.ReadFile(path)
 48 | 			if err != nil {
 49 | 				continue
 50 | 			}
 51 | 			section := ""
 52 | 			sectionFlags[""] = make(map[string]string)
 53 | 			for _, line := range strings.Split(string(contents), "\n") {
 54 | 				// ignore comment lines
 55 | 				if strings.HasPrefix(line, ";") {
 56 | 					continue
 57 | 				}
 58 | 
 59 | 				if match, _ := regexp.MatchString(`^\[.+\]$`, line); match {
 60 | 					section = line
 61 | 					sectionFlags[section] = make(map[string]string)
 62 | 				} else {
 63 | 					tokens := strings.SplitN(line, "=", 2)
 64 | 					if len(tokens) == 2 {
 65 | 						if section == "" {
 66 | 							flag.Set(tokens[0], tokens[1]) // ignore errors
 67 | 						}
 68 | 						sectionFlags[section][tokens[0]] = tokens[1]
 69 | 					}
 70 | 				}
 71 | 			}
 72 | 			break // successfully read .ini file
 73 | 		}
 74 | 	} else {
 75 | 		log.Print(err)
 76 | 	}
 77 | }
 78 | 
 79 | // setFileFlags sets flags based on INI settings, the current file path, and
 80 | // the first line of the buffer, and returns syntax rules to be used for the
 81 | // file.
 82 | func setFileFlags(path, line string) []edit.Rule {
 83 | 	fn := filepath.Base(path)
 84 | 	var sb string
 85 | 	if subs := shebangRegexp.FindStringSubmatch(line); subs != nil {
 86 | 		sb = subs[2]
 87 | 	}
 88 | 
 89 | 	// first, reset flags to defaults
 90 | 	for k, v := range sectionFlags[""] {
 91 | 		flag.Set(k, v) // ignore errors
 92 | 	}
 93 | 
 94 | 	for section, flags := range sectionFlags {
 95 | 		match := false
 96 | 		if globs, ok := flags["filename"]; ok {
 97 | 			for _, glob := range strings.Split(globs, ";") {
 98 | 				if match, _ = filepath.Match(glob, fn); match {
 99 | 					break
100 | 				}
101 | 			}
102 | 		}
103 | 		if shebangs, ok := flags["shebang"]; ok && !match && sb != "" {
104 | 			for _, shebang := range strings.Split(shebangs, ";") {
105 | 				if shebang == sb {
106 | 					match = true
107 | 					break
108 | 				}
109 | 			}
110 | 		}
111 | 		if match {
112 | 			for k, v := range flags {
113 | 				flag.Set(k, v) // ignore errors
114 | 			}
115 | 			clampFlags()
116 | 			if syntaxFunc, ok := syntaxMap[section]; ok {
117 | 				return syntaxFunc()
118 | 			}
119 | 			break
120 | 		}
121 | 	}
122 | 
123 | 	return []edit.Rule{}
124 | }
125 | 
126 | // clampFlags keeps flags within reasonable bounds.
127 | func clampFlags() {
128 | 	if ptsizeFlag < 8 {
129 | 		ptsizeFlag = 8
130 | 	}
131 | 	if tabstopFlag < 1 {
132 | 		tabstopFlag = 1
133 | 	}
134 | }
135 | 
136 | // initFlags initializes the flag package.
137 | func initFlags() {
138 | 	flag.Usage = func() {
139 | 		fmt.Fprintf(os.Stderr, "Usage: %s [<option> ...] [<file> ...]\n",
140 | 			os.Args[0])
141 | 		fmt.Fprintln(os.Stderr, "\nOptions:")
142 | 		flag.PrintDefaults()
143 | 		fmt.Fprintln(os.Stderr, `
144 | Global and file-specific default options can be specified in either
145 | ~/fervor.ini or ~/.config/fervor.ini.`)
146 | 	}
147 | 	flag.BoolVar(&darkFlag, "dark", darkFlag, "use dark color scheme")
148 | 	flag.BoolVar(&expandtabFlag, "expandtab", expandtabFlag,
149 | 		"insert spaces using the Tab key")
150 | 	flag.StringVar(&fontFlag, "font", fontFlag,
151 | 		"use the font at the given path")
152 | 	flag.IntVar(&ptsizeFlag, "ptsize", ptsizeFlag, "set point size of font")
153 | 	flag.IntVar(&tabstopFlag, "tabstop", tabstopFlag,
154 | 		"set width of tab stops, in columns")
155 | 	flag.BoolVar(&versionFlag, "version", versionFlag,
156 | 		"print version information and exit")
157 | }
158 | 
159 | // parseFlags processes command-line flags.
160 | func parseFlags() {
161 | 	flag.Parse()
162 | 	clampFlags()
163 | 
164 | 	if versionFlag {
165 | 		fmt.Printf("%s version %s %s/%s\n", os.Args[0], version, runtime.GOOS,
166 | 			runtime.GOARCH)
167 | 		os.Exit(0)
168 | 	}
169 | 
170 | 	sectionFlags[""] = map[string]string{
171 | 		"dark":      fmt.Sprintf("%v", darkFlag),
172 | 		"expandtab": fmt.Sprintf("%v", expandtabFlag),
173 | 		"font":      fmt.Sprintf("%v", fontFlag),
174 | 		"ptsize":    fmt.Sprintf("%v", ptsizeFlag),
175 | 		"tabstop":   fmt.Sprintf("%v", tabstopFlag),
176 | 	}
177 | }
178 | 
179 | // openFile attempts to open the file given by path and return a new buffer
180 | // containing the contents of that file. If an error is encountered, it returns
181 | // a nil buffer and the error instead.
182 | func openFile(path string) (*edit.Buffer, error) {
183 | 	contents, err := ioutil.ReadFile(path)
184 | 	if err != nil {
185 | 		return nil, err
186 | 	}
187 | 	buf := edit.NewBuffer()
188 | 	buf.Insert(buf.End(), string(contents))
189 | 	if buf.Get(buf.ShiftIndex(buf.End(), -1), buf.End()) == "\n" {
190 | 		buf.Delete(buf.ShiftIndex(buf.End(), -1), buf.End())
191 | 	}
192 | 	buf.ResetModified()
193 | 	buf.ResetUndo()
194 | 	syntaxRules := setFileFlags(path,
195 | 		buf.Get(edit.Index{1, 0}, edit.Index{1, 1 << 30}))
196 | 	buf.SetSyntax(syntaxRules)
197 | 	return buf, nil
198 | }
199 | 
200 | // lineEnding returns the line ending string used for a buffer, and converts
201 | // the buffer to Unix line endings if it uses DOS line endings.
202 | func lineEnding(b *edit.Buffer) string {
203 | 	if strings.Contains(b.Get(edit.Index{1, 0}, edit.Index{2, 0}), "\r\n") {
204 | 		text := b.Get(edit.Index{1, 0}, b.End())
205 | 		b.Delete(edit.Index{1, 0}, b.End())
206 | 		b.Insert(edit.Index{1, 0}, strings.Replace(text, "\r", "", -1))
207 | 		return "\r\n"
208 | 	}
209 | 	return "\n"
210 | }
211 | 
212 | func main() {
213 | 	log.SetFlags(log.Lshortfile)
214 | 	initFlags()
215 | 	readIni()
216 | 	parseFlags()
217 | 	setColorScheme()
218 | 
219 | 	// init SDL
220 | 	runtime.LockOSThread()
221 | 	sdl.Init(sdl.INIT_VIDEO)
222 | 	defer sdl.Quit()
223 | 	if err := ttf.Init(); err != nil {
224 | 		log.Fatal(err)
225 | 	}
226 | 	defer ttf.Quit()
227 | 
228 | 	// open new instances for other file args
229 | 	if flag.NArg() > 1 {
230 | 		for _, arg := range flag.Args()[1:] {
231 | 			newInstance(arg, "")
232 | 		}
233 | 	}
234 | 
235 | 	// init buffer
236 | 	var arg, status string
237 | 	if flag.NArg() == 0 || flag.Arg(0) == "" {
238 | 		arg = os.DevNull
239 | 	} else {
240 | 		arg = flag.Arg(0)
241 | 	}
242 | 	var buf *edit.Buffer
243 | 	var err error
244 | 	if buf, err = openFile(arg); err == nil {
245 | 		status = fmt.Sprintf(`Opened "%s".`, minPath(arg))
246 | 	} else {
247 | 		status = fmt.Sprintf(`New file: "%s".`, minPath(arg))
248 | 		buf = edit.NewBuffer()
249 | 		buf.SetSyntax(setFileFlags(arg, ""))
250 | 	}
251 | 	pane := &Pane{buf, minPath(arg), tabstopFlag, 80, 25, lineEnding(buf)}
252 | 	if pane.LineEnding == "\r\n" {
253 | 		status += " [DOS]"
254 | 	}
255 | 	pane.SetTabWidth(tabstopFlag)
256 | 	pane.Mark(edit.Index{1, 0}, selMark, insMark)
257 | 	font := getFont()
258 | 	win := createWindow(minPath(arg), font)
259 | 	defer win.Destroy()
260 | 	w, h := win.GetSize()
261 | 	resize(pane, w, h)
262 | 
263 | 	eventLoop(pane, status, font, win)
264 | }
265 | 


--------------------------------------------------------------------------------
/prompt.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import (
  4 | 	"fmt"
  5 | 	"io/ioutil"
  6 | 	"os"
  7 | 	"path/filepath"
  8 | 	"regexp"
  9 | 	"strconv"
 10 | 
 11 | 	"github.com/jangler/edit"
 12 | )
 13 | 
 14 | const (
 15 | 	cdPrompt           = "Change directory to: "
 16 | 	findBackwardPrompt = "Find backward: "
 17 | 	findForwardPrompt  = "Find forward: "
 18 | 	goToLinePrompt     = "Go to line: "
 19 | 	openNewPrompt      = "Open in new window: "
 20 | 	openPrompt         = "Open: "
 21 | 	pipePrompt         = "Pipe selection through: "
 22 | 	reallyOpenPrompt   = "Really open (y/n)? "
 23 | 	reallyQuitPrompt   = "Really quit (y/n)? "
 24 | 	runPrompt          = "Run: "
 25 | 	saveAsPrompt       = "Save as: "
 26 | )
 27 | 
 28 | // UpdateFlags updates file-dependent flags for the RenderContext.
 29 | func (rc *RenderContext) UpdateFlags() {
 30 | 	prevFontFlag, prevPtsizeFlag := fontFlag, ptsizeFlag
 31 | 	syntaxRules := setFileFlags(rc.Pane.Title,
 32 | 		rc.Pane.Get(edit.Index{1, 0}, edit.Index{1, 1 << 30}))
 33 | 	if fontFlag != prevFontFlag || ptsizeFlag != prevPtsizeFlag {
 34 | 		rc.Font = getFont()
 35 | 	}
 36 | 	if darkFlag != (bgColor == darkBgColor) {
 37 | 		setColorScheme()
 38 | 	}
 39 | 	rc.Pane.SetSyntax(syntaxRules)
 40 | 	rc.Pane.TabWidth = tabstopFlag
 41 | 	rc.Pane.SetTabWidth(tabstopFlag)
 42 | }
 43 | 
 44 | // EnterInput exits prompt mode, taking action based on the prompt string and
 45 | // input text. Returns false if the application should quit.
 46 | func (rc *RenderContext) EnterInput() bool {
 47 | 	input := rc.Input.Get(edit.Index{1, 0}, rc.Input.End())
 48 | 	switch rc.Status {
 49 | 	case cdPrompt:
 50 | 		input = expandVars(input)
 51 | 		if abs, err := filepath.Abs(input); err == nil {
 52 | 			input = abs
 53 | 		}
 54 | 		name := expandVars(rc.Pane.Title)
 55 | 		if abs, err := filepath.Abs(name); err == nil {
 56 | 			name = abs
 57 | 		}
 58 | 		if err := os.Chdir(input); err == nil {
 59 | 			rc.Status = fmt.Sprintf(`Working dir is "%s".`, input)
 60 | 			rc.Pane.Title = minPath(name)
 61 | 			rc.Window.SetTitle(rc.Pane.Title)
 62 | 		} else {
 63 | 			rc.Status = err.Error()
 64 | 		}
 65 | 	case findBackwardPrompt:
 66 | 		if re, err := regexp.Compile(input); err == nil {
 67 | 			rc.Regexp = re
 68 | 			rc.Status = find(rc.Pane.Buffer, rc.Regexp, false, rc.Status)
 69 | 		} else {
 70 | 			rc.Status = err.Error()
 71 | 		}
 72 | 	case findForwardPrompt:
 73 | 		if re, err := regexp.Compile(input); err == nil {
 74 | 			rc.Regexp = re
 75 | 			rc.Status = find(rc.Pane.Buffer, rc.Regexp, true, rc.Status)
 76 | 		} else {
 77 | 			rc.Status = err.Error()
 78 | 		}
 79 | 	case goToLinePrompt:
 80 | 		if n, err := strconv.ParseInt(input, 0, 0); err == nil {
 81 | 			rc.Status = rc.Pane.Title
 82 | 			selectLine(rc.Pane.Buffer, int(n))
 83 | 		} else {
 84 | 			rc.Status = err.Error()
 85 | 		}
 86 | 	case openPrompt:
 87 | 		if input == "" {
 88 | 			rc.Status = rc.Pane.Title
 89 | 			break
 90 | 		}
 91 | 		rc.Pane.Delete(edit.Index{1, 0}, rc.Pane.End())
 92 | 		input = expandVars(input)
 93 | 		if contents, err := ioutil.ReadFile(input); err == nil {
 94 | 			rc.Pane.Insert(edit.Index{1, 0}, string(contents))
 95 | 			penult := rc.Pane.ShiftIndex(rc.Pane.End(), -1)
 96 | 			if rc.Pane.Get(penult, rc.Pane.End()) == "\n" {
 97 | 				rc.Pane.Delete(penult, rc.Pane.End())
 98 | 			}
 99 | 			rc.Status = fmt.Sprintf(`Opened "%s".`, minPath(input))
100 | 		} else {
101 | 			rc.Status = fmt.Sprintf(`New file: "%s".`, minPath(input))
102 | 		}
103 | 		rc.Pane.LineEnding = lineEnding(rc.Pane.Buffer)
104 | 		if rc.Pane.LineEnding == "\r\n" {
105 | 			rc.Status += " [DOS]"
106 | 		}
107 | 		rc.Pane.Mark(edit.Index{1, 0}, selMark, insMark)
108 | 		rc.Pane.Title = minPath(input)
109 | 		rc.Window.SetTitle(rc.Pane.Title)
110 | 		rc.Pane.ResetModified()
111 | 		rc.Pane.ResetUndo()
112 | 		rc.UpdateFlags()
113 | 	case openNewPrompt:
114 | 		rc.Status = newInstance(expandVars(input), rc.Pane.Title)
115 | 	case pipePrompt:
116 | 		rc.Status = rc.Pane.Title
117 | 		if input == "" {
118 | 			break
119 | 		}
120 | 		rc.Status = pipeCmd(input, getSelection(rc.Pane.Buffer), rc.Status)
121 | 	case reallyOpenPrompt:
122 | 		if input == "y" || input == "yes" {
123 | 			rc.Prompt(openPrompt)
124 | 			return true // so that main buffer isn't focused
125 | 		}
126 | 		rc.Status = rc.Pane.Title
127 | 	case reallyQuitPrompt:
128 | 		if input == "y" || input == "yes" {
129 | 			return false
130 | 		}
131 | 		rc.Status = rc.Pane.Title
132 | 	case runPrompt:
133 | 		rc.Status = rc.Pane.Title
134 | 		if input == "" {
135 | 			break
136 | 		}
137 | 		runCmd(input)
138 | 	case saveAsPrompt:
139 | 		prevTitle := rc.Pane.Title
140 | 		input = expandVars(input)
141 | 		rc.Pane.Title = input
142 | 		if err := saveFile(rc.Pane); err == nil {
143 | 			rc.Pane.Title = minPath(input)
144 | 			rc.Status = fmt.Sprintf(`Saved "%s".`, rc.Pane.Title)
145 | 			if rc.Pane.LineEnding == "\r\n" {
146 | 				rc.Status += " [DOS]"
147 | 			}
148 | 			rc.Window.SetTitle(rc.Pane.Title)
149 | 			rc.Pane.ResetModified()
150 | 			rc.UpdateFlags()
151 | 		} else {
152 | 			rc.Status = err.Error()
153 | 			rc.Pane.Title = prevTitle
154 | 		}
155 | 	}
156 | 	rc.Focus = rc.Pane.Buffer
157 | 	return true
158 | }
159 | 
160 | // Prompt enters into prompt mode, prompting for input with the given string.
161 | func (rc *RenderContext) Prompt(s string) {
162 | 	rc.Input.ResetUndo()
163 | 	rc.Pane.Separate()
164 | 	rc.Status = s
165 | 	rc.Focus = rc.Input
166 | 	rc.Input.Delete(edit.Index{1, 0}, rc.Input.End())
167 | }
168 | 


--------------------------------------------------------------------------------
/syntax.go:
--------------------------------------------------------------------------------
  1 | package main
  2 | 
  3 | import "github.com/jangler/edit"
  4 | 
  5 | func mustCompile(pattern string, id int) edit.Rule {
  6 | 	rule, err := edit.NewRule(pattern, id)
  7 | 	if err != nil {
  8 | 		panic(err)
  9 | 	}
 10 | 	return rule
 11 | }
 12 | 
 13 | const (
 14 | 	commentID = iota
 15 | 	keywordID
 16 | 	literalID
 17 | )
 18 | 
 19 | var syntaxMap = map[string]func() []edit.Rule{
 20 | 	"[bash]":       bashRules,
 21 | 	"[c]":          cRules,
 22 | 	"[css]":        cssRules,
 23 | 	"[go]":         goRules,
 24 | 	"[html]":       htmlRules,
 25 | 	"[ini]":        iniRules,
 26 | 	"[javascript]": javaScriptRules,
 27 | 	"[json]":       jsonRules,
 28 | 	"[lua]":        luaRules,
 29 | 	"[make]":       makefileRules,
 30 | 	"[python]":     pythonRules,
 31 | 	"[ruby]":       rubyRules,
 32 | 	"[svg]":        svgRules,
 33 | }
 34 | 
 35 | // bashRules returns syntax highlighting rules for Bash.
 36 | func bashRules() []edit.Rule {
 37 | 	// Not sure how "complete" this is. All the builtins are accounted for, but
 38 | 	// I might check out how other programs syntax highlight bash to see if
 39 | 	// other things are usually highlighted.
 40 | 	return []edit.Rule{
 41 | 		mustCompile(`\$#`, -1),
 42 | 		mustCompile(`#.*$`, commentID),
 43 | 		mustCompile(`[!:.]| \[\[? | \]\]?|\b(alias|bg|bind|break|builtin|`+
 44 | 			`caller|case|cd|command|compgen|complete|compopt|continue|`+
 45 | 			`declare|dirs|disown|do|done|echo|elif|else|enable|esac|eval|`+
 46 | 			`exec|exit|export|false|fc|fg|fi|for|function|getopts|hash|help|`+
 47 | 			`history|if|in|jobs|kill|let|local|logout|mapfile|popd|printf|`+
 48 | 			`pushd|pwd|read|readarray|readonly|return|select|set|shift|shopt|`+
 49 | 			`source|suspend|test|then|time|times|trap|true|type|typeset|`+
 50 | 			`ulimit|umask|unalias|unset|until|wait|while)\b`, keywordID),
 51 | 		mustCompile(`\$?("(\\.|[^"])*?"|'(\\.|[^'])*?')`, literalID),
 52 | 		mustCompile("`(\\.|[^`])*?`", literalID),
 53 | 	}
 54 | }
 55 | 
 56 | // cRules returns syntax highlighting rules for C.
 57 | func cRules() []edit.Rule {
 58 | 	return []edit.Rule{
 59 | 		mustCompile(`^#(define|undef|include|if|elif|else|endif|ifdef|ifndef|`+
 60 | 			`line|pragma).*$`, commentID),
 61 | 		mustCompile(`//.+?$`, commentID),
 62 | 		mustCompile(`/\*.*?\*/`, commentID),
 63 | 		mustCompile(`\b(auto|break|case|char|const|continue|default|do|`+
 64 | 			`double|else|enum|extern|float|for|goto|if|inline|int|long|`+
 65 | 			`register|restrict|return|short|signed|sizeof|static|struct|`+
 66 | 			`switch|typedef|union|unsigned|void|volatile|while|_Bool|`+
 67 | 			`_Complex|_Imaginary)\b`, keywordID),
 68 | 		mustCompile(`\b(bool|true|false|NULL)\b`, literalID),
 69 | 		mustCompile(`L?'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
 70 | 		mustCompile(`\b(\d+\.\d*|\d*\.\d+|\d+)([eEpP][+-]?\d+)?`+
 71 | 			`[fFlL]?\b`, literalID),
 72 | 		mustCompile(`\b(0([bB][01]+|[0-7]+|[xX][0-9a-fA-F]+)|\d+)`+
 73 | 			`([uU]?[lL]?|[lL]?[uU]?)\b`, literalID),
 74 | 	}
 75 | }
 76 | 
 77 | // cssRules returns syntax highlighting rules for CSS.
 78 | func cssRules() []edit.Rule {
 79 | 	return []edit.Rule{
 80 | 		mustCompile(`/\*.*?\*/`, commentID),
 81 | 		mustCompile(`^\S*[^:] `, keywordID),
 82 | 		mustCompile(`\S+;`, literalID),
 83 | 	}
 84 | }
 85 | 
 86 | // goRules returns syntax highlighting rules for Go.
 87 | func goRules() []edit.Rule {
 88 | 	return []edit.Rule{
 89 | 		mustCompile(`//.+?$`, commentID),
 90 | 		mustCompile(`/\*.*?\*/`, commentID),
 91 | 		mustCompile(`\b(break|case|chan|const|continue|default|defer|else|`+
 92 | 			`fallthrough|for|func|go|goto|if|import|interface|map|package|`+
 93 | 			`range|return|select|struct|switch|type|var)\b`, keywordID),
 94 | 		mustCompile(`\b(append|cap|close|complex|copy|delete|imag|len|make|`+
 95 | 			`new|panic|print|println|real|recover)\b`, keywordID),
 96 | 		mustCompile(`\b(bool|byte|complex(64|128)|error|float(32|64)|`+
 97 | 			`u?int(8|16|32|64)?|rune|string|uintptr)\b`, keywordID),
 98 | 		mustCompile(`\b(true|false|iota|nil)\b`, literalID),
 99 | 		mustCompile(`'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
100 | 		mustCompile("`.*?`", literalID),
101 | 		mustCompile(`\b0[bB][01]+\b`, literalID),
102 | 		mustCompile(`\b0[0-7]+\b`, literalID),
103 | 		mustCompile(`\b0[xX][0-9a-fA-F]+\b`, literalID),
104 | 		mustCompile(`\b(\d+\.\d*|\d*\.\d+|\d+)([eE][+-]?\d+)?i?\b`, literalID),
105 | 		mustCompile(`\b\d+\bi`, literalID),
106 | 	}
107 | }
108 | 
109 | // htmlRules returns syntax highlighting rules for HTML.
110 | func htmlRules() []edit.Rule {
111 | 	return []edit.Rule{
112 | 		mustCompile(`<!(--.*--|DOCTYPE.*)>`, commentID),
113 | 		mustCompile(`\b(a|abbr|address|area|article|aside|audio|b|base|`+
114 | 			`bd[io]|blockquote|body|br|button|canvas|caption|cite|code|`+
115 | 			`col(group)?|datalist|dd|del|details|dfn|dialog|div|dl|dt|`+
116 | 			`em(bed)?|fieldset|fig(caption|ure)|footer|form|h[123456]|`+
117 | 			`head|header|hr|html|i|iframe|img|input|ins|kbd|keygen|label|`+
118 | 			`legend|li|link|main|map|mark|menu(item)?|meta|meter|nav|`+
119 | 			`noscript|object|ol|opt(group|tion)|output|p|param|pre|progress|`+
120 | 			`q|rp|rt|ruby|s|samp|script|section|select|small|source|span|`+
121 | 			`strong|style|sub|summary|sup|table|tbody|td|textarea|tfoot|th|`+
122 | 			`thead|time|title|tr|track|u|ul|var|video|wbr)\b`, keywordID),
123 | 		mustCompile(`'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
124 | 	}
125 | }
126 | 
127 | // iniRules returns syntax highlighting rules for INI files.
128 | func iniRules() []edit.Rule {
129 | 	return []edit.Rule{
130 | 		mustCompile(`(^| )[;#].*$`, commentID),
131 | 		mustCompile(`^\[.*\]$`, keywordID),
132 | 	}
133 | }
134 | 
135 | // javaScriptRules returns syntax highlighting rules for JavaScript.
136 | func javaScriptRules() []edit.Rule {
137 | 	return []edit.Rule{
138 | 		mustCompile(`//.+?$`, commentID),
139 | 		mustCompile(`/\*.*?\*/`, commentID),
140 | 		mustCompile(`\b(break|case|catch|continue|debugger|default|delete|`+
141 | 			`do|else|finally|for|function|if|in|instanceof|new|return|switch|`+
142 | 			`this|throw|try|typeof|var|void|while|with)\b`, keywordID),
143 | 		mustCompile(`\b(false|NaN|null|true|undefined)\b`, literalID),
144 | 		mustCompile(`\b0[xX][0-9a-fA-F]+\b`, literalID),
145 | 		mustCompile(`\b(\d+\.\d*|\d*\.\d+|\d+)([Ee][+-]?\d+)?\b`, literalID),
146 | 		mustCompile(`'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
147 | 		// missing: regexp literals, because of confusion with division
148 | 	}
149 | }
150 | 
151 | // jsonRules returns syntax highlighting rules for JSON.
152 | func jsonRules() []edit.Rule {
153 | 	return []edit.Rule{
154 | 		mustCompile(`"(\\.|[^"])*?":`, keywordID),
155 | 		mustCompile(`"(\\.|[^"])*?"`, literalID),
156 | 		mustCompile(`\b(true|false|null)\b`, literalID),
157 | 		mustCompile(`\b(\d+\.\d*|\d*\.\d+|\d+)([Ee][+-]?\d+)?\b`, literalID),
158 | 	}
159 | }
160 | 
161 | // luaRules returns syntax highlighting rules for Lua.
162 | func luaRules() []edit.Rule {
163 | 	return []edit.Rule{
164 | 		mustCompile(`(^#!|--).*$`, commentID),
165 | 		mustCompile(`\b(and|break|do|else|elseif|end|for|function|goto|`+
166 | 			`if|in|local|not|or|repeat|return|then|until|while)\b`, keywordID),
167 | 		mustCompile(`\b(assert|collectgarbage|dofile|error|_G|`+
168 | 			`(get|set)metatable|ipairs|load(file)?|next|pairs|pcall|print|`+
169 | 			`raw(equal|get|len|set)|select|to(number|string)|type|_VERSION|`+
170 | 			`xpcall|require)\b`, keywordID),
171 | 		mustCompile(`\b(false|nil|true)\b`, literalID),
172 | 		mustCompile(`'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
173 | 		mustCompile(`\b(0[xX][0-9a-fA-F]+(\.[0-9a-fA-F]+)?|\d+(\.\d+)?)`+
174 | 			`([EePp][+-]?\d+)?\b`, literalID),
175 | 	}
176 | }
177 | 
178 | // makefileRules returns syntax highlighting rules for makefiles.
179 | func makefileRules() []edit.Rule {
180 | 	return []edit.Rule{
181 | 		mustCompile(`#.*$`, commentID),
182 | 		mustCompile(`\b(else|end[ei]f|ifn?def|ifn?eq|(-|s)?include|load|`+
183 | 			`override|private|(un)?export|(un)?define|vpath)\b`, keywordID),
184 | 		mustCompile(`\b(abspath|addprefix|(add)?suffix|and|basename|call|`+
185 | 			`error|eval|file|filter(-out)?|findstring|firstword|flavor|`+
186 | 			`foreach|guile|if|info|join|lastword|(not)?dir|or(igin)?|`+
187 | 			`patsubst|realpath|shell|sort|strip|subst|value|warning|wildcard|`+
188 | 			`word(s|list)?)\b`, keywordID),
189 | 		mustCompile(`\b\.(DEFAULT|DELETE_ON_ERROR|EXPORT_ALL_VARIABLES|`+
190 | 			`IGNORE|INTERMEDIATE|LOW_RESOLUTION_TIME|NOTPARALLEL|ONESHELL|`+
191 | 			`PHONY|POSIX|PRECIOUS|SECONDARY|SECONDEXPANSION|SILENT|`+
192 | 			`SUFFIXES)\b`, keywordID),
193 | 		mustCompile(`\b(DEFAULT_GOAL|\.FEATURES|\.INCLUDE_DIRS|MAKEFILE_LIST|`+
194 | 			`MAKE_RESTARTS|MAKE_TERMERR|MAKE_TERMOUT|\.RECIPEPREFIX|`+
195 | 			`\.VARIABLES)\b`, keywordID),
196 | 		mustCompile(`\b(CURDIR|MAKE(CMDGOALS|FILES|FLAGS|_HOST|LEVEL|`+
197 | 			`\.LIBPATTERNS|SHELL|SUFFIXES|_VERSION)?|SHELL|VPATH)\b`,
198 | 			keywordID),
199 | 		mustCompile(`\$(\(.+\)|\{.+\}|.)`, literalID),
200 | 	}
201 | }
202 | 
203 | // pythonRules returns syntax highlighting rules for Python.
204 | func pythonRules() []edit.Rule {
205 | 	return []edit.Rule{
206 | 		mustCompile(`#.*$`, commentID),
207 | 		mustCompile(`\b(and|as|assert|break|class|continue|def|del|elif|else|`+
208 | 			`except|finally|for|from|global|if|import|in|is|lambda|nonlocal|`+
209 | 			`not|or|pass|raise|return|try|while|with|yield)\b`, keywordID),
210 | 		mustCompile(`\b(abs|all|any|ascii|bin|bool|bytearray|bytes|callable|`+
211 | 			`chr|classmethod|compile|complex|delattr|dict|dir|divmod|`+
212 | 			`enumerate|eval|exec|filter|float|format|frozenset|getattr|`+
213 | 			`globals|hasattr|hash|help|hex|id|input|int|isinstance|`+
214 | 			`issubclass|iter|len|list|locals|map|max|memoryview|min|next|`+
215 | 			`object|oct|open|ord|pow|print|property|range|repr|reversed|`+
216 | 			`round|set|setattr|slice|sorted|staticmethod|str|sum|super|`+
217 | 			`tuple|type|vars|zip|__import__)\b`, keywordID),
218 | 		mustCompile(`\b(False|None|True)\b`, literalID),
219 | 		mustCompile(`(\b([rR][bB]|[bB][rR]|\b[uUrR]))?('''(\\?.)*?'''|`+
220 | 			`"""(\\?.)*?"""|"(\.|[^"])*?"|'(\.|[^'])*?')`, literalID),
221 | 		mustCompile(`\b0[bB][01]+\b`, literalID),
222 | 		mustCompile(`\b0[oO]?[0-7]+\b`, literalID),
223 | 		mustCompile(`\b0[xX][0-9a-fA-F]+\b`, literalID),
224 | 		mustCompile(`\b(\d+\.\d*|\d*\.\d+|\d+)([eE][+-]?\d+)?`+
225 | 			`([jJ](\d+\.\d*|\d*\.\d+|\d+)([eE][+-]?\d+)?)?\b`, literalID),
226 | 	}
227 | }
228 | 
229 | // rubyRules returns syntax highlighting rules for Ruby.
230 | func rubyRules() []edit.Rule {
231 | 	return []edit.Rule{
232 | 		mustCompile(`#.*$`, commentID),
233 | 		mustCompile(`/\*.*?\*/`, commentID), // does anyone actually use these?
234 | 		mustCompile(`\b(__ENCODING__|__LINE__|__FILE__|BEGIN|END|alias|and|`+
235 | 			`begin|break|case|class|def|defined\?|do|else|elsif|end|ensure|`+
236 | 			`for|if|in|module|next|not|or|redo|rescue|retry|return|self|`+
237 | 			`super|then|undef|unless|until|when|while|yield)\b`, keywordID),
238 | 		mustCompile(`\b(__callee__|__dir__|__method__|abort|at_exit|`+
239 | 			`autoload\??|binding|block_given\?|callcc|caller(_locations)?|`+
240 | 			`catch|chomp|chop|eval|exec|exit|fail|fork|format|gets|`+
241 | 			`(global|local)_variables|g?sub|iterator\?|lambda|load|loop|open|`+
242 | 			`p|print|s?printf|proc|put[cs]|raise|s?rand|readlines?|`+
243 | 			`require(_relative)?|select|set_trace_func|sleep|spawn|`+
244 | 			`sys(call|tem)|test|throw|(un)?trace_var|trap|warn)\b`, keywordID),
245 | 		mustCompile(`\b(false|nil|true)\b`, literalID),
246 | 		mustCompile(`\b0[bB][01_]+\b`, literalID),
247 | 		mustCompile(`\b0[oO]?[0-7_]+\b`, literalID),
248 | 		mustCompile(`\b0[dD][0-9_]+\b`, literalID),
249 | 		mustCompile(`\b0[xX][0-9a-fA-F_]+\b`, literalID),
250 | 		mustCompile(`\b([0-9][0-9_]*\.([0-9][0-9_]*)?|`+
251 | 			`([0-9][0-9_]*)?\.[0-9][0-9_]*|[[0-9][0-9_]*)`+
252 | 			`([Ee][+-]?[0-9][0-9_]*)?\b`, literalID),
253 | 		mustCompile(`'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
254 | 		mustCompile("`(\\.|[^`])*?`", literalID),
255 | 		mustCompile(`%[iIqQrRsSwWxX](\(.*?\)|\{.*?\})`, literalID),
256 | 		// missing: regexp literals, because of confusion with division
257 | 		// missing: recognition of string interpolation: #{...}
258 | 		// should symbols be highlighted as literals?
259 | 	}
260 | }
261 | 
262 | // svgRules returns syntax highlighting rules for SVG.
263 | func svgRules() []edit.Rule {
264 | 	return []edit.Rule{
265 | 		mustCompile(`<!--.*-->`, commentID),
266 | 		mustCompile(`\b(a|altGlyph(Def|Item)?|animate(Motion|Transform)?|`+
267 | 			`circle|clipPath|color-profile|cursor|defs|desc|ellipse|`+
268 | 			`fe(Blend|(Color|Convolve)Matrix|ComponentTransfer|Composite|`+
269 | 			`(Diffuse|Specular)Lighting|DisplacementMap|`+
270 | 			`(Distant|Point|Spot)Light|Flood|Func[ABGR]|GaussianBlur|Image`+
271 | 			`|Merge(Node)?|Morphology|Offset|Tile|Turbulence)|filter|`+
272 | 			`font(-face(-format|-name|-src|-uri)?)?|foreignObject|g|`+
273 | 			`glyph(Ref)?|hkern|image|line(arGradient)?|marker|mask|metadata|`+
274 | 			`missing-glyph|m?path|pattern|poly(gon|line)|radialGradient|rect|`+
275 | 			`script|set|stop|style|svg|switch|symbol|text(Path)?|title|tref|`+
276 | 			`tspan|use|view|vkern)\b`, keywordID),
277 | 		mustCompile(`'(\\.|[^'])*?'|"(\\.|[^"])*?"`, literalID),
278 | 	}
279 | }
280 | 


--------------------------------------------------------------------------------