pterm

README

💻 PTerm | Pretty Terminal Printer

A golang module to print pretty text

Show Demo Code

---

PTerm.sh | Installation | Documentation | Quick Start | Examples | Q&A | Contributing

---

📦 Installation

To make PTerm available in your project, you can run the following command.
Make sure to run this command inside your project, when you're using go modules 😉

go get github.com/avissian/pterm

🥅 Goal of PTerm

PTerm is designed to create a platform independent way to create beautiful terminal output. Most modules that want to improve the terminal output do not guarantee platform independence - PTerm does. PTerm follows the most common methods for displaying color in a terminal. With PTerm, it is possible to create beautiful output even in low-level environments.

• 🪀 Easy to use

Our first priority is to keep PTerm as easy to use as possible. With many examples for each individual component, getting started with PTerm is extremely easy. All components are similar in design and implement interfaces to simplify mixing individual components together.

• 🤹‍♀️ Cross-Platform

We take special precautions to ensure that PTerm works on as many operating systems and terminals as possible. Whether it's Windows CMD, macOS iTerm2 or in the backend (for example inside a GitHub Action or other CI systems), PTerm guarantees beautiful output!

PTerm is actively tested on Windows, Linux (Debian & Ubuntu) and macOS.

• ⭐ Main Features

Feature	Example	Docs	-	Feature	Example	Docs
Bar Charts	Example	Docs	-	RGB	Example	Docs
BigText	Example	Docs	-	Sections	Example	Docs
Boxed	Example	Docs	-	Spinners	Example	Docs
Bullet Lists	Example	Docs	-	Trees	Example	Docs
Centered	Example	Docs	-	Theming	Example	Docs
Colors	Example	Docs	-	Tables	Example	Docs
Headers	Example	Docs	-	Styles	Example	Docs
Panels	Example	Docs	-
Paragraphs	Example	Docs	-
Prefixes	Example	Docs	-
Progress Bars	Example	Docs	-

• 🧪 Well tested

PTerm has a 100% test coverage, which means that every line of code inside PTerm gets tested automatically

We test PTerm continuously. However, since a human cannot test everything all the time, we have our own test system with which we currently run 5455 automated tests to ensure that PTerm has no bugs.

• ✨ Consistent Colors

PTerm uses the ANSI color scheme which is widely used by terminals to ensure consistent colors in different terminal themes. If that's not enough, PTerm can be used to access the full RGB color scheme (16 million colors) in terminals that support TrueColor.

• 📚 Component system

PTerm consists of many components, called Printers, which can be used individually or together to generate pretty console output.

• 🛠 Configurable

PTerm can be used by without any configuration. However, you can easily configure each component with little code, so everyone has the freedom to design their own terminal output.

⚠ NOTICE

PTerm is currently under development. It is very likely that not all things will remain as they are at the moment. However, PTerm is still functional. The versioning of PTerm follows the SemVer guidelines. Breaking Changes are explicitly mentioned in the changelogs and the version will be increased accordingly. Everybody is welcome to improve PTerm, whether by making suggestions or pull requests. Thanks ❤

If you want to wait for a stable release, make sure to star the project and follow it, to get notified when we release v1.0.0 (stable) 🚀

✏ Documentation

To view the official documentation of the latest release, you can go to the automatically generated page of pkg.go.dev This documentation is very technical and includes every method that can be used in PTerm.

For an easy start we recommend that you take a look at the examples section. Here you can see pretty much every feature of PTerm with its source code. The animations of the examples are automatically updated as soon as something changes in PTerm.

Have fun exploring this project 🚀

💖 Contributing

If you have found a bug or want to suggest a feature, you can do so here by opening a new issue.

If you want to contribute to the development of PTerm, you are very welcome to do so. Our contribution guidelines can be found here.

💕 Support

If you want to support me in further developing my open source projects, you can give me a little tip 😄
Your financial support enables me to focus more on my projects. Thank you very much!

🧪 Examples

You can find all the examples, with their source code, here: ./_examples

barchart

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	bars := pterm.Bars{
		pterm.Bar{
			Label: "Bar 1",
			Value: 5,
		},
		pterm.Bar{
			Label: "Bar 2",
			Value: 3,
		},
		pterm.Bar{
			Label: "Longer Label",
			Value: 7,
		},
	}

	_ = pterm.DefaultBarChart.WithBars(bars).Render()
	_ = pterm.DefaultBarChart.WithHorizontal().WithBars(bars).Render()
}

bigtext

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print a large text with the LetterStyle from the standard theme.
	// Useful for title screens.
	pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString("PTerm")).Render()

	// Print a large text with differently colored letters.
	pterm.DefaultBigText.WithLetters(
		pterm.NewLettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgCyan)),
		pterm.NewLettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
		Render()
}

box

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	pterm.Info.Println("This might not be rendered correctly on GitHub, but it will work in a real terminal.\nThis is because GitHub does not use a monospaced font by default for SVGs.")

	panel1 := pterm.DefaultBox.Sprint("Lorem ipsum dolor sit amet,\nconsectetur adipiscing elit,\nsed do eiusmod tempor incididunt\nut labore et dolore\nmagna aliqua.")
	panel2 := pterm.DefaultBox.Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
	panel3 := pterm.DefaultBox.Sprint("Duis aute irure\ndolor in reprehenderit\nin voluptate velit esse cillum\ndolore eu fugiat\nnulla pariatur.")

	panels, _ := pterm.DefaultPanel.WithPanels(pterm.Panels{
		{{Data: panel1}, {Data: panel2}},
		{{Data: panel3}},
	}).Srender()

	pterm.DefaultBox.WithRightPadding(0).WithBottomPadding(0).Println(panels)
}

bulletlist

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print a list with different levels.
	// Useful to generate lists automatically from data.
	pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
		{Level: 0, Text: "Level 0"},
		{Level: 1, Text: "Level 1"},
		{Level: 2, Text: "Level 2"},
	}).Render()

	// Convert a text to a list and print it.
	pterm.NewBulletListFromString(`0
 1
  2
   3`, " ").Render()
}

bulletlist-custom

SHOW SOURCE

package main

import (
	"github.com/avissian/pterm"
)

func main() {
	// Print a customized list with different styles and levels.
	pterm.DefaultBulletList.WithItems([]pterm.BulletListItem{
		{Level: 0, Text: "Blue", TextStyle: pterm.NewStyle(pterm.FgBlue), BulletStyle: pterm.NewStyle(pterm.FgRed)},
		{Level: 1, Text: "Green", TextStyle: pterm.NewStyle(pterm.FgGreen), Bullet: "-", BulletStyle: pterm.NewStyle(pterm.FgLightWhite)},
		{Level: 2, Text: "Cyan", TextStyle: pterm.NewStyle(pterm.FgCyan), Bullet: ">", BulletStyle: pterm.NewStyle(pterm.FgYellow)},
	}).Render()
}

center

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	pterm.DefaultCenter.Println("This text is centered!\nIt centeres the whole block by default.\nIn that way you can do stuff like this:")

	// Generate BigLetters
	s, _ := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString("PTerm")).Srender()
	pterm.DefaultCenter.Println(s) // Print BigLetters with the default CenterPrinter

	pterm.DefaultCenter.WithCenterEachLineSeparately().Println("This text is centered!\nBut each line is\ncentered\nseparately")
}

demo

SHOW SOURCE

package main

import (
	"math/rand"
	"strconv"
	"strings"
	"time"

	"github.com/avissian/pterm"
)

// Change this to time.Millisecond*200 to speed up the demo.
// Useful when debugging.
const second = time.Second

var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
	"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")

func main() {
	introScreen()
	clear()
	pseudoApplicationHeader()
	time.Sleep(second)
	installingPseudoList()
	time.Sleep(second * 2)
	pterm.DefaultSection.WithLevel(2).Println("Program Install Report")
	installedProgramsSize()
	time.Sleep(second * 4)
	pterm.DefaultSection.Println("Tree Printer")
	installedTree()
	time.Sleep(second * 4)
	pterm.DefaultSection.Println("TrueColor Support")
	fadeText()
	time.Sleep(second)
	pterm.DefaultSection.Println("Bullet List Printer")
	listPrinter()
}

func installedTree() {
	leveledList := pterm.LeveledList{
		pterm.LeveledListItem{Level: 0, Text: "C:"},
		pterm.LeveledListItem{Level: 1, Text: "Go"},
		pterm.LeveledListItem{Level: 1, Text: "Windows"},
		pterm.LeveledListItem{Level: 1, Text: "Programs"},
	}
	for _, s := range pseudoProgramList {
		if s != "pseudo-minecraft" {
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 2, Text: s})
		}
		if s == "pseudo-chrome" {
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 3, Text: "pseudo-Tabs"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 3, Text: "pseudo-Extensions"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 4, Text: "Refined GitHub"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 4, Text: "GitHub Dark Theme"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 3, Text: "pseudo-Bookmarks"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 4, Text: "PTerm"})
		}
	}

	pterm.DefaultTree.WithRoot(pterm.NewTreeFromLeveledList(leveledList)).Render()
}

func installingPseudoList() {
	pterm.DefaultSection.Println("Installing pseudo programs")

	p, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
	for i := 0; i < p.Total; i++ {
		p.Title = "Installing " + pseudoProgramList[i]
		if pseudoProgramList[i] == "pseudo-minecraft" {
			pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
		} else {
			pterm.Success.Println("Installing " + pseudoProgramList[i])
			p.Increment()
		}
		time.Sleep(second / 2)
	}
	p.Stop()
}

func listPrinter() {
	pterm.NewBulletListFromString(`Good bye
 Have a nice day!`, " ").Render()
}

func fadeText() {
	from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
	to := pterm.NewRGB(255, 0, 255)   // This RGB value is used as the gradients first point.

	str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)"
	strs := strings.Split(str, "")
	var fadeInfo string // String which will be used to print info.
	// For loop over the range of the string length.
	for i := 0; i < len(str); i++ {
		// Append faded letter to info string.
		fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
	}
	pterm.Info.Println(fadeInfo)
}

func installedProgramsSize() {
	d := pterm.TableData{{"Program Name", "Status", "Size"}}
	for _, s := range pseudoProgramList {
		if s != "pseudo-minecraft" {
			d = append(d, []string{s, pterm.LightGreen("pass"), strconv.Itoa(randomInt(7, 200)) + "mb"})
		} else {
			d = append(d, []string{pterm.LightRed(s), pterm.LightRed("fail"), "0mb"})
		}
	}
	pterm.DefaultTable.WithHasHeader().WithData(d).Render()
}

func pseudoApplicationHeader() *pterm.TextPrinter {
	return pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Println(
		"Pseudo Application created with PTerm")
}

func introScreen() {
	ptermLogo, _ := pterm.DefaultBigText.WithLetters(
		pterm.NewLettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
		pterm.NewLettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
		Srender()

	pterm.DefaultCenter.Print(ptermLogo)

	pterm.DefaultCenter.Print(pterm.DefaultHeader.WithFullWidth().WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Sprint("PTDP - PTerm Demo Program"))

	pterm.Info.Println("This animation was generated with the latest version of PTerm!" +
		"\nPTerm works on nearly every terminal and operating system." +
		"\nIt's super easy to use!" +
		"\nIf you want, you can customize everything :)" +
		"\nYou can see the code of this demo in the " + pterm.LightMagenta("./_examples/demo") + " directory." +
		"\n" +
		"\nThis demo was updated at: " + pterm.Green(time.Now().Format("02 Jan 2006 - 15:04:05 MST")))
	pterm.Println()
	introSpinner, _ := pterm.DefaultSpinner.WithRemoveWhenDone(true).Start("Waiting for 15 seconds...")
	time.Sleep(second)
	for i := 14; i > 0; i-- {
		if i > 1 {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " seconds...")
		} else {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " second...")
		}
		time.Sleep(second)
	}
	introSpinner.Stop()
}

func clear() {
	print("\033[H\033[2J")
}

func randomInt(min, max int) int {
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(max-min+1) + min
}

disable-color

SHOW SOURCE

package main

import (
	"math/rand"
	"strconv"
	"strings"
	"time"

	"github.com/avissian/pterm"
)

// Change this to time.Millisecond*200 to speed up the demo.
// Useful when debugging.
const second = time.Second

var pseudoProgramList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
	"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")

func main() {
	pterm.DisableColor()
	introScreen()
	clear()
	pseudoApplicationHeader()
	time.Sleep(second)
	installingPseudoList()
	time.Sleep(second * 2)
	pterm.DefaultSection.WithLevel(2).Println("Program Install Report")
	installedProgramsSize()
	time.Sleep(second * 4)
	pterm.DefaultSection.Println("Tree Printer")
	installedTree()
	time.Sleep(second * 4)
	pterm.DefaultSection.Println("TrueColor Support")
	fadeText()
	time.Sleep(second)
	pterm.DefaultSection.Println("Bullet List Printer")
	listPrinter()
}

func installedTree() {
	leveledList := pterm.LeveledList{
		pterm.LeveledListItem{Level: 0, Text: "C:"},
		pterm.LeveledListItem{Level: 1, Text: "Go"},
		pterm.LeveledListItem{Level: 1, Text: "Windows"},
		pterm.LeveledListItem{Level: 1, Text: "Programs"},
	}
	for _, s := range pseudoProgramList {
		if s != "pseudo-minecraft" {
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 2, Text: s})
		}
		if s == "pseudo-chrome" {
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 3, Text: "pseudo-Tabs"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 3, Text: "pseudo-Extensions"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 4, Text: "Refined GitHub"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 4, Text: "GitHub Dark Theme"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 3, Text: "pseudo-Bookmarks"})
			leveledList = append(leveledList, pterm.LeveledListItem{Level: 4, Text: "PTerm"})
		}
	}

	pterm.DefaultTree.WithRoot(pterm.NewTreeFromLeveledList(leveledList)).Render()
}

func installingPseudoList() {
	pterm.DefaultSection.Println("Installing pseudo programs")

	p, _ := pterm.DefaultProgressbar.WithTotal(len(pseudoProgramList)).WithTitle("Installing stuff").Start()
	for i := 0; i < p.Total; i++ {
		p.Title = "Installing " + pseudoProgramList[i]
		if pseudoProgramList[i] == "pseudo-minecraft" {
			pterm.Warning.Println("Could not install pseudo-minecraft\nThe company policy forbids games.")
		} else {
			pterm.Success.Println("Installing " + pseudoProgramList[i])
			p.Increment()
		}
		time.Sleep(second / 2)
	}
	p.Stop()
}

func listPrinter() {
	pterm.NewBulletListFromString(`Good bye
 Have a nice day!`, " ").Render()
}

func fadeText() {
	from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
	to := pterm.NewRGB(255, 0, 255)   // This RGB value is used as the gradients first point.

	str := "If your terminal has TrueColor support, you can use RGB colors!\nYou can even fade them :)"
	strs := strings.Split(str, "")
	var fadeInfo string // String which will be used to print info.
	// For loop over the range of the string length.
	for i := 0; i < len(str); i++ {
		// Append faded letter to info string.
		fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
	}
	pterm.Info.Println(fadeInfo)
}

func installedProgramsSize() {
	d := pterm.TableData{{"Program Name", "Status", "Size"}}
	for _, s := range pseudoProgramList {
		if s != "pseudo-minecraft" {
			d = append(d, []string{s, pterm.LightGreen("pass"), strconv.Itoa(randomInt(7, 200)) + "mb"})
		} else {
			d = append(d, []string{pterm.LightRed(s), pterm.LightRed("fail"), "0mb"})
		}
	}
	pterm.DefaultTable.WithHasHeader().WithData(d).Render()
}

func pseudoApplicationHeader() *pterm.TextPrinter {
	return pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Println(
		"Pseudo Application created with PTerm")
}

func introScreen() {
	pterm.DefaultBigText.WithLetters(
		pterm.NewLettersFromStringWithStyle("P", pterm.NewStyle(pterm.FgLightCyan)),
		pterm.NewLettersFromStringWithStyle("Term", pterm.NewStyle(pterm.FgLightMagenta))).
		Render()

	pterm.DefaultHeader.WithBackgroundStyle(pterm.NewStyle(pterm.BgLightBlue)).WithMargin(10).Println(
		"PTDP - PTerm Demo Program")

	pterm.Info.Println("This animation was generated with the latest version of PTerm!" +
		"\nPTerm works on nearly every terminal and operating system." +
		"\nIt's super easy to use!" +
		"\nIf you want, you can customize everything :)" +
		"\nYou can see the code of this demo in the " + pterm.LightMagenta("./_examples/demo") + " directory." +
		"\n" +
		"\nThis demo was updated at: " + pterm.Green(time.Now().Format("02 Jan 2006 - 15:04:05 MST")))
	pterm.Println()
	introSpinner, _ := pterm.DefaultSpinner.WithRemoveWhenDone(true).Start("Waiting for 15 seconds...")
	time.Sleep(second)
	for i := 14; i > 0; i-- {
		if i > 1 {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " seconds...")
		} else {
			introSpinner.UpdateText("Waiting for " + strconv.Itoa(i) + " second...")
		}
		time.Sleep(second)
	}
	introSpinner.Stop()
}

func clear() {
	print("\033[H\033[2J")
}

func randomInt(min, max int) int {
	rand.Seed(time.Now().UnixNano())
	return rand.Intn(max-min+1) + min
}

disable-output

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	for i := 0; i < 15; i++ {
		switch i {
		case 5:
			pterm.Info.Println("Disabled Output!")
			pterm.DisableOutput()
		case 10:
			pterm.EnableOutput()
			pterm.Info.Println("Enabled Output!")
		}

		pterm.Printf("Printing something... [%d/%d]\n", i, 15)
	}
}

header

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print a default header.
	pterm.DefaultHeader.Println("This is the default header!")
}

header-custom

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// All available options: https://pkg.go.dev/github.com/avissian/pterm#HeaderPrinter

	// Build on top of DefaultHeader
	pterm.DefaultHeader. // Use DefaultHeader as base
				WithMargin(15).
				WithBackgroundStyle(pterm.NewStyle(pterm.BgCyan)).
				WithTextStyle(pterm.NewStyle(pterm.FgBlack)).
				Println("This is a custom header!")
	// Instead of printing the header you can set it to a variable.
	// You can then reuse your custom header.

	// Making a completely new HeaderPrinter
	newHeader := pterm.HeaderPrinter{
		TextStyle:       pterm.NewStyle(pterm.FgBlack),
		BackgroundStyle: pterm.NewStyle(pterm.BgRed),
		Margin:          20,
	}

	// Print header.
	newHeader.Println("This is a custom header!")
}

override-default-printers

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print default error.
	pterm.Error.Println("This is the default Error")

	// Customize default error.
	pterm.Error.Prefix = pterm.Prefix{
		Text:  "OVERRIDE",
		Style: pterm.NewStyle(pterm.BgCyan, pterm.FgRed),
	}

	// Print new default error.
	pterm.Error.Println("This is the default Error after the prefix was overridden")
}

panel

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Declare panels in a two dimensional grid system.
	panels := pterm.Panels{
		{{Data: "This is the first panel"}, {Data: pterm.DefaultHeader.Sprint("Hello, World!")}, {Data: "This\npanel\ncontains\nmultiple\nlines"}},
		{{Data: pterm.Red("This is another\npanel line")}, {Data: "This is the second panel\nwith a new line"}},
	}

	// Print panels.
	_ = pterm.DefaultPanel.WithPanels(panels).WithPadding(5).Render()
}

paragraph

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print long text with default paragraph printer.
	pterm.DefaultParagraph.Println("This is the default paragraph printer. As you can see, no words are separated, " +
		"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")

	// Print one line space.
	pterm.Println()

	// Print long text without paragraph printer.
	pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}

paragraph-custom

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print a paragraph with a custom maximal width.
	pterm.DefaultParagraph.WithMaxWidth(60).Println("This is a custom paragraph printer. As you can see, no words are separated, " +
		"but the text is split at the spaces. This is useful for continuous text of all kinds. You can manually change the line width if you want to." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")

	// Print one line space.
	pterm.Println()

	// Print text without a paragraph printer.
	pterm.Println("This text is written with the default Println() function. No intelligent splitting here." +
		"Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam")
}

prefix

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Enable debug messages.
	pterm.EnableDebugMessages()

	pterm.Debug.Println("Hello, World!")                                                // Print Debug.
	pterm.Info.Println("Hello, World!")                                                 // Print Info.
	pterm.Success.Println("Hello, World!")                                              // Print Success.
	pterm.Warning.Println("Hello, World!")                                              // Print Warning.
	pterm.Error.Println("Errors show the filename and linenumber inside the terminal!") // Print Error.
	pterm.Info.WithShowLineNumber().Println("Other PrefixPrinters can do that too!")    // Print Error.
	// Temporarily set Fatal to false, so that the CI won't crash.
	pterm.Fatal.WithFatal(false).Println("Hello, World!") // Print Fatal.
}

print-basic-text

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// A BasicText printer is used to print text, without special formatting.
	// As it implements the TextPrinter interface, you can use it in combination with other printers.
	pterm.DefaultBasicText.Println("Default basic text printer.")
	pterm.DefaultBasicText.Println("Can be used in any" + pterm.LightMagenta(" TextPrinter ") + "context.")
	pterm.DefaultBasicText.Println("For example to resolve progressbars and spinners.")
	// If you just want to print text, you should use this instead:
	// 	pterm.Println("Hello, World!")
}

print-color-fade

SHOW SOURCE

package main

import (
	"github.com/avissian/pterm"
)

func main() {
	// Print info.
	pterm.Info.Println("RGB colors only work in Terminals which support TrueColor.")

	from := pterm.NewRGB(0, 255, 255) // This RGB value is used as the gradients start point.
	to := pterm.NewRGB(255, 0, 255)   // This RGB value is used as the gradients end point.

	// For loop over the range of the terminal height.
	for i := 0; i < pterm.GetTerminalHeight()-2; i++ {
		// Print string which is colored with the faded RGB value.
		from.Fade(0, float32(pterm.GetTerminalHeight()-2), float32(i), to).Println("Hello, World!")
	}
}

print-color-fade-multiple

SHOW SOURCE

package main

import (
	"strings"

	"github.com/avissian/pterm"
)

func main() {
	from := pterm.NewRGB(0, 255, 255)  // This RGB value is used as the gradients start point.
	to := pterm.NewRGB(255, 0, 255)    // This RGB value is used as the gradients first point.
	to2 := pterm.NewRGB(255, 0, 0)     // This RGB value is used as the gradients second point.
	to3 := pterm.NewRGB(0, 255, 0)     // This RGB value is used as the gradients third point.
	to4 := pterm.NewRGB(255, 255, 255) // This RGB value is used as the gradients end point.

	str := "RGB colors only work in Terminals which support TrueColor."
	strs := strings.Split(str, "")
	var fadeInfo string // String which will be used to print info.
	// For loop over the range of the string length.
	for i := 0; i < len(str); i++ {
		// Append faded letter to info string.
		fadeInfo += from.Fade(0, float32(len(str)), float32(i), to).Sprint(strs[i])
	}

	// Print info.
	pterm.Info.Println(fadeInfo)

	// For loop over the range of the terminal height.
	for i := 0; i < pterm.GetTerminalHeight()-2; i++ {
		// Print string which is colored with the faded RGB value.
		from.Fade(0, float32(pterm.GetTerminalHeight()-2), float32(i), to, to2, to3, to4).Println("Hello, World!")
	}
}

print-color-rgb

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print strings with a custom RGB color.
	// NOTICE: This only works with terminals which support TrueColor.
	pterm.NewRGB(178, 44, 199).Println("This text is printed with a custom RGB!")
	pterm.NewRGB(15, 199, 209).Println("This text is printed with a custom RGB!")
	pterm.NewRGB(201, 144, 30).Println("This text is printed with a custom RGB!")
}

print-with-color

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print different colored words.
	pterm.Println(pterm.Red("Hello, ") + pterm.Green("World") + pterm.Cyan("!"))
	pterm.Println(pterm.Red("Even " + pterm.Cyan("nested ") + pterm.Green("colors ") + "are supported!"))

	// Print strings with set color.
	pterm.FgBlack.Println("FgBlack")
	pterm.FgRed.Println("FgRed")
	pterm.FgGreen.Println("FgGreen")
	pterm.FgYellow.Println("FgYellow")
	pterm.FgBlue.Println("FgBlue")
	pterm.FgMagenta.Println("FgMagenta")
	pterm.FgCyan.Println("FgCyan")
	pterm.FgWhite.Println("FgWhite")
	pterm.Println() // Print one line space.
	pterm.FgLightRed.Println("FgLightRed")
	pterm.FgLightGreen.Println("FgLightGreen")
	pterm.FgLightYellow.Println("FgLightYellow")
	pterm.FgLightBlue.Println("FgLightBlue")
	pterm.FgLightMagenta.Println("FgLightMagenta")
	pterm.FgLightCyan.Println("FgLightCyan")
	pterm.FgLightWhite.Println("FgLightWhite")
}

progressbar

SHOW SOURCE

package main

import (
	"strings"
	"time"

	"github.com/avissian/pterm"
)

// Slice of strings with placeholder text.
var fakeInstallList = strings.Split("pseudo-excel pseudo-photoshop pseudo-chrome pseudo-outlook pseudo-explorer "+
	"pseudo-dops pseudo-git pseudo-vsc pseudo-intellij pseudo-minecraft pseudo-scoop pseudo-chocolatey", " ")

func main() {
	// Create progressbar as fork from the default progressbar.
	p, _ := pterm.DefaultProgressbar.WithTotal(len(fakeInstallList)).WithTitle("Downloading stuff").Start()

	for i := 0; i < p.Total; i++ {
		p.Title = "Downloading " + fakeInstallList[i]              // Update the title of the progressbar.
		pterm.Success.Println("Downloading " + fakeInstallList[i]) // If a progressbar is running, each print will be printed above the progressbar.
		p.Increment()                                              // Increment the progressbar by one. Use Add(x int) to increment by a custom amount.
		time.Sleep(time.Millisecond * 350)                         // Sleep 350 milliseconds.
	}
}

section

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Print a section with level one.
	pterm.DefaultSection.Println("This is a section!")
	// Print placeholder.
	pterm.Info.Println("And here is some text.\nThis text could be anything.\nBasically it's just a placeholder")

	// Print a section with level two.
	pterm.DefaultSection.WithLevel(2).Println("This is another section!")
	// Print placeholder.
	pterm.Info.Println("And this is\nmore placeholder text")
}

spinner

SHOW SOURCE

package main

import (
	"time"

	"github.com/avissian/pterm"
)

func main() {
	// Create and start a fork of the default spinner.
	spinnerSuccess, _ := pterm.DefaultSpinner.Start("Doing something important... (will succeed)")
	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something.
	spinnerSuccess.Success()    // Resolve spinner with success message.

	// Create and start a fork of the default spinner.
	spinnerWarning, _ := pterm.DefaultSpinner.Start("Doing something important... (will warn)")
	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something.
	spinnerWarning.Warning()    // Resolve spinner with warning message.

	// Create and start a fork of the default spinner.
	spinnerFail, _ := pterm.DefaultSpinner.Start("Doing something important... (will fail)")
	time.Sleep(time.Second * 3) // Simulate 3 seconds of processing something.
	spinnerFail.Fail()          // Resolve spinner with error message.

	// Create and start a fork of the default spinner.
	spinnerLiveText, _ := pterm.DefaultSpinner.Start("Doing a lot of stuff...")
	time.Sleep(time.Second * 2)                      // Simulate 2 seconds of processing something.
	spinnerLiveText.UpdateText("It's really much")   // Update spinner text.
	time.Sleep(time.Second * 2)                      // Simulate 2 seconds of processing something.
	spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
	time.Sleep(time.Second * 2)                      // Simulate 2 seconds of processing something.
	spinnerLiveText.Success("Finally!")              // Resolve spinner with success message.
}

style

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Create styles as new variables
	primary := pterm.NewStyle(pterm.FgLightCyan, pterm.BgGray, pterm.Bold)
	secondary := pterm.NewStyle(pterm.FgLightGreen, pterm.BgWhite, pterm.Italic)

	// Use created styles
	primary.Println("Hello, World!")
	secondary.Println("Hello, World!")
}

table

SHOW SOURCE

package main

import "github.com/avissian/pterm"

func main() {
	// Create a fork of the default table, fill it with data and print it.
	// Data can also be generated and inserted later.
	pterm.DefaultTable.WithHasHeader().WithData(pterm.TableData{
		{"Firstname", "Lastname", "Email"},
		{"Paul", "Dean", "nisi.dictum.augue@velitAliquam.co.uk"},
		{"Callie", "Mckay", "egestas.nunc.sed@est.com"},
		{"Libby", "Camacho", "aliquet.lobortis@semper.com"},
	}).Render()
}

theme

SHOW SOURCE

package main

import (
	"github.com/avissian/pterm"
	"reflect"
	"time"
)

func main() {
	// Print info.
	pterm.Info.Println("These are the default theme styles.\n" +
		"You can modify them easily to your personal preference,\n" +
		"or create new themes from scratch :)")

	pterm.Println() // Print one line space.

	// Print every value of the default theme with its own style.
	v := reflect.ValueOf(pterm.ThemeDefault)
	typeOfS := v.Type()

	if typeOfS == reflect.TypeOf(pterm.Theme{}) {
		for i := 0; i < v.NumField(); i++ {
			field, ok := v.Field(i).Interface().(pterm.Style)
			if ok {
				field.Println(typeOfS.Field(i).Name)
			}
			time.Sleep(time.Millisecond * 250)
		}
	}
}

tree

SHOW SOURCE

package main

import (
	"github.com/avissian/pterm"
)

func main() {
	// You can use a LeveledList here, for easy generation.
	leveledList := pterm.LeveledList{
		pterm.LeveledListItem{Level: 0, Text: "C:"},
		pterm.LeveledListItem{Level: 1, Text: "Users"},
		pterm.LeveledListItem{Level: 1, Text: "Windows"},
		pterm.LeveledListItem{Level: 1, Text: "Programs"},
		pterm.LeveledListItem{Level: 1, Text: "Programs(x86)"},
		pterm.LeveledListItem{Level: 1, Text: "dev"},
		pterm.LeveledListItem{Level: 0, Text: "D:"},
		pterm.LeveledListItem{Level: 0, Text: "E:"},
		pterm.LeveledListItem{Level: 1, Text: "Movies"},
		pterm.LeveledListItem{Level: 1, Text: "Music"},
		pterm.LeveledListItem{Level: 2, Text: "LinkinPark"},
		pterm.LeveledListItem{Level: 1, Text: "Games"},
		pterm.LeveledListItem{Level: 2, Text: "Shooter"},
		pterm.LeveledListItem{Level: 3, Text: "CallOfDuty"},
		pterm.LeveledListItem{Level: 3, Text: "CS:GO"},
		pterm.LeveledListItem{Level: 3, Text: "Battlefield"},
		pterm.LeveledListItem{Level: 4, Text: "Battlefield 1"},
		pterm.LeveledListItem{Level: 4, Text: "Battlefield 2"},
		pterm.LeveledListItem{Level: 0, Text: "F:"},
		pterm.LeveledListItem{Level: 1, Text: "dev"},
		pterm.LeveledListItem{Level: 2, Text: "dops"},
		pterm.LeveledListItem{Level: 2, Text: "PTerm"},
	}

	// Generate tree from LeveledList.
	root := pterm.NewTreeFromLeveledList(leveledList)

	// Render TreePrinter
	pterm.DefaultTree.WithRoot(root).Render()
}

---

GitHub @pterm  ·  Author @MarvinJWendt | PTerm.sh

Documentation

Overview

Package pterm is a modern go module to beautify console output. It can be used without configuration, but if desired, everything can be customized down to the smallest detail. View the animated examples here: https://github.com/avissian/pterm#-examples

Index

• Variables
• func DisableColor()
• func DisableDebugMessages()
• func DisableOutput()
• func EnableColor()
• func EnableDebugMessages()
• func EnableOutput()
• func Fprint(writer io.Writer, a ...interface{})
• func Fprintln(writer io.Writer, a ...interface{})
• func Fprinto(w io.Writer, a ...interface{})
• func GetTerminalHeight() int
• func GetTerminalSize() (width, height int, err error)
• func GetTerminalWidth() int
• func Print(a ...interface{})
• func Printf(format string, a ...interface{})
• func Println(a ...interface{})
• func Printo(a ...interface{})
• func RemoveColorFromString(a ...interface{}) string
• func SetDefaultOutput(w io.Writer)
• func Sprint(a ...interface{}) string
• func Sprintf(format string, a ...interface{}) string
• func Sprintln(a ...interface{}) string
• func Sprinto(a ...interface{}) string
• type Bar
  • func (p Bar) WithLabel(s string) *Bar
  • func (p Bar) WithLabelStyle(style *Style) *Bar
  • func (p Bar) WithStyle(style *Style) *Bar
  • func (p Bar) WithValue(value int) *Bar
• type BarChartPrinter
  • func (p BarChartPrinter) Render() error
  • func (p BarChartPrinter) Srender() (string, error)
  • func (p BarChartPrinter) WithBars(bars Bars) *BarChartPrinter
  • func (p BarChartPrinter) WithHeight(value int) *BarChartPrinter
  • func (p BarChartPrinter) WithHorizontal(b ...bool) *BarChartPrinter
  • func (p BarChartPrinter) WithHorizontalBarCharacter(char string) *BarChartPrinter
  • func (p BarChartPrinter) WithShowValue(b ...bool) *BarChartPrinter
  • func (p BarChartPrinter) WithVerticalBarCharacter(char string) *BarChartPrinter
  • func (p BarChartPrinter) WithWidth(value int) *BarChartPrinter
• type Bars
• type BasicTextPrinter
  • func (p *BasicTextPrinter) Print(a ...interface{}) *TextPrinter
  • func (p *BasicTextPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p *BasicTextPrinter) Println(a ...interface{}) *TextPrinter
  • func (p BasicTextPrinter) Sprint(a ...interface{}) string
  • func (p BasicTextPrinter) Sprintf(format string, a ...interface{}) string
  • func (p BasicTextPrinter) Sprintln(a ...interface{}) string
  • func (p BasicTextPrinter) WithStyle(style *Style) *BasicTextPrinter
• type BigTextPrinter
  • func (p BigTextPrinter) Render() error
  • func (p BigTextPrinter) Srender() (string, error)
  • func (p BigTextPrinter) WithBigCharacters(chars map[string]string) *BigTextPrinter
  • func (p BigTextPrinter) WithLetters(letters ...Letters) *BigTextPrinter
• type BoxPrinter
  • func (p BoxPrinter) Print(a ...interface{}) *TextPrinter
  • func (p BoxPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p BoxPrinter) Println(a ...interface{}) *TextPrinter
  • func (p BoxPrinter) Sprint(a ...interface{}) string
  • func (p BoxPrinter) Sprintf(format string, a ...interface{}) string
  • func (p BoxPrinter) Sprintln(a ...interface{}) string
  • func (p BoxPrinter) WithBottomLeftCornerString(str string) *BoxPrinter
  • func (p BoxPrinter) WithBottomPadding(padding int) *BoxPrinter
  • func (p BoxPrinter) WithBottomRightCornerString(str string) *BoxPrinter
  • func (p BoxPrinter) WithBoxStyle(style *Style) *BoxPrinter
  • func (p BoxPrinter) WithHorizontalString(str string) *BoxPrinter
  • func (p BoxPrinter) WithLeftPadding(padding int) *BoxPrinter
  • func (p BoxPrinter) WithRightPadding(padding int) *BoxPrinter
  • func (p BoxPrinter) WithTextStyle(style *Style) *BoxPrinter
  • func (p BoxPrinter) WithTopLeftCornerString(str string) *BoxPrinter
  • func (p BoxPrinter) WithTopPadding(padding int) *BoxPrinter
  • func (p BoxPrinter) WithTopRightCornerString(str string) *BoxPrinter
  • func (p BoxPrinter) WithVerticalString(str string) *BoxPrinter
• type BulletListItem
  • func NewBulletListItemFromString(text string, padding string) BulletListItem
  • func (p BulletListItem) WithBullet(bullet string) *BulletListItem
  • func (p BulletListItem) WithBulletStyle(style *Style) *BulletListItem
  • func (p BulletListItem) WithLevel(level int) *BulletListItem
  • func (p BulletListItem) WithText(text string) *BulletListItem
  • func (p BulletListItem) WithTextStyle(style *Style) *BulletListItem
• type BulletListPrinter
  • func NewBulletListFromString(s string, padding string) BulletListPrinter
  • func NewBulletListFromStrings(s []string, padding string) BulletListPrinter
  • func (l BulletListPrinter) Render() error
  • func (l BulletListPrinter) Srender() (string, error)
  • func (l BulletListPrinter) WithBullet(bullet string) *BulletListPrinter
  • func (l BulletListPrinter) WithBulletStyle(style *Style) *BulletListPrinter
  • func (l BulletListPrinter) WithItems(items []BulletListItem) *BulletListPrinter
  • func (l BulletListPrinter) WithTextStyle(style *Style) *BulletListPrinter
• type CenterPrinter
  • func (p CenterPrinter) Print(a ...interface{}) *TextPrinter
  • func (p CenterPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p CenterPrinter) Println(a ...interface{}) *TextPrinter
  • func (p CenterPrinter) Sprint(a ...interface{}) string
  • func (p CenterPrinter) Sprintf(format string, a ...interface{}) string
  • func (p CenterPrinter) Sprintln(a ...interface{}) string
  • func (p CenterPrinter) WithCenterEachLineSeparately(b ...bool) *CenterPrinter
• type Color
  • func (c Color) Print(a ...interface{}) *TextPrinter
  • func (c Color) Printf(format string, a ...interface{}) *TextPrinter
  • func (c Color) Println(a ...interface{}) *TextPrinter
  • func (c Color) Sprint(a ...interface{}) string
  • func (c Color) Sprintf(format string, a ...interface{}) string
  • func (c Color) Sprintln(a ...interface{}) string
  • func (c Color) String() string
• type HeaderPrinter
  • func (p *HeaderPrinter) Print(a ...interface{}) *TextPrinter
  • func (p *HeaderPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p *HeaderPrinter) Println(a ...interface{}) *TextPrinter
  • func (p HeaderPrinter) Sprint(a ...interface{}) string
  • func (p HeaderPrinter) Sprintf(format string, a ...interface{}) string
  • func (p HeaderPrinter) Sprintln(a ...interface{}) string
  • func (p HeaderPrinter) WithBackgroundStyle(style *Style) *HeaderPrinter
  • func (p HeaderPrinter) WithFullWidth(b ...bool) *HeaderPrinter
  • func (p HeaderPrinter) WithMargin(margin int) *HeaderPrinter
  • func (p HeaderPrinter) WithTextStyle(style *Style) *HeaderPrinter
• type Letter
  • func (l Letter) WithString(s string) *Letter
  • func (l Letter) WithStyle(style *Style) *Letter
• type Letters
  • func NewLettersFromString(text string) Letters
  • func NewLettersFromStringWithStyle(text string, style *Style) Letters
• type LeveledList
• type LeveledListItem
• type LivePrinter
• type Panel
• type PanelPrinter
  • func (p PanelPrinter) Render() error
  • func (p PanelPrinter) Srender() (string, error)
  • func (p PanelPrinter) WithBottomPadding(bottomPadding int) *PanelPrinter
  • func (p PanelPrinter) WithBoxPrinter(boxPrinter BoxPrinter) *PanelPrinter
  • func (p PanelPrinter) WithPadding(padding int) *PanelPrinter
  • func (p PanelPrinter) WithPanels(panels Panels) *PanelPrinter
  • func (p PanelPrinter) WithSameColumnWidth(b ...bool) *PanelPrinter
• type Panels
• type ParagraphPrinter
  • func (p *ParagraphPrinter) Print(a ...interface{}) *TextPrinter
  • func (p *ParagraphPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p *ParagraphPrinter) Println(a ...interface{}) *TextPrinter
  • func (p ParagraphPrinter) Sprint(a ...interface{}) string
  • func (p ParagraphPrinter) Sprintf(format string, a ...interface{}) string
  • func (p ParagraphPrinter) Sprintln(a ...interface{}) string
  • func (p ParagraphPrinter) WithMaxWidth(width int) *ParagraphPrinter
• type Prefix
• type PrefixPrinter
  • func (p PrefixPrinter) GetFormattedPrefix() string
  • func (p *PrefixPrinter) Print(a ...interface{}) *TextPrinter
  • func (p *PrefixPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p *PrefixPrinter) Println(a ...interface{}) *TextPrinter
  • func (p *PrefixPrinter) Sprint(a ...interface{}) string
  • func (p PrefixPrinter) Sprintf(format string, a ...interface{}) string
  • func (p PrefixPrinter) Sprintln(a ...interface{}) string
  • func (p PrefixPrinter) WithDebugger(b ...bool) *PrefixPrinter
  • func (p PrefixPrinter) WithFatal(b ...bool) *PrefixPrinter
  • func (p PrefixPrinter) WithMessageStyle(style *Style) *PrefixPrinter
  • func (p PrefixPrinter) WithPrefix(prefix Prefix) *PrefixPrinter
  • func (p PrefixPrinter) WithScope(scope Scope) *PrefixPrinter
  • func (p PrefixPrinter) WithShowLineNumber(b ...bool) *PrefixPrinter
• type ProgressbarPrinter
  • func (p *ProgressbarPrinter) Add(count int) *ProgressbarPrinter
  • func (p ProgressbarPrinter) GenericStart() (*LivePrinter, error)
  • func (p ProgressbarPrinter) GenericStop() (*LivePrinter, error)
  • func (p *ProgressbarPrinter) GetElapsedTime() time.Duration
  • func (p *ProgressbarPrinter) Increment() *ProgressbarPrinter
  • func (p ProgressbarPrinter) Start() (*ProgressbarPrinter, error)
  • func (p *ProgressbarPrinter) Stop() (*ProgressbarPrinter, error)
  • func (p ProgressbarPrinter) WithBarCharacter(char string) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithBarStyle(style *Style) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithCurrent(current int) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithElapsedTimeRoundingFactor(duration time.Duration) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithLastCharacter(char string) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithRemoveWhenDone(b ...bool) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithShowCount(b ...bool) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithShowElapsedTime(b ...bool) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithShowPercentage(b ...bool) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithShowTitle(b ...bool) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithTitle(name string) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithTitleStyle(style *Style) *ProgressbarPrinter
  • func (p ProgressbarPrinter) WithTotal(total int) *ProgressbarPrinter
• type RGB
  • func NewRGB(r, g, b uint8) RGB
  • func NewRGBFromHEX(hex string) (RGB, error)
  • func (p RGB) Fade(min, max, current float32, end ...RGB) RGB
  • func (p RGB) GetValues() (r, g, b uint8)
  • func (p RGB) Print(a ...interface{}) *TextPrinter
  • func (p RGB) Printf(format string, a ...interface{}) *TextPrinter
  • func (p RGB) Println(a ...interface{}) *TextPrinter
  • func (p RGB) Sprint(a ...interface{}) string
  • func (p RGB) Sprintf(format string, a ...interface{}) string
  • func (p RGB) Sprintln(a ...interface{}) string
• type RenderPrinter
• type Scope
• type SectionPrinter
  • func (p *SectionPrinter) Print(a ...interface{}) *TextPrinter
  • func (p *SectionPrinter) Printf(format string, a ...interface{}) *TextPrinter
  • func (p *SectionPrinter) Println(a ...interface{}) *TextPrinter
  • func (p SectionPrinter) Sprint(a ...interface{}) string
  • func (p SectionPrinter) Sprintf(format string, a ...interface{}) string
  • func (p SectionPrinter) Sprintln(a ...interface{}) string
  • func (p SectionPrinter) WithBottomPadding(padding int) *SectionPrinter
  • func (p SectionPrinter) WithIndentCharacter(char string) *SectionPrinter
  • func (p SectionPrinter) WithLevel(level int) *SectionPrinter
  • func (p SectionPrinter) WithStyle(style *Style) *SectionPrinter
  • func (p SectionPrinter) WithTopPadding(padding int) *SectionPrinter
• type SpinnerPrinter
  • func (s *SpinnerPrinter) Fail(message ...interface{})
  • func (s *SpinnerPrinter) GenericStart() (*LivePrinter, error)
  • func (s *SpinnerPrinter) GenericStop() (*LivePrinter, error)
  • func (s SpinnerPrinter) Start(text ...interface{}) (*SpinnerPrinter, error)
  • func (s *SpinnerPrinter) Stop() error
  • func (s *SpinnerPrinter) Success(message ...interface{})
  • func (s *SpinnerPrinter) UpdateText(text string)
  • func (s *SpinnerPrinter) Warning(message ...interface{})
  • func (s SpinnerPrinter) WithDelay(delay time.Duration) *SpinnerPrinter
  • func (s SpinnerPrinter) WithMessageStyle(style *Style) *SpinnerPrinter
  • func (s SpinnerPrinter) WithRemoveWhenDone(b ...bool) *SpinnerPrinter
  • func (s SpinnerPrinter) WithSequence(sequence ...string) *SpinnerPrinter
  • func (s SpinnerPrinter) WithStyle(style *Style) *SpinnerPrinter
  • func (s SpinnerPrinter) WithText(text string) *SpinnerPrinter
• type Style
  • func NewStyle(colors ...Color) *Style
  • func (s Style) Add(styles ...Style) Style
  • func (s Style) Code() string
  • func (s Style) Print(a ...interface{})
  • func (s Style) Printf(format string, a ...interface{})
  • func (s Style) Println(a ...interface{})
  • func (s Style) Sprint(a ...interface{}) string
  • func (s Style) Sprintf(format string, a ...interface{}) string
  • func (s Style) Sprintln(a ...interface{}) string
  • func (s Style) String() string
• type TableData
• type TablePrinter
  • func (p TablePrinter) Render() error
  • func (p TablePrinter) Srender() (string, error)
  • func (p TablePrinter) WithCSVReader(reader *csv.Reader) *TablePrinter
  • func (p TablePrinter) WithData(data [][]string) *TablePrinter
  • func (p TablePrinter) WithHasHeader(b ...bool) *TablePrinter
  • func (p TablePrinter) WithHeaderStyle(style *Style) *TablePrinter
  • func (p TablePrinter) WithSeparator(separator string) *TablePrinter
  • func (p TablePrinter) WithSeparatorStyle(style *Style) *TablePrinter
  • func (p TablePrinter) WithStyle(style *Style) *TablePrinter
• type TextPrinter
• type Theme
  • func (t Theme) WithBarLabelStyle(style Style) Theme
  • func (t Theme) WithBarStyle(style Style) Theme
  • func (t Theme) WithBoxStyle(style Style) Theme
  • func (t Theme) WithBoxTextStyle(style Style) Theme
  • func (t Theme) WithBulletListBulletStyle(style Style) Theme
  • func (t Theme) WithBulletListTextStyle(style Style) Theme
  • func (t Theme) WithDebugMessageStyle(style Style) Theme
  • func (t Theme) WithDebugPrefixStyle(style Style) Theme
  • func (t Theme) WithDescriptionMessageStyle(style Style) Theme
  • func (t Theme) WithDescriptionPrefixStyle(style Style) Theme
  • func (t Theme) WithErrorMessageStyle(style Style) Theme
  • func (t Theme) WithErrorPrefixStyle(style Style) Theme
  • func (t Theme) WithFatalMessageStyle(style Style) Theme
  • func (t Theme) WithFatalPrefixStyle(style Style) Theme
  • func (t Theme) WithHighlightStyle(style Style) Theme
  • func (t Theme) WithInfoMessageStyle(style Style) Theme
  • func (t Theme) WithInfoPrefixStyle(style Style) Theme
  • func (t Theme) WithLetterStyle(style Style) Theme
  • func (t Theme) WithPrimaryStyle(style Style) Theme
  • func (t Theme) WithSecondaryStyle(style Style) Theme
  • func (t Theme) WithSuccessMessageStyle(style Style) Theme
  • func (t Theme) WithSuccessPrefixStyle(style Style) Theme
  • func (t Theme) WithTreeStyle(style Style) Theme
  • func (t Theme) WithTreeTextStyle(style Style) Theme
  • func (t Theme) WithWarningMessageStyle(style Style) Theme
  • func (t Theme) WithWarningPrefixStyle(style Style) Theme
• type TreeNode
  • func NewTreeFromLeveledList(leveledListItems LeveledList) TreeNode
• type TreePrinter
  • func (p TreePrinter) Render() error
  • func (p TreePrinter) Srender() (string, error)
  • func (p TreePrinter) WithHorizontalString(s string) *TreePrinter
  • func (p TreePrinter) WithIndent(indent int) *TreePrinter
  • func (p TreePrinter) WithRoot(root TreeNode) *TreePrinter
  • func (p TreePrinter) WithTextStyle(style *Style) *TreePrinter
  • func (p TreePrinter) WithTopRightCornerString(s string) *TreePrinter
  • func (p TreePrinter) WithTopRightDownStringOngoing(s string) *TreePrinter
  • func (p TreePrinter) WithTreeStyle(style *Style) *TreePrinter
  • func (p TreePrinter) WithVerticalString(s string) *TreePrinter

Variables

var (
	// Red is an alias for FgRed.Sprint.
	Red = FgRed.Sprint
	// Cyan is an alias for FgCyan.Sprint.
	Cyan = FgCyan.Sprint
	// Gray is an alias for FgGray.Sprint.
	Gray = FgGray.Sprint
	// Blue is an alias for FgBlue.Sprint.
	Blue = FgBlue.Sprint
	// Black is an alias for FgBlack.Sprint.
	Black = FgBlack.Sprint
	// Green is an alias for FgGreen.Sprint.
	Green = FgGreen.Sprint
	// White is an alias for FgWhite.Sprint.
	White = FgWhite.Sprint
	// Yellow is an alias for FgYellow.Sprint.
	Yellow = FgYellow.Sprint
	// Magenta is an alias for FgMagenta.Sprint.
	Magenta = FgMagenta.Sprint

	// Normal is an alias for FgDefault.Sprint.
	Normal = FgDefault.Sprint

	// LightRed is a shortcut for FgLightRed.Sprint.
	LightRed = FgLightRed.Sprint
	// LightCyan is a shortcut for FgLightCyan.Sprint.
	LightCyan = FgLightCyan.Sprint
	// LightBlue is a shortcut for FgLightBlue.Sprint.
	LightBlue = FgLightBlue.Sprint
	// LightGreen is a shortcut for FgLightGreen.Sprint.
	LightGreen = FgLightGreen.Sprint
	// LightWhite is a shortcut for FgLightWhite.Sprint.
	LightWhite = FgLightWhite.Sprint
	// LightYellow is a shortcut for FgLightYellow.Sprint.
	LightYellow = FgLightYellow.Sprint
	// LightMagenta is a shortcut for FgLightMagenta.Sprint.
	LightMagenta = FgLightMagenta.Sprint
)

var (
	// ErrTerminalSizeNotDetectable - the terminal size can not be detected and the fallback values are used.
	ErrTerminalSizeNotDetectable = errors.New("terminal size could not be detected - using fallback value")

	// ErrHexCodeIsInvalid - the given HEX code is invalid.
	ErrHexCodeIsInvalid = errors.New("hex code is not valid")
)

var (
	// Info returns a PrefixPrinter, which can be used to print text with an "info" Prefix.
	Info = PrefixPrinter{
		MessageStyle: &ThemeDefault.InfoMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.InfoPrefixStyle,
			Text:  "INFO",
		},
	}

	// Warning returns a PrefixPrinter, which can be used to print text with a "warning" Prefix.
	Warning = PrefixPrinter{
		MessageStyle: &ThemeDefault.WarningMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.WarningPrefixStyle,
			Text:  "WARNING",
		},
	}

	// Success returns a PrefixPrinter, which can be used to print text with a "success" Prefix.
	Success = PrefixPrinter{
		MessageStyle: &ThemeDefault.SuccessMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.SuccessPrefixStyle,
			Text:  "SUCCESS",
		},
	}

	// Error returns a PrefixPrinter, which can be used to print text with an "error" Prefix.
	Error = PrefixPrinter{
		MessageStyle: &ThemeDefault.ErrorMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.ErrorPrefixStyle,
			Text:  " ERROR ",
		},
		ShowLineNumber: true,
	}

	// Fatal returns a PrefixPrinter, which can be used to print text with an "fatal" Prefix.
	// NOTICE: Fatal terminates the application immediately!
	Fatal = PrefixPrinter{
		MessageStyle: &ThemeDefault.FatalMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.FatalPrefixStyle,
			Text:  " FATAL ",
		},
		Fatal: true,
	}

	// Debug Prints debug messages. By default it will only print if PrintDebugMessages is true.
	// You can change PrintDebugMessages with EnableDebugMessages and DisableDebugMessages, or by setting the variable itself.
	Debug = PrefixPrinter{
		MessageStyle: &ThemeDefault.DebugMessageStyle,
		Prefix: Prefix{
			Text:  " DEBUG ",
			Style: &ThemeDefault.DebugPrefixStyle,
		},
		Debugger: true,
	}

	// Description returns a PrefixPrinter, which can be used to print text with a "description" Prefix.
	Description = PrefixPrinter{
		MessageStyle: &ThemeDefault.DescriptionMessageStyle,
		Prefix: Prefix{
			Style: &ThemeDefault.DescriptionPrefixStyle,
			Text:  "Description",
		},
	}
)

var (
	// Output completely disables output from pterm if set to false. Can be used in CLI application quiet mode.
	Output = true
	// PrintDebugMessages sets if messages printed by the DebugPrinter should be printed.
	PrintDebugMessages = false
)

var ActiveProgressBarPrinters []*ProgressbarPrinter

ActiveProgressBarPrinters contains all running ProgressbarPrinters. Generally, there should only be one active ProgressbarPrinter at a time.

var (
	// DefaultBarChart is the default BarChartPrinter.
	DefaultBarChart = BarChartPrinter{
		Horizontal:             false,
		VerticalBarCharacter:   "██",
		HorizontalBarCharacter: "█",
		Height:                 GetTerminalHeight() * 2 / 3,
		Width:                  GetTerminalWidth() * 2 / 3,
	}
)

var (
	// DefaultBasicText returns a default BasicTextPrinter, which can be used to print text as is.
	// No default style is present for BasicTextPrinter.
	DefaultBasicText = BasicTextPrinter{}
)

var DefaultBigText = BigTextPrinter{
	BigCharacters: map[string]string{
		"a": ` █████
██   ██
███████
██   ██
██   ██ `,
		"A": ` █████
██   ██
███████
██   ██
██   ██ `,
		"b": `██████
██   ██
██████
██   ██
██████`,
		"B": `██████
██   ██
██████
██   ██
██████`,
		"c": ` ██████
██
██
██
 ██████`,
		"C": ` ██████
██
██
██
 ██████`,
		"d": `██████
██   ██
██   ██
██   ██
██████ `,
		"D": `██████
██   ██
██   ██
██   ██
██████ `,
		"e": `███████
██
█████
██
███████`,
		"E": `███████
██
█████
██
███████`,
		"f": `███████
██
█████
██
██     `,
		"F": `███████
██
█████
██
██     `,
		"g": ` ██████
██
██   ███
██    ██
 ██████  `,
		"G": ` ██████
██
██   ███
██    ██
 ██████  `,
		"h": `██   ██
██   ██
███████
██   ██
██   ██ `,
		"H": `██   ██
██   ██
███████
██   ██
██   ██ `,
		"i": `██
██
██
██
██`,
		"I": `██
██
██
██
██`,
		"j": `     ██
     ██
     ██
██   ██
 █████ `,
		"J": `     ██
     ██
     ██
██   ██
 █████ `,
		"k": `██   ██
██  ██
█████
██  ██
██   ██`,
		"K": `██   ██
██  ██
█████
██  ██
██   ██`,
		"l": `██
██
██
██
███████ `,
		"L": `██
██
██
██
███████ `,
		"m": `███    ███
████  ████
██ ████ ██
██  ██  ██
██      ██`,
		"M": `███    ███
████  ████
██ ████ ██
██  ██  ██
██      ██`,
		"n": `███    ██
████   ██
██ ██  ██
██  ██ ██
██   ████`,
		"N": `███    ██
████   ██
██ ██  ██
██  ██ ██
██   ████`,
		"o": ` ██████
██    ██
██    ██
██    ██
 ██████  `,
		"O": ` ██████
██    ██
██    ██
██    ██
 ██████  `,
		"p": `██████
██   ██
██████
██
██     `,
		"P": `██████
██   ██
██████
██
██     `,
		"q": ` ██████
██    ██
██    ██
██ ▄▄ ██
 ██████
    ▀▀   `,
		"Q": ` ██████
██    ██
██    ██
██ ▄▄ ██
 ██████
    ▀▀   `,
		"r": `██████
██   ██
██████
██   ██
██   ██`,
		"R": `██████
██   ██
██████
██   ██
██   ██`,
		"s": `███████
██
███████
     ██
███████`,
		"S": `███████
██
███████
     ██
███████`,
		"t": `████████
   ██
   ██
   ██
   ██    `,
		"T": `████████
   ██
   ██
   ██
   ██    `,
		"u": `██    ██
██    ██
██    ██
██    ██
 ██████ `,
		"U": `██    ██
██    ██
██    ██
██    ██
 ██████ `,
		"v": `██    ██
██    ██
██    ██
 ██  ██
  ████   `,
		"V": `██    ██
██    ██
██    ██
 ██  ██
  ████   `,
		"w": `██     ██
██     ██
██  █  ██
██ ███ ██
 ███ ███ `,
		"W": `██     ██
██     ██
██  █  ██
██ ███ ██
 ███ ███ `,
		"x": `██   ██
 ██ ██
  ███
 ██ ██
██   ██ `,
		"X": `██   ██
 ██ ██
  ███
 ██ ██
██   ██ `,
		"y": `██    ██
 ██  ██
  ████
   ██
   ██   `,
		"Y": `██    ██
 ██  ██
  ████
   ██
   ██   `,
		"z": `███████
   ███
  ███
 ███
███████`,
		"Z": `███████
   ███
  ███
 ███
███████`,
		"0": ` ██████
██  ████
██ ██ ██
████  ██
 ██████ `,
		"1": ` ██
███
 ██
 ██
 ██ `,
		"2": `██████
     ██
 █████
██
███████ `,
		"3": `██████
     ██
 █████
     ██
██████ `,
		"4": `██   ██
██   ██
███████
     ██
     ██ `,
		"5": `███████
██
███████
     ██
███████`,
		"6": ` ██████
██
███████
██    ██
 ██████ `,
		"7": `███████
     ██
    ██
   ██
   ██`,
		"8": ` █████
██   ██
 █████
██   ██
 █████ `,
		"9": ` █████
██   ██
 ██████
     ██
 █████ `,
		" ": "    ",
		"!": `██
██
██

██ `,
		"$": `▄▄███▄▄·
██
███████
     ██
███████
  ▀▀▀  `,
		"%": `██  ██
   ██
  ██
 ██
██  ██`,
		"/": `    ██
   ██
  ██
 ██
██   `,
		"(": ` ██
██
██
██
 ██ `,
		")": `██
 ██
 ██
 ██
██  `,
		"?": `██████
     ██
  ▄███
  ▀▀
  ██   `,
		"[": `███
██
██
██
███`,
		"]": `███
 ██
 ██
 ██
███ `,
		".": `



██`,
		",": `



▄█`,
		"-": `

█████


     `,
		"<": `  ██
 ██
██
 ██
  ██ `,
		">": `██
 ██
  ██
 ██
██ `,
		"*": `
▄ ██ ▄
 ████
▀ ██ ▀
     `,
		"#": ` ██  ██
████████
 ██  ██
████████
 ██  ██ `,
		"_": `



███████ `,
		":": `
██


██ `,
		"°": ` ████
██  ██
 ████

      `,
	},
}

DefaultBigText contains default values for BigTextPrinter.

var DefaultBox = BoxPrinter{
	VerticalString:          "|",
	TopRightCornerString:    "└",
	TopLeftCornerString:     "┘",
	BottomLeftCornerString:  "┐",
	BottomRightCornerString: "┌",
	HorizontalString:        "─",
	BoxStyle:                &ThemeDefault.BoxStyle,
	TextStyle:               &ThemeDefault.BoxTextStyle,
	RightPadding:            1,
	LeftPadding:             1,
	TopPadding:              0,
	BottomPadding:           0,
}

DefaultBox is the default BoxPrinter.

var DefaultBulletList = BulletListPrinter{
	Bullet:      "•",
	TextStyle:   &ThemeDefault.BulletListTextStyle,
	BulletStyle: &ThemeDefault.BulletListBulletStyle,
}

DefaultBulletList contains standards, which can be used to print a BulletListPrinter.

var DefaultCenter = CenterPrinter{
	CenterEachLineSeparately: false,
}

DefaultCenter is the default CenterPrinter.

var (
	// DefaultHeader returns the printer for a default header text.
	// Defaults to LightWhite, Bold Text and a Gray DefaultHeader background.
	DefaultHeader = HeaderPrinter{
		TextStyle:       &ThemeDefault.HeaderTextStyle,
		BackgroundStyle: &ThemeDefault.HeaderBackgroundStyle,
		Margin:          5,
	}
)

var DefaultPanel = PanelPrinter{
	Padding: 1,
}

DefaultPanel is the default PanelPrinter.

var DefaultParagraph = ParagraphPrinter{
	MaxWidth: GetTerminalWidth(),
}

DefaultParagraph contains the default values for a ParagraphPrinter.

var (
	// DefaultProgressbar is the default ProgressbarPrinter.
	DefaultProgressbar = ProgressbarPrinter{
		Total:                     100,
		BarCharacter:              "█",
		LastCharacter:             "█",
		ElapsedTimeRoundingFactor: time.Second,
		BarStyle:                  &ThemeDefault.ProgressbarBarStyle,
		TitleStyle:                &ThemeDefault.ProgressbarTitleStyle,
		ShowTitle:                 true,
		ShowCount:                 true,
		ShowPercentage:            true,
		ShowElapsedTime:           true,
		BarFiller:                 " ",
	}
)

var DefaultSection = SectionPrinter{
	Style:           &ThemeDefault.SectionStyle,
	Level:           1,
	TopPadding:      1,
	BottomPadding:   1,
	IndentCharacter: "#",
}

DefaultSection is the default section printer.

var DefaultSpinner = SpinnerPrinter{
	Sequence:       []string{"▀ ", " ▀", " ▄", "▄ "},
	Style:          &ThemeDefault.SpinnerStyle,
	Delay:          time.Millisecond * 200,
	MessageStyle:   &ThemeDefault.SpinnerTextStyle,
	SuccessPrinter: &Success,
	FailPrinter:    &Error,
	WarningPrinter: &Warning,
}

DefaultSpinner is the default SpinnerPrinter.

var DefaultTable = TablePrinter{
	Style:          &ThemeDefault.TableStyle,
	HeaderStyle:    &ThemeDefault.TableHeaderStyle,
	Separator:      " | ",
	SeparatorStyle: &ThemeDefault.TableSeparatorStyle,
}

DefaultTable contains standards, which can be used to print a TablePrinter.

var DefaultTree = TreePrinter{
	TreeStyle:            &ThemeDefault.TreeStyle,
	TextStyle:            &ThemeDefault.TreeTextStyle,
	TopRightCornerString: "└",
	HorizontalString:     "─",
	TopRightDownString:   "├",
	VerticalString:       "│",
	RightDownLeftString:  "┬",
	Indent:               2,
}

DefaultTree contains standards, which can be used to render a TreePrinter.

var FallbackTerminalHeight = 10

FallbackTerminalHeight is the value used for GetTerminalHeight, if the actual height can not be detected You can override that value if necessary.

var FallbackTerminalWidth = 80

FallbackTerminalWidth is the value used for GetTerminalWidth, if the actual width can not be detected You can override that value if necessary.

var (
	// GrayBoxStyle wraps text in a gray box.
	GrayBoxStyle = NewStyle(BgGray, FgLightWhite)
)

var PrintColor = true

PrintColor is false if PTerm should not print colored output.

var (
	// ThemeDefault is the default theme used by PTerm.
	// If this variable is overwritten, the new value is used as default theme.
	ThemeDefault = Theme{
		PrimaryStyle:            Style{FgCyan},
		SecondaryStyle:          Style{FgLightMagenta},
		HighlightStyle:          Style{Bold, FgYellow},
		InfoMessageStyle:        Style{FgLightCyan},
		InfoPrefixStyle:         Style{FgBlack, BgCyan},
		SuccessMessageStyle:     Style{FgGreen},
		SuccessPrefixStyle:      Style{FgBlack, BgGreen},
		WarningMessageStyle:     Style{FgYellow},
		WarningPrefixStyle:      Style{FgBlack, BgYellow},
		ErrorMessageStyle:       Style{FgLightRed},
		ErrorPrefixStyle:        Style{FgBlack, BgLightRed},
		FatalMessageStyle:       Style{FgLightRed},
		FatalPrefixStyle:        Style{FgBlack, BgLightRed},
		DescriptionMessageStyle: Style{FgDefault},
		DescriptionPrefixStyle:  Style{FgLightWhite, BgDarkGray},
		ScopeStyle:              Style{FgGray},
		ProgressbarBarStyle:     Style{FgCyan},
		ProgressbarTitleStyle:   Style{FgLightCyan},
		HeaderTextStyle:         Style{FgLightWhite, Bold},
		HeaderBackgroundStyle:   Style{BgGray},
		SpinnerStyle:            Style{FgLightCyan},
		SpinnerTextStyle:        Style{FgLightWhite},
		TableStyle:              Style{FgDefault},
		TableHeaderStyle:        Style{FgLightCyan},
		TableSeparatorStyle:     Style{FgGray},
		SectionStyle:            Style{Bold, FgYellow},
		BulletListTextStyle:     Style{FgDefault},
		BulletListBulletStyle:   Style{FgGray},
		TreeStyle:               Style{FgGray},
		TreeTextStyle:           Style{FgDefault},
		LetterStyle:             Style{FgDefault},
		DebugMessageStyle:       Style{FgGray},
		DebugPrefixStyle:        Style{FgBlack, BgGray},
		BoxStyle:                Style{FgDefault},
		BoxTextStyle:            Style{FgDefault},
		BarLabelStyle:           Style{FgLightCyan},
		BarStyle:                Style{FgCyan},
	}
)

Functions

func DisableColor

func DisableColor()

DisableColor disables colors.

func DisableDebugMessages

func DisableDebugMessages()

DisableDebugMessages disables the output of debug printers.

func DisableOutput

func DisableOutput()

DisableOutput disables the output of PTerm.

func EnableColor

func EnableColor()

EnableColor enables colors.

func EnableDebugMessages

func EnableDebugMessages()

EnableDebugMessages enables the output of debug printers.

func EnableOutput

func EnableOutput()

EnableOutput enables the output of PTerm.

func Fprint

func Fprint(writer io.Writer, a ...interface{})

Fprint formats using the default formats for its operands and writes to w. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func Fprintln

func Fprintln(writer io.Writer, a ...interface{})

Fprintln formats using the default formats for its operands and writes to w. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Fprinto

func Fprinto(w io.Writer, a ...interface{})

Fprinto prints Printo to a custom writer.

func GetTerminalHeight

func GetTerminalHeight() int

GetTerminalHeight returns the terminal height of the active terminal.

func GetTerminalSize

func GetTerminalSize() (width, height int, err error)

GetTerminalSize returns the width and the height of the active terminal.

func GetTerminalWidth

func GetTerminalWidth() int

GetTerminalWidth returns the terminal width of the active terminal.

func Print

func Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func Printf

func Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func Println

func Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func Printo

func Printo(a ...interface{})

Printo overrides the current line in a terminal. If the current line is empty, the text will be printed like with pterm.Print. Example:

pterm.Printo("Hello, World")
time.Sleep(time.Second)
pterm.Printo("Hello, Earth!")

func RemoveColorFromString

func RemoveColorFromString(a ...interface{}) string

RemoveColorFromString removes color codes from a string.

func SetDefaultOutput

func SetDefaultOutput(w io.Writer)

SetDefaultOutput sets the default output of pterm.

func Sprint

func Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func Sprintf

func Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func Sprintln

func Sprintln(a ...interface{}) string

Sprintln returns what Println would print to the terminal.

func Sprinto

func Sprinto(a ...interface{}) string

Sprinto returns what Printo would print.

Types

type Bar

type Bar struct {
	Label      string
	Value      int
	Style      *Style
	LabelStyle *Style
}

Bar is used in bar charts.

func (Bar) WithLabel

func (p Bar) WithLabel(s string) *Bar

WithLabel returns a new Bar with a specific option.

func (Bar) WithLabelStyle

func (p Bar) WithLabelStyle(style *Style) *Bar

WithLabelStyle returns a new Bar with a specific option.

func (Bar) WithStyle

func (p Bar) WithStyle(style *Style) *Bar

WithStyle returns a new Bar with a specific option.

func (Bar) WithValue

func (p Bar) WithValue(value int) *Bar

WithValue returns a new Bar with a specific option.

type BarChartPrinter

type BarChartPrinter struct {
	Bars       Bars
	Horizontal bool
	ShowValue  bool
	// Height sets the maximum height of a vertical bar chart.
	// The default is calculated to fit into the terminal.
	// Ignored if Horizontal is set to true.
	Height int
	// Width sets the maximum width of a horizontal bar chart.
	// The default is calculated to fit into the terminal.
	// Ignored if Horizontal is set to false.
	Width                  int
	VerticalBarCharacter   string
	HorizontalBarCharacter string
}

BarChartPrinter is used to print bar charts.

func (BarChartPrinter) Render

func (p BarChartPrinter) Render() error

Render prints the Template to the terminal.

func (BarChartPrinter) Srender

func (p BarChartPrinter) Srender() (string, error)

Srender renders the BarChart as a string.

func (BarChartPrinter) WithBars

func (p BarChartPrinter) WithBars(bars Bars) *BarChartPrinter

WithBars returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithHeight

func (p BarChartPrinter) WithHeight(value int) *BarChartPrinter

WithHeight returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithHorizontal

func (p BarChartPrinter) WithHorizontal(b ...bool) *BarChartPrinter

WithHorizontal returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithHorizontalBarCharacter

func (p BarChartPrinter) WithHorizontalBarCharacter(char string) *BarChartPrinter

WithHorizontalBarCharacter returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithShowValue

func (p BarChartPrinter) WithShowValue(b ...bool) *BarChartPrinter

WithShowValue returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithVerticalBarCharacter

func (p BarChartPrinter) WithVerticalBarCharacter(char string) *BarChartPrinter

WithVerticalBarCharacter returns a new BarChartPrinter with a specific option.

func (BarChartPrinter) WithWidth

func (p BarChartPrinter) WithWidth(value int) *BarChartPrinter

WithWidth returns a new BarChartPrinter with a specific option.

type Bars

type Bars []Bar

Bars is used to display multiple Bar.

type BasicTextPrinter

type BasicTextPrinter struct {
	Style *Style
}

BasicTextPrinter is the printer used to print the input as-is or as specified by user formatting.

func (*BasicTextPrinter) Print

func (p *BasicTextPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*BasicTextPrinter) Printf

func (p *BasicTextPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*BasicTextPrinter) Println

func (p *BasicTextPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (BasicTextPrinter) Sprint

func (p BasicTextPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (BasicTextPrinter) Sprintf

func (p BasicTextPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (BasicTextPrinter) Sprintln

func (p BasicTextPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (BasicTextPrinter) WithStyle

func (p BasicTextPrinter) WithStyle(style *Style) *BasicTextPrinter

WithStyle adds a style to the printer.

type BigTextPrinter

type BigTextPrinter struct {
	// BigCharacters holds the map from a normal character to it's big version.
	BigCharacters map[string]string
	Letters       Letters
}

BigTextPrinter renders big text. You can use this as title screen for your application.

func (BigTextPrinter) Render

func (p BigTextPrinter) Render() error

Render prints the BigText to the terminal.

func (BigTextPrinter) Srender

func (p BigTextPrinter) Srender() (string, error)

Srender renders the BigText as a string.

func (BigTextPrinter) WithBigCharacters

func (p BigTextPrinter) WithBigCharacters(chars map[string]string) *BigTextPrinter

WithBigCharacters returns a new BigTextPrinter with specific BigCharacters.

func (BigTextPrinter) WithLetters

func (p BigTextPrinter) WithLetters(letters ...Letters) *BigTextPrinter

WithLetters returns a new BigTextPrinter with specific Letters

type BoxPrinter

type BoxPrinter struct {
	TextStyle               *Style
	VerticalString          string
	BoxStyle                *Style
	HorizontalString        string
	TopRightCornerString    string
	TopLeftCornerString     string
	BottomLeftCornerString  string
	BottomRightCornerString string
	TopPadding              int
	BottomPadding           int
	RightPadding            int
	LeftPadding             int
}

BoxPrinter is able to render a box around printables.

func (BoxPrinter) Print

func (p BoxPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) Printf

func (p BoxPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) Println

func (p BoxPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (BoxPrinter) Sprint

func (p BoxPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (BoxPrinter) Sprintf

func (p BoxPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (BoxPrinter) Sprintln

func (p BoxPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (BoxPrinter) WithBottomLeftCornerString

func (p BoxPrinter) WithBottomLeftCornerString(str string) *BoxPrinter

WithBottomLeftCornerString returns a new box with a specific BottomLeftCornerString.

func (BoxPrinter) WithBottomPadding

func (p BoxPrinter) WithBottomPadding(padding int) *BoxPrinter

WithBottomPadding returns a new box with a specific BottomPadding.

func (BoxPrinter) WithBottomRightCornerString

func (p BoxPrinter) WithBottomRightCornerString(str string) *BoxPrinter

WithBottomRightCornerString returns a new box with a specific BottomRightCornerString.

func (BoxPrinter) WithBoxStyle

func (p BoxPrinter) WithBoxStyle(style *Style) *BoxPrinter

WithBoxStyle returns a new box with a specific box Style.

func (BoxPrinter) WithHorizontalString

func (p BoxPrinter) WithHorizontalString(str string) *BoxPrinter

WithHorizontalString returns a new box with a specific HorizontalString.

func (BoxPrinter) WithLeftPadding

func (p BoxPrinter) WithLeftPadding(padding int) *BoxPrinter

WithLeftPadding returns a new box with a specific LeftPadding.

func (BoxPrinter) WithRightPadding

func (p BoxPrinter) WithRightPadding(padding int) *BoxPrinter

WithRightPadding returns a new box with a specific RightPadding.

func (BoxPrinter) WithTextStyle

func (p BoxPrinter) WithTextStyle(style *Style) *BoxPrinter

WithTextStyle returns a new box with a specific text Style.

func (BoxPrinter) WithTopLeftCornerString

func (p BoxPrinter) WithTopLeftCornerString(str string) *BoxPrinter

WithTopLeftCornerString returns a new box with a specific TopLeftCornerString.

func (BoxPrinter) WithTopPadding

func (p BoxPrinter) WithTopPadding(padding int) *BoxPrinter

WithTopPadding returns a new box with a specific TopPadding.

func (BoxPrinter) WithTopRightCornerString

func (p BoxPrinter) WithTopRightCornerString(str string) *BoxPrinter

WithTopRightCornerString returns a new box with a specific TopRightCornerString.

func (BoxPrinter) WithVerticalString

func (p BoxPrinter) WithVerticalString(str string) *BoxPrinter

WithVerticalString returns a new box with a specific VerticalString.

type BulletListItem

type BulletListItem struct {
	Level       int
	Text        string
	TextStyle   *Style
	Bullet      string
	BulletStyle *Style
}

BulletListItem is able to render a ListItem.

func NewBulletListItemFromString

func NewBulletListItemFromString(text string, padding string) BulletListItem

NewBulletListItemFromString returns a BulletListItem with a Text. The padding is counted in the Text to define the Level of the ListItem.

func (BulletListItem) WithBullet

func (p BulletListItem) WithBullet(bullet string) *BulletListItem

WithBullet returns a new BulletListItem with a specific Prefix.

func (BulletListItem) WithBulletStyle

func (p BulletListItem) WithBulletStyle(style *Style) *BulletListItem

WithBulletStyle returns a new BulletListItem with a specific BulletStyle.

func (BulletListItem) WithLevel

func (p BulletListItem) WithLevel(level int) *BulletListItem

WithLevel returns a new BulletListItem with a specific Level.

func (BulletListItem) WithText

func (p BulletListItem) WithText(text string) *BulletListItem

WithText returns a new BulletListItem with a specific Text.

func (BulletListItem) WithTextStyle

func (p BulletListItem) WithTextStyle(style *Style) *BulletListItem

WithTextStyle returns a new BulletListItem with a specific TextStyle.

type BulletListPrinter

type BulletListPrinter struct {
	Items       []BulletListItem
	TextStyle   *Style
	Bullet      string
	BulletStyle *Style
}

BulletListPrinter is able to render a list.

func NewBulletListFromString

func NewBulletListFromString(s string, padding string) BulletListPrinter

NewBulletListFromString returns a BulletListPrinter with Text using the NewTreeListItemFromString method, splitting after return (\n).

func NewBulletListFromStrings

func NewBulletListFromStrings(s []string, padding string) BulletListPrinter

NewBulletListFromStrings returns a BulletListPrinter with Text using the NewTreeListItemFromString method.

func (BulletListPrinter) Render

func (l BulletListPrinter) Render() error

Render prints the list to the terminal.

func (BulletListPrinter) Srender

func (l BulletListPrinter) Srender() (string, error)

Srender renders the list as a string.

func (BulletListPrinter) WithBullet

func (l BulletListPrinter) WithBullet(bullet string) *BulletListPrinter

WithBullet returns a new list with a specific bullet.

func (BulletListPrinter) WithBulletStyle

func (l BulletListPrinter) WithBulletStyle(style *Style) *BulletListPrinter

WithBulletStyle returns a new list with a specific bullet style.

func (BulletListPrinter) WithItems

func (l BulletListPrinter) WithItems(items []BulletListItem) *BulletListPrinter

WithItems returns a new list with specific Items.

func (BulletListPrinter) WithTextStyle

func (l BulletListPrinter) WithTextStyle(style *Style) *BulletListPrinter

WithTextStyle returns a new list with a specific text style.

type CenterPrinter

type CenterPrinter struct {
	CenterEachLineSeparately bool
}

CenterPrinter prints centered text.

func (CenterPrinter) Print

func (p CenterPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) Printf

func (p CenterPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) Println

func (p CenterPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (CenterPrinter) Sprint

func (p CenterPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (CenterPrinter) Sprintf

func (p CenterPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (CenterPrinter) Sprintln

func (p CenterPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (CenterPrinter) WithCenterEachLineSeparately

func (p CenterPrinter) WithCenterEachLineSeparately(b ...bool) *CenterPrinter

WithCenterEachLineSeparately centers each line separately.

type Color

type Color uint8

Color is a number which will be used to color strings in the terminal.

const (
	FgBlack Color = iota + 30
	FgRed
	FgGreen
	FgYellow
	FgBlue
	FgMagenta
	FgCyan
	FgWhite
	// FgDefault revert default FG.
	FgDefault Color = 39
)

Foreground colors. basic foreground colors 30 - 37.

const (
	FgDarkGray Color = iota + 90
	FgLightRed
	FgLightGreen
	FgLightYellow
	FgLightBlue
	FgLightMagenta
	FgLightCyan
	FgLightWhite
	// FgGray is an alias of FgDarkGray.
	FgGray Color = 90
)

Extra foreground color 90 - 97.

const (
	BgBlack Color = iota + 40
	BgRed
	BgGreen
	BgYellow // BgBrown like yellow
	BgBlue
	BgMagenta
	BgCyan
	BgWhite
	// BgDefault reverts to the default background.
	BgDefault Color = 49
)

Background colors. basic background colors 40 - 47.

const (
	BgDarkGray Color = iota + 100
	BgLightRed
	BgLightGreen
	BgLightYellow
	BgLightBlue
	BgLightMagenta
	BgLightCyan
	BgLightWhite
	// BgGray is an alias of BgDarkGray.
	BgGray Color = 100
)

Extra background color 100 - 107.

const (
	Reset Color = iota
	Bold
	Fuzzy
	Italic
	Underscore
	Blink
	FastBlink
	Reverse
	Concealed
	Strikethrough
)

Option settings.

func (Color) Print

func (c Color) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Printf

func (c Color) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Println

func (c Color) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Color.

func (Color) Sprint

func (c Color) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Color.

func (Color) Sprintf

func (c Color) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Color.

func (Color) Sprintln

func (c Color) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Color.

func (Color) String

func (c Color) String() string

String converts the color to a string. eg "35".

type HeaderPrinter

type HeaderPrinter struct {
	TextStyle       *Style
	BackgroundStyle *Style
	Margin          int
	FullWidth       bool
}

HeaderPrinter contains the data used to craft a header. A header is printed as a big box with text in it. Can be used as title screens or section separator.

func (*HeaderPrinter) Print

func (p *HeaderPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*HeaderPrinter) Printf

func (p *HeaderPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*HeaderPrinter) Println

func (p *HeaderPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (HeaderPrinter) Sprint

func (p HeaderPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (HeaderPrinter) Sprintf

func (p HeaderPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (HeaderPrinter) Sprintln

func (p HeaderPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (HeaderPrinter) WithBackgroundStyle

func (p HeaderPrinter) WithBackgroundStyle(style *Style) *HeaderPrinter

WithBackgroundStyle changes the background styling of the header.

func (HeaderPrinter) WithFullWidth

func (p HeaderPrinter) WithFullWidth(b ...bool) *HeaderPrinter

WithFullWidth enables full width on a HeaderPrinter.

func (HeaderPrinter) WithMargin

func (p HeaderPrinter) WithMargin(margin int) *HeaderPrinter

WithMargin changes the background styling of the header.

func (HeaderPrinter) WithTextStyle

func (p HeaderPrinter) WithTextStyle(style *Style) *HeaderPrinter

WithTextStyle returns a new HeaderPrinter with changed

type Letter

type Letter struct {
	String string
	Style  *Style
}

Letter is an object, which holds a string and a specific Style for it.

func (Letter) WithString

func (l Letter) WithString(s string) *Letter

WithString returns a new Letter with a specific String.

func (Letter) WithStyle

func (l Letter) WithStyle(style *Style) *Letter

WithStyle returns a new Letter with a specific Style.

type Letters

type Letters []Letter

Letters is a slice of Letter.

func NewLettersFromString

func NewLettersFromString(text string) Letters

NewLettersFromString creates a Letters object from a string, which is prefilled with the LetterStyle from ThemeDefault. You can override the ThemeDefault LetterStyle if you want to.

func NewLettersFromStringWithStyle

func NewLettersFromStringWithStyle(text string, style *Style) Letters

NewLettersFromStringWithStyle creates a Letters object from a string and applies a Style to it.

type LeveledList

type LeveledList []LeveledListItem

LeveledList is a list, which contains multiple LeveledListItem.

type LeveledListItem

type LeveledListItem struct {
	Level int
	Text  string
}

LeveledListItem combines a text with a specific level. The level is the indent, which would normally be seen in a BulletListPrinter.

type LivePrinter

type LivePrinter interface {
	// GenericStart runs Start, but returns a LivePrinter.
	// This is used for the interface LivePrinter.
	// You most likely want to use Start instead of this in your program.
	GenericStart() (*LivePrinter, error)

	// GenericStop runs Stop, but returns a LivePrinter.
	// This is used for the interface LivePrinter.
	// You most likely want to use Stop instead of this in your program.
	GenericStop() (*LivePrinter, error)
}

LivePrinter is a printer which can update it's output live.

type Panel

type Panel struct {
	Data string
}

Panel contains the data, which should be printed inside a PanelPrinter.

type PanelPrinter

type PanelPrinter struct {
	Panels          Panels
	Padding         int
	BottomPadding   int
	SameColumnWidth bool
	BoxPrinter      BoxPrinter
}

PanelPrinter prints content in boxes.

func (PanelPrinter) Render

func (p PanelPrinter) Render() error

Render prints the Template to the terminal.

func (PanelPrinter) Srender

func (p PanelPrinter) Srender() (string, error)

Srender renders the Template as a string.

func (PanelPrinter) WithBottomPadding

func (p PanelPrinter) WithBottomPadding(bottomPadding int) *PanelPrinter

WithBottomPadding returns a new PanelPrinter with specific options.

func (PanelPrinter) WithBoxPrinter

func (p PanelPrinter) WithBoxPrinter(boxPrinter BoxPrinter) *PanelPrinter

WithBoxPrinter returns a new PanelPrinter with specific options.

func (PanelPrinter) WithPadding

func (p PanelPrinter) WithPadding(padding int) *PanelPrinter

WithPadding returns a new PanelPrinter with specific options.

func (PanelPrinter) WithPanels

func (p PanelPrinter) WithPanels(panels Panels) *PanelPrinter

WithPanels returns a new PanelPrinter with specific options.

func (PanelPrinter) WithSameColumnWidth

func (p PanelPrinter) WithSameColumnWidth(b ...bool) *PanelPrinter

WithSameColumnWidth returns a new PanelPrinter with specific options.

type Panels

type Panels [][]Panel

Panels is a two dimensional coordinate system for Panel.

type ParagraphPrinter

type ParagraphPrinter struct {
	MaxWidth int
}

ParagraphPrinter can print paragraphs to a fixed line width. The text will split between words, so that words will stick together. It's like in a book.

func (*ParagraphPrinter) Print

func (p *ParagraphPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*ParagraphPrinter) Printf

func (p *ParagraphPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*ParagraphPrinter) Println

func (p *ParagraphPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (ParagraphPrinter) Sprint

func (p ParagraphPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (ParagraphPrinter) Sprintf

func (p ParagraphPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (ParagraphPrinter) Sprintln

func (p ParagraphPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (ParagraphPrinter) WithMaxWidth

func (p ParagraphPrinter) WithMaxWidth(width int) *ParagraphPrinter

WithMaxWidth returns a new ParagraphPrinter with a specific MaxWidth

type Prefix

type Prefix struct {
	Text  string
	Style *Style
}

Prefix contains the data used as the beginning of a printed text via a PrefixPrinter.

type PrefixPrinter

type PrefixPrinter struct {
	Prefix         Prefix
	Scope          Scope
	MessageStyle   *Style
	Fatal          bool
	ShowLineNumber bool
	// If Debugger is true, the printer will only print if PrintDebugMessages is set to true.
	// You can change PrintDebugMessages with EnableDebugMessages and DisableDebugMessages, or by setting the variable itself.
	Debugger bool
}

PrefixPrinter is the printer used to print a Prefix.

func (PrefixPrinter) GetFormattedPrefix

func (p PrefixPrinter) GetFormattedPrefix() string

GetFormattedPrefix returns the Prefix as a styled text string.

func (*PrefixPrinter) Print

func (p *PrefixPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) Printf

func (p *PrefixPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) Println

func (p *PrefixPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (*PrefixPrinter) Sprint

func (p *PrefixPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (PrefixPrinter) Sprintf

func (p PrefixPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (PrefixPrinter) Sprintln

func (p PrefixPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (PrefixPrinter) WithDebugger

func (p PrefixPrinter) WithDebugger(b ...bool) *PrefixPrinter

WithDebugger returns a new Printer with specific Debugger value. If Debugger is true, the printer will only print if PrintDebugMessages is set to true. You can change PrintDebugMessages with EnableDebugMessages and DisableDebugMessages, or by setting the variable itself.

func (PrefixPrinter) WithFatal

func (p PrefixPrinter) WithFatal(b ...bool) *PrefixPrinter

WithFatal sets if the printer should panic after printing. NOTE: The printer will only panic if either PrefixPrinter.Println, PrefixPrinter.Print or PrefixPrinter.Printf is called.

func (PrefixPrinter) WithMessageStyle

func (p PrefixPrinter) WithMessageStyle(style *Style) *PrefixPrinter

WithMessageStyle adds a custom prefix to the printer.

func (PrefixPrinter) WithPrefix

func (p PrefixPrinter) WithPrefix(prefix Prefix) *PrefixPrinter

WithPrefix adds a custom prefix to the printer.

func (PrefixPrinter) WithScope

func (p PrefixPrinter) WithScope(scope Scope) *PrefixPrinter

WithScope adds a scope to the Prefix.

func (PrefixPrinter) WithShowLineNumber

func (p PrefixPrinter) WithShowLineNumber(b ...bool) *PrefixPrinter

WithShowLineNumber sets if the printer should print the line number from where it's called in a go file.

type ProgressbarPrinter

type ProgressbarPrinter struct {
	Title                     string
	Total                     int
	Current                   int
	BarCharacter              string
	LastCharacter             string
	ElapsedTimeRoundingFactor time.Duration
	BarFiller                 string

	ShowElapsedTime bool
	ShowCount       bool
	ShowTitle       bool
	ShowPercentage  bool
	RemoveWhenDone  bool

	TitleStyle *Style
	BarStyle   *Style

	IsActive bool
	// contains filtered or unexported fields
}

ProgressbarPrinter shows a progress animation in the terminal.

func (*ProgressbarPrinter) Add

func (p *ProgressbarPrinter) Add(count int) *ProgressbarPrinter

Add to current value.

func (ProgressbarPrinter) GenericStart

func (p ProgressbarPrinter) GenericStart() (*LivePrinter, error)

GenericStart runs Start, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Start instead of this in your program.

func (ProgressbarPrinter) GenericStop

func (p ProgressbarPrinter) GenericStop() (*LivePrinter, error)

GenericStop runs Stop, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Stop instead of this in your program.

func (*ProgressbarPrinter) GetElapsedTime

func (p *ProgressbarPrinter) GetElapsedTime() time.Duration

GetElapsedTime returns the elapsed time, since the ProgressbarPrinter was started.

func (*ProgressbarPrinter) Increment

func (p *ProgressbarPrinter) Increment() *ProgressbarPrinter

Increment current value by one.

func (ProgressbarPrinter) Start

func (p ProgressbarPrinter) Start() (*ProgressbarPrinter, error)

Start the ProgressbarPrinter.

func (*ProgressbarPrinter) Stop

func (p *ProgressbarPrinter) Stop() (*ProgressbarPrinter, error)

Stop the ProgressbarPrinter.

func (ProgressbarPrinter) WithBarCharacter

func (p ProgressbarPrinter) WithBarCharacter(char string) *ProgressbarPrinter

WithBarCharacter sets the bar character of the ProgressbarPrinter.

func (ProgressbarPrinter) WithBarStyle

func (p ProgressbarPrinter) WithBarStyle(style *Style) *ProgressbarPrinter

WithBarStyle sets the style of the bar.

func (ProgressbarPrinter) WithCurrent

func (p ProgressbarPrinter) WithCurrent(current int) *ProgressbarPrinter

WithCurrent sets the current value of the ProgressbarPrinter.

func (ProgressbarPrinter) WithElapsedTimeRoundingFactor

func (p ProgressbarPrinter) WithElapsedTimeRoundingFactor(duration time.Duration) *ProgressbarPrinter

WithElapsedTimeRoundingFactor sets the rounding factor of the elapsed time.

func (ProgressbarPrinter) WithLastCharacter

func (p ProgressbarPrinter) WithLastCharacter(char string) *ProgressbarPrinter

WithLastCharacter sets the last character of the ProgressbarPrinter.

func (ProgressbarPrinter) WithRemoveWhenDone

func (p ProgressbarPrinter) WithRemoveWhenDone(b ...bool) *ProgressbarPrinter

WithRemoveWhenDone sets if the ProgressbarPrinter should be removed when it is done.

func (ProgressbarPrinter) WithShowCount

func (p ProgressbarPrinter) WithShowCount(b ...bool) *ProgressbarPrinter

WithShowCount sets if the total and current count should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithShowElapsedTime

func (p ProgressbarPrinter) WithShowElapsedTime(b ...bool) *ProgressbarPrinter

WithShowElapsedTime sets if the elapsed time should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithShowPercentage

func (p ProgressbarPrinter) WithShowPercentage(b ...bool) *ProgressbarPrinter

WithShowPercentage sets if the completed percentage should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithShowTitle

func (p ProgressbarPrinter) WithShowTitle(b ...bool) *ProgressbarPrinter

WithShowTitle sets if the title should be displayed in the ProgressbarPrinter.

func (ProgressbarPrinter) WithTitle

func (p ProgressbarPrinter) WithTitle(name string) *ProgressbarPrinter

WithTitle sets the name of the ProgressbarPrinter.

func (ProgressbarPrinter) WithTitleStyle

func (p ProgressbarPrinter) WithTitleStyle(style *Style) *ProgressbarPrinter

WithTitleStyle sets the style of the title.

func (ProgressbarPrinter) WithTotal

func (p ProgressbarPrinter) WithTotal(total int) *ProgressbarPrinter

WithTotal sets the total value of the ProgressbarPrinter.

type RGB

type RGB struct {
	R uint8
	G uint8
	B uint8
}

RGB color model is an additive color model in which red, green, and blue light are added together in various ways to reproduce a broad array of colors. The name of the model comes from the initials of the three additive primary colors, red, green, and blue. https://en.wikipedia.org/wiki/RGB_color_model

func NewRGB

func NewRGB(r, g, b uint8) RGB

NewRGB returns a new RGB.

func NewRGBFromHEX

func NewRGBFromHEX(hex string) (RGB, error)

NewRGBFromHEX converts a HEX and returns a new RGB.

func (RGB) Fade

func (p RGB) Fade(min, max, current float32, end ...RGB) RGB

Fade fades one RGB value (over other RGB values) to another RGB value, by giving the function a minimum, maximum and current value.

func (RGB) GetValues

func (p RGB) GetValues() (r, g, b uint8)

GetValues returns the RGB values separately.

func (RGB) Print

func (p RGB) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (RGB) Printf

func (p RGB) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (RGB) Println

func (p RGB) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (RGB) Sprint

func (p RGB) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (RGB) Sprintf

func (p RGB) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (RGB) Sprintln

func (p RGB) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

type RenderPrinter

type RenderPrinter interface {
	// Render the XXX to the terminal.
	Render() error

	// Srender returns the rendered string of XXX.
	Srender() (string, error)
}

RenderPrinter is used to display renderable content. Example for renderable content is a Table.

type Scope

type Scope struct {
	Text  string
	Style *Style
}

Scope contains the data of the optional scope of a prefix. If it has a text, it will be printed after the Prefix in brackets.

type SectionPrinter

type SectionPrinter struct {
	Style           *Style
	Level           int
	IndentCharacter string
	TopPadding      int
	BottomPadding   int
}

SectionPrinter prints a new section title. It can be used to structure longer text, or different chapters of your program.

func (*SectionPrinter) Print

func (p *SectionPrinter) Print(a ...interface{}) *TextPrinter

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered.

func (*SectionPrinter) Printf

func (p *SectionPrinter) Printf(format string, a ...interface{}) *TextPrinter

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered.

func (*SectionPrinter) Println

func (p *SectionPrinter) Println(a ...interface{}) *TextPrinter

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered.

func (SectionPrinter) Sprint

func (p SectionPrinter) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string.

func (SectionPrinter) Sprintf

func (p SectionPrinter) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string.

func (SectionPrinter) Sprintln

func (p SectionPrinter) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended.

func (SectionPrinter) WithBottomPadding

func (p SectionPrinter) WithBottomPadding(padding int) *SectionPrinter

WithBottomPadding returns a new SectionPrinter with a specific top padding.

func (SectionPrinter) WithIndentCharacter

func (p SectionPrinter) WithIndentCharacter(char string) *SectionPrinter

WithIndentCharacter returns a new SectionPrinter with a specific IndentCharacter.

func (SectionPrinter) WithLevel

func (p SectionPrinter) WithLevel(level int) *SectionPrinter

WithLevel returns a new SectionPrinter with a specific level.

func (SectionPrinter) WithStyle

func (p SectionPrinter) WithStyle(style *Style) *SectionPrinter

WithStyle returns a new SectionPrinter with a specific style.

func (SectionPrinter) WithTopPadding

func (p SectionPrinter) WithTopPadding(padding int) *SectionPrinter

WithTopPadding returns a new SectionPrinter with a specific top padding.

type SpinnerPrinter

type SpinnerPrinter struct {
	Text           string
	Sequence       []string
	Style          *Style
	Delay          time.Duration
	MessageStyle   *Style
	SuccessPrinter TextPrinter
	FailPrinter    TextPrinter
	WarningPrinter TextPrinter
	RemoveWhenDone bool

	IsActive bool
}

SpinnerPrinter is a loading animation, which can be used if the progress is unknown. It's an animation loop, which can have a text and supports throwing errors or warnings. A TextPrinter is used to display all outputs, after the SpinnerPrinter is done.

func (*SpinnerPrinter) Fail

func (s *SpinnerPrinter) Fail(message ...interface{})

Fail displays the fail printer. If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (*SpinnerPrinter) GenericStart

func (s *SpinnerPrinter) GenericStart() (*LivePrinter, error)

GenericStart runs Start, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Start instead of this in your program.

func (*SpinnerPrinter) GenericStop

func (s *SpinnerPrinter) GenericStop() (*LivePrinter, error)

GenericStop runs Stop, but returns a LivePrinter. This is used for the interface LivePrinter. You most likely want to use Stop instead of this in your program.

func (SpinnerPrinter) Start

func (s SpinnerPrinter) Start(text ...interface{}) (*SpinnerPrinter, error)

Start the SpinnerPrinter.

func (*SpinnerPrinter) Stop

func (s *SpinnerPrinter) Stop() error

Stop terminates the SpinnerPrinter immediately. The SpinnerPrinter will not resolve into anything.

func (*SpinnerPrinter) Success

func (s *SpinnerPrinter) Success(message ...interface{})

Success displays the success printer. If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (*SpinnerPrinter) UpdateText

func (s *SpinnerPrinter) UpdateText(text string)

UpdateText updates the message of the active SpinnerPrinter. Can be used live.

func (*SpinnerPrinter) Warning

func (s *SpinnerPrinter) Warning(message ...interface{})

Warning displays the warning printer. If no message is given, the text of the SpinnerPrinter will be reused as the default message.

func (SpinnerPrinter) WithDelay

func (s SpinnerPrinter) WithDelay(delay time.Duration) *SpinnerPrinter

WithDelay adds a delay to the SpinnerPrinter.

func (SpinnerPrinter) WithMessageStyle

func (s SpinnerPrinter) WithMessageStyle(style *Style) *SpinnerPrinter

WithMessageStyle adds a style to the SpinnerPrinter message.

func (SpinnerPrinter) WithRemoveWhenDone

func (s SpinnerPrinter) WithRemoveWhenDone(b ...bool) *SpinnerPrinter

WithRemoveWhenDone removes the SpinnerPrinter after it is done.

func (SpinnerPrinter) WithSequence

func (s SpinnerPrinter) WithSequence(sequence ...string) *SpinnerPrinter

WithSequence adds a sequence to the SpinnerPrinter.

func (SpinnerPrinter) WithStyle

func (s SpinnerPrinter) WithStyle(style *Style) *SpinnerPrinter

WithStyle adds a style to the SpinnerPrinter.

func (SpinnerPrinter) WithText

func (s SpinnerPrinter) WithText(text string) *SpinnerPrinter

WithText adds a text to the SpinnerPrinter.

type Style

type Style []Color

Style is a collection of colors. Can include foreground, background and styling (eg. Bold, Underscore, etc.) colors.

func NewStyle

func NewStyle(colors ...Color) *Style

NewStyle returns a new Style. Accepts multiple colors.

func (Style) Add

func (s Style) Add(styles ...Style) Style

Add styles to the current Style.

func (Style) Code

func (s Style) Code() string

Code convert to code string. returns like "32;45;3".

func (Style) Print

func (s Style) Print(a ...interface{})

Print formats using the default formats for its operands and writes to standard output. Spaces are added between operands when neither is a string. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Printf

func (s Style) Printf(format string, a ...interface{})

Printf formats according to a format specifier and writes to standard output. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Println

func (s Style) Println(a ...interface{})

Println formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended. It returns the number of bytes written and any write error encountered. Input will be colored with the parent Style.

func (Style) Sprint

func (s Style) Sprint(a ...interface{}) string

Sprint formats using the default formats for its operands and returns the resulting string. Spaces are added between operands when neither is a string. Input will be colored with the parent Style.

func (Style) Sprintf

func (s Style) Sprintf(format string, a ...interface{}) string

Sprintf formats according to a format specifier and returns the resulting string. Input will be colored with the parent Style.

func (Style) Sprintln

func (s Style) Sprintln(a ...interface{}) string

Sprintln formats using the default formats for its operands and returns the resulting string. Spaces are always added between operands and a newline is appended. Input will be colored with the parent Style.

func (Style) String

func (s Style) String() string

String convert to code string. returns like "32;45;3".

type TableData

type TableData [][]string

TableData is the type that contains the data of a TablePrinter.

type TablePrinter

type TablePrinter struct {
	Style          *Style
	HasHeader      bool
	HeaderStyle    *Style
	Separator      string
	SeparatorStyle *Style
	Data           TableData
}

TablePrinter is able to render tables.

func (TablePrinter) Render

func (p TablePrinter) Render() error

Render prints the TablePrinter to the terminal.

func (TablePrinter) Srender

func (p TablePrinter) Srender() (string, error)

Srender renders the TablePrinter as a string.

func (TablePrinter) WithCSVReader

func (p TablePrinter) WithCSVReader(reader *csv.Reader) *TablePrinter

WithCSVReader return a new TablePrinter with specified Data extracted from CSV.

func (TablePrinter) WithData

func (p TablePrinter) WithData(data [][]string) *TablePrinter

WithData returns a new TablePrinter with specific Data.

func (TablePrinter) WithHasHeader

func (p TablePrinter) WithHasHeader(b ...bool) *TablePrinter

WithHasHeader returns a new TablePrinter, where the first line is marked as a header.

func (TablePrinter) WithHeaderStyle

func (p TablePrinter) WithHeaderStyle(style *Style) *TablePrinter

WithHeaderStyle returns a new TablePrinter with a specific HeaderStyle.

func (TablePrinter) WithSeparator

func (p TablePrinter) WithSeparator(separator string) *TablePrinter

WithSeparator returns a new TablePrinter with a specific separator.

func (TablePrinter) WithSeparatorStyle

func (p TablePrinter) WithSeparatorStyle(style *Style) *TablePrinter

WithSeparatorStyle returns a new TablePrinter with a specific SeparatorStyle.

func (TablePrinter) WithStyle

func (p TablePrinter) WithStyle(style *Style) *TablePrinter

WithStyle returns a new TablePrinter with a specific Style.

type TextPrinter

type TextPrinter interface {
	// Sprint formats using the default formats for its operands and returns the resulting string.
	// Spaces are added between operands when neither is a string.
	Sprint(a ...interface{}) string

	// Sprintln formats using the default formats for its operands and returns the resulting string.
	// Spaces are always added between operands and a newline is appended.
	Sprintln(a ...interface{}) string

	// Sprintf formats according to a format specifier and returns the resulting string.
	Sprintf(format string, a ...interface{}) string

	// Print formats using the default formats for its operands and writes to standard output.
	// Spaces are added between operands when neither is a string.
	// It returns the number of bytes written and any write error encountered.
	Print(a ...interface{}) *TextPrinter

	// Println formats using the default formats for its operands and writes to standard output.
	// Spaces are always added between operands and a newline is appended.
	// It returns the number of bytes written and any write error encountered.
	Println(a ...interface{}) *TextPrinter

	// Printf formats according to a format specifier and writes to standard output.
	// It returns the number of bytes written and any write error encountered.
	Printf(format string, a ...interface{}) *TextPrinter
}

TextPrinter contains methods to print formatted text to the console or return it as a string.

type Theme

type Theme struct {
	PrimaryStyle            Style
	SecondaryStyle          Style
	HighlightStyle          Style
	InfoMessageStyle        Style
	InfoPrefixStyle         Style
	SuccessMessageStyle     Style
	SuccessPrefixStyle      Style
	WarningMessageStyle     Style
	WarningPrefixStyle      Style
	ErrorMessageStyle       Style
	ErrorPrefixStyle        Style
	FatalMessageStyle       Style
	FatalPrefixStyle        Style
	DescriptionMessageStyle Style
	DescriptionPrefixStyle  Style
	ScopeStyle              Style
	ProgressbarBarStyle     Style
	ProgressbarTitleStyle   Style
	HeaderTextStyle         Style
	HeaderBackgroundStyle   Style
	SpinnerStyle            Style
	SpinnerTextStyle        Style
	TableStyle              Style
	TableHeaderStyle        Style
	TableSeparatorStyle     Style
	SectionStyle            Style
	BulletListTextStyle     Style
	BulletListBulletStyle   Style
	TreeStyle               Style
	TreeTextStyle           Style
	LetterStyle             Style
	DebugMessageStyle       Style
	DebugPrefixStyle        Style
	BoxStyle                Style
	BoxTextStyle            Style
	BarLabelStyle           Style
	BarStyle                Style
}

Theme for PTerm. Theme contains every Style used in PTerm. You can create own themes for your application or use one of the existing themes.

func (Theme) WithBarLabelStyle

func (t Theme) WithBarLabelStyle(style Style) Theme

WithBarLabelStyle returns a new theme with overridden value.

func (Theme) WithBarStyle

func (t Theme) WithBarStyle(style Style) Theme

WithBarStyle returns a new theme with overridden value.

func (Theme) WithBoxStyle

func (t Theme) WithBoxStyle(style Style) Theme

WithBoxStyle returns a new theme with overridden value.

func (Theme) WithBoxTextStyle

func (t Theme) WithBoxTextStyle(style Style) Theme

WithBoxTextStyle returns a new theme with overridden value.

func (Theme) WithBulletListBulletStyle

func (t Theme) WithBulletListBulletStyle(style Style) Theme

WithBulletListBulletStyle returns a new theme with overridden value.

func (Theme) WithBulletListTextStyle

func (t Theme) WithBulletListTextStyle(style Style) Theme

WithBulletListTextStyle returns a new theme with overridden value.

func (Theme) WithDebugMessageStyle

func (t Theme) WithDebugMessageStyle(style Style) Theme

WithDebugMessageStyle returns a new theme with overridden value.

func (Theme) WithDebugPrefixStyle

func (t Theme) WithDebugPrefixStyle(style Style) Theme

WithDebugPrefixStyle returns a new theme with overridden value.

func (Theme) WithDescriptionMessageStyle

func (t Theme) WithDescriptionMessageStyle(style Style) Theme

WithDescriptionMessageStyle returns a new theme with overridden value.

func (Theme) WithDescriptionPrefixStyle

func (t Theme) WithDescriptionPrefixStyle(style Style) Theme

WithDescriptionPrefixStyle returns a new theme with overridden value.

func (Theme) WithErrorMessageStyle

func (t Theme) WithErrorMessageStyle(style Style) Theme

WithErrorMessageStyle returns a new theme with overridden value.

func (Theme) WithErrorPrefixStyle

func (t Theme) WithErrorPrefixStyle(style Style) Theme

WithErrorPrefixStyle returns a new theme with overridden value.

func (Theme) WithFatalMessageStyle

func (t Theme) WithFatalMessageStyle(style Style) Theme

WithFatalMessageStyle returns a new theme with overridden value.

func (Theme) WithFatalPrefixStyle

func (t Theme) WithFatalPrefixStyle(style Style) Theme

WithFatalPrefixStyle returns a new theme with overridden value.

func (Theme) WithHighlightStyle

func (t Theme) WithHighlightStyle(style Style) Theme

WithHighlightStyle returns a new theme with overridden value.

func (Theme) WithInfoMessageStyle

func (t Theme) WithInfoMessageStyle(style Style) Theme

WithInfoMessageStyle returns a new theme with overridden value.

func (Theme) WithInfoPrefixStyle

func (t Theme) WithInfoPrefixStyle(style Style) Theme

WithInfoPrefixStyle returns a new theme with overridden value.

func (Theme) WithLetterStyle

func (t Theme) WithLetterStyle(style Style) Theme

WithLetterStyle returns a new theme with overridden value.

func (Theme) WithPrimaryStyle

func (t Theme) WithPrimaryStyle(style Style) Theme

WithPrimaryStyle returns a new theme with overridden value.

func (Theme) WithSecondaryStyle

func (t Theme) WithSecondaryStyle(style Style) Theme

WithSecondaryStyle returns a new theme with overridden value.

func (Theme) WithSuccessMessageStyle

func (t Theme) WithSuccessMessageStyle(style Style) Theme

WithSuccessMessageStyle returns a new theme with overridden value.

func (Theme) WithSuccessPrefixStyle

func (t Theme) WithSuccessPrefixStyle(style Style) Theme

WithSuccessPrefixStyle returns a new theme with overridden value.

func (Theme) WithTreeStyle

func (t Theme) WithTreeStyle(style Style) Theme

WithTreeStyle returns a new theme with overridden value.

func (Theme) WithTreeTextStyle

func (t Theme) WithTreeTextStyle(style Style) Theme

WithTreeTextStyle returns a new theme with overridden value.

func (Theme) WithWarningMessageStyle

func (t Theme) WithWarningMessageStyle(style Style) Theme

WithWarningMessageStyle returns a new theme with overridden value.

func (Theme) WithWarningPrefixStyle

func (t Theme) WithWarningPrefixStyle(style Style) Theme

WithWarningPrefixStyle returns a new theme with overridden value.

type TreeNode

type TreeNode struct {
	Children []TreeNode
	Text     string
}

TreeNode is used as items in a TreePrinter.

func NewTreeFromLeveledList

func NewTreeFromLeveledList(leveledListItems LeveledList) TreeNode

NewTreeFromLeveledList converts a TreeItems list to a TreeNode and returns it.

type TreePrinter

type TreePrinter struct {
	Root                 TreeNode
	TreeStyle            *Style
	TextStyle            *Style
	TopRightCornerString string
	TopRightDownString   string
	HorizontalString     string
	VerticalString       string
	RightDownLeftString  string
	Indent               int
}

TreePrinter is able to render a list.

func (TreePrinter) Render

func (p TreePrinter) Render() error

Render prints the list to the terminal.

func (TreePrinter) Srender

func (p TreePrinter) Srender() (string, error)

Srender renders the list as a string.

func (TreePrinter) WithHorizontalString

func (p TreePrinter) WithHorizontalString(s string) *TreePrinter

WithHorizontalString returns a new list with a specific HorizontalString.

func (TreePrinter) WithIndent

func (p TreePrinter) WithIndent(indent int) *TreePrinter

WithIndent returns a new list with a specific amount of spacing between the levels. Indent must be at least 1.

func (TreePrinter) WithRoot

func (p TreePrinter) WithRoot(root TreeNode) *TreePrinter

WithRoot returns a new list with a specific Root.

func (TreePrinter) WithTextStyle

func (p TreePrinter) WithTextStyle(style *Style) *TreePrinter

WithTextStyle returns a new list with a specific text style.

func (TreePrinter) WithTopRightCornerString

func (p TreePrinter) WithTopRightCornerString(s string) *TreePrinter

WithTopRightCornerString returns a new list with a specific TopRightCornerString.

func (TreePrinter) WithTopRightDownStringOngoing

func (p TreePrinter) WithTopRightDownStringOngoing(s string) *TreePrinter

WithTopRightDownStringOngoing returns a new list with a specific TopRightDownString.

func (TreePrinter) WithTreeStyle

func (p TreePrinter) WithTreeStyle(style *Style) *TreePrinter

WithTreeStyle returns a new list with a specific tree style.

func (TreePrinter) WithVerticalString

func (p TreePrinter) WithVerticalString(s string) *TreePrinter

WithVerticalString returns a new list with a specific VerticalString.