nasin/application.go

package nasin

import "fmt"
import "log"
import "flag"
import "image"
import "strings"
import "net/url"
import "path/filepath"
import "git.tebibyte.media/tomo/tomo"
import "git.tebibyte.media/tomo/objects"
import "git.tebibyte.media/tomo/nasin/config"
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)

	// Stop stops the application and does not return until all ongoing
	// operations have been completely shut down.
	Stop ()
}

// 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.
	OpenNone () error
}

// 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
}

// GlobalApplicationDescription returns the global application description which
// points to cache, data, config, etc. used by Nasin itself.
func GlobalApplicationDescription () ApplicationDescription {
	return ApplicationDescription {
		Name: "Nasin",
		ID:   "xyz.holanet.Nasin",
	}
}

// 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. It automatically
// sets up a backend. 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()

	// open config
	globalConfig, err := ApplicationConfig(GlobalApplicationDescription())
	if err != nil { log.Fatalln("nasin: could not open config:", err) }
	currentGlobalConfig = globalConfig
	defer func () {
		globalConfig.Close()
		currentGlobalConfig = nil
	} ()
	styleConfigKey   := "Style"
	iconSetConfigKey := "IconSet"

	// registry
	// TODO: rebuild registry around the config
	reg := new(registrar.Registrar)
	backend, err := reg.SetBackend()
	if err != nil { log.Fatalln("nasin: could not register backend:", err) }
	err = reg.SetFaceSet()
	if err != nil { log.Fatalln("nasin: could not set face set:", err) }
	updateStyle := func () {
		value, err := globalConfig.GetString(styleConfigKey, "")
		if err != nil { log.Fatalln("nasin: could not set theme:", err) }
		err = reg.SetStyle(value)
		if err != nil { log.Fatalln("nasin: could not set theme:", err) }
	}
	updateIconSet := func () {
		value, err := globalConfig.GetString(iconSetConfigKey, "")
		if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
		err = reg.SetIconSet(value)
		if err != nil { log.Fatalln("nasin: could not set icon set:", err) }
	}
	updateStyle()
	updateIconSet()

	globalConfig.OnChange(func (key string) {
		switch key {
		case styleConfigKey:   updateStyle()
		case iconSetConfigKey: updateIconSet()
		}
	})

	// init application
	err = application.Init()
	if err != nil { log.Fatalln("nasin: could not run application:", err) }

	// open URLs
	args := flag.Args()
	applicationOpenUrls(application, args...)

	if manager.count > 0 {
		err = backend.Run()
		if err != nil { log.Fatalln("nasin: could not run application:", err) }
	}
	application.Stop()
}

// 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
}

// ApplicationConfig opens a new config for the specified application. It must
// be closed when it is no longer needed.
func ApplicationConfig (app ApplicationDescription) (config.ConfigCloser, error) {
	user, err := ApplicationUserConfigDir(app)
	if err != nil { return nil, err }
	user = filepath.Join(user, "config.conf")
	system, err := ApplicationSystemConfigDirs(app)
	if err != nil { return nil, err }
	for index, path := range system {
		system[index] = filepath.Join(path, "config.conf")
	}
	return config.NewConfig(user, system...)
}

var currentGlobalConfig config.Config
// GlobalConfig returns the global config. It contains options that apply to
// Tomo/Nasin itself, such as the style sheet and the icon set. This is managed
// by Nasin and must not be closed by the application.
func GlobalConfig () config.Config {
	return currentGlobalConfig
}

func errorPopupf (title, format string, v ...any) func (func ()) {
	return func (callback func ()) {
		dialog, err := objects.NewDialogOk (
			objects.DialogError, nil,
			title,
			fmt.Sprintf(format, v...),
			callback)
		if err != nil { log.Fatal(err) }
		dialog.SetVisible(true)
		WaitFor(dialog)
	}
}

func applicationOpenUrls (app Application, args ...string) {
	application, ok := app.(ApplicationURLOpener)
	if !ok {
		if len(args) > 0 {
			log.Fatal("nasin: this application cannot open URLs")
		}
		return
	}
	
	openNone := func () bool {
		err := application.OpenNone()
		if err != nil {
			log.Fatalf("nasin: could not open main window: %v", err)
			return false
		}
		return true
	}
	
	if len(args) <= 0 {
		openNone()
		return
	}

	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 {
			errorPopupf(
				"Could Not Open URL",
				"Could not open %v: %v",
				arg, err,
			)(func () {
				if !openedAny {
					openNone()
				}
			})
		}
	}
}

func setApplicationWindowIcon (window tomo.Window, description ApplicationDescription) {
	iconExists := func (icon tomo.Icon) bool {
		return icon.Texture(tomo.IconSizeMedium) != nil
	}

	if iconExists(tomo.Icon(description.ID)) {
		window.SetIcon(tomo.Icon(description.ID))
		return
	}
	if iconExists(description.Role.Icon()) {
		window.SetIcon(description.Role.Icon())
		return
	}
}