Example #1
0
// PlsNotify notifies you of begining and end of pomododo
func PlsNotify(status string) {
	if status == "begin" {
		os := checkOsVersion()
		if os == "darwin" {
			cmd := exec.Command("bash", "-c", `osascript -e  'display  notification  "Pomodoro begins!"  with  title  "Pomodoro"'`)
			_, err := cmd.Output()
			if err != nil {
				fmt.Println("Error sending notification")
			}
		} else if os == "linux" {
			notify = notificator.New(notificator.Options{
				AppName: "Termodoro",
			})
			notify.Push("Termordoro", "Pomodoro begins!", "", notificator.UR_NORMAL)
		} else if os == "window" {
			fmt.Println("Notifications aren't supported on your platform.")
		}
	} else if status == "end" {
		os := checkOsVersion()
		if os == "darwin" {
			cmd := exec.Command("bash", "-c", `osascript -e  'display  notification  "Your Pomodoro has ended!"  with  title  "Pomodoro"'`)
			_, err := cmd.Output()
			if err != nil {
				fmt.Println("Error sending notification")
			}
		} else if os == "linux" {
			notify = notificator.New(notificator.Options{
				AppName: "Termodoro",
			})
			notify.Push("Termordoro", "Your pomodoro has ended!", "", notificator.UR_NORMAL)
		} else if os == "window" {
			fmt.Println("Notifications aren't supported on your platform.")
		}
	}
}
func SendNotification(result []string) {
	var notify *notificator.Notificator
	notify = notificator.New(notificator.Options{
		DefaultIcon: Icon,
		AppName:     "Zabbix",
	})

	for _, val := range result {
		notify.Push("Server Alert", val, Icon, notificator.UR_CRITICAL)
	}

}
Example #3
0
func showNotification(message string) {
	notify := notificator.New(notificator.Options{
		DefaultIcon: "icon/default.png",
		AppName:     "Timer",
	})

	notify.Push("Take a Break", message, "", notificator.UR_CRITICAL)

	// Check errors
	//	err := notify.Push("error", "ops =(", "", notificator.UR_CRITICAL)

	//if err != nil {
	//	log.Fatal(err)
	//}

}
Example #4
0
func init() {
	const (
		defaultDuration = "25m"
		durationUsage   = "Duration, e.g. 1m30s or 90s"
		silenceUsage    = "Suppresses the notification after the timer ends"
	)

	flag.StringVar(&duration, "duration", defaultDuration, durationUsage)
	flag.StringVar(&duration, "d", defaultDuration, durationUsage+" (shorthand)")
	flag.BoolVar(&silence, "silence", false, silenceUsage)
	flag.BoolVar(&silence, "s", false, silenceUsage+" (shorthand)")
	flag.Parse()

	notify = notificator.New(notificator.Options{
		DefaultIcon: "icon/default.png",
		AppName:     "Pomodoro",
	})
}
func main() {
	var database DataBase
	var notify *notificator.Notificator
	notify = notificator.New(notificator.Options{
		DefaultIcon: "icon/default.png",
		AppName:     "Youtube",
	})

	database.session, _ = mgo.Dial("localhost:27017")
	defer database.session.Close()
	fmt.Println("session connected to mongodb")
	c := database.session.DB("youtube").C("toDownload")
	var R *Result
	//fmt.Println(*R)
	iter := c.Find(nil).Sort("$natural").Tail(time.Second * 5)
	for {
		for iter.Next(&R) {
			Res := R
			fmt.Println("Added result : " + Res.Url)
			notify.Push("Youtube Video", Res.Url, "", notificator.UR_NORMAL)
			mack.Notify(Res.Url, "Youtube")
			if !R.isDownloaded(&database) {
				go func(Res *Result) {
					err := R.download()
					if err == nil {
						Res.updateDB(&database)
						fmt.Println("waiting for : " + Res.Url)
						if err != nil {
							fmt.Println("Error while downloading video : " + Res.Url)
							fmt.Println(err)
						}
					}
				}(Res)
			} else {
				log.Printf("Video is already downloaded ", R.Url)
			}
		}
	}
}
Example #6
0
	"fmt"
	"os"
	"path/filepath"

	"github.com/0xAX/notificator"
)

var imagePath string

func init() {
	defaultIconLocation := fmt.Sprintf("%s/%s", os.Getenv("HOME"), "pomodogo/icon.png")
	flag.StringVar(&imagePath, "icon", defaultIconLocation, "location of notification icon")
}

var notify = notificator.New(notificator.Options{
	DefaultIcon: getImagePath("tomato.png"),
	AppName:     "PomodoGo",
})

func showMessage(message string) {
	notify.Push("PomodoGo!", message, imagePath, notificator.UR_CRITICAL)
}

func getImagePath(fileName string) string {
	dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
	if err != nil {
		return fileName
	}
	return fmt.Sprintf("%s/%s", dir, fileName)
}

// Finish displays system notification about finished Pomodoro period.
Example #7
0
File: main.go Project: Depado/gofip
// Initializes the GUI. Function is passed to ui.Do.
func initGui() {
	var cs, ps, ns song
	var player *gst.Element
	var playing bool

	// Creates the initial songs that will be used as long as the program runs.
	cs = song{api: &current.Current.songAPIType}
	ps = song{api: &current.Previous1.songAPIType}
	// ps2 := song{api: &current.Previous2.songAPIType}
	ns = song{api: &current.Next1.songAPIType}
	// ns2 := song{api: &current.Next2.songAPIType}

	// Creates the player and the controls for the player (as well as label).
	player = initPlayer()
	playing = true
	psl := ui.NewLabel("Currently Playing")
	ppbtn := ui.NewButton("Pause")
	ppbtn.OnClicked(func() {
		if playing {
			ppbtn.SetText("Play")
			player.SetState(gst.STATE_PAUSED)
			psl.SetText("Currently Paused")
		} else {
			ppbtn.SetText("Pause")
			psl.SetText("Currently Playing")
			player.SetState(gst.STATE_PLAYING)
		}
		playing = !playing
	})

	// Creates the notification system
	nt := notificator.New(notificator.Options{
		DefaultIcon: "icon/default.png",
		AppName:     "GoFip",
	})

	// Notification settings. Will be passed to the updateGui goroutine to Check
	// whether or not to send a system notification when the music changes.
	ntc := ui.NewCheckbox("Notifications")
	ntc.SetChecked(true)
	// Defines a closableTicker that is used in the updateGui goroutine
	// This allows to close the ticker when the setting button is unchecked.
	ct := closableTicker{
		ticker: time.NewTicker(1 * time.Minute),
		halt:   make(chan bool, 1),
	}
	prc := ui.NewCheckbox("Periodic Check")
	prc.SetChecked(true)
	prc.OnToggled(func() {
		if !prc.Checked() {
			ct.stop()
		} else {
			ct = closableTicker{
				ticker: time.NewTicker(1 * time.Minute),
				halt:   make(chan bool, 1),
			}
			go updateGui(ct, nt, ntc, &cs, &ps, &ns)
		}
	})

	// Start the goroutine to update the GUI every minute (default behaviour)
	// Uses the closableTicker defined earlier so the goroutine can be stopped.
	go updateGui(ct, nt, ntc, &cs, &ps, &ns)

	// Creating the tabs with the songs as well as settings and credits.
	createTabs(&cs, &ps, &ns)
	ts := ui.NewTab()
	ts.Append("Current", cs.stack)
	ts.Append("Previous", ps.stack)
	ts.Append("Next", ns.stack)
	ts.Append("Settings", ui.NewVerticalStack(ntc, prc))
	ts.Append("Credits", ui.NewLabel("Depado 2015"))

	// Creates the main vertical stack that is passed to the main window.
	mvs := ui.NewVerticalStack(ts, ppbtn, psl)
	// The tab control must be set to stretchy otherwise it won't display the content.
	mvs.SetStretchy(0)

	// Creates the main window and the behaviour on close event.
	window = ui.NewWindow("GoFIP", width, height, mvs)
	window.OnClosing(func() bool {
		ui.Stop()
		return true
	})
	window.Show()

	// Starts the player once the window is shown.
	player.SetState(gst.STATE_PLAYING)
}
Example #8
0
func Layout(g *gocui.Gui) error {
	maxX, maxY := g.Size()

	notify = notificator.New(notificator.Options{
		AppName: Name,
	})

	// if _, err := g.SetView("sidebar", -1, -1, int(0.2*float32(maxX)), maxY-3); err != nil {
	// if err != gocui.ErrorUnkView {
	// return err
	// }
	// }

	if err := HeaderView(g, -1, -1, maxX, 1); err != nil {
		panic(err)
	}

	if _, _, ok := Server.HasChannel(client.StatusChannel); !ok {
		status := client.Channel{
			Status: true,
			Name:   client.StatusChannel,
			MaxX:   maxX,
			MaxY:   maxY,
			RenderHandler: func(channel *client.Channel, view *gocui.View) error {
				view.Autoscroll = true
				view.Wrap = true
				view.Frame = false

				// view.FgColor = gocui.ColorGreen
				view.BgColor = gocui.ColorDefault

				fmt.Fprintln(view, "")
				fmt.Fprintln(view, Logo)
				fmt.Fprintln(view, color.GreenString(VersionLine))

				client.StatusMessage(view, fmt.Sprintf("Welcome to the %s IRC client.", Name))
				client.StatusMessage(view, "Type /help for a list of commands.\n")

				return nil
			},
		}

		Server.AddChannel(&status)

		logger.Logger.Printf("LAYOUT %p %p\n", g, Server.Gui)

		if err := status.Render(false); err != nil {
			return err
		}

		BindHandlers()

	} else {
		for _, c := range Server.Channels {
			c.Update()
		}
	}

	if err := MenuView(g, maxX, maxY); err != nil {
		return err
	}

	// if err := InputView(g, 20, maxY-2, maxX, maxY); err != nil {
	// return err
	// }

	return nil
}