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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.