astilectron

package module
Version: v0.29.0 Latest Latest
Warning

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

Go to latest
Published: May 11, 2022 License: MIT Imports: 20 Imported by: 212

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
  • 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 asynchronous 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.

HTML paths

NB! All paths in HTML (and Javascript) must be relative, otherwise the files will not be found. To make this happen in React for example, just set the homepage property of your package.json to "./".

{ "homepage": "./" }

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
  • on MacOS MenuItem without SubMenu is not displayed

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.55.0"
	DefaultVersionElectron    = "11.4.3"
)

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"
	EventNameAppEventSecondInstance = "app.event.second.instance"
	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 (
	EventNamePowerSuspend             = "power.event.suspend"
	EventNamePowerResume              = "power.event.resume"
	EventNamePowerOnAC                = "power.event.on.ac"
	EventNamePowerOnBattery           = "power.event.on.battery"
	EventNamePowerShutdown            = "power.event.shutdown"
	EventNamePowerLockScreen          = "power.event.lock.screen"
	EventNamePowerUnlockScreen        = "power.event.unlock.screen"
	EventNamePowerUserDidBecomeActive = "power.event.user.did.become.active"
	EventNamePowerUserDidResignActive = "power.event.user.did.resign.active"
)

Power event names

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

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"
	EventNameWindowCmdResizeContent                = "window.cmd.resize.content"
	EventNameWindowCmdSetBounds                    = "window.cmd.set.bounds"
	EventNameWindowCmdRestore                      = "window.cmd.restore"
	EventNameWindowCmdSetContentProtection         = "window.cmd.set.content.protection"
	EventNameWindowCmdShow                         = "window.cmd.show"
	EventNameWindowCmdUnmaximize                   = "window.cmd.unmaximize"
	EventNameWindowCmdUpdateCustomOptions          = "window.cmd.update.custom.options"
	EventNameWindowCmdWebContentsCloseDevTools     = "window.cmd.web.contents.close.dev.tools"
	EventNameWindowCmdWebContentsOpenDevTools      = "window.cmd.web.contents.open.dev.tools"
	EventNameWindowCmdWebContentsExecuteJavaScript = "window.cmd.web.contents.execute.javascript"
	EventNameWindowCmdSetAlwaysOnTop               = "window.cmd.set.always.on.top"
	EventNameWindowCmdSetFullScreen                = "window.cmd.set.full.screen"
	EventNameWindowEventBlur                       = "window.event.blur"
	EventNameWindowEventClosed                     = "window.event.closed"
	EventNameWindowEventContentProtectionSet       = "window.event.content.protection.set"
	EventNameWindowEventDidFinishLoad              = "window.event.did.finish.load"
	EventNameWindowEventEnterFullScreen            = "window.event.enter.full.screen"
	EventNameWindowEventFocus                      = "window.event.focus"
	EventNameWindowEventHide                       = "window.event.hide"
	EventNameWindowEventLeaveFullScreen            = "window.event.leave.full.screen"
	EventNameWindowEventMaximize                   = "window.event.maximize"

	EventNameWindowEventMinimize                      = "window.event.minimize"
	EventNameWindowEventMove                          = "window.event.move"
	EventNameWindowEventMoved                         = "window.event.moved"
	EventNameWindowEventReadyToShow                   = "window.event.ready.to.show"
	EventNameWindowEventResize                        = "window.event.resize"
	EventNameWindowEventResizeContent                 = "window.event.resize.content"
	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"
	EventNameWindowEventWillMove                      = "window.event.will.move"
	EventNameWindowEventWillNavigate                  = "window.event.will.navigate"
	EventNameWindowEventUpdatedCustomOptions          = "window.event.updated.custom.options"
	EventNameWindowEventAlwaysOnTopChanged            = "window.event.always.on.top.changed"
)

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 added in v0.5.0

func AstilectronDownloadSrc(versionAstilectron string) string

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

func DefaultExecuter added in v0.6.0

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

DefaultExecuter represents the default executer

func Disembed added in v0.2.0

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 added in v0.5.0

func ElectronDownloadSrc(os, arch, versionElectron string) string

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

func IsValidOS added in v0.6.0

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 added in v0.6.0

type Accelerator []string

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

func NewAccelerator added in v0.6.0

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

NewAccelerator creates a new accelerator

func (*Accelerator) MarshalText added in v0.6.0

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

MarshalText implements the encoding.TextMarshaler interface

func (*Accelerator) UnmarshalText added in v0.6.0

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 added in v0.2.0

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

Displays returns the displays

func (*Astilectron) Dock added in v0.6.0

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 added in v0.2.0

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

NewMenu creates a new app menu

func (*Astilectron) NewNotification added in v0.6.0

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

NewNotification creates a new notification

func (*Astilectron) NewTray added in v0.5.0

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 added in v0.2.0

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 added in v0.6.0

func (a *Astilectron) Paths() Paths

Paths returns the paths

func (*Astilectron) PrimaryDisplay added in v0.2.0

func (a *Astilectron) PrimaryDisplay() *Display

PrimaryDisplay returns the primary display

func (*Astilectron) Quit added in v0.6.0

func (a *Astilectron) Quit() error

Quit quits the app

func (*Astilectron) SetExecuter added in v0.6.0

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 added in v0.6.0

type CallbackMessage func(m *EventMessage)

CallbackMessage represents a message callback

type Disembedder added in v0.2.0

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

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

type Display added in v0.2.0

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 added in v0.2.0

func (d Display) Bounds() Rectangle

Bounds returns the display bounds

func (Display) ID added in v0.14.1

func (d Display) ID() int64

ID returns the display's ID

func (Display) IsPrimary added in v0.2.0

func (d Display) IsPrimary() bool

IsPrimary checks whether the display is the primary display

func (Display) IsTouchAvailable added in v0.2.0

func (d Display) IsTouchAvailable() bool

IsTouchAvailable checks whether touch is available on this display

func (Display) Rotation added in v0.2.0

func (d Display) Rotation() int

Rotation returns the display rotation

func (Display) ScaleFactor added in v0.2.0

func (d Display) ScaleFactor() float64

ScaleFactor returns the display scale factor

func (Display) Size added in v0.2.0

func (d Display) Size() Size

Size returns the display size

func (Display) WorkArea added in v0.2.0

func (d Display) WorkArea() Rectangle

WorkArea returns the display work area

func (Display) WorkAreaSize added in v0.2.0

func (d Display) WorkAreaSize() Size

WorkAreaSize returns the display work area size

type DisplayOptions added in v0.2.0

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 added in v0.6.0

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 added in v0.6.0

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

Bounce bounces the dock

func (*Dock) BounceDownloads added in v0.6.0

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

BounceDownloads bounces the downloads part of the dock

func (*Dock) CancelBounce added in v0.6.0

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

CancelBounce cancels the dock bounce

func (*Dock) Hide added in v0.6.0

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

Hide hides the dock

func (*Dock) NewMenu added in v0.6.0

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

NewMenu creates a new dock menu

func (Dock) On added in v0.6.0

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

On implements the Listenable interface

func (*Dock) SetBadge added in v0.6.0

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

SetBadge sets the badge of the dock

func (*Dock) SetIcon added in v0.6.0

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

SetIcon sets the icon of the dock

func (*Dock) Show added in v0.6.0

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"`
	Enable              *bool                `json:"enable,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"`
	Path                string               `json:"path,omitempty"`
	Reply               string               `json:"reply,omitempty"`
	Request             *EventRequest        `json:"request,omitempty"`
	SecondInstance      *EventSecondInstance `json:"secondInstance,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 added in v0.6.0

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 added in v0.2.0

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

EventDisplays represents events displays

type EventMenu added in v0.2.0

type EventMenu struct {
	*EventSubMenu
}

EventMenu represents an event menu

type EventMenuItem added in v0.2.0

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 added in v0.6.0

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

EventRequest represents an event request

type EventSecondInstance added in v0.20.0

type EventSecondInstance struct {
	CommandLine      []string `json:"commandLine,omitempty"`
	WorkingDirectory string   `json:"workingDirectory,omitempty"`
}

EventSecondInstance represents data related to a second instance of the app being started

type EventSubMenu added in v0.2.0

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

EventSubMenu represents a sub menu event

type Executer added in v0.6.0

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 added in v0.6.0

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 added in v0.6.0

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 added in v0.6.0

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 added in v0.6.0

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

Create creates the notification

func (Notification) On added in v0.6.0

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

On implements the Listenable interface

func (*Notification) Show added in v0.6.0

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

Show shows the notification

type NotificationOptions added in v0.6.0

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 {
	AcceptTCPTimeout   time.Duration
	AppName            string
	AppIconDarwinPath  string // Darwin systems requires a specific .icns file
	AppIconDefaultPath string
	CustomElectronPath 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 added in v0.2.0

func (p Paths) AppExecutable() string

AppExecutable returns the app executable path

func (Paths) AppIconDarwinSrc added in v0.2.0

func (p Paths) AppIconDarwinSrc() string

AppIconDarwinSrc returns the darwin app icon path

func (Paths) AppIconDefaultSrc added in v0.6.0

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 added in v0.6.0

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 added in v0.2.0

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 added in v0.2.0

type Position struct {
	X, Y int
}

Position represents a position

type PositionOptions added in v0.2.0

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

PositionOptions represents position options

type ProvisionStatus added in v0.2.0

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

ProvisionStatus represents the provision status

type ProvisionStatusPackage added in v0.2.0

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 added in v0.2.0

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

NewDisembedderProvisioner creates a provisioner that can provision based on embedded data

type Rectangle added in v0.2.0

type Rectangle struct {
	Position
	Size
}

Rectangle represents a rectangle

type RectangleOptions added in v0.2.0

type RectangleOptions struct {
	PositionOptions
	SizeOptions
}

RectangleOptions represents rectangle options

type Session added in v0.6.0

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 added in v0.6.0

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

ClearCache clears the Session's HTTP cache

func (*Session) FlushStorage added in v0.14.0

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

FlushStorage writes any unwritten DOMStorage data to disk

func (*Session) LoadExtension added in v0.23.0

func (s *Session) LoadExtension(path string) (err error)

Loads a chrome extension

func (Session) On added in v0.6.0

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

On implements the Listenable interface

type Size added in v0.2.0

type Size struct {
	Height, Width int
}

Size represents a size

type SizeOptions added in v0.2.0

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 added in v0.6.0

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

Supported represents Astilectron supported features

type Tray added in v0.5.0

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

Tray represents a tray

func (*Tray) Create added in v0.5.0

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

Create creates the tray

func (*Tray) Destroy added in v0.5.0

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

Destroy destroys the tray

func (*Tray) NewMenu added in v0.5.0

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

NewMenu creates a new tray menu

func (Tray) On added in v0.5.0

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

On implements the Listenable interface

func (*Tray) SetImage added in v0.6.0

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

SetImage sets the tray image

type TrayOptions added in v0.5.0

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 added in v0.5.0

type WebPreferences struct {
	AllowRunningInsecureContent *bool   `json:"allowRunningInsecureContent,omitempty"`
	BackgroundThrottling        *bool   `json:"backgroundThrottling,omitempty"`
	BlinkFeatures               *string `json:"blinkFeatures,omitempty"`
	// This attribute needs to be false at all time
	// 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"`
	EnableRemoteModule         *bool                  `json:"enableRemoteModule,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) Bounds added in v0.28.0

func (w *Window) Bounds() (rect Rectangle, err error)

Bounds return the window bounds

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 added in v0.16.0

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) IsFullScreen added in v0.29.0

func (w *Window) IsFullScreen() bool

IsFullScreen returns whether the window is in full screen mode

func (*Window) IsShown added in v0.6.0

func (w *Window) IsShown() bool

IsShown returns whether the window is shown

func (*Window) Log added in v0.6.0

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 added in v0.2.0

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

MoveInDisplay moves the window in the proper display

func (*Window) NewMenu added in v0.2.0

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 added in v0.6.0

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

func (*Window) OnMessage added in v0.6.0

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) ResizeContent added in v0.27.0

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

ResizeContent resizes the content viewport

func (*Window) Restore

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

Restore restores the window

func (*Window) SendMessage added in v0.6.0

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) SetAlwaysOnTop added in v0.28.0

func (w *Window) SetAlwaysOnTop(flag bool) (err error)

SetAlwaysOnTop sets whether the window should show always on top of other windows.

func (*Window) SetBounds added in v0.9.0

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

SetBounds set bounds of the window

func (*Window) SetContentProtection added in v0.25.0

func (w *Window) SetContentProtection(enable bool) (err error)

Enable content protection on the window

func (*Window) SetFullScreen added in v0.29.0

func (w *Window) SetFullScreen(enable bool) (err error)

SetFullScreen sets the fullscreen flag 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

func (*Window) UpdateCustomOptions added in v0.22.0

func (w *Window) UpdateCustomOptions(o WindowCustomOptions) (err error)

UpdateCustomOptions updates the window custom options

type WindowAppDetails added in v0.9.0

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 added in v0.6.0

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 added in v0.6.0

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 added in v0.6.0

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

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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