Esempio n. 1
0
func main() {
	window := geometry.Flag("window.geometry", image.Rect(0, 0, 117, 20), "window geometry in pixels")
	battRect := geometry.Flag("battery.geometry", image.Rect(0, 0, 21, 18).Add(image.Pt(1, 2)), "battery icon geometry in pixels")
	borderThickness := flag.Int("border", 1, "battery border thickness in pixels")
	textRect := geometry.Flag("text.geometry", image.Rect(0, 0, 95, 20).Add(image.Pt(22, 0)), "text box geometry in pixels")
	textFont := flag.String("text.font", "DejaVuSans-Bold", "application text font")
	textFontSize := flag.Float64("text.fontsize", 14, "application text font size")
	textInterval := flag.Duration("text.interval", 7*time.Second+500*time.Millisecond, "interval to display each formatted text metric")
	flag.Parse()

	// remaining arguments are text formatters to rotate between
	var formatters []battery.MetricFormatter
	for _, tsrc := range flag.Args() {
		t, err := battery.FormatMetricTemplate(tsrc)
		if err != nil {
			log.Fatalf("template: %v %q", err, tsrc)
		}
		formatters = append(formatters, t)
	}
	if len(formatters) == 0 {
		formatters = append(formatters, defaultFormatters...)
	}

	// Open the specified font.
	ttfpath, err := LocateFont(*textFont)
	if err != nil {
		log.Fatalf("font: %v", err)
	}
	font, err := ReadFontFile(ttfpath)
	if err != nil {
		log.Fatalf("font: %v", err)
	}

	// configure the application window layout
	layout := &AppLayout{
		rect:      *window,
		battRect:  *battRect,
		textRect:  *textRect,
		thickness: *borderThickness,
		DPI:       72,
		font:      font,
		fontSize:  *textFontSize,
	}

	app := NewApp(layout)
	app.BatteryColor = defaultGrey

	// Connect to the x server and create a dockapp window for the process.
	X, err := xgbutil.NewConn()
	if err != nil {
		log.Fatal(err)
	}
	dockapp, err := dockapp.New(X, *window)
	if err != nil {
		log.Fatal(err)
	}
	defer dockapp.Destroy()

	// begin profiling the battery.  prime the profile by immediately calling
	// the Metrics method.
	metricsc := make(chan *battery.Metrics, 1)
	guage, err := creeperguage.NewCreeperBatteryGuage()
	if err != nil {
		log.Fatal(err)
	}
	batt := battery.NewProfiler(guage)
	go batt.Start(time.Minute, metricsc)
	defer batt.Stop()

	// rotate through all provided formatters (or the default set), sending
	// them to the draw loop at the specified interval.
	formatterc := make(chan battery.MetricFormatter, 1)
	go battery.RotateMetricsFormat(*textInterval, formatterc, formatters...)

	// begin the main draw loop. the draw loop receives updates in the form of
	// new battery metrics and formatters.  The event loop will exit if the
	// draw loop ever terminates.
	go RunApp(dockapp, app, metricsc, formatterc)

	// finally map the window and start the main event loop
	dockapp.Main()
}
Esempio n. 2
0
func main() {
	defer func() {
		if e := recover(); e != nil {
			panic(e)
		}
		panic("show me the stacks")
	}()
	window := geometry.Flag("window.geometry", image.Rect(0, 0, 100, 20), "window geometry in pixels")
	ignore := flag.String("ignore", "", "comma separated list of cpus to ignore")
	flag.Parse()

	poll, err := Poll(time.Second)
	if err != nil {
		log.Fatal(err)
	}
	delta := Delta(poll.C)
	deltaCPU := TimeToCPU(delta)
	if *ignore != "" {
		ignores := strings.Split(*ignore, ",")
		deltaCPU = FilterCPU(deltaCPU, ignores)
	}

	app := NewApp()

	// Connect to the x server and create a dockapp window for the process.
	X, err := xgbutil.NewConn()
	if err != nil {
		log.Fatal(err)
	}

	sig := make(chan os.Signal, 1)
	signal.Notify(sig, os.Interrupt, syscall.SIGTERM)

	dockapp, err := dockapp.New(X, *window)
	if err != nil {
		log.Fatal(err)
	}
	defer dockapp.Destroy()
	defer dockapp.Quit()
	// map the window and start the main event loop
	go dockapp.Main()

	// begin the main draw loop. the draw loop receives updates in the form of
	// new battery metrics and formatters.  The event loop will exit if the
	// draw loop ever terminates.
	go RunApp(dockapp, app, deltaCPU)

	var timeout <-chan time.Time
	for {
		select {
		case s := <-sig:
			signal.Stop(sig)

			log.Printf("signal received: %s", s)

			poll.Stop()
			timeout = time.After(time.Second)
		case <-timeout:
			panic("timeout")
		case <-app.Done():
			return
		}
	}
}