astilectron

package module
v1.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Mar 28, 2021 License: MIT Imports: 20 Imported by: 2

README

GoReportCard GoDoc Travis Coveralls

Thanks to go-astilectron build cross platform GUI apps with GO and HTML/JS/CSS. It is the official GO bindings of astilectron and is powered by Electron.

Demo

To see a minimal Astilectron app, checkout out the demo.

It uses the bootstrap and the bundler.

If you're looking for a minimalistic example, run go run example/main.go -v.

Real-life examples

Here's a list of awesome projects using go-astilectron (if you're using go-astilectron and want your project to be listed here please submit a PR):

  • go-astivid Video tools written in GO
  • GroupMatcher Program to allocate persons to groups while trying to fulfill all the given wishes as good as possible
  • ipeye-onvif ONVIF Search Tool
  • Stellite GUI Miner An easy to use GUI cryptocurrency miner for Stellite

Bootstrap

For convenience purposes, a bootstrap has been implemented.

The bootstrap allows you to quickly create a one-window application.

There's no obligation to use it, but it's strongly recommended.

If you decide to use it, read thoroughly the documentation as you'll have to structure your project in a specific way.

Bundler

Still for convenience purposes, a bundler has been implemented.

The bundler allows you to bundle your app for every os/arch combinations and get a nice set of files to send your users.

Quick start

WARNING: the code below doesn't handle errors for readibility purposes. However you SHOULD!

Import go-astilectron

To import go-astilectron run:

$ go get -u github.com/asticode/go-astilectron

Start go-astilectron

// Initialize astilectron
var a, _ = astilectron.New(log.New(os.Stderr, "", 0), astilectron.Options{
    AppName: "<your app name>",
    AppIconDefaultPath: "<your .png icon>", // If path is relative, it must be relative to the data directory
    AppIconDarwinPath:  "<your .icns icon>", // Same here
    BaseDirectoryPath: "<where you want the provisioner to install the dependencies>",
    VersionAstilectron: "<version of Astilectron to utilize such as `0.33.0`>",
    VersionElectron: "<version of Electron to utilize such as `4.0.1` | `6.1.2`>",
})
defer a.Close()

// Start astilectron
a.Start()

// Blocking pattern
a.Wait()

For everything to work properly we need to fetch 2 dependencies : astilectron and Electron. .Start() takes care of it by downloading the sources and setting them up properly.

In case you want to embed the sources in the binary to keep a unique binary you can use the NewDisembedderProvisioner function to get the proper Provisioner and attach it to go-astilectron with .SetProvisioner(p Provisioner). Or you can use the bootstrap and the bundler. Check out the demo to see how to use them.

Beware when trying to add your own app icon as you'll need 2 icons : one compatible with MacOSX (.icns) and one compatible with the rest (.png for instance).

If no BaseDirectoryPath is provided, it defaults to the executable's directory path.

The majority of methods are synchrone which means that when executing them go-astilectron will block until it receives a specific Electron event or until the overall context is cancelled. This is the case of .Start() which will block until it receives the app.event.ready astilectron event or until the overall context is cancelled.

Create a window

// Create a new window
var w, _ = a.NewWindow("http://127.0.0.1:4000", &astilectron.WindowOptions{
    Center: astikit.BoolPtr(true),
    Height: astikit.IntPtr(600),
    Width:  astikit.IntPtr(600),
})
w.Create()

When creating a window you need to indicate a URL as well as options such as position, size, etc.

This is pretty straightforward except the astilectron.Ptr* methods so let me explain: GO doesn't do optional fields when json encoding unless you use pointers whereas Electron does handle optional fields. Therefore I added helper methods to convert int, bool and string into pointers and used pointers in structs sent to Electron.

Open the dev tools

When developing in JS, it's very convenient to debug your code using the browser window's dev tools:

// Open dev tools
w.OpenDevTools()

// Close dev tools
w.CloseDevTools()

Add listeners

// Add a listener on Astilectron
a.On(astilectron.EventNameAppCrash, func(e astilectron.Event) (deleteListener bool) {
    log.Println("App has crashed")
    return
})

// Add a listener on the window
w.On(astilectron.EventNameWindowEventResize, func(e astilectron.Event) (deleteListener bool) {
    log.Println("Window resized")
    return
})

Nothing much to say here either except that you can add listeners to Astilectron as well.

Play with the window

// Play with the window
w.Resize(200, 200)
time.Sleep(time.Second)
w.Maximize()

Check out the Window doc for a list of all exported methods

Send messages from GO to Javascript

Javascript
// This will wait for the astilectron namespace to be ready
document.addEventListener('astilectron-ready', function() {
    // This will listen to messages sent by GO
    astilectron.onMessage(function(message) {
        // Process message
        if (message === "hello") {
            return "world";
        }
    });
})
GO
// This will send a message and execute a callback
// Callbacks are optional
w.SendMessage("hello", func(m *astilectron.EventMessage) {
        // Unmarshal
        var s string
        m.Unmarshal(&s)

        // Process message
        log.Printf("received %s\n", s)
})

This will print received world in the GO output

Send messages from Javascript to GO

GO
// This will listen to messages sent by Javascript
w.OnMessage(func(m *astilectron.EventMessage) interface{} {
        // Unmarshal
        var s string
        m.Unmarshal(&s)

        // Process message
        if s == "hello" {
                return "world"
        }
        return nil
})
Javascript
// This will wait for the astilectron namespace to be ready
document.addEventListener('astilectron-ready', function() {
    // This will send a message to GO
    astilectron.sendMessage("hello", function(message) {
        console.log("received " + message)
    });
})

This will print "received world" in the Javascript output

Play with the window's session

// Clear window's HTTP cache
w.Session.ClearCache()

Handle several screens/displays

// If several displays, move the window to the second display
var displays = a.Displays()
if len(displays) > 1 {
    time.Sleep(time.Second)
    w.MoveInDisplay(displays[1], 50, 50)
}

Menus

// Init a new app menu
// You can do the same thing with a window
var m = a.NewMenu([]*astilectron.MenuItemOptions{
    {
        Label: astikit.StrPtr("Separator"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Label: astikit.StrPtr("Normal 1")},
            {
                Label: astikit.StrPtr("Normal 2"),
                OnClick: func(e astilectron.Event) (deleteListener bool) {
                    log.Println("Normal 2 item has been clicked")
                    return
                },
            },
            {Type: astilectron.MenuItemTypeSeparator},
            {Label: astikit.StrPtr("Normal 3")},
        },
    },
    {
        Label: astikit.StrPtr("Checkbox"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Checked: astikit.BoolPtr(true), Label: astikit.StrPtr("Checkbox 1"), Type: astilectron.MenuItemTypeCheckbox},
            {Label: astikit.StrPtr("Checkbox 2"), Type: astilectron.MenuItemTypeCheckbox},
            {Label: astikit.StrPtr("Checkbox 3"), Type: astilectron.MenuItemTypeCheckbox},
        },
    },
    {
        Label: astikit.StrPtr("Radio"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Checked: astikit.BoolPtr(true), Label: astikit.StrPtr("Radio 1"), Type: astilectron.MenuItemTypeRadio},
            {Label: astikit.StrPtr("Radio 2"), Type: astilectron.MenuItemTypeRadio},
            {Label: astikit.StrPtr("Radio 3"), Type: astilectron.MenuItemTypeRadio},
        },
    },
    {
        Label: astikit.StrPtr("Roles"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Label: astikit.StrPtr("Minimize"), Role: astilectron.MenuItemRoleMinimize},
            {Label: astikit.StrPtr("Close"), Role: astilectron.MenuItemRoleClose},
        },
    },
})

// Retrieve a menu item
// This will retrieve the "Checkbox 1" item
mi, _ := m.Item(1, 0)

// Add listener manually
// An OnClick listener has already been added in the options directly for another menu item
mi.On(astilectron.EventNameMenuItemEventClicked, func(e astilectron.Event) bool {
    log.Printf("Menu item has been clicked. 'Checked' status is now %t\n", *e.MenuItemOptions.Checked)
    return false
})

// Create the menu
m.Create()

// Manipulate a menu item
mi.SetChecked(true)

// Init a new menu item
var ni = m.NewItem(&astilectron.MenuItemOptions{
    Label: astikit.StrPtr("Inserted"),
    SubMenu: []*astilectron.MenuItemOptions{
        {Label: astikit.StrPtr("Inserted 1")},
        {Label: astikit.StrPtr("Inserted 2")},
    },
})

// Insert the menu item at position "1"
m.Insert(1, ni)

// Fetch a sub menu
s, _ := m.SubMenu(0)

// Init a new menu item
ni = s.NewItem(&astilectron.MenuItemOptions{
    Label: astikit.StrPtr("Appended"),
    SubMenu: []*astilectron.MenuItemOptions{
        {Label: astikit.StrPtr("Appended 1")},
        {Label: astikit.StrPtr("Appended 2")},
    },
})

// Append menu item dynamically
s.Append(ni)

// Pop up sub menu as a context menu
s.Popup(&astilectron.MenuPopupOptions{PositionOptions: astilectron.PositionOptions{X: astikit.IntPtr(50), Y: astikit.IntPtr(50)}})

// Close popup
s.ClosePopup()

// Destroy the menu
m.Destroy()

A few things to know:

  • when assigning a role to a menu item, go-astilectron won't be able to capture its click event
  • on MacOS there's no such thing as a window menu, only app menus therefore my advice is to stick to one global app menu instead of creating separate window menus

Tray

// New tray
var t = a.NewTray(&astilectron.TrayOptions{
    Image:   astikit.StrPtr("/path/to/image.png"),
    Tooltip: astikit.StrPtr("Tray's tooltip"),
})

// Create tray
t.Create()

// New tray menu
var m = t.NewMenu([]*astilectron.MenuItemOptions{
    {
        Label: astikit.StrPtr("Root 1"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Label: astikit.StrPtr("Item 1")},
            {Label: astikit.StrPtr("Item 2")},
            {Type: astilectron.MenuItemTypeSeparator},
            {Label: astikit.StrPtr("Item 3")},
        },
    },
    {
        Label: astikit.StrPtr("Root 2"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Label: astikit.StrPtr("Item 1")},
            {Label: astikit.StrPtr("Item 2")},
        },
    },
})

// Create the menu
m.Create()

// Change tray's image
time.Sleep(time.Second)
t.SetImage("/path/to/image-2.png")

Notifications

// Create the notification
var n = a.NewNotification(&astilectron.NotificationOptions{
	Body: "My Body",
	HasReply: astikit.BoolPtr(true), // Only MacOSX
	Icon: "/path/to/icon",
	ReplyPlaceholder: "type your reply here", // Only MacOSX
	Title: "My title",
})

// Add listeners
n.On(astilectron.EventNameNotificationEventClicked, func(e astilectron.Event) (deleteListener bool) {
	log.Println("the notification has been clicked!")
	return
})
// Only for MacOSX
n.On(astilectron.EventNameNotificationEventReplied, func(e astilectron.Event) (deleteListener bool) {
	log.Printf("the user has replied to the notification: %s\n", e.Reply)
	return
})

// Create notification
n.Create()

// Show notification
n.Show()

Dock (MacOSX only)

// Get the dock
var d = a.Dock()

// Hide and show the dock
d.Hide()
d.Show()

// Make the Dock bounce
id, _ := d.Bounce(astilectron.DockBounceTypeCritical)

// Cancel the bounce
d.CancelBounce(id)

// Update badge and icon
d.SetBadge("test")
d.SetIcon("/path/to/icon")

// New dock menu
var m = d.NewMenu([]*astilectron.MenuItemOptions{
    {
        Label: astikit.StrPtr("Root 1"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Label: astikit.StrPtr("Item 1")},
            {Label: astikit.StrPtr("Item 2")},
            {Type: astilectron.MenuItemTypeSeparator},
            {Label: astikit.StrPtr("Item 3")},
        },
    },
        {
        Label: astikit.StrPtr("Root 2"),
        SubMenu: []*astilectron.MenuItemOptions{
            {Label: astikit.StrPtr("Item 1")},
            {Label: astikit.StrPtr("Item 2")},
        },
    },
})

// Create the menu
m.Create()

Dialogs

Add the following line at the top of your javascript file :

const { dialog } = require('electron').remote

Use the available methods.

Basic auth

// Listen to login events
w.OnLogin(func(i astilectron.Event) (username, password string, err error) {
	// Process the request and auth info
	if i.Request.Method == "GET" && i.AuthInfo.Scheme == "http://" {
		username = "username"
		password = "password"
	}
    return
})

Features and roadmap

  • custom branding (custom app name, app icon, etc.)
  • window basic methods (create, show, close, resize, minimize, maximize, ...)
  • window basic events (close, blur, focus, unresponsive, crashed, ...)
  • remote messaging (messages between GO and Javascript)
  • single binary distribution
  • multi screens/displays
  • menu methods and events (create, insert, append, popup, clicked, ...)
  • bootstrap
  • dialogs (open or save file, alerts, ...)
  • tray
  • bundler
  • session
  • accelerators (shortcuts)
  • dock
  • notifications
  • loader
  • file methods (drag & drop, ...)
  • clipboard methods
  • power monitor events (suspend, resume, ...)
  • desktop capturer (audio and video)
  • window advanced options (add missing ones)
  • window advanced methods (add missing ones)
  • window advanced events (add missing ones)
  • child windows

Cheers to

go-thrust which is awesome but unfortunately not maintained anymore. It inspired this project.

Documentation

Index

Constants

View Source
const (
	DefaultAcceptTCPTimeout   = 30 * time.Second
	DefaultVersionAstilectron = "0.39.0"
	DefaultVersionElectron    = "7.1.10"
)

Versions

View Source
const (
	EventNameAppClose         = "app.close"
	EventNameAppCmdQuit       = "app.cmd.quit" // Sends an event to Electron to properly quit the app
	EventNameAppCmdStop       = "app.cmd.stop" // Cancel the context which results in exiting abruptly Electron's app
	EventNameAppCrash         = "app.crash"
	EventNameAppErrorAccept   = "app.error.accept"
	EventNameAppEventReady    = "app.event.ready"
	EventNameAppNoAccept      = "app.no.accept"
	EventNameAppTooManyAccept = "app.too.many.accept"
)

App event names

View Source
const (
	MessageBoxTypeError    = "error"
	MessageBoxTypeInfo     = "info"
	MessageBoxTypeNone     = "none"
	MessageBoxTypeQuestion = "question"
	MessageBoxTypeWarning  = "warning"
)

Message box types

View Source
const (
	EventNameDisplayEventAdded          = "display.event.added"
	EventNameDisplayEventMetricsChanged = "display.event.metrics.changed"
	EventNameDisplayEventRemoved        = "display.event.removed"
)

Display event names

View Source
const (
	DockBounceTypeCritical      = "critical"
	DockBounceTypeInformational = "informational"
)

Dock bounce types

View Source
const (
	EventNameMenuCmdCreate      = "menu.cmd.create"
	EventNameMenuCmdDestroy     = "menu.cmd.destroy"
	EventNameMenuEventCreated   = "menu.event.created"
	EventNameMenuEventDestroyed = "menu.event.destroyed"
)

Menu event names

View Source
const (
	EventNameMenuItemCmdSetChecked   = "menu.item.cmd.set.checked"
	EventNameMenuItemCmdSetEnabled   = "menu.item.cmd.set.enabled"
	EventNameMenuItemCmdSetLabel     = "menu.item.cmd.set.label"
	EventNameMenuItemCmdSetVisible   = "menu.item.cmd.set.visible"
	EventNameMenuItemEventCheckedSet = "menu.item.event.checked.set"
	EventNameMenuItemEventClicked    = "menu.item.event.clicked"
	EventNameMenuItemEventEnabledSet = "menu.item.event.enabled.set"
	EventNameMenuItemEventLabelSet   = "menu.item.event.label.set"
	EventNameMenuItemEventVisibleSet = "menu.item.event.visible.set"
)

Menu item event names

View Source
const (
	EventNameNotificationEventClicked = "notification.event.clicked"
	EventNameNotificationEventClosed  = "notification.event.closed"
	EventNameNotificationEventCreated = "notification.event.created"
	EventNameNotificationEventReplied = "notification.event.replied"
	EventNameNotificationEventShown   = "notification.event.shown"
)

Notification event names

View Source
const (
	EventNameSessionCmdClearCache       = "session.cmd.clear.cache"
	EventNameSessionEventClearedCache   = "session.event.cleared.cache"
	EventNameSessionEventWillDownload   = "session.event.will.download"
	EventNameSessionCmdFlushStorage     = "session.cmd.flush.storage"
	EventNameSessionEventFlushedStorage = "session.event.flushed.storage"
)

Session event names

View Source
const (
	EventNameSubMenuCmdAppend        = "sub.menu.cmd.append"
	EventNameSubMenuCmdClosePopup    = "sub.menu.cmd.close.popup"
	EventNameSubMenuCmdInsert        = "sub.menu.cmd.insert"
	EventNameSubMenuCmdPopup         = "sub.menu.cmd.popup"
	EventNameSubMenuEventAppended    = "sub.menu.event.appended"
	EventNameSubMenuEventClosedPopup = "sub.menu.event.closed.popup"
	EventNameSubMenuEventInserted    = "sub.menu.event.inserted"
	EventNameSubMenuEventPoppedUp    = "sub.menu.event.popped.up"
)

Sub menu event names

View Source
const (
	EventNameTrayCmdCreate          = "tray.cmd.create"
	EventNameTrayCmdDestroy         = "tray.cmd.destroy"
	EventNameTrayCmdSetImage        = "tray.cmd.set.image"
	EventNameTrayEventClicked       = "tray.event.clicked"
	EventNameTrayEventCreated       = "tray.event.created"
	EventNameTrayEventDestroyed     = "tray.event.destroyed"
	EventNameTrayEventDoubleClicked = "tray.event.double.clicked"
	EventNameTrayEventImageSet      = "tray.event.image.set"
	EventNameTrayEventRightClicked  = "tray.event.right.clicked"
)

Tray event names

View Source
const (
	EventNameWebContentsEventLogin         = "web.contents.event.login"
	EventNameWebContentsEventLoginCallback = "web.contents.event.login.callback"
	EventNameWindowCmdBlur                 = "window.cmd.blur"
	EventNameWindowCmdCenter               = "window.cmd.center"
	EventNameWindowCmdClose                = "window.cmd.close"
	EventNameWindowCmdCreate               = "window.cmd.create"
	EventNameWindowCmdDestroy              = "window.cmd.destroy"
	EventNameWindowCmdFocus                = "window.cmd.focus"
	EventNameWindowCmdHide                 = "window.cmd.hide"
	EventNameWindowCmdLog                  = "window.cmd.log"
	EventNameWindowCmdMaximize             = "window.cmd.maximize"

	EventNameWindowCmdMinimize                     = "window.cmd.minimize"
	EventNameWindowCmdMove                         = "window.cmd.move"
	EventNameWindowCmdResize                       = "window.cmd.resize"
	EventNameWindowCmdSetBounds                    = "window.cmd.set.bounds"
	EventNameWindowCmdRestore                      = "window.cmd.restore"
	EventNameWindowCmdShow                         = "window.cmd.show"
	EventNameWindowCmdUnmaximize                   = "window.cmd.unmaximize"
	EventNameWindowCmdWebContentsCloseDevTools     = "window.cmd.web.contents.close.dev.tools"
	EventNameWindowCmdWebContentsOpenDevTools      = "window.cmd.web.contents.open.dev.tools"
	EventNameWindowCmdWebContentsExecuteJavaScript = "window.cmd.web.contents.execute.javascript"
	EventNameWindowEventBlur                       = "window.event.blur"
	EventNameWindowEventClosed                     = "window.event.closed"
	EventNameWindowEventDidFinishLoad              = "window.event.did.finish.load"
	EventNameWindowEventFocus                      = "window.event.focus"
	EventNameWindowEventHide                       = "window.event.hide"
	EventNameWindowEventMaximize                   = "window.event.maximize"

	EventNameWindowEventMinimize                      = "window.event.minimize"
	EventNameWindowEventMove                          = "window.event.move"
	EventNameWindowEventReadyToShow                   = "window.event.ready.to.show"
	EventNameWindowEventResize                        = "window.event.resize"
	EventNameWindowEventRestore                       = "window.event.restore"
	EventNameWindowEventShow                          = "window.event.show"
	EventNameWindowEventUnmaximize                    = "window.event.unmaximize"
	EventNameWindowEventUnresponsive                  = "window.event.unresponsive"
	EventNameWindowEventDidGetRedirectRequest         = "window.event.did.get.redirect.request"
	EventNameWindowEventWebContentsExecutedJavaScript = "window.event.web.contents.executed.javascript"
	EventNameWindowEventWillNavigate                  = "window.event.will.navigate"
)

Window event names

Variables

View Source
var (
	// All
	MenuItemRoleClose              = astikit.StrPtr("close")
	MenuItemRoleCopy               = astikit.StrPtr("copy")
	MenuItemRoleCut                = astikit.StrPtr("cut")
	MenuItemRoleDelete             = astikit.StrPtr("delete")
	MenuItemRoleEditMenu           = astikit.StrPtr("editMenu")
	MenuItemRoleForceReload        = astikit.StrPtr("forcereload")
	MenuItemRoleMinimize           = astikit.StrPtr("minimize")
	MenuItemRolePaste              = astikit.StrPtr("paste")
	MenuItemRolePasteAndMatchStyle = astikit.StrPtr("pasteandmatchstyle")
	MenuItemRoleQuit               = astikit.StrPtr("quit")
	MenuItemRoleRedo               = astikit.StrPtr("redo")
	MenuItemRoleReload             = astikit.StrPtr("reload")
	MenuItemRoleResetZoom          = astikit.StrPtr("resetzoom")
	MenuItemRoleSelectAll          = astikit.StrPtr("selectall")
	MenuItemRoleToggleDevTools     = astikit.StrPtr("toggledevtools")
	MenuItemRoleToggleFullScreen   = astikit.StrPtr("togglefullscreen")
	MenuItemRoleUndo               = astikit.StrPtr("undo")
	MenuItemRoleWindowMenu         = astikit.StrPtr("windowMenu")
	MenuItemRoleZoomOut            = astikit.StrPtr("zoomout")
	MenuItemRoleZoomIn             = astikit.StrPtr("zoomin")

	// MacOSX
	MenuItemRoleAbout         = astikit.StrPtr("about")
	MenuItemRoleHide          = astikit.StrPtr("hide")
	MenuItemRoleHideOthers    = astikit.StrPtr("hideothers")
	MenuItemRoleUnhide        = astikit.StrPtr("unhide")
	MenuItemRoleStartSpeaking = astikit.StrPtr("startspeaking")
	MenuItemRoleStopSpeaking  = astikit.StrPtr("stopspeaking")
	MenuItemRoleFront         = astikit.StrPtr("front")
	MenuItemRoleZoom          = astikit.StrPtr("zoom")
	MenuItemRoleWindow        = astikit.StrPtr("window")
	MenuItemRoleHelp          = astikit.StrPtr("help")
	MenuItemRoleServices      = astikit.StrPtr("services")
)

Menu item roles

View Source
var (
	MenuItemTypeNormal    = astikit.StrPtr("normal")
	MenuItemTypeSeparator = astikit.StrPtr("separator")
	MenuItemTypeCheckbox  = astikit.StrPtr("checkbox")
	MenuItemTypeRadio     = astikit.StrPtr("radio")
)

Menu item types

View Source
var (
	TitleBarStyleDefault     = astikit.StrPtr("default")
	TitleBarStyleHidden      = astikit.StrPtr("hidden")
	TitleBarStyleHiddenInset = astikit.StrPtr("hidden-inset")
)

Title bar styles

Functions

func AstilectronDownloadSrc

func AstilectronDownloadSrc(versionAstilectron string) string

AstilectronDownloadSrc returns the download URL of the (currently platform-independent) astilectron zip file

func DefaultExecuter

func DefaultExecuter(l astikit.SeverityLogger, a *Astilectron, cmd *exec.Cmd) (err error)

DefaultExecuter represents the default executer

func Disembed

func Disembed(ctx context.Context, l astikit.SeverityLogger, d Disembedder, src, dst string) (err error)

Disembed is a cancellable disembed of an src to a dst using a custom Disembedder

func Download

func Download(ctx context.Context, l astikit.SeverityLogger, d *astikit.HTTPDownloader, src, dst string) (err error)

Download is a cancellable function that downloads a src into a dst using a specific *http.Client and cleans up on failed downloads

func ElectronDownloadSrc

func ElectronDownloadSrc(os, arch, versionElectron string) string

ElectronDownloadSrc returns the download URL of the platform-dependant electron zipfile

func IsValidOS

func IsValidOS(os string) (ok bool)

IsValidOS validates the OS

func Unzip

func Unzip(ctx context.Context, l astikit.SeverityLogger, src, dst string) (err error)

Unzip unzips a src into a dst. Possible src formats are /path/to/zip.zip or /path/to/zip.zip/internal/path.

Types

type Accelerator

type Accelerator []string

Accelerator represents an accelerator https://github.com/electron/electron/blob/v1.8.1/docs/api/accelerator.md

func NewAccelerator

func NewAccelerator(items ...string) (a *Accelerator)

NewAccelerator creates a new accelerator

func (*Accelerator) MarshalText

func (a *Accelerator) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface

func (*Accelerator) UnmarshalText

func (a *Accelerator) UnmarshalText(b []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface

type Astilectron

type Astilectron struct {
	// contains filtered or unexported fields
}

Astilectron represents an object capable of interacting with Astilectron

func New

func New(l astikit.StdLogger, o Options) (a *Astilectron, err error)

New creates a new Astilectron instance

func (*Astilectron) Close

func (a *Astilectron) Close()

Close closes Astilectron properly

func (*Astilectron) Displays

func (a *Astilectron) Displays() []*Display

Displays returns the displays

func (*Astilectron) Dock

func (a *Astilectron) Dock() *Dock

Dock returns the dock

func (*Astilectron) HandleSignals

func (a *Astilectron) HandleSignals(hs ...astikit.SignalHandler)

HandleSignals handles signals

func (*Astilectron) NewMenu

func (a *Astilectron) NewMenu(i []*MenuItemOptions) *Menu

NewMenu creates a new app menu

func (*Astilectron) NewNotification

func (a *Astilectron) NewNotification(o *NotificationOptions) *Notification

NewNotification creates a new notification

func (*Astilectron) NewTray

func (a *Astilectron) NewTray(o *TrayOptions) *Tray

NewTray creates a new tray

func (*Astilectron) NewWindow

func (a *Astilectron) NewWindow(url string, o *WindowOptions) (*Window, error)

NewWindow creates a new window

func (*Astilectron) NewWindowInDisplay

func (a *Astilectron) NewWindowInDisplay(d *Display, url string, o *WindowOptions) (*Window, error)

NewWindowInDisplay creates a new window in a specific display This overrides the center attribute

func (*Astilectron) On

func (a *Astilectron) On(eventName string, l Listener)

On implements the Listenable interface

func (*Astilectron) Paths

func (a *Astilectron) Paths() Paths

Paths returns the paths

func (*Astilectron) PrimaryDisplay

func (a *Astilectron) PrimaryDisplay() *Display

PrimaryDisplay returns the primary display

func (*Astilectron) Quit

func (a *Astilectron) Quit() error

Quit quits the app

func (*Astilectron) SetExecuter

func (a *Astilectron) SetExecuter(e Executer) *Astilectron

SetExecuter sets the executer

func (*Astilectron) SetProvisioner

func (a *Astilectron) SetProvisioner(p Provisioner) *Astilectron

SetProvisioner sets the provisioner

func (*Astilectron) Start

func (a *Astilectron) Start() (err error)

Start starts Astilectron

func (*Astilectron) Stop

func (a *Astilectron) Stop()

Stop orders Astilectron to stop

func (*Astilectron) Wait

func (a *Astilectron) Wait()

Wait is a blocking pattern

type CallbackMessage

type CallbackMessage func(m *EventMessage)

CallbackMessage represents a message callback

type Disembedder

type Disembedder func(src string) ([]byte, error)

Disembedder is a functions that allows to disembed data from a path

type Display

type Display struct {
	// contains filtered or unexported fields
}

Display represents a display https://github.com/electron/electron/blob/v1.8.1/docs/api/structures/display.md

func (Display) Bounds

func (d Display) Bounds() Rectangle

Bounds returns the display bounds

func (Display) ID

func (d Display) ID() int64

ID returns the display's ID

func (Display) IsPrimary

func (d Display) IsPrimary() bool

IsPrimary checks whether the display is the primary display

func (Display) IsTouchAvailable

func (d Display) IsTouchAvailable() bool

IsTouchAvailable checks whether touch is available on this display

func (Display) Rotation

func (d Display) Rotation() int

Rotation returns the display rotation

func (Display) ScaleFactor

func (d Display) ScaleFactor() float64

ScaleFactor returns the display scale factor

func (Display) Size

func (d Display) Size() Size

Size returns the display size

func (Display) WorkArea

func (d Display) WorkArea() Rectangle

WorkArea returns the display work area

func (Display) WorkAreaSize

func (d Display) WorkAreaSize() Size

WorkAreaSize returns the display work area size

type DisplayOptions

type DisplayOptions struct {
	Bounds       *RectangleOptions `json:"bounds,omitempty"`
	ID           *int64            `json:"id,omitempty"`
	Rotation     *int              `json:"rotation,omitempty"` // 0, 90, 180 or 270
	ScaleFactor  *float64          `json:"scaleFactor,omitempty"`
	Size         *SizeOptions      `json:"size,omitempty"`
	TouchSupport *string           `json:"touchSupport,omitempty"` // available, unavailable or unknown
	WorkArea     *RectangleOptions `json:"workArea,omitempty"`
	WorkAreaSize *SizeOptions      `json:"workAreaSize,omitempty"`
}

DisplayOptions represents display options https://github.com/electron/electron/blob/v1.8.1/docs/api/structures/display.md

type Dock

type Dock struct {
	// contains filtered or unexported fields
}

Dock represents a dock https://github.com/electron/electron/blob/v1.8.1/docs/api/app.md#appdockbouncetype-macos

func (*Dock) Bounce

func (d *Dock) Bounce(bounceType string) (id int, err error)

Bounce bounces the dock

func (*Dock) BounceDownloads

func (d *Dock) BounceDownloads(filePath string) (err error)

BounceDownloads bounces the downloads part of the dock

func (*Dock) CancelBounce

func (d *Dock) CancelBounce(id int) (err error)

CancelBounce cancels the dock bounce

func (*Dock) Hide

func (d *Dock) Hide() (err error)

Hide hides the dock

func (*Dock) NewMenu

func (d *Dock) NewMenu(i []*MenuItemOptions) *Menu

NewMenu creates a new dock menu

func (Dock) On

func (o Dock) On(eventName string, l Listener)

On implements the Listenable interface

func (*Dock) SetBadge

func (d *Dock) SetBadge(badge string) (err error)

SetBadge sets the badge of the dock

func (*Dock) SetIcon

func (d *Dock) SetIcon(image string) (err error)

SetIcon sets the icon of the dock

func (*Dock) Show

func (d *Dock) Show() (err error)

Show shows the dock

type Event

type Event struct {
	// This is the base of the event
	Name     string `json:"name"`
	TargetID string `json:"targetID,omitempty"`

	// This is a list of all possible payloads.
	// A choice was made not to use interfaces since it's a pain in the ass asserting each an every payload afterwards
	// We use pointers so that omitempty works
	AuthInfo            *EventAuthInfo       `json:"authInfo,omitempty"`
	Badge               string               `json:"badge,omitempty"`
	BounceType          string               `json:"bounceType,omitempty"`
	Bounds              *RectangleOptions    `json:"bounds,omitempty"`
	CallbackID          string               `json:"callbackId,omitempty"`
	Code                string               `json:"code,omitempty"`
	Displays            *EventDisplays       `json:"displays,omitempty"`
	FilePath            string               `json:"filePath,omitempty"`
	ID                  *int                 `json:"id,omitempty"`
	Image               string               `json:"image,omitempty"`
	Index               *int                 `json:"index,omitempty"`
	Menu                *EventMenu           `json:"menu,omitempty"`
	MenuItem            *EventMenuItem       `json:"menuItem,omitempty"`
	MenuItemOptions     *MenuItemOptions     `json:"menuItemOptions,omitempty"`
	MenuItemPosition    *int                 `json:"menuItemPosition,omitempty"`
	MenuPopupOptions    *MenuPopupOptions    `json:"menuPopupOptions,omitempty"`
	Message             *EventMessage        `json:"message,omitempty"`
	NotificationOptions *NotificationOptions `json:"notificationOptions,omitempty"`
	Password            string               `json:"password,omitempty"`
	Reply               string               `json:"reply,omitempty"`
	Request             *EventRequest        `json:"request,omitempty"`
	SessionID           string               `json:"sessionId,omitempty"`
	Supported           *Supported           `json:"supported,omitempty"`
	TrayOptions         *TrayOptions         `json:"trayOptions,omitempty"`
	URL                 string               `json:"url,omitempty"`
	URLNew              string               `json:"newUrl,omitempty"`
	URLOld              string               `json:"oldUrl,omitempty"`
	Username            string               `json:"username,omitempty"`
	WindowID            string               `json:"windowId,omitempty"`
	WindowOptions       *WindowOptions       `json:"windowOptions,omitempty"`
}

Event represents an event

type EventAuthInfo

type EventAuthInfo struct {
	Host    string `json:"host,omitempty"`
	IsProxy *bool  `json:"isProxy,omitempty"`
	Port    *int   `json:"port,omitempty"`
	Realm   string `json:"realm,omitempty"`
	Scheme  string `json:"scheme,omitempty"`
}

EventAuthInfo represents an event auth info

type EventDisplays

type EventDisplays struct {
	All     []*DisplayOptions `json:"all,omitempty"`
	Primary *DisplayOptions   `json:"primary,omitempty"`
}

EventDisplays represents events displays

type EventMenu

type EventMenu struct {
	*EventSubMenu
}

EventMenu represents an event menu

type EventMenuItem

type EventMenuItem struct {
	ID      string           `json:"id"`
	Options *MenuItemOptions `json:"options,omitempty"`
	RootID  string           `json:"rootId"`
	SubMenu *EventSubMenu    `json:"submenu,omitempty"`
}

EventMenuItem represents an event menu item

type EventMessage

type EventMessage struct {
	// contains filtered or unexported fields
}

EventMessage represents an event message

func (*EventMessage) MarshalJSON

func (p *EventMessage) MarshalJSON() ([]byte, error)

MarshalJSON implements the JSONMarshaler interface

func (*EventMessage) Unmarshal

func (p *EventMessage) Unmarshal(i interface{}) error

Unmarshal unmarshals the payload into the given interface

func (*EventMessage) UnmarshalJSON

func (p *EventMessage) UnmarshalJSON(i []byte) error

UnmarshalJSON implements the JSONUnmarshaler interface

type EventRequest

type EventRequest struct {
	Method   string `json:"method,omitempty"`
	Referrer string `json:"referrer,omitempty"`
	URL      string `json:"url,omitempty"`
}

EventRequest represents an event request

type EventSubMenu

type EventSubMenu struct {
	ID     string           `json:"id"`
	Items  []*EventMenuItem `json:"items,omitempty"`
	RootID string           `json:"rootId"`
}

EventSubMenu represents a sub menu event

type Executer

type Executer func(l astikit.SeverityLogger, a *Astilectron, cmd *exec.Cmd) (err error)

Executer represents an object capable of executing Astilectron run command

type Listener

type Listener func(e Event) (deleteListener bool)

Listener represents a listener executed when an event is dispatched

type ListenerMessage

type ListenerMessage func(m *EventMessage) (v interface{})

ListenerMessage represents a message listener executed when receiving a message from the JS

type Menu struct {
	// contains filtered or unexported fields
}

Menu represents a menu https://github.com/electron/electron/blob/v1.8.1/docs/api/menu.md

func (m Menu) Append(i *MenuItem) (err error)

Append appends a menu item into the sub menu

func (m Menu) ClosePopup() error

ClosePopup close the context menu in the focused window

func (m Menu) ClosePopupInWindow(w *Window) (err error)

ClosePopupInWindow close the context menu in the specified window

func (m *Menu) Create() (err error)

Create creates the menu

func (m *Menu) Destroy() (err error)

Destroy destroys the menu

func (m Menu) Insert(pos int, i *MenuItem) (err error)

Insert inserts a menu item to the position of the sub menu

func (m Menu) Item(indexes ...int) (mi *MenuItem, err error)

Item returns the item at the specified indexes

func (m Menu) NewItem(o *MenuItemOptions) *MenuItem

NewItem returns a new menu item

func (m Menu) Popup(o *MenuPopupOptions) error

Popup pops up the menu as a context menu in the focused window

func (m Menu) PopupInWindow(w *Window, o *MenuPopupOptions) (err error)

PopupInWindow pops up the menu as a context menu in the specified window

func (m Menu) SubMenu(indexes ...int) (s *SubMenu, err error)

SubMenu returns the sub menu at the specified indexes

type MenuItem struct {
	// contains filtered or unexported fields
}

MenuItem represents a menu item

func (o MenuItem) On(eventName string, l Listener)

On implements the Listenable interface

func (i *MenuItem) SetChecked(checked bool) (err error)

SetChecked sets the checked attribute

func (i *MenuItem) SetEnabled(enabled bool) (err error)

SetEnabled sets the enabled attribute

func (i *MenuItem) SetLabel(label string) (err error)

SetLabel sets the label attribute

func (i *MenuItem) SetVisible(visible bool) (err error)

SetVisible sets the visible attribute

func (i *MenuItem) SubMenu() *SubMenu

SubMenu returns the menu item sub menu

type MenuItemOptions struct {
	Accelerator *Accelerator       `json:"accelerator,omitempty"`
	Checked     *bool              `json:"checked,omitempty"`
	Enabled     *bool              `json:"enabled,omitempty"`
	Icon        *string            `json:"icon,omitempty"`
	Label       *string            `json:"label,omitempty"`
	OnClick     Listener           `json:"-"`
	Position    *string            `json:"position,omitempty"`
	Role        *string            `json:"role,omitempty"`
	SubLabel    *string            `json:"sublabel,omitempty"`
	SubMenu     []*MenuItemOptions `json:"-"`
	Type        *string            `json:"type,omitempty"`
	Visible     *bool              `json:"visible,omitempty"`
}

MenuItemOptions represents menu item options We must use pointers since GO doesn't handle optional fields whereas NodeJS does. Use astikit.BoolPtr, astikit.IntPtr or astikit.StrPtr to fill the struct https://github.com/electron/electron/blob/v1.8.1/docs/api/menu-item.md

type MenuPopupOptions struct {
	PositionOptions
	PositioningItem *int `json:"positioningItem,omitempty"`
}

MenuPopupOptions represents menu pop options

type MessageBoxOptions

type MessageBoxOptions struct {
	Buttons         []string `json:"buttons,omitempty"`
	CancelID        *int     `json:"cancelId,omitempty"`
	CheckboxChecked *bool    `json:"checkboxChecked,omitempty"`
	CheckboxLabel   string   `json:"checkboxLabel,omitempty"`
	ConfirmID       *int     `json:"confirmId,omitempty"`
	DefaultID       *int     `json:"defaultId,omitempty"`
	Detail          string   `json:"detail,omitempty"`
	Icon            string   `json:"icon,omitempty"`
	Message         string   `json:"message,omitempty"`
	NoLink          *bool    `json:"noLink,omitempty"`
	Title           string   `json:"title,omitempty"`
	Type            string   `json:"type,omitempty"`
}

MessageBoxOptions represents message box options We must use pointers since GO doesn't handle optional fields whereas NodeJS does. Use astikit.BoolPtr, astikit.IntPtr or astikit.StrPtr to fill the struct https://github.com/electron/electron/blob/v1.8.1/docs/api/dialog.md#dialogshowmessageboxbrowserwindow-options-callback

type Notification

type Notification struct {
	// contains filtered or unexported fields
}

Notification represents a notification https://github.com/electron/electron/blob/v1.8.1/docs/api/notification.md

func (*Notification) Create

func (n *Notification) Create() (err error)

Create creates the notification

func (Notification) On

func (o Notification) On(eventName string, l Listener)

On implements the Listenable interface

func (*Notification) Show

func (n *Notification) Show() (err error)

Show shows the notification

type NotificationOptions

type NotificationOptions struct {
	Body             string `json:"body,omitempty"`
	HasReply         *bool  `json:"hasReply,omitempty"`
	Icon             string `json:"icon,omitempty"`
	ReplyPlaceholder string `json:"replyPlaceholder,omitempty"`
	Silent           *bool  `json:"silent,omitempty"`
	Sound            string `json:"sound,omitempty"`
	Subtitle         string `json:"subtitle,omitempty"`
	Title            string `json:"title,omitempty"`
}

NotificationOptions represents notification options

type Options

type Options struct {
	PubEvent           func(e Event) error
	AcceptTCPTimeout   time.Duration
	AppName            string
	AppIconDarwinPath  string // Darwin systems requires a specific .icns file
	AppIconDefaultPath string
	BaseDirectoryPath  string
	DataDirectoryPath  string
	ElectronSwitches   []string
	SingleInstance     bool
	SkipSetup          bool // If true, the user must handle provisioning and executing astilectron.
	TCPPort            *int // The port to listen on.
	VersionAstilectron string
	VersionElectron    string
}

Options represents Astilectron options

type Paths

type Paths struct {
	// contains filtered or unexported fields
}

Paths represents the set of paths needed by Astilectron

func (Paths) AppExecutable

func (p Paths) AppExecutable() string

AppExecutable returns the app executable path

func (Paths) AppIconDarwinSrc

func (p Paths) AppIconDarwinSrc() string

AppIconDarwinSrc returns the darwin app icon path

func (Paths) AppIconDefaultSrc

func (p Paths) AppIconDefaultSrc() string

AppIconDefaultSrc returns the default app icon path

func (Paths) AstilectronApplication

func (p Paths) AstilectronApplication() string

AstilectronApplication returns the astilectron application path

func (Paths) AstilectronDirectory

func (p Paths) AstilectronDirectory() string

AstilectronDirectory returns the astilectron directory path

func (Paths) AstilectronDownloadDst

func (p Paths) AstilectronDownloadDst() string

AstilectronDownloadDst returns the astilectron download destination path

func (Paths) AstilectronDownloadSrc

func (p Paths) AstilectronDownloadSrc() string

AstilectronDownloadSrc returns the astilectron download source path

func (Paths) AstilectronUnzipSrc

func (p Paths) AstilectronUnzipSrc() string

AstilectronUnzipSrc returns the astilectron unzip source path

func (Paths) BaseDirectory

func (p Paths) BaseDirectory() string

BaseDirectory returns the base directory path

func (Paths) DataDirectory

func (p Paths) DataDirectory() string

DataDirectory returns the data directory path

func (Paths) ElectronDirectory

func (p Paths) ElectronDirectory() string

ElectronDirectory returns the electron directory path

func (Paths) ElectronDownloadDst

func (p Paths) ElectronDownloadDst() string

ElectronDownloadDst returns the electron download destination path

func (Paths) ElectronDownloadSrc

func (p Paths) ElectronDownloadSrc() string

ElectronDownloadSrc returns the electron download source path

func (Paths) ElectronUnzipSrc

func (p Paths) ElectronUnzipSrc() string

ElectronUnzipSrc returns the electron unzip source path

func (Paths) ProvisionStatus

func (p Paths) ProvisionStatus() string

ProvisionStatus returns the provision status path

func (Paths) VendorDirectory

func (p Paths) VendorDirectory() string

VendorDirectory returns the vendor directory path

type Position

type Position struct {
	X, Y int
}

Position represents a position

type PositionOptions

type PositionOptions struct {
	X *int `json:"x,omitempty"`
	Y *int `json:"y,omitempty"`
}

PositionOptions represents position options

type ProvisionStatus

type ProvisionStatus struct {
	Astilectron *ProvisionStatusPackage            `json:"astilectron,omitempty"`
	Electron    map[string]*ProvisionStatusPackage `json:"electron,omitempty"`
}

ProvisionStatus represents the provision status

type ProvisionStatusPackage

type ProvisionStatusPackage struct {
	Version string `json:"version"`
}

ProvisionStatusPackage represents the provision status of a package

type Provisioner

type Provisioner interface {
	Provision(ctx context.Context, appName, os, arch, versionAstilectron, versionElectron string, p Paths) error
}

Provisioner represents an object capable of provisioning Astilectron

func NewDisembedderProvisioner

func NewDisembedderProvisioner(d Disembedder, pathAstilectron, pathElectron string, l astikit.StdLogger) Provisioner

NewDisembedderProvisioner creates a provisioner that can provision based on embedded data

type Rectangle

type Rectangle struct {
	Position
	Size
}

Rectangle represents a rectangle

type RectangleOptions

type RectangleOptions struct {
	PositionOptions
	SizeOptions
}

RectangleOptions represents rectangle options

type Session

type Session struct {
	// contains filtered or unexported fields
}

Session represents a session TODO Add missing session methods TODO Add missing session events https://github.com/electron/electron/blob/v1.8.1/docs/api/session.md

func (*Session) ClearCache

func (s *Session) ClearCache() (err error)

ClearCache clears the Session's HTTP cache

func (*Session) FlushStorage

func (s *Session) FlushStorage() (err error)

FlushStorage writes any unwritten DOMStorage data to disk

func (Session) On

func (o Session) On(eventName string, l Listener)

On implements the Listenable interface

type Size

type Size struct {
	Height, Width int
}

Size represents a size

type SizeOptions

type SizeOptions struct {
	Height *int `json:"height,omitempty"`
	Width  *int `json:"width,omitempty"`
}

SizeOptions represents size options

type SubMenu struct {
	// contains filtered or unexported fields
}

SubMenu represents an exported sub menu

func (m SubMenu) Append(i *MenuItem) (err error)

Append appends a menu item into the sub menu

func (m SubMenu) ClosePopup() error

ClosePopup close the context menu in the focused window

func (m SubMenu) ClosePopupInWindow(w *Window) (err error)

ClosePopupInWindow close the context menu in the specified window

func (m SubMenu) Insert(pos int, i *MenuItem) (err error)

Insert inserts a menu item to the position of the sub menu

func (m SubMenu) Item(indexes ...int) (mi *MenuItem, err error)

Item returns the item at the specified indexes

func (m SubMenu) NewItem(o *MenuItemOptions) *MenuItem

NewItem returns a new menu item

func (m SubMenu) Popup(o *MenuPopupOptions) error

Popup pops up the menu as a context menu in the focused window

func (m SubMenu) PopupInWindow(w *Window, o *MenuPopupOptions) (err error)

PopupInWindow pops up the menu as a context menu in the specified window

func (m SubMenu) SubMenu(indexes ...int) (s *SubMenu, err error)

SubMenu returns the sub menu at the specified indexes

type Supported

type Supported struct {
	Notification *bool `json:"notification"`
}

Supported represents Astilectron supported features

type Tray

type Tray struct {
	// contains filtered or unexported fields
}

Tray represents a tray

func (*Tray) Create

func (t *Tray) Create() (err error)

Create creates the tray

func (*Tray) Destroy

func (t *Tray) Destroy() (err error)

Destroy destroys the tray

func (*Tray) NewMenu

func (t *Tray) NewMenu(i []*MenuItemOptions) *Menu

NewMenu creates a new tray menu

func (Tray) On

func (o Tray) On(eventName string, l Listener)

On implements the Listenable interface

func (*Tray) SetImage

func (t *Tray) SetImage(image string) (err error)

SetImage sets the tray image

type TrayOptions

type TrayOptions struct {
	Image   *string `json:"image,omitempty"`
	Tooltip *string `json:"tooltip,omitempty"`
}

TrayOptions represents tray options We must use pointers since GO doesn't handle optional fields whereas NodeJS does. Use astikit.BoolPtr, astikit.IntPtr or astikit.StrPtr to fill the struct https://github.com/electron/electron/blob/v1.8.1/docs/api/tray.md

type WebPreferences

type WebPreferences struct {
	AllowRunningInsecureContent *bool                  `json:"allowRunningInsecureContent,omitempty"`
	BackgroundThrottling        *bool                  `json:"backgroundThrottling,omitempty"`
	BlinkFeatures               *string                `json:"blinkFeatures,omitempty"`
	ContextIsolation            *bool                  `json:"contextIsolation,omitempty"`
	DefaultEncoding             *string                `json:"defaultEncoding,omitempty"`
	DefaultFontFamily           map[string]interface{} `json:"defaultFontFamily,omitempty"`
	DefaultFontSize             *int                   `json:"defaultFontSize,omitempty"`
	DefaultMonospaceFontSize    *int                   `json:"defaultMonospaceFontSize,omitempty"`
	DevTools                    *bool                  `json:"devTools,omitempty"`
	DisableBlinkFeatures        *string                `json:"disableBlinkFeatures,omitempty"`
	ExperimentalCanvasFeatures  *bool                  `json:"experimentalCanvasFeatures,omitempty"`
	ExperimentalFeatures        *bool                  `json:"experimentalFeatures,omitempty"`
	Images                      *bool                  `json:"images,omitempty"`
	Javascript                  *bool                  `json:"javascript,omitempty"`
	MinimumFontSize             *int                   `json:"minimumFontSize,omitempty"`
	// This attribute needs to be true at all time
	// NodeIntegration             *bool                  `json:"nodeIntegration,omitempty"`
	NodeIntegrationInWorker *bool                  `json:"nodeIntegrationInWorker,omitempty"`
	Offscreen               *bool                  `json:"offscreen,omitempty"`
	Partition               *string                `json:"partition,omitempty"`
	Plugins                 *bool                  `json:"plugins,omitempty"`
	Preload                 *string                `json:"preload,omitempty"`
	Sandbox                 *bool                  `json:"sandbox,omitempty"`
	ScrollBounce            *bool                  `json:"scrollBounce,omitempty"`
	Session                 map[string]interface{} `json:"session,omitempty"`
	TextAreasAreResizable   *bool                  `json:"textAreasAreResizable,omitempty"`
	Webaudio                *bool                  `json:"webaudio,omitempty"`
	Webgl                   *bool                  `json:"webgl,omitempty"`
	WebSecurity             *bool                  `json:"webSecurity,omitempty"`
	WebviewTag              *bool                  `json:"webviewTag,omitempty"`
	ZoomFactor              *float64               `json:"zoomFactor,omitempty"`
}

WebPreferences represents web preferences in window options. We must use pointers since GO doesn't handle optional fields whereas NodeJS does. Use astikit.BoolPtr, astikit.IntPtr or astikit.StrPtr to fill the struct

type Window

type Window struct {
	Session *Session
	// contains filtered or unexported fields
}

Window represents a window TODO Add missing window options TODO Add missing window methods TODO Add missing window events

func (*Window) Blur

func (w *Window) Blur() (err error)

Blur blurs the window

func (*Window) Center

func (w *Window) Center() (err error)

Center centers the window

func (*Window) Close

func (w *Window) Close() (err error)

Close closes the window

func (*Window) CloseDevTools

func (w *Window) CloseDevTools() (err error)

CloseDevTools closes the dev tools

func (*Window) Create

func (w *Window) Create() (err error)

Create creates the window We wait for EventNameWindowEventDidFinishLoad since we need the web content to be fully loaded before being able to send messages to it

func (*Window) Destroy

func (w *Window) Destroy() (err error)

Destroy destroys the window

func (*Window) ExecuteJavaScript

func (w *Window) ExecuteJavaScript(code string) (err error)

ExecuteJavaScript executes some js

func (*Window) Focus

func (w *Window) Focus() (err error)

Focus focuses on the window

func (*Window) Hide

func (w *Window) Hide() (err error)

Hide hides the window

func (*Window) IsShown

func (w *Window) IsShown() bool

IsShown returns whether the window is shown

func (*Window) Log

func (w *Window) Log(message string) (err error)

Log logs a message in the JS console of the window

func (*Window) Maximize

func (w *Window) Maximize() (err error)

Maximize maximizes the window

func (*Window) Minimize

func (w *Window) Minimize() (err error)

Minimize minimizes the window

func (*Window) Move

func (w *Window) Move(x, y int) (err error)

Move moves the window

func (*Window) MoveInDisplay

func (w *Window) MoveInDisplay(d *Display, x, y int) error

MoveInDisplay moves the window in the proper display

func (*Window) NewMenu

func (w *Window) NewMenu(i []*MenuItemOptions) *Menu

NewMenu creates a new window menu

func (Window) On

func (o Window) On(eventName string, l Listener)

On implements the Listenable interface

func (*Window) OnLogin

func (w *Window) OnLogin(fn func(i Event) (username, password string, err error))

func (*Window) OnMessage

func (w *Window) OnMessage(l ListenerMessage)

OnMessage adds a specific listener executed when receiving a message from the JS This method can be called only once

func (*Window) OpenDevTools

func (w *Window) OpenDevTools() (err error)

OpenDevTools opens the dev tools

func (*Window) Resize

func (w *Window) Resize(width, height int) (err error)

Resize resizes the window

func (*Window) Restore

func (w *Window) Restore() (err error)

Restore restores the window

func (*Window) SendMessage

func (w *Window) SendMessage(message interface{}, callbacks ...CallbackMessage) (err error)

SendMessage sends a message to the JS window and execute optional callbacks upon receiving a response from the JS Use astilectron.onMessage method to capture those messages in JS

func (*Window) SetBounds

func (w *Window) SetBounds(r RectangleOptions) (err error)

SetBounds set bounds of the window

func (*Window) Show

func (w *Window) Show() (err error)

Show shows the window

func (*Window) Unmaximize

func (w *Window) Unmaximize() (err error)

Unmaximize unmaximize the window

type WindowAppDetails

type WindowAppDetails struct {
	AppID               *string `json:"appId,omitempty"`
	AppIconPath         *string `json:"appIconPath,omitempty"`
	RelaunchCommand     *string `json:"relaunchCommand,omitempty"`
	AppIconIndex        *int    `json:"appIconIndex,omitempty"`
	RelaunchDisplayName *string `json:"relaunchDisplayName,omitempty"`
}

WindowAppDetails represents window app details https://github.com/electron/electron/blob/v4.0.1/docs/api/browser-window.md#winsetappdetailsoptions-windows

type WindowCustomOptions

type WindowCustomOptions struct {
	HideOnClose       *bool              `json:"hideOnClose,omitempty"`
	MessageBoxOnClose *MessageBoxOptions `json:"messageBoxOnClose,omitempty"`
	MinimizeOnClose   *bool              `json:"minimizeOnClose,omitempty"`
	Script            string             `json:"script,omitempty"`
}

WindowCustomOptions represents window custom options

type WindowLoadOptions

type WindowLoadOptions struct {
	ExtraHeaders string `json:"extraHeaders,omitempty"`
	HTTPReferer  string `json:"httpReferrer,omitempty"`
	UserAgent    string `json:"userAgent,omitempty"`
}

WindowLoadOptions represents window load options https://github.com/electron/electron/blob/v1.8.1/docs/api/browser-window.md#winloadurlurl-options

type WindowOptions

type WindowOptions struct {
	AcceptFirstMouse       *bool           `json:"acceptFirstMouse,omitempty"`
	AlwaysOnTop            *bool           `json:"alwaysOnTop,omitempty"`
	AutoHideMenuBar        *bool           `json:"autoHideMenuBar,omitempty"`
	BackgroundColor        *string         `json:"backgroundColor,omitempty"`
	Center                 *bool           `json:"center,omitempty"`
	Closable               *bool           `json:"closable,omitempty"`
	DisableAutoHideCursor  *bool           `json:"disableAutoHideCursor,omitempty"`
	EnableLargerThanScreen *bool           `json:"enableLargerThanScreen,omitempty"`
	Focusable              *bool           `json:"focusable,omitempty"`
	Frame                  *bool           `json:"frame,omitempty"`
	Fullscreen             *bool           `json:"fullscreen,omitempty"`
	Fullscreenable         *bool           `json:"fullscreenable,omitempty"`
	HasShadow              *bool           `json:"hasShadow,omitempty"`
	Height                 *int            `json:"height,omitempty"`
	Icon                   *string         `json:"icon,omitempty"`
	Kiosk                  *bool           `json:"kiosk,omitempty"`
	MaxHeight              *int            `json:"maxHeight,omitempty"`
	Maximizable            *bool           `json:"maximizable,omitempty"`
	MaxWidth               *int            `json:"maxWidth,omitempty"`
	MinHeight              *int            `json:"minHeight,omitempty"`
	Minimizable            *bool           `json:"minimizable,omitempty"`
	MinWidth               *int            `json:"minWidth,omitempty"`
	Modal                  *bool           `json:"modal,omitempty"`
	Movable                *bool           `json:"movable,omitempty"`
	Resizable              *bool           `json:"resizable,omitempty"`
	Show                   *bool           `json:"show,omitempty"`
	SkipTaskbar            *bool           `json:"skipTaskbar,omitempty"`
	Title                  *string         `json:"title,omitempty"`
	TitleBarStyle          *string         `json:"titleBarStyle,omitempty"`
	Transparent            *bool           `json:"transparent,omitempty"`
	UseContentSize         *bool           `json:"useContentSize,omitempty"`
	WebPreferences         *WebPreferences `json:"webPreferences,omitempty"`
	Width                  *int            `json:"width,omitempty"`
	X                      *int            `json:"x,omitempty"`
	Y                      *int            `json:"y,omitempty"`

	// Additional options
	AppDetails *WindowAppDetails    `json:"appDetails,omitempty"`
	Custom     *WindowCustomOptions `json:"custom,omitempty"`
	Load       *WindowLoadOptions   `json:"load,omitempty"`
	Proxy      *WindowProxyOptions  `json:"proxy,omitempty"`
}

WindowOptions represents window options We must use pointers since GO doesn't handle optional fields whereas NodeJS does. Use astikit.BoolPtr, astikit.IntPtr or astikit.StrPtr to fill the struct https://github.com/electron/electron/blob/v1.8.1/docs/api/browser-window.md

type WindowProxyOptions

type WindowProxyOptions struct {
	BypassRules string `json:"proxyBypassRules,omitempty"`
	PACScript   string `json:"pacScript,omitempty"`
	Rules       string `json:"proxyRules,omitempty"`
}

WindowProxyOptions represents window proxy options https://github.com/electron/electron/blob/v1.8.1/docs/api/session.md#sessetproxyconfig-callback

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL