nasin/application.go

224 lines
6.9 KiB
Go

package nasin
import "fmt"
import "log"
import "flag"
import "image"
import "strings"
import "net/url"
import "git.tebibyte.media/tomo/tomo"
import "git.tebibyte.media/tomo/objects"
import "git.tebibyte.media/tomo/tomo/canvas"
import "git.tebibyte.media/tomo/nasin/internal/registrar"
// Application represents an application object.
type Application interface {
// Describe returns a description of the application.
Describe () ApplicationDescription
// Init performs the initial setup of the application.
Init () error
}
// ApplicationURLOpener is an application that can open a URL.
type ApplicationURLOpener interface {
Application
// OpenURL opens a new window with the contents of the given URL. If the
// given URL is unsupported, it returns an error (for example, an image
// viewer is not expected to open a text file).
//
// Applications should support the file:// scheme at the very least, and
// should also support others like http:// and https:// if possible.
OpenURL (*url.URL) error
// OpenNone is called when the application is launched without any URLs
// to open. The application may create some sort of default starting
// window, or call tomo.Stop().
OpenNone ()
}
// ApplicationFlagAdder is an application that supports reading command line
// flags.
type ApplicationFlagAdder interface {
Application
// AddFlags is called before Init and given the default flag set that
// Nasin uses to parse command line arguments. Note that when this
// method is called, Tomo will not yet be initialized.
AddFlags (*flag.FlagSet)
}
// ApplicationDescription describes the name and type of an application.
type ApplicationDescription struct {
// The name of the application.
Name string
// The ID of the application. This should be a well-known name, that is,
// a reversed domain name owned by the author with the application name
// as the subdomain.
//
// For example:
// com.example.Application
ID string
// Role describes what the application does.
Role ApplicationRole
}
// String satisfies the fmt.Stringer interface.
func (application ApplicationDescription) String () string {
if application.Name == "" {
return string(application.Role)
} else {
return application.Name
}
}
// ApplicationRole describes what an application does.
type ApplicationRole string; const (
RoleUnknown ApplicationRole = ""
RoleWebBrowser ApplicationRole = "Web Browser"
RoleMesssanger ApplicationRole = "Messsanger"
RolePhone ApplicationRole = "Phone"
RoleMail ApplicationRole = "Mail"
RoleTerminalEmulator ApplicationRole = "Terminal Emulator"
RoleFileBrowser ApplicationRole = "File Browser"
RoleTextEditor ApplicationRole = "Text Editor"
RoleDocumentViewer ApplicationRole = "Document Viewer"
RoleWordProcessor ApplicationRole = "Word Processor"
RoleSpreadsheet ApplicationRole = "Spreadsheet"
RoleSlideshow ApplicationRole = "Slideshow"
RoleCalculator ApplicationRole = "Calculator"
RolePreferences ApplicationRole = "Preferences"
RoleProcessManager ApplicationRole = "Process Manager"
RoleSystemInformation ApplicationRole = "System Information"
RoleManual ApplicationRole = "Manual"
RoleCamera ApplicationRole = "Camera"
RoleImageViewer ApplicationRole = "Image Viewer"
RoleMediaPlayer ApplicationRole = "Media Player"
RoleImageEditor ApplicationRole = "Image Editor"
RoleAudioEditor ApplicationRole = "Audio Editor"
RoleVideoEditor ApplicationRole = "Video Editor"
RoleClock ApplicationRole = "Clock"
RoleCalendar ApplicationRole = "Calendar"
RoleChecklist ApplicationRole = "Checklist"
)
// Icon returns the icon ID for this role.
func (role ApplicationRole) Icon () tomo.Icon {
if role == "" {
return tomo.IconApplication
} else {
return tomo.Icon("Application" + strings.ReplaceAll(string(role), " ", ""))
}
}
// RunApplication is like tomo.Run, but runs an application. If something fails
// to initialize, an error is written to the standard logger.
func RunApplication (application Application) {
// TODO: see #4
if application, ok := application.(ApplicationFlagAdder); ok {
application.AddFlags(flag.CommandLine)
}
flag.Parse()
err := registrar.RegisterBackend()
if err != nil { log.Fatalln("nasin: could not register backend:", err) }
err = tomo.Run(func () {
err := registrar.SetTheme()
if err != nil { log.Fatalln("nasin: could not set theme:", err) }
err = application.Init()
if err != nil { log.Fatalln("nasin: could not run application:", err) }
// open URLs
args := flag.Args()
applicationOpenUrls(application, args...)
})
if err != nil { log.Fatalln("nasin: could not run application:", err) }
}
// NewApplicationWindow creates a window for an application. It will
// automatically set window information to signal to the OS that the window is
// owned by the application. The window's icon will be automatically set by
// looking for an icon with the name of the application's ID. If that is not
// found, the default icon for the application's ApplicationRole will used.
func NewApplicationWindow (application Application, bounds image.Rectangle) (tomo.Window, error) {
window, err := tomo.NewWindow(bounds)
if err != nil { return nil, err }
description := application.Describe()
window.SetTitle(description.Name)
setApplicationWindowIcon(window, description)
return window, nil
}
func applicationOpenUrls (application Application, args ...string) {
if application, ok := application.(ApplicationURLOpener); ok {
if len(args) <= 0 {
application.OpenNone()
}
openedAny := false
for _, arg := range flag.Args() {
ur, err := url.Parse(arg)
if err != nil {
log.Fatalf (
"nasin: invalid URL %v: %v",
arg, err)
}
if ur.Scheme == "" {
ur.Scheme = "file"
}
err = application.OpenURL(ur)
if err != nil {
dialog, err := objects.NewDialogOk (
objects.DialogError, nil,
"Could Not Open URL",
fmt.Sprintf (
"Could not open %v: %v",
arg, err),
func () {
if !openedAny {
application.OpenNone()
}
})
if err != nil { log.Fatal(err) }
dialog.SetVisible(true)
}
}
} else {
if len(args) > 0 {
log.Fatal("nasin: this application cannot open URLs")
}
}
}
func setApplicationWindowIcon (window tomo.Window, description ApplicationDescription) {
allSizes := func (icon tomo.Icon) (sizes []canvas.Texture) {
small := icon.Texture(tomo.IconSizeSmall)
medium := icon.Texture(tomo.IconSizeMedium)
large := icon.Texture(tomo.IconSizeLarge)
if small != nil { sizes = append(sizes, small) }
if medium != nil { sizes = append(sizes, medium) }
if large != nil { sizes = append(sizes, large) }
return sizes
}
if sizes := allSizes(tomo.Icon(description.ID)); len(sizes) > 0 {
window.SetIcon(sizes...)
return
}
if sizes := allSizes(description.Role.Icon()); len(sizes) > 0 {
window.SetIcon(sizes...)
return
}
}