From dc8cc5aa4db5cc08ae01b2ce48b6d310b98e858f Mon Sep 17 00:00:00 2001 From: Caleb Bassi Date: Tue, 27 Mar 2018 14:27:23 -0700 Subject: [PATCH] Change methods to use 'self' keyword --- termui/block.go | 70 +++++++++--------- termui/buffer.go | 50 ++++++------- termui/gauge.go | 24 +++---- termui/grid.go | 22 +++--- termui/linegraph.go | 34 ++++----- termui/sparkline.go | 36 +++++----- termui/table.go | 148 +++++++++++++++++++------------------- widgets/cpu.go | 36 +++++----- widgets/disk.go | 20 +++--- widgets/help.go | 6 +- widgets/mem.go | 24 +++---- widgets/net.go | 34 ++++----- widgets/proc.go | 168 ++++++++++++++++++++++---------------------- widgets/temp.go | 36 +++++----- 14 files changed, 354 insertions(+), 354 deletions(-) diff --git a/termui/block.go b/termui/block.go index d6d9856..4695f25 100644 --- a/termui/block.go +++ b/termui/block.go @@ -32,69 +32,69 @@ func NewBlock() *Block { } } -func (b *Block) drawBorder(buf *Buffer) { - x := b.X + 1 - y := b.Y + 1 +func (self *Block) drawBorder(buf *Buffer) { + x := self.X + 1 + y := self.Y + 1 // draw lines - buf.Merge(NewFilledBuffer(0, 0, x, 1, Cell{HORIZONTAL_LINE, b.BorderFg, b.BorderBg})) - buf.Merge(NewFilledBuffer(0, y, x, y+1, Cell{HORIZONTAL_LINE, b.BorderFg, b.BorderBg})) - buf.Merge(NewFilledBuffer(0, 0, 1, y+1, Cell{VERTICAL_LINE, b.BorderFg, b.BorderBg})) - buf.Merge(NewFilledBuffer(x, 0, x+1, y+1, Cell{VERTICAL_LINE, b.BorderFg, b.BorderBg})) + buf.Merge(NewFilledBuffer(0, 0, x, 1, Cell{HORIZONTAL_LINE, self.BorderFg, self.BorderBg})) + buf.Merge(NewFilledBuffer(0, y, x, y+1, Cell{HORIZONTAL_LINE, self.BorderFg, self.BorderBg})) + buf.Merge(NewFilledBuffer(0, 0, 1, y+1, Cell{VERTICAL_LINE, self.BorderFg, self.BorderBg})) + buf.Merge(NewFilledBuffer(x, 0, x+1, y+1, Cell{VERTICAL_LINE, self.BorderFg, self.BorderBg})) // draw corners - buf.SetCell(0, 0, Cell{TOP_LEFT, b.BorderFg, b.BorderBg}) - buf.SetCell(x, 0, Cell{TOP_RIGHT, b.BorderFg, b.BorderBg}) - buf.SetCell(0, y, Cell{BOTTOM_LEFT, b.BorderFg, b.BorderBg}) - buf.SetCell(x, y, Cell{BOTTOM_RIGHT, b.BorderFg, b.BorderBg}) + buf.SetCell(0, 0, Cell{TOP_LEFT, self.BorderFg, self.BorderBg}) + buf.SetCell(x, 0, Cell{TOP_RIGHT, self.BorderFg, self.BorderBg}) + buf.SetCell(0, y, Cell{BOTTOM_LEFT, self.BorderFg, self.BorderBg}) + buf.SetCell(x, y, Cell{BOTTOM_RIGHT, self.BorderFg, self.BorderBg}) } -func (b *Block) drawLabel(buf *Buffer) { - r := MaxString(b.Label, (b.X-3)-1) - buf.SetString(3, 0, r, b.LabelFg, b.LabelBg) - if b.Label == "" { +func (self *Block) drawLabel(buf *Buffer) { + r := MaxString(self.Label, (self.X-3)-1) + buf.SetString(3, 0, r, self.LabelFg, self.LabelBg) + if self.Label == "" { return } - c := Cell{' ', b.Fg, b.Bg} + c := Cell{' ', self.Fg, self.Bg} buf.SetCell(2, 0, c) - if len(b.Label)+3 < b.X { - buf.SetCell(len(b.Label)+3, 0, c) + if len(self.Label)+3 < self.X { + buf.SetCell(len(self.Label)+3, 0, c) } else { - buf.SetCell(b.X-1, 0, c) + buf.SetCell(self.X-1, 0, c) } } // Resize computes Height, Width, XOffset, and YOffset given terminal dimensions. -func (b *Block) Resize(termWidth, termHeight, termCols, termRows int) { - b.X = int((float64(b.Grid.Dx())/float64(termCols))*float64(termWidth)) - 2 - b.Y = int((float64(b.Grid.Dy())/float64(termRows))*float64(termHeight)) - 2 - b.XOffset = int((float64(b.Grid.Min.X) / float64(termCols)) * float64(termWidth)) - b.YOffset = int((float64(b.Grid.Min.Y) / float64(termRows)) * float64(termHeight)) +func (self *Block) Resize(termWidth, termHeight, termCols, termRows int) { + self.X = int((float64(self.Grid.Dx())/float64(termCols))*float64(termWidth)) - 2 + self.Y = int((float64(self.Grid.Dy())/float64(termRows))*float64(termHeight)) - 2 + self.XOffset = int((float64(self.Grid.Min.X) / float64(termCols)) * float64(termWidth)) + self.YOffset = int((float64(self.Grid.Min.Y) / float64(termRows)) * float64(termHeight)) } // SetGrid create a rectangle representing the block's dimensions in the grid. -func (b *Block) SetGrid(c0, r0, c1, r1 int) { - b.Grid = image.Rect(c0, r0, c1, r1) +func (self *Block) SetGrid(c0, r0, c1, r1 int) { + self.Grid = image.Rect(c0, r0, c1, r1) } // GetXOffset implements Bufferer interface. -func (b *Block) GetXOffset() int { - return b.XOffset +func (self *Block) GetXOffset() int { + return self.XOffset } // GetYOffset implements Bufferer interface. -func (b *Block) GetYOffset() int { - return b.YOffset +func (self *Block) GetYOffset() int { + return self.YOffset } // Buffer implements Bufferer interface and draws background, border, and borderlabel. -func (b *Block) Buffer() *Buffer { +func (self *Block) Buffer() *Buffer { buf := NewBuffer() - buf.SetAreaXY(b.X+2, b.Y+2) - buf.Fill(Cell{' ', ColorDefault, b.Bg}) + buf.SetAreaXY(self.X+2, self.Y+2) + buf.Fill(Cell{' ', ColorDefault, self.Bg}) - b.drawBorder(buf) - b.drawLabel(buf) + self.drawBorder(buf) + self.drawLabel(buf) return buf } diff --git a/termui/buffer.go b/termui/buffer.go index 47c234c..9faabaf 100644 --- a/termui/buffer.go +++ b/termui/buffer.go @@ -40,60 +40,60 @@ func NewFilledBuffer(x0, y0, x1, y1 int, c Cell) *Buffer { } // SetCell assigns a Cell to (x,y). -func (b *Buffer) SetCell(x, y int, c Cell) { - b.CellMap[image.Pt(x, y)] = c +func (self *Buffer) SetCell(x, y int, c Cell) { + self.CellMap[image.Pt(x, y)] = c } // SetString assigns a string to a Buffer starting at (x,y). -func (b *Buffer) SetString(x, y int, s string, fg, bg Color) { +func (self *Buffer) SetString(x, y int, s string, fg, bg Color) { for i, char := range s { - b.SetCell(x+i, y, Cell{char, fg, bg}) + self.SetCell(x+i, y, Cell{char, fg, bg}) } } // At returns the cell at (x,y). -func (b *Buffer) At(x, y int) Cell { - return b.CellMap[image.Pt(x, y)] +func (self *Buffer) At(x, y int) Cell { + return self.CellMap[image.Pt(x, y)] } -// SetArea assigns a new rect area to Buffer b. -func (b *Buffer) SetArea(r image.Rectangle) { - b.Area.Max = r.Max - b.Area.Min = r.Min +// SetArea assigns a new rect area to self. +func (self *Buffer) SetArea(r image.Rectangle) { + self.Area.Max = r.Max + self.Area.Min = r.Min } // SetAreaXY sets the Buffer bounds from (0,0) to (x,y). -func (b *Buffer) SetAreaXY(x, y int) { - b.Area.Min.Y = 0 - b.Area.Min.X = 0 - b.Area.Max.Y = y - b.Area.Max.X = x +func (self *Buffer) SetAreaXY(x, y int) { + self.Area.Min.Y = 0 + self.Area.Min.X = 0 + self.Area.Max.Y = y + self.Area.Max.X = x } // Merge merges the given buffers onto the current Buffer. -func (b *Buffer) Merge(bs ...*Buffer) { +func (self *Buffer) Merge(bs ...*Buffer) { for _, buf := range bs { for p, c := range buf.CellMap { - b.SetCell(p.X, p.Y, c) + self.SetCell(p.X, p.Y, c) } - b.SetArea(b.Area.Union(buf.Area)) + self.SetArea(self.Area.Union(buf.Area)) } } // MergeWithOffset merges a Buffer onto another with an offset. -func (b *Buffer) MergeWithOffset(buf *Buffer, xOffset, yOffset int) { +func (self *Buffer) MergeWithOffset(buf *Buffer, xOffset, yOffset int) { for p, c := range buf.CellMap { - b.SetCell(p.X+xOffset, p.Y+yOffset, c) + self.SetCell(p.X+xOffset, p.Y+yOffset, c) } rect := image.Rect(xOffset, yOffset, buf.Area.Max.X+xOffset, buf.Area.Max.Y+yOffset) - b.SetArea(b.Area.Union(rect)) + self.SetArea(self.Area.Union(rect)) } // Fill fills the Buffer with a Cell. -func (b *Buffer) Fill(c Cell) { - for x := b.Area.Min.X; x < b.Area.Max.X; x++ { - for y := b.Area.Min.Y; y < b.Area.Max.Y; y++ { - b.SetCell(x, y, c) +func (self *Buffer) Fill(c Cell) { + for x := self.Area.Min.X; x < self.Area.Max.X; x++ { + for y := self.Area.Min.Y; y < self.Area.Max.Y; y++ { + self.SetCell(x, y, c) } } } diff --git a/termui/gauge.go b/termui/gauge.go index 1896871..a5b3b2a 100644 --- a/termui/gauge.go +++ b/termui/gauge.go @@ -21,27 +21,27 @@ func NewGauge() *Gauge { } // Buffer implements Bufferer interface. -func (g *Gauge) Buffer() *Buffer { - buf := g.Block.Buffer() +func (self *Gauge) Buffer() *Buffer { + buf := self.Block.Buffer() // plot bar - width := g.Percent * g.X / 100 - for y := 1; y <= g.Y; y++ { + width := self.Percent * self.X / 100 + for y := 1; y <= self.Y; y++ { for x := 1; x <= width; x++ { - buf.SetCell(x, y, Cell{' ', g.GaugeColor, g.GaugeColor}) + buf.SetCell(x, y, Cell{' ', self.GaugeColor, self.GaugeColor}) } } // plot percentage - s := strconv.Itoa(g.Percent) + "%" + g.Description - s = MaxString(s, g.X) - y := (g.Y + 1) / 2 - x := ((g.X - len(s)) + 1) / 2 + s := strconv.Itoa(self.Percent) + "%" + self.Description + s = MaxString(s, self.X) + y := (self.Y + 1) / 2 + x := ((self.X - len(s)) + 1) / 2 for i, char := range s { - bg := g.Bg - fg := g.Fg + bg := self.Bg + fg := self.Fg if x+i < width { - fg = g.GaugeColor + fg = self.GaugeColor bg = AttrReverse } buf.SetCell(1+x+i, y, Cell{char, fg, bg}) diff --git a/termui/grid.go b/termui/grid.go index a005234..58b4839 100644 --- a/termui/grid.go +++ b/termui/grid.go @@ -25,7 +25,7 @@ func NewGrid() *Grid { } // Set assigns a widget and its grid dimensions to Grid. -func (g *Grid) Set(x0, y0, x1, y1 int, widget GridBufferer) { +func (self *Grid) Set(x0, y0, x1, y1 int, widget GridBufferer) { if widget == nil { return } @@ -34,33 +34,33 @@ func (g *Grid) Set(x0, y0, x1, y1 int, widget GridBufferer) { } widget.SetGrid(x0, y0, x1, y1) - widget.Resize(g.Width, g.Height, g.Cols, g.Rows) + widget.Resize(self.Width, self.Height, self.Cols, self.Rows) - g.Widgets = append(g.Widgets, widget) + self.Widgets = append(self.Widgets, widget) } // Resize resizes each widget in the grid. -func (g *Grid) Resize() { - for _, w := range g.Widgets { - w.Resize(g.Width, g.Height, g.Cols, g.Rows) +func (self *Grid) Resize() { + for _, w := range self.Widgets { + w.Resize(self.Width, self.Height, self.Cols, self.Rows) } } // Buffer implements the Bufferer interface by merging each widget in Grid into one buffer. -func (g *Grid) Buffer() *Buffer { - buf := NewFilledBuffer(0, 0, g.Width, g.Height, Cell{' ', ColorDefault, Theme.Bg}) - for _, w := range g.Widgets { +func (self *Grid) Buffer() *Buffer { + buf := NewFilledBuffer(0, 0, self.Width, self.Height, Cell{' ', ColorDefault, Theme.Bg}) + for _, w := range self.Widgets { buf.MergeWithOffset(w.Buffer(), w.GetXOffset(), w.GetYOffset()) } return buf } // GetXOffset implements Bufferer interface. -func (g *Grid) GetXOffset() int { +func (self *Grid) GetXOffset() int { return 0 } // GetYOffset implements Bufferer interface. -func (g *Grid) GetYOffset() int { +func (self *Grid) GetYOffset() int { return 0 } diff --git a/termui/linegraph.go b/termui/linegraph.go index 01d8414..cc71e8f 100644 --- a/termui/linegraph.go +++ b/termui/linegraph.go @@ -30,21 +30,21 @@ func NewLineGraph() *LineGraph { } // Buffer implements Bufferer interface. -func (lc *LineGraph) Buffer() *Buffer { - buf := lc.Block.Buffer() +func (self *LineGraph) Buffer() *Buffer { + buf := self.Block.Buffer() // we render each data point on to the canvas then copy over the braille to the buffer at the end // fyi braille characters have 2x4 dots for each character c := drawille.NewCanvas() // used to keep track of the braille colors until the end when we render the braille to the buffer - colors := make([][]Color, lc.X+2) + colors := make([][]Color, self.X+2) for i := range colors { - colors[i] = make([]Color, lc.Y+2) + colors[i] = make([]Color, self.Y+2) } // sort the series so that overlapping data will overlap the same way each time - seriesList := make([]string, len(lc.Data)) + seriesList := make([]string, len(self.Data)) i := 0 - for seriesName := range lc.Data { + for seriesName := range self.Data { seriesList[i] = seriesName i++ } @@ -53,21 +53,21 @@ func (lc *LineGraph) Buffer() *Buffer { // draw lines in reverse order so that the first color defined in the colorscheme is on top for i := len(seriesList) - 1; i >= 0; i-- { seriesName := seriesList[i] - seriesData := lc.Data[seriesName] - seriesLineColor, ok := lc.LineColor[seriesName] + seriesData := self.Data[seriesName] + seriesLineColor, ok := self.LineColor[seriesName] if !ok { - seriesLineColor = lc.DefaultLineColor + seriesLineColor = self.DefaultLineColor } // coordinates of last point lastY, lastX := -1, -1 // assign colors to `colors` and lines/points to the canvas for i := len(seriesData) - 1; i >= 0; i-- { - x := ((lc.X + 1) * 2) - 1 - (((len(seriesData) - 1) - i) * lc.Zoom) - y := ((lc.Y + 1) * 4) - 1 - int((float64((lc.Y)*4)-1)*(seriesData[i]/100)) + x := ((self.X + 1) * 2) - 1 - (((len(seriesData) - 1) - i) * self.Zoom) + y := ((self.Y + 1) * 4) - 1 - int((float64((self.Y)*4)-1)*(seriesData[i]/100)) if x < 0 { // render the line to the last point up to the wall - if x > 0-lc.Zoom { + if x > 0-self.Zoom { for _, p := range drawille.Line(lastX, lastY, x, y) { if p.X > 0 { c.Set(p.X, p.Y) @@ -97,7 +97,7 @@ func (lc *LineGraph) Buffer() *Buffer { continue } if char != 10240 { // empty braille character - buf.SetCell(x, y, Cell{char, colors[x][y], lc.Bg}) + buf.SetCell(x, y, Cell{char, colors[x][y], self.Bg}) } } } @@ -106,17 +106,17 @@ func (lc *LineGraph) Buffer() *Buffer { // renders key ontop for j, seriesName := range seriesList { // sorts lines again - seriesData := lc.Data[seriesName] - seriesLineColor, ok := lc.LineColor[seriesName] + seriesData := self.Data[seriesName] + seriesLineColor, ok := self.LineColor[seriesName] if !ok { - seriesLineColor = lc.DefaultLineColor + seriesLineColor = self.DefaultLineColor } // render key ontop, but let braille be drawn over space characters str := fmt.Sprintf("%s %3.0f%%", seriesName, seriesData[len(seriesData)-1]) for k, char := range str { if char != ' ' { - buf.SetCell(3+k, j+2, Cell{char, seriesLineColor, lc.Bg}) + buf.SetCell(3+k, j+2, Cell{char, seriesLineColor, self.Bg}) } } diff --git a/termui/sparkline.go b/termui/sparkline.go index 6beeb8d..8cefff8 100644 --- a/termui/sparkline.go +++ b/termui/sparkline.go @@ -18,8 +18,8 @@ type Sparklines struct { } // Add appends a given Sparkline to the *Sparklines. -func (s *Sparklines) Add(sl Sparkline) { - s.Lines = append(s.Lines, &sl) +func (self *Sparklines) Add(sl Sparkline) { + self.Lines = append(self.Lines, &sl) } // NewSparkline returns an unrenderable single sparkline that intended to be added into a Sparklines. @@ -39,37 +39,37 @@ func NewSparklines(ss ...*Sparkline) *Sparklines { } // Buffer implements Bufferer interface. -func (sl *Sparklines) Buffer() *Buffer { - buf := sl.Block.Buffer() +func (self *Sparklines) Buffer() *Buffer { + buf := self.Block.Buffer() - lc := len(sl.Lines) // lineCount + lc := len(self.Lines) // lineCount // renders each sparkline and its titles - for i, line := range sl.Lines { + for i, line := range self.Lines { // prints titles - title1Y := 2 + (sl.Y/lc)*i - title2Y := (2 + (sl.Y/lc)*i) + 1 - title1 := MaxString(line.Title1, sl.X) - title2 := MaxString(line.Title2, sl.X) - buf.SetString(1, title1Y, title1, line.TitleColor|AttrBold, sl.Bg) - buf.SetString(1, title2Y, title2, line.TitleColor|AttrBold, sl.Bg) + title1Y := 2 + (self.Y/lc)*i + title2Y := (2 + (self.Y/lc)*i) + 1 + title1 := MaxString(line.Title1, self.X) + title2 := MaxString(line.Title2, self.X) + buf.SetString(1, title1Y, title1, line.TitleColor|AttrBold, self.Bg) + buf.SetString(1, title2Y, title2, line.TitleColor|AttrBold, self.Bg) - sparkY := (sl.Y / lc) * (i + 1) + sparkY := (self.Y / lc) * (i + 1) // finds max data in current view used for relative heights max := 1 - for i := len(line.Data) - 1; i >= 0 && sl.X-((len(line.Data)-1)-i) >= 1; i-- { + for i := len(line.Data) - 1; i >= 0 && self.X-((len(line.Data)-1)-i) >= 1; i-- { if line.Data[i] > max { max = line.Data[i] } } // prints sparkline - for x := sl.X; x >= 1; x-- { + for x := self.X; x >= 1; x-- { char := SPARKS[0] - if (sl.X - x) < len(line.Data) { - char = SPARKS[int((float64(line.Data[(len(line.Data)-1)-(sl.X-x)])/float64(max))*7)] + if (self.X - x) < len(line.Data) { + char = SPARKS[int((float64(line.Data[(len(line.Data)-1)-(self.X-x)])/float64(max))*7)] } - buf.SetCell(x, sparkY, Cell{char, line.LineColor, sl.Bg}) + buf.SetCell(x, sparkY, Cell{char, line.LineColor, self.Bg}) } } diff --git a/termui/table.go b/termui/table.go index 7e377d2..e24031b 100644 --- a/termui/table.go +++ b/termui/table.go @@ -22,82 +22,82 @@ type Table struct { // NewTable returns a new Table instance func NewTable() *Table { - t := &Table{ + self := &Table{ Block: NewBlock(), Cursor: Theme.TableCursor, SelectedRow: 0, TopRow: 0, UniqueCol: 0, } - t.ColResizer = t.ColResize - return t + self.ColResizer = self.ColResize + return self } // ColResize is the default column resizer, but can be overriden. // ColResize calculates the width of each column. -func (t *Table) ColResize() { +func (self *Table) ColResize() { // calculate gap size based on total width - t.Gap = 3 - if t.X < 50 { - t.Gap = 1 - } else if t.X < 75 { - t.Gap = 2 + self.Gap = 3 + if self.X < 50 { + self.Gap = 1 + } else if self.X < 75 { + self.Gap = 2 } cur := 0 - for _, w := range t.ColWidths { - cur += t.Gap - t.CellXPos = append(t.CellXPos, cur) + for _, w := range self.ColWidths { + cur += self.Gap + self.CellXPos = append(self.CellXPos, cur) cur += w } } // Buffer implements the Bufferer interface. -func (t *Table) Buffer() *Buffer { - buf := t.Block.Buffer() +func (self *Table) Buffer() *Buffer { + buf := self.Block.Buffer() // removes gap at the bottom of the current view if there is one - if t.TopRow > len(t.Rows)-(t.Y-1) { - t.TopRow = len(t.Rows) - (t.Y - 1) + if self.TopRow > len(self.Rows)-(self.Y-1) { + self.TopRow = len(self.Rows) - (self.Y - 1) } - t.ColResizer() + self.ColResizer() // prints header - for i, width := range t.ColWidths { + for i, width := range self.ColWidths { if width == 0 { break } - r := MaxString(t.Header[i], t.X-6) - buf.SetString(t.CellXPos[i], 1, r, t.Fg|AttrBold, t.Bg) + r := MaxString(self.Header[i], self.X-6) + buf.SetString(self.CellXPos[i], 1, r, self.Fg|AttrBold, self.Bg) } // prints each row - for rowNum := t.TopRow; rowNum < t.TopRow+t.Y-1 && rowNum < len(t.Rows); rowNum++ { - row := t.Rows[rowNum] - y := (rowNum + 2) - t.TopRow + for rowNum := self.TopRow; rowNum < self.TopRow+self.Y-1 && rowNum < len(self.Rows); rowNum++ { + row := self.Rows[rowNum] + y := (rowNum + 2) - self.TopRow // prints cursor - bg := t.Bg - if (t.SelectedItem == "" && rowNum == t.SelectedRow) || (t.SelectedItem != "" && t.SelectedItem == row[t.UniqueCol]) { - bg = t.Cursor - for _, width := range t.ColWidths { + bg := self.Bg + if (self.SelectedItem == "" && rowNum == self.SelectedRow) || (self.SelectedItem != "" && self.SelectedItem == row[self.UniqueCol]) { + bg = self.Cursor + for _, width := range self.ColWidths { if width == 0 { break } - buf.SetString(1, y, strings.Repeat(" ", t.X), t.Fg, bg) + buf.SetString(1, y, strings.Repeat(" ", self.X), self.Fg, bg) } - t.SelectedItem = row[t.UniqueCol] - t.SelectedRow = rowNum + self.SelectedItem = row[self.UniqueCol] + self.SelectedRow = rowNum } // prints each col of the row - for i, width := range t.ColWidths { + for i, width := range self.ColWidths { if width == 0 { break } - r := MaxString(row[i], t.X-6) - buf.SetString(t.CellXPos[i], y, r, t.Fg, bg) + r := MaxString(row[i], self.X-6) + buf.SetString(self.CellXPos[i], y, r, self.Fg, bg) } } @@ -109,71 +109,71 @@ func (t *Table) Buffer() *Buffer { ///////////////////////////////////////////////////////////////////////////////// // calcPos is used to calculate the cursor position and the current view. -func (t *Table) calcPos() { - t.SelectedItem = "" +func (self *Table) calcPos() { + self.SelectedItem = "" - if t.SelectedRow < 0 { - t.SelectedRow = 0 + if self.SelectedRow < 0 { + self.SelectedRow = 0 } - if t.SelectedRow < t.TopRow { - t.TopRow = t.SelectedRow + if self.SelectedRow < self.TopRow { + self.TopRow = self.SelectedRow } - if t.SelectedRow > len(t.Rows)-1 { - t.SelectedRow = len(t.Rows) - 1 + if self.SelectedRow > len(self.Rows)-1 { + self.SelectedRow = len(self.Rows) - 1 } - if t.SelectedRow > t.TopRow+(t.Y-2) { - t.TopRow = t.SelectedRow - (t.Y - 2) + if self.SelectedRow > self.TopRow+(self.Y-2) { + self.TopRow = self.SelectedRow - (self.Y - 2) } } -func (t *Table) Up() { - t.SelectedRow -= 1 - t.calcPos() +func (self *Table) Up() { + self.SelectedRow -= 1 + self.calcPos() } -func (t *Table) Down() { - t.SelectedRow += 1 - t.calcPos() +func (self *Table) Down() { + self.SelectedRow += 1 + self.calcPos() } -func (t *Table) Top() { - t.SelectedRow = 0 - t.calcPos() +func (self *Table) Top() { + self.SelectedRow = 0 + self.calcPos() } -func (t *Table) Bottom() { - t.SelectedRow = len(t.Rows) - 1 - t.calcPos() +func (self *Table) Bottom() { + self.SelectedRow = len(self.Rows) - 1 + self.calcPos() } -// The number of lines in a page is equal to the height of the widget. +// The number of lines in a page is equal to the height of the widgeself. -func (t *Table) HalfPageUp() { - t.SelectedRow = t.SelectedRow - (t.Y-2)/2 - t.calcPos() +func (self *Table) HalfPageUp() { + self.SelectedRow = self.SelectedRow - (self.Y-2)/2 + self.calcPos() } -func (t *Table) HalfPageDown() { - t.SelectedRow = t.SelectedRow + (t.Y-2)/2 - t.calcPos() +func (self *Table) HalfPageDown() { + self.SelectedRow = self.SelectedRow + (self.Y-2)/2 + self.calcPos() } -func (t *Table) PageUp() { - t.SelectedRow -= (t.Y - 2) - t.calcPos() +func (self *Table) PageUp() { + self.SelectedRow -= (self.Y - 2) + self.calcPos() } -func (t *Table) PageDown() { - t.SelectedRow += (t.Y - 2) - t.calcPos() +func (self *Table) PageDown() { + self.SelectedRow += (self.Y - 2) + self.calcPos() } -func (t *Table) Click(x, y int) { - x = x - t.XOffset - y = y - t.YOffset - if (x > 0 && x <= t.X) && (y > 0 && y <= t.Y) { - t.SelectedRow = (t.TopRow + y) - 2 - t.calcPos() +func (self *Table) Click(x, y int) { + x = x - self.XOffset + y = y - self.YOffset + if (x > 0 && x <= self.X) && (y > 0 && y <= self.Y) { + self.SelectedRow = (self.TopRow + y) - 2 + self.calcPos() } } diff --git a/widgets/cpu.go b/widgets/cpu.go index 9d57eba..2e6e821 100644 --- a/widgets/cpu.go +++ b/widgets/cpu.go @@ -16,43 +16,43 @@ type CPU struct { func NewCPU(interval time.Duration, zoom int) *CPU { count, _ := psCPU.Counts(false) - c := &CPU{ + self := &CPU{ LineGraph: ui.NewLineGraph(), Count: count, interval: interval, } - c.Label = "CPU Usage" - c.Zoom = zoom - if c.Count <= 8 { - for i := 0; i < c.Count; i++ { + self.Label = "CPU Usage" + self.Zoom = zoom + if self.Count <= 8 { + for i := 0; i < self.Count; i++ { key := "CPU" + strconv.Itoa(i+1) - c.Data[key] = []float64{0} + self.Data[key] = []float64{0} } } else { - c.Data["Average"] = []float64{0} + self.Data["Average"] = []float64{0} } - go c.update() - ticker := time.NewTicker(c.interval) + go self.update() + ticker := time.NewTicker(self.interval) go func() { for range ticker.C { - c.update() + self.update() } }() - return c + return self } -func (c *CPU) update() { +func (self *CPU) update() { // psutil calculates the CPU usage over a 1 second interval, therefore it blocks for 1 second - if c.Count <= 8 { - percent, _ := psCPU.Percent(c.interval, true) - for i := 0; i < c.Count; i++ { + if self.Count <= 8 { + percent, _ := psCPU.Percent(self.interval, true) + for i := 0; i < self.Count; i++ { key := "CPU" + strconv.Itoa(i+1) - c.Data[key] = append(c.Data[key], percent[i]) + self.Data[key] = append(self.Data[key], percent[i]) } } else { - percent, _ := psCPU.Percent(c.interval, false) - c.Data["Average"] = append(c.Data["Average"], percent[0]) + percent, _ := psCPU.Percent(self.interval, false) + self.Data["Average"] = append(self.Data["Average"], percent[0]) } } diff --git a/widgets/disk.go b/widgets/disk.go index cab0135..33ab3af 100644 --- a/widgets/disk.go +++ b/widgets/disk.go @@ -16,26 +16,26 @@ type Disk struct { } func NewDisk() *Disk { - d := &Disk{ + self := &Disk{ Gauge: ui.NewGauge(), fs: "/", interval: time.Second * 5, } - d.Label = "Disk Usage" + self.Label = "Disk Usage" - go d.update() - ticker := time.NewTicker(d.interval) + go self.update() + ticker := time.NewTicker(self.interval) go func() { for range ticker.C { - d.update() + self.update() } }() - return d + return self } -func (d *Disk) update() { - usage, _ := psDisk.Usage(d.fs) - d.Percent = int(usage.UsedPercent) - d.Description = fmt.Sprintf(" (%dGB free)", int(utils.BytesToGB(usage.Free))) +func (self *Disk) update() { + usage, _ := psDisk.Usage(self.fs) + self.Percent = int(usage.UsedPercent) + self.Description = fmt.Sprintf(" (%dGB free)", int(utils.BytesToGB(usage.Free))) } diff --git a/widgets/help.go b/widgets/help.go index faa64b9..1fd16d2 100644 --- a/widgets/help.go +++ b/widgets/help.go @@ -39,12 +39,12 @@ func NewHelpMenu() *HelpMenu { return &HelpMenu{block} } -func (hm *HelpMenu) Buffer() *ui.Buffer { - buf := hm.Block.Buffer() +func (self *HelpMenu) Buffer() *ui.Buffer { + buf := self.Block.Buffer() for y, line := range strings.Split(KEYBINDS, "\n") { for x, char := range line { - buf.SetCell(x+1, y, ui.NewCell(char, ui.Color(7), hm.Bg)) + buf.SetCell(x+1, y, ui.NewCell(char, ui.Color(7), self.Bg)) } } diff --git a/widgets/mem.go b/widgets/mem.go index 073d9e6..77cf146 100644 --- a/widgets/mem.go +++ b/widgets/mem.go @@ -13,29 +13,29 @@ type Mem struct { } func NewMem(interval time.Duration, zoom int) *Mem { - m := &Mem{ + self := &Mem{ LineGraph: ui.NewLineGraph(), interval: interval, } - m.Label = "Memory Usage" - m.Zoom = zoom - m.Data["Main"] = []float64{0} - m.Data["Swap"] = []float64{0} + self.Label = "Memory Usage" + self.Zoom = zoom + self.Data["Main"] = []float64{0} + self.Data["Swap"] = []float64{0} - go m.update() - ticker := time.NewTicker(m.interval) + go self.update() + ticker := time.NewTicker(self.interval) go func() { for range ticker.C { - m.update() + self.update() } }() - return m + return self } -func (m *Mem) update() { +func (self *Mem) update() { main, _ := psMem.VirtualMemory() swap, _ := psMem.SwapMemory() - m.Data["Main"] = append(m.Data["Main"], main.UsedPercent) - m.Data["Swap"] = append(m.Data["Swap"], swap.UsedPercent) + self.Data["Main"] = append(self.Data["Main"], main.UsedPercent) + self.Data["Swap"] = append(self.Data["Swap"], swap.UsedPercent) } diff --git a/widgets/net.go b/widgets/net.go index d0fa097..ee69894 100644 --- a/widgets/net.go +++ b/widgets/net.go @@ -25,46 +25,46 @@ func NewNet() *Net { sent.Data = []int{0} spark := ui.NewSparklines(recv, sent) - n := &Net{ + self := &Net{ Sparklines: spark, interval: time.Second, } - n.Label = "Network Usage" + self.Label = "Network Usage" - go n.update() - ticker := time.NewTicker(n.interval) + go self.update() + ticker := time.NewTicker(self.interval) go func() { for range ticker.C { - n.update() + self.update() } }() - return n + return self } -func (n *Net) update() { +func (self *Net) update() { // `false` causes psutil to group all network activity interfaces, _ := psNet.IOCounters(false) recvTotal := interfaces[0].BytesRecv sentTotal := interfaces[0].BytesSent - if n.recvTotal != 0 { // if this isn't the first update - recvRecent := recvTotal - n.recvTotal - sentRecent := sentTotal - n.sentTotal + if self.recvTotal != 0 { // if this isn't the first update + recvRecent := recvTotal - self.recvTotal + sentRecent := sentTotal - self.sentTotal - n.Lines[0].Data = append(n.Lines[0].Data, int(recvRecent)) - n.Lines[1].Data = append(n.Lines[1].Data, int(sentRecent)) + self.Lines[0].Data = append(self.Lines[0].Data, int(recvRecent)) + self.Lines[1].Data = append(self.Lines[1].Data, int(sentRecent)) } // used in later calls to update - n.recvTotal = recvTotal - n.sentTotal = sentTotal + self.recvTotal = recvTotal + self.sentTotal = sentTotal // renders net widget titles for i := 0; i < 2; i++ { var method string // either 'Rx' or 'Tx' var total float64 - recent := n.Lines[i].Data[len(n.Lines[i].Data)-1] + recent := self.Lines[i].Data[len(self.Lines[i].Data)-1] unitTotal := "B" unitRecent := "B" @@ -92,7 +92,7 @@ func (n *Net) update() { unitTotal = "MB" } - n.Lines[i].Title1 = fmt.Sprintf(" Total %s: %5.1f %s", method, total, unitTotal) - n.Lines[i].Title2 = fmt.Sprintf(" %s/s: %9d %2s/s", method, recent, unitRecent) + self.Lines[i].Title1 = fmt.Sprintf(" Total %s: %5.1f %s", method, total, unitTotal) + self.Lines[i].Title2 = fmt.Sprintf(" %s/s: %9d %2s/s", method, recent, unitRecent) } } diff --git a/widgets/proc.go b/widgets/proc.go index b63a7c1..c7c4369 100644 --- a/widgets/proc.go +++ b/widgets/proc.go @@ -37,7 +37,7 @@ type Proc struct { func NewProc(loaded, keyPressed chan bool) *Proc { cpuCount, _ := psCPU.Counts(false) - p := &Proc{ + self := &Proc{ Table: ui.NewTable(), interval: time.Second, cpuCount: cpuCount, @@ -45,33 +45,33 @@ func NewProc(loaded, keyPressed chan bool) *Proc { group: true, KeyPressed: keyPressed, } - p.ColResizer = p.ColResize - p.Label = "Process List" - p.ColWidths = []int{5, 10, 4, 4} + self.ColResizer = self.ColResize + self.Label = "Process List" + self.ColWidths = []int{5, 10, 4, 4} - p.UniqueCol = 0 - if p.group { - p.UniqueCol = 1 + self.UniqueCol = 0 + if self.group { + self.UniqueCol = 1 } - p.keyBinds() + self.keyBinds() go func() { - p.update() + self.update() loaded <- true }() - ticker := time.NewTicker(p.interval) + ticker := time.NewTicker(self.interval) go func() { for range ticker.C { - p.update() + self.update() } }() - return p + return self } -func (p *Proc) update() { +func (self *Proc) update() { psProcesses, _ := psProc.Processes() processes := make([]Process, len(psProcesses)) for i, psProcess := range psProcesses { @@ -83,150 +83,150 @@ func (p *Proc) update() { processes[i] = Process{ pid, command, - cpu / float64(p.cpuCount), + cpu / float64(self.cpuCount), mem, } } - p.ungroupedProcs = processes - p.groupedProcs = Group(processes) + self.ungroupedProcs = processes + self.groupedProcs = Group(processes) - p.Sort() + self.Sort() } // Sort sorts either the grouped or ungrouped []Process based on the sortMethod. // Called with every update, when the sort method is changed, and when processes are grouped and ungrouped. -func (p *Proc) Sort() { - p.Header = []string{"Count", "Command", "CPU%", "Mem%"} +func (self *Proc) Sort() { + self.Header = []string{"Count", "Command", "CPU%", "Mem%"} - if !p.group { - p.Header[0] = "PID" + if !self.group { + self.Header[0] = "PID" } - processes := &p.ungroupedProcs - if p.group { - processes = &p.groupedProcs + processes := &self.ungroupedProcs + if self.group { + processes = &self.groupedProcs } - switch p.sortMethod { + switch self.sortMethod { case "c": sort.Sort(sort.Reverse(ProcessByCPU(*processes))) - p.Header[2] += DOWN + self.Header[2] += DOWN case "p": - if p.group { + if self.group { sort.Sort(sort.Reverse(ProcessByPID(*processes))) } else { sort.Sort(ProcessByPID(*processes)) } - p.Header[0] += DOWN + self.Header[0] += DOWN case "m": sort.Sort(sort.Reverse(ProcessByMem(*processes))) - p.Header[3] += DOWN + self.Header[3] += DOWN } - p.Rows = FieldsToStrings(*processes) + self.Rows = FieldsToStrings(*processes) } // ColResize overrides the default ColResize in the termui table. -func (p *Proc) ColResize() { +func (self *Proc) ColResize() { // calculate gap size based on total width - p.Gap = 3 - if p.X < 50 { - p.Gap = 1 - } else if p.X < 75 { - p.Gap = 2 + self.Gap = 3 + if self.X < 50 { + self.Gap = 1 + } else if self.X < 75 { + self.Gap = 2 } - p.CellXPos = []int{ - p.Gap, - p.Gap + p.ColWidths[0] + p.Gap, - p.X - p.Gap - p.ColWidths[3] - p.Gap - p.ColWidths[2], - p.X - p.Gap - p.ColWidths[3], + self.CellXPos = []int{ + self.Gap, + self.Gap + self.ColWidths[0] + self.Gap, + self.X - self.Gap - self.ColWidths[3] - self.Gap - self.ColWidths[2], + self.X - self.Gap - self.ColWidths[3], } - rowWidth := p.Gap + p.ColWidths[0] + p.Gap + p.ColWidths[1] + p.Gap + p.ColWidths[2] + p.Gap + p.ColWidths[3] + p.Gap + rowWidth := self.Gap + self.ColWidths[0] + self.Gap + self.ColWidths[1] + self.Gap + self.ColWidths[2] + self.Gap + self.ColWidths[3] + self.Gap // only renders a column if it fits - if p.X < (rowWidth - p.Gap - p.ColWidths[3]) { - p.ColWidths[2] = 0 - p.ColWidths[3] = 0 - } else if p.X < rowWidth { - p.CellXPos[2] = p.CellXPos[3] - p.ColWidths[3] = 0 + if self.X < (rowWidth - self.Gap - self.ColWidths[3]) { + self.ColWidths[2] = 0 + self.ColWidths[3] = 0 + } else if self.X < rowWidth { + self.CellXPos[2] = self.CellXPos[3] + self.ColWidths[3] = 0 } } -func (p *Proc) keyBinds() { +func (self *Proc) keyBinds() { ui.On("", func(e ui.Event) { - p.Click(e.MouseX, e.MouseY) - p.KeyPressed <- true + self.Click(e.MouseX, e.MouseY) + self.KeyPressed <- true }) ui.On("", "", func(e ui.Event) { switch e.Key { case "": - p.Down() + self.Down() case "": - p.Up() + self.Up() } - p.KeyPressed <- true + self.KeyPressed <- true }) ui.On("", "", func(e ui.Event) { switch e.Key { case "": - p.Up() + self.Up() case "": - p.Down() + self.Down() } - p.KeyPressed <- true + self.KeyPressed <- true }) viKeys := []string{"j", "k", "gg", "G", "", "", "", ""} ui.On(viKeys, func(e ui.Event) { switch e.Key { case "j": - p.Down() + self.Down() case "k": - p.Up() + self.Up() case "gg": - p.Top() + self.Top() case "G": - p.Bottom() + self.Bottom() case "": - p.HalfPageDown() + self.HalfPageDown() case "": - p.HalfPageUp() + self.HalfPageUp() case "": - p.PageDown() + self.PageDown() case "": - p.PageUp() + self.PageUp() } - p.KeyPressed <- true + self.KeyPressed <- true }) ui.On("dd", func(e ui.Event) { - p.Kill() + self.Kill() }) ui.On("", func(e ui.Event) { - p.group = !p.group - if p.group { - p.UniqueCol = 1 + self.group = !self.group + if self.group { + self.UniqueCol = 1 } else { - p.UniqueCol = 0 + self.UniqueCol = 0 } - p.sortMethod = "c" - p.Sort() - p.Top() - p.KeyPressed <- true + self.sortMethod = "c" + self.Sort() + self.Top() + self.KeyPressed <- true }) ui.On("m", "c", "p", func(e ui.Event) { - if p.sortMethod != e.Key { - p.sortMethod = e.Key - p.Top() - p.Sort() - p.KeyPressed <- true + if self.sortMethod != e.Key { + self.sortMethod = e.Key + self.Top() + self.Sort() + self.KeyPressed <- true } }) } @@ -279,13 +279,13 @@ func FieldsToStrings(P []Process) [][]string { } // Kill kills process or group of processes. -func (p *Proc) Kill() { - p.SelectedItem = "" +func (self *Proc) Kill() { + self.SelectedItem = "" command := "kill" - if p.UniqueCol == 1 { + if self.UniqueCol == 1 { command = "pkill" } - cmd := exec.Command(command, p.Rows[p.SelectedRow][p.UniqueCol]) + cmd := exec.Command(command, self.Rows[self.SelectedRow][self.UniqueCol]) cmd.Start() } diff --git a/widgets/temp.go b/widgets/temp.go index c630613..a29bcb2 100644 --- a/widgets/temp.go +++ b/widgets/temp.go @@ -23,60 +23,60 @@ type Temp struct { } func NewTemp() *Temp { - t := &Temp{ + self := &Temp{ Block: ui.NewBlock(), interval: time.Second * 5, Data: make(map[string]int), Threshold: 80, // temp at which color should change } - t.Label = "Temperatures" + self.Label = "Temperatures" - go t.update() - ticker := time.NewTicker(t.interval) + go self.update() + ticker := time.NewTicker(self.interval) go func() { for range ticker.C { - t.update() + self.update() } }() - return t + return self } -func (t *Temp) update() { +func (self *Temp) update() { sensors, _ := psHost.SensorsTemperatures() for _, sensor := range sensors { // only sensors with input in their name are giving us live temp info if strings.Contains(sensor.SensorKey, "input") { // removes '_input' from the end of the sensor name label := sensor.SensorKey[:strings.Index(sensor.SensorKey, "_input")] - t.Data[label] = int(sensor.Temperature) + self.Data[label] = int(sensor.Temperature) } } } // Buffer implements ui.Bufferer interface. -func (t *Temp) Buffer() *ui.Buffer { - buf := t.Block.Buffer() +func (self *Temp) Buffer() *ui.Buffer { + buf := self.Block.Buffer() var keys []string - for k := range t.Data { + for k := range self.Data { keys = append(keys, k) } sort.Strings(keys) for y, key := range keys { - if y+1 > t.Y { + if y+1 > self.Y { break } - fg := t.TempLow - if t.Data[key] >= t.Threshold { - fg = t.TempHigh + fg := self.TempLow + if self.Data[key] >= self.Threshold { + fg = self.TempHigh } - s := ui.MaxString(key, (t.X - 4)) - buf.SetString(1, y+1, s, t.Fg, t.Bg) - buf.SetString(t.X-2, y+1, fmt.Sprintf("%dC", t.Data[key]), fg, t.Bg) + s := ui.MaxString(key, (self.X - 4)) + buf.SetString(1, y+1, s, self.Fg, self.Bg) + buf.SetString(self.X-2, y+1, fmt.Sprintf("%dC", self.Data[key]), fg, self.Bg) }