oswin

package
v0.0.0-...-5f41422 Latest Latest
Warning

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

 Go to latest Published: Jul 29, 2018 License: BSD-3-Clause Imports: 11 Imported by: 0

Documentation

Overview

Package oswin provides interfaces for OS-specific GUI hardware for portable two-dimensional graphics and input events.

The App interface provides a top-level, single-instance struct that knows about specific hardware, and can create new Window, Image, and Texture objects that are hardware-specific and provide the primary GUI interface. It is aways available as oswin.TheApp.

Events are commuinicated through the Window -- see EventType and Event in event.go for all the different types.

The driver package creates the App, via its Main function, which is designed to be called by the program's main function. The driver package provides the default driver for the system, such as the X11 driver for desktop Linux, but other drivers, such as the OpenGL driver, can be explicitly invoked by calling that driver's Main function. To use the default driver: 

 TODO: following is out-of-date

	package main

	import (
		"github.com/rcoreilly/goki/gi/oswin/driver"
		"github.com/rcoreilly/goki/gi/oswin"
		"github.com/rcoreilly/goki/gi/oswin/lifecycle"
	)

	func main() {
		driver.Main(func(app oswin.App) {
			w, err := app.NewWindow(nil)
			if err != nil {
				handleError(err)
				return
			}
			defer w.Release()

			for {
				switch e := w.NextEvent().(type) {
				case lifecycle.Event:
					if e.To == lifecycle.StageDead {
						return
					}
					etc
				case etc:
					etc
				}
			}
		})
	}

Complete examples can be found in the gi/example directory.

Each driver package provides App, Screen, Image, Texture and Window implementations that work together. Such types are interface types because this package is driver-independent, but those interfaces aren't expected to be implemented outside of drivers. For example, a driver's Window implementation will generally work only with that driver's Image implementation, and will not work with an arbitrary type that happens to implement the Image methods.

Index

Constants

View Source 
const (
	Over = draw.Over
	Src  = draw.Src
)

These draw.Op constants are provided so that users of this package don't have to explicitly import "image/draw".

Variables

View Source 
var KiT_EventType = kit.Enums.AddEnum(EventTypeN, false, nil)
View Source 
var KiT_ScreenOrientation = kit.Enums.AddEnum(ScreenOrientationN, false, nil)
View Source 
var KiT_WindowFlags = kit.Enums.AddEnum(WindowFlagsN, true, nil) // bitflags
View Source 
var LogicalDPIScale = float32(0.6)

LogicalDPIScale is a scaling factor that can be set by preferences to rescale the logical DPI relative to the actual physical DPI, thereby scaling the overall density of the display (e.g., smaller numbers produce smaller, higher-density displays)

Functions

func LogicalFmPhysicalDPI 

func LogicalFmPhysicalDPI(pdpi float32) float32

LogicalFmPhysicalDPI computes the logical DPI used in actual screen scaling based on the LogicalDPIScale factor, and also makes it a multiple of 6 to make normal font sizes look best

func WindowFlagsToBool 

func WindowFlagsToBool(flags int64) (dialog, modal, tool, fullscreen bool)

Types

type App 

type App interface {
	// Name is the overall name of the application -- used for specifying an
	// application-specific preferences directory, etc
	Name() string

	// SetName sets the application name -- defaults to GoGi if not otherwise set
	SetName(name string)

	// NScreens returns the number of different logical and/or physical
	// screens managed under this overall screen hardware
	NScreens() int

	// Screen returns screen for given screen number, or nil if not a
	// valid screen number
	Screen(scrN int) *Screen

	// NWindows returns the number of windows open for this app
	NWindows() int

	// Window returns given window in list of windows opened under this screen
	// -- list is not in any guaranteed order, but typically in order of
	// creation (see also WindowByName) -- returns nil for invalid index
	Window(win int) Window

	// WindowByName returns given window in list of windows opened under this
	// screen, by name -- nil if not found
	WindowByName(name string) Window

	// NewWindow returns a new Window for this screen. A nil opts is valid and
	// means to use the default option values.
	NewWindow(opts *NewWindowOptions) (Window, error)

	// NewImage returns a new Image for this screen.  Images can be drawn upon
	// directly using image and other packages, and have an accessable []byte
	// slice holding the image data
	NewImage(size image.Point) (Image, error)

	// NewTexture returns a new Texture for the given window.  Textures are opaque
	// and could be non-local, but very fast for rendering to windows --
	// typically create a texture of each window and render to that texture,
	// then Draw that texture to the window when it is time to update (call
	// Publish on window after drawing)
	NewTexture(win Window, size image.Point) (Texture, error)

	// PrefsDir returns the OS-specific preferences directory: Mac: ~/Library,
	// Linux: ~/.config, Windows: ?
	PrefsDir() string

	// GoGiPrefsDir returns the GoGi preferences directory: PrefsDir + GoGi --
	// ensures that the directory exists first
	GoGiPrefsDir() string

	// AppPrefsDir returns the application-specific preferences directory:
	// PrefsDir + App.Name --ensures that the directory exists first
	AppPrefsDir() string

	// FontPaths returns the default system font paths
	FontPaths() []string
}

App represents the overall OS GUI hardware, and creates Images, Textures and Windows, appropriate for that hardware / OS, and maintains data about the physical screen(s) 

var TheApp App

TheApp is the current oswin App -- only ever one in effect

type DrawOptions 

type DrawOptions struct {
}

DrawOptions are optional arguments to Draw.

type Drawer 

type Drawer interface {
	// Draw draws the sub-Texture defined by src and sr to the destination (the
	// method receiver). src2dst defines how to transform src coordinates to
	// dst coordinates. For example, if src2dst is the matrix
	//
	// m00 m01 m02
	// m10 m11 m12
	//
	// then the src-space point (sx, sy) maps to the dst-space point
	// (m00*sx + m01*sy + m02, m10*sx + m11*sy + m12).
	Draw(src2dst f64.Aff3, src Texture, sr image.Rectangle, op draw.Op, opts *DrawOptions)

	// DrawUniform is like Draw except that the src is a uniform color instead
	// of a Texture.
	DrawUniform(src2dst f64.Aff3, src color.Color, sr image.Rectangle, op draw.Op, opts *DrawOptions)

	// Copy copies the sub-Texture defined by src and sr to the destination
	// (the method receiver), such that sr.Min in src-space aligns with dp in
	// dst-space.
	Copy(dp image.Point, src Texture, sr image.Rectangle, op draw.Op, opts *DrawOptions)

	// Scale scales the sub-Texture defined by src and sr to the destination
	// (the method receiver), such that sr in src-space is mapped to dr in
	// dst-space.
	Scale(dr image.Rectangle, src Texture, sr image.Rectangle, op draw.Op, opts *DrawOptions)
}

Drawer is something you can draw Textures on.

Draw is the most general purpose of this interface's methods. It supports arbitrary affine transformations, such as translations, scales and rotations.

Copy and Scale are more specific versions of Draw. The affected dst pixels are an axis-aligned rectangle, quantized to the pixel grid. Copy copies pixels in a 1:1 manner, Scale is more general. They have simpler parameters than Draw, using ints instead of float64s.

When drawing on a Window, there will not be any visible effect until Publish is called.

type Event 

type Event interface {
	// Type returns the type of event associated with given event
	Type() EventType

	// HasPos returns true if the event has a window position where it takes place
	HasPos() bool

	// Pos returns the position in raw display dots (pixels) where event took place -- needed for sending events to the right place
	Pos() image.Point

	// OnFocus returns true if the event operates only on focus item (e.g., keyboard events)
	OnFocus() bool

	// Time returns the time at which the event was generated, in UnixNano nanosecond units
	Time() time.Time

	// IsProcessed returns whether this event has already been processed
	IsProcessed() bool

	// SetProcessed marks the event as having been processed
	SetProcessed()

	// Init sets the time to now, and any other init -- done just prior to event delivery
	Init()

	// SetTime sets the event time to Now
	SetTime()
}

interface for GUI events

type EventBase 

type EventBase struct {
	// GenTime records the time when the event was first generated, as seconds
	// and nanoseconds instead of the default Time struct, to avoid having the
	// location pointer per this:
	// https://segment.com/blog/allocation-efficiency-in-high-performance-go-services/
	GenTimeSec  int64
	GenTimeNSec uint32

	// Processed indicates if the event has been processed by an end receiver,
	// and thus should no longer be processed by other possible receivers
	Processed bool
}

EventBase is the base type for events -- records time and whether event has been processed by a receiver of the event -- in which case it is skipped

func (*EventBase) Init 

func (ev *EventBase) Init()

func (EventBase) IsProcessed 

func (ev EventBase) IsProcessed() bool

func (*EventBase) SetProcessed 

func (ev *EventBase) SetProcessed()

func (*EventBase) SetTime 

func (ev *EventBase) SetTime()

SetTime sets the event time to Now

func (EventBase) Time 

func (ev EventBase) Time() time.Time

type EventDeque 

type EventDeque interface {
	// Send adds an event to the end of the deque. They are returned by
	// NextEvent in FIFO order.
	Send(event Event)

	// SendFirst adds an event to the start of the deque. They are returned by
	// NextEvent in LIFO order, and have priority over events sent via Send.
	SendFirst(event Event)

	// NextEvent returns the next event in the deque. It blocks until such an
	// event has been sent.
	NextEvent() Event
}

EventDeque is an infinitely buffered double-ended queue of events.

type EventType 

type EventType int64

EventType determines which type of GUI event is being sent -- need this for indexing into different event signalers based on event type, and sending event type in signals -- critical to break up different event types into the right categories needed for different types of widgets -- e.g., most do not need move or scroll events, so those are separated 

const (
	// MouseEvent includes all mouse button actions, but not move or drag
	MouseEvent EventType = iota
	// MouseMoveEvent is when the mouse is moving but no button is down
	MouseMoveEvent
	// MouseDragEvent is when the mouse is moving and there is a button down
	MouseDragEvent
	// MouseScrollEvent is for mouse scroll wheel events
	MouseScrollEvent
	// MouseFocusEvent is for mouse focus (enter / exit of widget area) --
	// generated by gi.Window based on mouse move events
	MouseFocusEvent

	// KeyEvent for key pressed or released -- fine-grained data about each key as it happens
	KeyEvent
	// KeyChordEvent is only generated when a non-modifier key is released,
	// and it also contains a string representation of the full chord,
	// suitable for translation into keyboard commands, emacs-style etc
	KeyChordEvent

	// touch and gesture events
	TouchEvent
	MagnifyEvent
	RotateEvent

	// WindowEvent reports any changes in the window size, orientation,
	// iconify, close, open
	WindowEvent

	// WindowResizeEvent is specifically for window resize events which need
	// special treatment
	WindowResizeEvent

	// LifeCycleEvent for app window activation, focus, and startup / termination
	LifeCycleEvent

	// PaintEvent for notifications about painting windows
	PaintEvent

	// number of event types
	EventTypeN
)

func (*EventType) FromString 

func (i *EventType) FromString(s string) error

func (EventType) String 

func (i EventType) String() string

type Image 

type Image interface {
	// Release releases the Image's resources, after all pending uploads and
	// draws resolve.
	//
	// The behavior of the Image after Release, whether calling its methods or
	// passing it as an argument, is undefined.
	Release()

	// Size returns the size of the Image's image.
	Size() image.Point

	// Bounds returns the bounds of the Image's image. It is equal to
	// image.Rectangle{Max: b.Size()}.
	Bounds() image.Rectangle

	// RGBA returns the pixel buffer as an *image.RGBA.
	//
	// Its contents should not be accessed while the Image is uploading.
	//
	// The contents of the returned *image.RGBA's Pix field (of type []byte)
	// can be modified at other times, but that Pix slice itself (i.e. its
	// underlying pointer, length and capacity) should not be modified at any
	// time.
	//
	// The following is valid:
	//	m := buffer.RGBA()
	//	if len(m.Pix) >= 4 {
	//		m.Pix[0] = 0xff
	//		m.Pix[1] = 0x00
	//		m.Pix[2] = 0x00
	//		m.Pix[3] = 0xff
	//	}
	// or, equivalently:
	//	m := buffer.RGBA()
	//	m.SetRGBA(m.Rect.Min.X, m.Rect.Min.Y, color.RGBA{0xff, 0x00, 0x00, 0xff})
	// and using the standard library's image/draw package is also valid:
	//	dst := buffer.RGBA()
	//	draw.Draw(dst, dst.Bounds(), etc)
	// but the following is invalid:
	//	m := buffer.RGBA()
	//	m.Pix = anotherByteSlice
	// and so is this:
	//	*buffer.RGBA() = anotherImageRGBA
	RGBA() *image.RGBA
}

Image is an in-memory pixel buffer. Its pixels can be modified by any Go code that takes an *image.RGBA, such as the standard library's image/draw package. A Image is essentially an *image.RGBA, but not all *image.RGBA values (including those returned by image.NewRGBA) are valid Images, as a driver may assume that the memory backing a Image's pixels are specially allocated.

To see a Image's contents on a screen, upload it to a Texture (and then draw the Texture on a Window) or upload it directly to a Window.

When specifying a sub-Image via Upload, a Image's top-left pixel is always (0, 0) in its own coordinate space.

type NewWindowOptions 

type NewWindowOptions struct {
	// Size specifies the dimensions of the new window, either in raw pixels
	// or std 96 dpi pixels depending on StdPixels. If Width or Height are
	// zero, a driver-dependent default will be used for each zero value
	// dimension
	Size image.Point

	// StdPixels means use standardized "pixel" units for the window size (96
	// per inch), not the actual underlying raw display dot pixels
	StdPixels bool

	// Pos specifies the position of the window, if non-zero -- always in
	// device-specific raw pixels
	Pos image.Point

	// Title specifies the window title.
	Title string

	// Flags can be set using WindowFlags to request different types of windows
	Flags int64
}

NewWindowOptions are optional arguments to NewWindow.

func (*NewWindowOptions) Fixup 

func (o *NewWindowOptions) Fixup()

Fixup fills in defaults and updates everything based on current screen and window context Specific hardware can fine-tune this as well, in driver code

func (*NewWindowOptions) GetTitle 

func (o *NewWindowOptions) GetTitle() string

GetTitle returns a sanitized form of o.Title. In particular, its length will not exceed 4096, and it may be further truncated so that it is valid UTF-8 and will not contain the NUL byte.

o may be nil, in which case "" is returned.

func (*NewWindowOptions) SetDialog 

func (o *NewWindowOptions) SetDialog()

func (*NewWindowOptions) SetFullScreen 

func (o *NewWindowOptions) SetFullScreen()

func (*NewWindowOptions) SetModal 

func (o *NewWindowOptions) SetModal()

func (*NewWindowOptions) SetTool 

func (o *NewWindowOptions) SetTool()

type PublishResult 

type PublishResult struct {
	// BackImagePreserved is whether the contents of the back buffer was
	// preserved. If false, the contents are undefined.
	BackImagePreserved bool
}

PublishResult is the result of an Window.Publish call.

type Screen 

type Screen struct {
	// ScreenNumber is the index of this screen in the list of screens
	// maintained under Screen
	ScreenNumber int

	// Geometry contains the geometry of the screen in raw pixels -- all physical screens start at 0,0
	Geometry image.Rectangle

	// Color depth of the screen, in bits
	Depth int

	// LogicalDPI is the logical dots per inch of the window, which is used for all
	// rendering -- subject to zooming effects etc -- see the gi/units package
	// for translating into various other units
	LogicalDPI float32

	// PhysicalDPI is the physical dots per inch of the window, for generating
	// true-to-physical-size output, for example -- see the gi/units package for
	// translating into various other units
	PhysicalDPI float32

	// PhysicalSize is the actual physical size of the screen, in mm
	PhysicalSize image.Point

	// DevicePixelRatio is a multiplier factor that scales the screen's
	// "natural" pixel coordinates into actual device pixels.
	//
	// On OS-X  it is backingScaleFactor, which is 2.0 on "retina" displays
	DevicePixelRatio float32

	RefreshRate float32

	AvailableGeometry        image.Rectangle
	VirtualGeometry          image.Rectangle
	AvailableVirtualGeometry image.Rectangle

	Orientation        ScreenOrientation
	NativeOrientation  ScreenOrientation
	PrimaryOrientation ScreenOrientation

	Name         string
	Manufacturer string
	Model        string
	SerialNumber string
}

Screen contains data about each physical and / or logical screen

type ScreenOrientation 

type ScreenOrientation int32

ScreenOrientation is the orientation of the device screen. 

const (
	// OrientationUnknown means device orientation cannot be determined.
	//
	// Equivalent on Android to Configuration.ORIENTATION_UNKNOWN
	// and on iOS to:
	//	UIDeviceOrientationUnknown
	//	UIDeviceOrientationFaceUp
	//	UIDeviceOrientationFaceDown
	OrientationUnknown ScreenOrientation = iota

	// Portrait is a device oriented so it is tall and thin.
	//
	// Equivalent on Android to Configuration.ORIENTATION_PORTRAIT
	// and on iOS to:
	//	UIDeviceOrientationPortrait
	//	UIDeviceOrientationPortraitUpsideDown
	Portrait

	// Landscape is a device oriented so it is short and wide.
	//
	// Equivalent on Android to Configuration.ORIENTATION_LANDSCAPE
	// and on iOS to:
	//	UIDeviceOrientationLandscapeLeft
	//	UIDeviceOrientationLandscapeRight
	Landscape

	ScreenOrientationN
)

func (*ScreenOrientation) FromString 

func (i *ScreenOrientation) FromString(s string) error

func (ScreenOrientation) String 

func (i ScreenOrientation) String() string

type Texture 

type Texture interface {
	// Release releases the Texture's resources, after all pending uploads and
	// draws resolve.
	//
	// The behavior of the Texture after Release, whether calling its methods
	// or passing it as an argument, is undefined.
	Release()

	// Size returns the size of the Texture's image.
	Size() image.Point

	// Bounds returns the bounds of the Texture's image. It is equal to
	// image.Rectangle{Max: t.Size()}.
	Bounds() image.Rectangle

	Uploader
}

Texture is a pixel buffer, but not one that is directly accessible as a []byte. Conceptually, it could live on a GPU, in another process or even be across a network, instead of on a CPU in this process.

Images can be uploaded to Textures, and Textures can be drawn on Windows.

When specifying a sub-Texture via Draw, a Texture's top-left pixel is always (0, 0) in its own coordinate space.

type Uploader 

type Uploader interface {
	// Upload uploads the sub-Image defined by src and sr to the destination
	// (the method receiver), such that sr.Min in src-space aligns with dp in
	// dst-space. The destination's contents are overwritten; the draw operator
	// is implicitly draw.Src.
	//
	// It is valid to upload a Image while another upload of the same Image
	// is in progress, but a Image's image.RGBA pixel contents should not be
	// accessed while it is uploading. A Image is re-usable, in that its pixel
	// contents can be further modified, once all outstanding calls to Upload
	// have returned.
	//
	// TODO: make it optional that a Image's contents is preserved after
	// Upload? Undoing a swizzle is a non-trivial amount of work, and can be
	// redundant if the next paint cycle starts by clearing the buffer.
	//
	// When uploading to a Window, there will not be any visible effect until
	// Publish is called.
	Upload(dp image.Point, src Image, sr image.Rectangle)

	// Fill fills that part of the destination (the method receiver) defined by
	// dr with the given color.
	//
	// When filling a Window, there will not be any visible effect until
	// Publish is called.
	Fill(dr image.Rectangle, src color.Color, op draw.Op)
}

Uploader is something you can upload a Image to.

type Window 

type Window interface {
	// Name returns the name of the window -- name is used strictly for
	// internal tracking and finding of windows -- see Title for the displayed
	// title of the window
	Name() string

	// SetName sets the name of the window
	SetName(name string)

	// Title returns the current title of the window, which is displayed in the GUI
	Title() string

	// SetTitle sets the current title of the window, which is displayed in the GUI
	SetTitle(title string)

	// Size returns the current size of the window, in raw underlying dots / pixels
	Size() image.Point

	// SetSize attempts to set the size of the window to given size, in raw
	// underlying dots / pixels
	SetSize(sz image.Point)

	// Position returns the current lef-top position of the window relative to
	// underlying screen, in raw underlying dots / pixels
	Position() image.Point

	// PhysicalDPI is the physical dots per inch of the window, for generating
	// true-to-physical-size output, for example -- see the gi/units package for
	// translating into various other units
	PhysicalDPI() float32

	// LogicalDPI returns the current logical dots-per-inch resolution of the
	// window, which should be used for most conversion of standard units --
	// physical DPI can be found in the Screen
	LogicalDPI() float32

	// SetLogicalDPI sets the current logical dots-per-inch resolution of the
	// window, which should be used for most conversion of standard units --
	// physical DPI can be found in the Screen
	SetLogicalDPI(dpi float32)

	// Screen returns the screen for this window, with all the relevant
	// information about its properties
	Screen() *Screen

	// Parent returns the parent object of a given window -- for GoGi it is a
	// gi.Window but could be something else in other frameworks
	Parent() interface{}

	// SetParent sets the parent object of a given window -- for GoGi it is a
	// gi.Window but could be something else in other frameworks
	SetParent(par interface{})

	// Flags returns the bit flags for this window's properties set according
	// to WindowFlags bits (use bitflag package to access)
	Flags() int64

	// Release closes the window. The behavior of the Window after Release,
	// whether calling its methods or passing it as an argument, is undefined.
	Release()

	EventDeque

	Uploader

	Drawer

	// Publish flushes any pending Upload and Draw calls to the window, and
	// swaps the back buffer to the front.
	Publish() PublishResult
}

Window is a double-buffered OS-specific hardware window

type WindowBase 

type WindowBase struct {
	Nm      string
	Titl    string
	Sz      image.Point
	Pos     image.Point
	PhysDPI float32
	LogDPI  float32
	Scrn    *Screen
	Par     interface{}
	Flag    int64
}

WindowBase provides a base-level implementation of the generic data aspects of the window, including maintaining the current window size and dpi

func (*WindowBase) Flags 

func (w *WindowBase) Flags() int64

func (WindowBase) LogicalDPI 

func (w WindowBase) LogicalDPI() float32

func (WindowBase) Name 

func (w WindowBase) Name() string

func (WindowBase) Parent 

func (w WindowBase) Parent() interface{}

func (WindowBase) PhysicalDPI 

func (w WindowBase) PhysicalDPI() float32

func (WindowBase) Position 

func (w WindowBase) Position() image.Point

func (WindowBase) Screen 

func (w WindowBase) Screen() *Screen

func (*WindowBase) SetLogicalDPI 

func (w *WindowBase) SetLogicalDPI(dpi float32)

func (*WindowBase) SetName 

func (w *WindowBase) SetName(name string)

func (*WindowBase) SetParent 

func (w *WindowBase) SetParent(parent interface{})

func (*WindowBase) SetTitle 

func (w *WindowBase) SetTitle(title string)

func (WindowBase) Size 

func (w WindowBase) Size() image.Point

func (WindowBase) Title 

func (w WindowBase) Title() string

type WindowFlags 

type WindowFlags int32

WindowFlags contains all the optional properties of a window -- by default with no flags a window is a main top-level window 

const (
	// Dialog indicates that this is a temporary, pop-up window
	Dialog WindowFlags = iota

	// Modal indicates that this dialog window blocks events going to other
	// windows until it is closed
	Modal

	// Tool indicates that this is a floating tool window that has minimized
	// window decoration
	Tool

	// FullScreen indicates that this window should be opened full-screen
	FullScreen

	WindowFlagsN
)

func (*WindowFlags) FromString 

func (i *WindowFlags) FromString(s string) error

func (WindowFlags) String 

func (i WindowFlags) String() string

Source Files

View all Source files

Directories

Path Synopsis
Package driver provides the default driver for accessing a screen.
 Package driver provides the default driver for accessing a screen.
gldriver
Package gldriver provides an OpenGL driver for accessing a screen.
 Package gldriver provides an OpenGL driver for accessing a screen.
internal/drawer
Package drawer provides functions that help implement screen.Drawer methods.
 Package drawer provides functions that help implement screen.Drawer methods.
internal/errapp
Package errapp provides a stub App implementation.
 Package errapp provides a stub App implementation.
internal/event
Package event provides an infinitely buffered double-ended queue of events.
 Package event provides an infinitely buffered double-ended queue of events.
internal/lifecycler
Package lifecycler tracks a window's lifecycle state.
 Package lifecycler tracks a window's lifecycle state.
internal/swizzle
Package swizzle provides functions for converting between RGBA pixel formats.
 Package swizzle provides functions for converting between RGBA pixel formats.
internal/win32
internal/x11key
x11key contains X11 numeric codes for the keyboard and mouse.
 x11key contains X11 numeric codes for the keyboard and mouse.
windriver
Package windriver provides the Windows driver for accessing a screen.
 Package windriver provides the Windows driver for accessing a screen.
x11driver
Package x11driver provides the X11 driver for accessing a screen.
 Package x11driver provides the X11 driver for accessing a screen.
Package key defines an event for physical keyboard keys, for the GoGi GUI system.
 Package key defines an event for physical keyboard keys, for the GoGi GUI system.
Package lifecycle defines an event for an app's lifecycle, for the GoGI GUI system.
 Package lifecycle defines an event for an app's lifecycle, for the GoGI GUI system.
Package mouse defines mouse events, for the GoGi GUI system.
 Package mouse defines mouse events, for the GoGi GUI system.
Package paint defines an event for the app being ready to paint.
 Package paint defines an event for the app being ready to paint.
Package touch defines an event for touch input, for the GoGi GUI system.
 Package touch defines an event for touch input, for the GoGi GUI system.
Package window defines an event associated with windows -- including changes in the dimensions, physical resolution and orientation of the app's window, and iconify, open and close events (see also lifecycle events, which pertain to the main app window -- these window events are for all windows including dialogs and popups)
 Package window defines an event associated with windows -- including changes in the dimensions, physical resolution and orientation of the app's window, and iconify, open and close events (see also lifecycle events, which pertain to the main app window -- these window events are for all windows including dialogs and popups)

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.