Change methods to use 'self' keyword

7 files changed, 162 insertions, 162 deletions

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("<MouseLeft>", func(e ui.Event) {
-		p.Click(e.MouseX, e.MouseY)
-		p.KeyPressed <- true
+		self.Click(e.MouseX, e.MouseY)
+		self.KeyPressed <- true
 	})
 
 	ui.On("<MouseWheelUp>", "<MouseWheelDown>", func(e ui.Event) {
 		switch e.Key {
 		case "<MouseWheelDown>":
-			p.Down()
+			self.Down()
 		case "<MouseWheelUp>":
-			p.Up()
+			self.Up()
 		}
-		p.KeyPressed <- true
+		self.KeyPressed <- true
 	})
 
 	ui.On("<up>", "<down>", func(e ui.Event) {
 		switch e.Key {
 		case "<up>":
-			p.Up()
+			self.Up()
 		case "<down>":
-			p.Down()
+			self.Down()
 		}
-		p.KeyPressed <- true
+		self.KeyPressed <- true
 	})
 
 	viKeys := []string{"j", "k", "gg", "G", "<C-d>", "<C-u>", "<C-f>", "<C-b>"}
 	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 "<C-d>":
-			p.HalfPageDown()
+			self.HalfPageDown()
 		case "<C-u>":
-			p.HalfPageUp()
+			self.HalfPageUp()
 		case "<C-f>":
-			p.PageDown()
+			self.PageDown()
 		case "<C-b>":
-			p.PageUp()
+			self.PageUp()
 		}
-		p.KeyPressed <- true
+		self.KeyPressed <- true
 	})
 
 	ui.On("dd", func(e ui.Event) {
-		p.Kill()
+		self.Kill()
 	})
 
 	ui.On("<tab>", 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)
 
 	}