This directory contains examples of using the PTerm library.
SHOW SOURCE
package main
import (
"time"
"github.com/pterm/pterm"
)
func main() {
pterm.Info.Println("The previous text will stay in place, while the area updates.")
pterm.Print("\n\n") // Add two new lines as spacer.
area, _ := pterm.DefaultArea.WithCenter().Start() // Start the Area printer, with the Center option.
for i := 0; i < 10; i++ {
str, _ := pterm.DefaultBigText.WithLetters(pterm.NewLettersFromString(time.Now().Format("15:04:05"))).Srender() // Save current time in str.
area.Update(str) // Update Area contents.
time.Sleep(time.Second)
}
area.Stop()
}
SHOW SOURCE
package main
import (
"github.com/pterm/pterm"
)
func main() {
positiveBars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 5,
},
pterm.Bar{
Label: "Bar 2",
Value: 3,
},
pterm.Bar{
Label: "Longer Label",
Value: 7,
},
}
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
_ = pterm.DefaultBarChart.WithBars(positiveBars).Render()
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(positiveBars).Render()
}
SHOW SOURCE
package main
import (
"github.com/pterm/pterm"
)
func main() {
positiveBars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 5,
},
pterm.Bar{
Label: "Bar 2",
Value: 3,
},
pterm.Bar{
Label: "Longer Label",
Value: 7,
},
}
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
_ = pterm.DefaultBarChart.WithBars(positiveBars).Render()
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(positiveBars).Render()
}
SHOW SOURCE
package main
import (
"github.com/pterm/pterm"
)
func main() {
mixedBars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 2,
},
pterm.Bar{
Label: "Bar 2",
Value: -3,
},
pterm.Bar{
Label: "Bar 3",
Value: -2,
},
pterm.Bar{
Label: "Bar 4",
Value: 5,
},
pterm.Bar{
Label: "Longer Label",
Value: 7,
},
}
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
_ = pterm.DefaultBarChart.WithBars(mixedBars).WithShowValue().Render()
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(mixedBars).WithShowValue().Render()
}
SHOW SOURCE
package main
import (
"github.com/pterm/pterm"
)
func main() {
positiveBars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 5,
},
pterm.Bar{
Label: "Bar 2",
Value: 3,
},
pterm.Bar{
Label: "Longer Label",
Value: 7,
},
}
pterm.Info.Println("Chart example with positive only values (bars use 100% of chart area)")
_ = pterm.DefaultBarChart.WithBars(positiveBars).Render()
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(positiveBars).Render()
}
SHOW SOURCE
package main
import (
"github.com/pterm/pterm"
)
func main() {
mixedBars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: 2,
},
pterm.Bar{
Label: "Bar 2",
Value: -3,
},
pterm.Bar{
Label: "Bar 3",
Value: -2,
},
pterm.Bar{
Label: "Bar 4",
Value: 5,
},
pterm.Bar{
Label: "Longer Label",
Value: 7,
},
}
pterm.DefaultSection.Println("Chart example with mixed values (note screen space usage in case when ABSOLUTE values of negative and positive parts are differ too much)")
_ = pterm.DefaultBarChart.WithBars(mixedBars).WithShowValue().Render()
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(mixedBars).WithShowValue().Render()
}
SHOW SOURCE
package main
import (
"github.com/pterm/pterm"
)
func main() {
negativeBars := pterm.Bars{
pterm.Bar{
Label: "Bar 1",
Value: -5,
},
pterm.Bar{
Label: "Bar 2",
Value: -3,
},
pterm.Bar{
Label: "Longer Label",
Value: -7,
},
}
pterm.Info.Println("Chart example with negative only values (bars use 100% of chart area)")
_ = pterm.DefaultBarChart.WithBars(negativeBars).WithShowValue().Render()
_ = pterm.DefaultBarChart.WithHorizontal().WithBars(negativeBars).WithShowValue().Render()
}
SHOW SOURCE
package main
import "github.com/pterm/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!")
}
SHOW SOURCE
package main
import "github.com/pterm/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()
// NewLettersFromStringWithRGB can be used to create a large text with a specific RGB color.
pterm.DefaultBigText.WithLetters(
pterm.NewLettersFromStringWithRGB("PTerm", pterm.NewRGB(255, 215, 0))).
Render()
}
SHOW SOURCE
package main
import "github.com/pterm/pterm"
func main() {
pterm.Info.Println("This might not be rendered correctly on GitHub,\nbut 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.WithTitle("title").Sprint("Ut enim ad minim veniam,\nquis nostrud exercitation\nullamco laboris\nnisi ut aliquip\nex ea commodo\nconsequat.")
panel3 := pterm.DefaultBox.WithTitle("bottom center title").WithTitleBottomCenter().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.WithTitle("Lorem Ipsum").WithTitleBottomRight().WithRightPadding(0).WithBottomPadding(0).Println(panels)
}
SHOW SOURCE
package main
import (
"github.com/pterm/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()
}
SHOW SOURCE
package main
import (
"github.com/pterm/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()
}
SHOW SOURCE
package main
import "github.com/pterm/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()
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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)
}
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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)
}
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.DisableStyling()
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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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)
}
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.DisableStyling()
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.UpdateTitle("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
}
SHOW SOURCE
package main
import (
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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)
}
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.DisableStyling()
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.UpdateTitle("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
}
SHOW SOURCE
package main
import (
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import (
"strings"
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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)
}
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.DisableStyling()
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.UpdateTitle("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
}
SHOW SOURCE
package main
import (
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import (
"strings"
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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
}
SHOW SOURCE
package main
import "github.com/pterm/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)
}
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.DisableStyling()
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.UpdateTitle("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
}
SHOW SOURCE
package main
import (
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import (
"strings"
"github.com/pterm/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!")
}
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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!")
}
SHOW SOURCE
package main
import (
"math/rand"
"strconv"
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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.WithShowTimer(false).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
}
SHOW SOURCE
package main
import "github.com/pterm/pterm"
func main() {
// Print a default header.
pterm.DefaultHeader.Println("This is the default header!")
pterm.Println() // spacer
pterm.DefaultHeader.WithFullWidth().Println("This is a full-width header.")
}
SHOW SOURCE
package main
import "github.com/pterm/pterm"
func main() {
// All available options: https://pkg.go.dev/github.com/pterm/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!")
}
SHOW SOURCE
package main
import "github.com/pterm/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()
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import "github.com/pterm/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.
}
SHOW SOURCE
package main
import (
"strings"
"time"
"github.com/pterm/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.UpdateTitle("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.
}
}
SHOW SOURCE
package main
import "github.com/pterm/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")
}
SHOW SOURCE
package main
import (
"time"
"github.com/pterm/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 * 2) // 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 * 2) // 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 * 2) // 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) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("It's really much") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.UpdateText("We're nearly done!") // Update spinner text.
time.Sleep(time.Second) // Simulate 2 seconds of processing something.
spinnerLiveText.Success("Finally!") // Resolve spinner with success message.
}
SHOW SOURCE
package main
import "github.com/pterm/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!")
}
SHOW SOURCE
package main
import "github.com/pterm/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()
pterm.Println() // Blank line
// Create a table with right alignment.
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"},
}).WithRightAlignment().Render()
}
SHOW SOURCE
package main
import (
"github.com/pterm/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)
}
}
}
SHOW SOURCE
package main
import (
"github.com/pterm/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()
}