Merge pull request #3 from codelaboratoryltd/blink

Add blinking

Author: mgazza

color.go

@@ -46,6 +46,7 @@ func (t *Terminal) handleColorEscape(message string) {
 		t.currentBG = nil
 		t.currentFG = nil
 		t.bold = false
+		t.blinking = false
 		return
 	}
 
@@ -81,9 +82,12 @@ func (t *Terminal) handleColorMode(modeStr string) {
 	case 0:
 		t.currentBG, t.currentFG = nil, nil
 		t.bold = false
+		t.blinking = false
 	case 1:
 		t.bold = true
 	case 4, 24: //italic
+	case 5:
+		t.blinking = true
 	case 7: // reverse
 		bg := t.currentBG
 		if t.currentFG == nil {

internal/widget/textgrid.go

@@ -14,9 +14,9 @@ func HighlightRange(t *widget.TextGrid, blockMode bool, startRow, startCol, endR
 		// Check if already highlighted
 		if h, ok := cell.Style.(*TermTextGridStyle); !ok {
 			if cell.Style != nil {
-				cell.Style = NewTermTextGridStyle(cell.Style.TextColor(), cell.Style.BackgroundColor(), bitmask)
+				cell.Style = NewTermTextGridStyle(cell.Style.TextColor(), cell.Style.BackgroundColor(), bitmask, false)
 			} else {
-				cell.Style = NewTermTextGridStyle(nil, nil, bitmask)
+				cell.Style = NewTermTextGridStyle(nil, nil, bitmask, false)
 			}
 			cell.Style.(*TermTextGridStyle).Highlighted = true
 
@@ -80,14 +80,14 @@ func GetTextRange(t *widget.TextGrid, blockMode bool, startRow, startCol, endRow
 // - eachRow (func(row *widget.TextGridRow)): A function that takes a pointer to a TextGridRow and is applied to each row in the specified range. Pass `nil` if you don't want to apply a row function.
 //
 // Note:
-// - If startRow or endRow are out of bounds (negative or greater/equal to the number of rows in the TermGrid), they will be adjusted to valid values.
+// - If startRow or endRow are out of bounds (negative or greater/equal to the number of rows in the TextGrid), they will be adjusted to valid values.
 // - If startRow and endRow are the same, the iteration will be limited to the specified column range within that row.
 // - When blockMode is true, it iterates through rows from startRow to endRow, applying the cell function for each cell in the specified column range.
 // - When blockMode is false, it iterates through individual cells row by row, applying the cell function for each cell and optionally applying the row function for each row.
 //
 // Example Usage:
-// termGrid.forRange(true, 0, 1, 2, 3, cellFunc, rowFunc) // Iterate in block mode, applying cellFunc to cells in columns 1 to 3 and rowFunc to rows 0 to 2.
-// termGrid.forRange(false, 1, 0, 3, 2, cellFunc, rowFunc) // Iterate cell by cell, applying cellFunc to all cells and rowFunc to rows 1 and 2.
+// forRange(termGrid, true, 0, 1, 2, 3, cellFunc, rowFunc) // Iterate in block mode, applying cellFunc to cells in columns 1 to 3 and rowFunc to rows 0 to 2.
+// forRange(termGrid, false, 1, 0, 3, 2, cellFunc, rowFunc) // Iterate cell by cell, applying cellFunc to all cells and rowFunc to rows 1 and 2.
 func forRange(t *widget.TextGrid, blockMode bool, startRow, startCol, endRow, endCol int, eachCell func(cell *widget.TextGridCell), eachRow func(row *widget.TextGridRow)) {
 	if startRow >= len(t.Rows) || endRow < 0 {
 		return
@@ -171,13 +171,21 @@ type TermTextGridStyle struct {
 	InvertedTextColor       color.Color
 	InvertedBackgroundColor color.Color
 	Highlighted             bool
+	BlinkEnabled            bool
+	Blink                   bool
 }
 
 // TextColor returns the color of the text, depending on whether it is highlighted.
 func (h *TermTextGridStyle) TextColor() color.Color {
 	if h.Highlighted {
+		if h.BlinkEnabled && h.Blink {
+			return h.InvertedBackgroundColor
+		}
 		return h.InvertedTextColor
 	}
+	if h.BlinkEnabled && h.Blink {
+		return h.OriginalBackgroundColor
+	}
 	return h.OriginalTextColor
 }
 
@@ -201,11 +209,12 @@ type HighlightOption func(h *TermTextGridStyle)
 //   - fg: The foreground color.
 //   - bg: The background color.
 //   - bitmask: The bitmask to control color inversion.
+//   - blinkEnabled: Should this cell blink when told to.
 //
 // Returns:
 //
 //	A pointer to a TermTextGridStyle initialized with the provided colors and inversion settings.
-func NewTermTextGridStyle(fg, bg color.Color, bitmask byte) widget.TextGridStyle {
+func NewTermTextGridStyle(fg, bg color.Color, bitmask byte, blinkEnabled bool) widget.TextGridStyle {
 	// calculate the inverted colors
 	var invertedFg, invertedBg color.Color
 	if fg == nil {
@@ -225,6 +234,8 @@ func NewTermTextGridStyle(fg, bg color.Color, bitmask byte) widget.TextGridStyle
 		InvertedTextColor:       invertedFg,
 		InvertedBackgroundColor: invertedBg,
 		Highlighted:             false,
+		BlinkEnabled:            blinkEnabled,
+		Blink:                   false,
 	}
 }
 

output.go

@@ -4,6 +4,7 @@ import (
 	"time"
 
 	"fyne.io/fyne/v2/widget"
+	widget2 "github.com/fyne-io/terminal/internal/widget"
 )
 
 const (
@@ -13,6 +14,8 @@ const (
 
 	noEscape = 5000
 	tabWidth = 8
+
+	blinkingInterval = 500 * time.Millisecond
 )
 
 var charSetMap = map[charSet]func(rune) rune{
@@ -187,15 +190,18 @@ func (t *Terminal) handleOutputChar(r rune) {
 		t.content.Rows = append(t.content.Rows, widget.TextGridRow{})
 	}
 
-	cellStyle := &widget.CustomTextGridStyle{FGColor: t.currentFG, BGColor: t.currentBG}
+	var cellStyle widget.TextGridStyle
+	cellStyle = &widget.CustomTextGridStyle{FGColor: t.currentFG, BGColor: t.currentBG}
 	for len(t.content.Rows[t.cursorRow].Cells)-1 < t.cursorCol {
 		newCell := widget.TextGridCell{
 			Rune:  ' ',
 			Style: cellStyle,
 		}
 		t.content.Rows[t.cursorRow].Cells = append(t.content.Rows[t.cursorRow].Cells, newCell)
 	}
-
+	if t.blinking {
+		cellStyle = widget2.NewTermTextGridStyle(t.currentFG, t.currentBG, t.highlightBitMask, t.blinking)
+	}
 	t.content.SetCell(t.cursorRow, t.cursorCol, widget.TextGridCell{Rune: r, Style: cellStyle})
 	t.cursorCol++
 }

term.go

@@ -17,6 +17,10 @@ import (
 	widget2 "github.com/fyne-io/terminal/internal/widget"
 )
 
+const (
+	bufLen = 4069
+)
+
 // Config is the state of a terminal, updated upon certain actions or commands.
 // Use Terminal.OnConfigure hook to register for changes.
 type Config struct {
@@ -74,6 +78,7 @@ type Terminal struct {
 	}
 	newLineMode        bool // new line mode or line feed mode
 	bracketedPasteMode bool
+	blinking           bool
 }
 
 // Cursor is used for displaying a specific cursor.
@@ -264,26 +269,73 @@ func (t *Terminal) guessCellSize() fyne.Size {
 	return fyne.NewSize(float32(math.Round(float64(min.Width))), float32(math.Round(float64(min.Height))))
 }
 
+// run starts the main loop for handling terminal output, blinking, and refreshing.
+// It reads terminal output asynchronously, processes it, and toggles blinking every
+// blinkingInterval duration.
+// The function returns when the terminal is closed.
 func (t *Terminal) run() {
-	bufLen := 4069
+	ch := make(chan []byte)
+	ticker := time.NewTicker(blinkingInterval)
+	blinking := false
+	go t.readOutAsync(ch)
+
+	for {
+		select {
+		case b, ok := <-ch:
+			if !ok {
+				// we've been closed
+				return
+			}
+			t.handleOutput(b)
+			if len(b) < bufLen {
+				t.Refresh()
+			}
+		case <-ticker.C:
+			blinking = !blinking
+			t.runBlink(blinking)
+		}
+	}
+}
+
+// runBlink manages the blinking effect for cells in the terminal content.
+// It toggles the blinking state for blinking cells and refreshes the content as needed.
+func (t *Terminal) runBlink(blinking bool) {
+	for rowNo, r := range t.content.Rows {
+		for colNo, c := range r.Cells {
+			s, ok := c.Style.(*widget2.TermTextGridStyle)
+			if ok {
+				s.Blink = blinking
+			}
+
+			_, _ = rowNo, colNo
+		}
+	}
+
+	// redraw the cells we just flipped
+	t.content.Refresh()
+}
+
+// readOutAsync reads terminal output asynchronously and sends it to the provided channel.
+// It handles  when the terminal is closed or encounters an error. The chanel is closed on returning.
+func (t *Terminal) readOutAsync(ch chan []byte) {
 	buf := make([]byte, bufLen)
 	for {
 		num, err := t.out.Read(buf)
 		if err != nil {
 			// this is the pre-go 1.13 way to check for the read failing (terminal closed)
 			if err.Error() == "EOF" {
+				close(ch)
 				break // term exit on macOS
 			} else if err, ok := err.(*os.PathError); ok && err.Err.Error() == "input/output error" {
+				close(ch)
 				break // broken pipe, terminal exit
 			}
 
 			fyne.LogError("pty read error", err)
 		}
-
-		t.handleOutput(buf[:num])
-		if num < bufLen {
-			t.Refresh()
-		}
+		cp := make([]byte, num)
+		copy(cp, buf[:num])
+		ch <- cp
 	}
 }