fyneextensions

type ActionItem ¶

type ActionItem struct {
	Name                  binding.String
	CriticalName          bool
	AlwaysShowAsContainer bool
	Resources             []fyne.Resource
	Triggered             func(int)
	SubActions            []*ActionItem
	HasDynamicStates      bool

	Disabler binding.Bool
	Hider    binding.Bool
	Stater   binding.Int
}

ActionItem is a struct that represents an action. An action typically has a name, a state resources associated with it (icons), an action function to trigger and some binding states. Instead of a function to trigger, it could have sub-actions to create complex "menu" systems

The fields are as follows: - Name is a binding.String which provides a way to display a name for an action and observe changes to this name. - CriticalName is a bool that determines if the name is critical and should always be rendered. - AlwaysShowAsContainer is a bool that defines if the action should always be represented as a container even if there are no sub-actions. - Resources is a slice of fyne.Resource which can be used for representing the action in UI, like using an icon. The state of the item will force the related resource to be shown - Triggered is a function that will be invoked when the action is triggered. - SubActions are nested actions. - HasDynamicStates is a bool that defines if the action has dynamic states that can change. - Disabler, Hider, and Stater are binding variables which provide a way to control the disabled, hidden, and state properties of an action and observe changes to these properties.

The `Actionable` interface and its related items aim to provide a structured way to represent and manipulate actions in a Fyne application.

func NewActionItem(name string, isNameCritical, alwaysShowAsContainer bool, resources []fyne.Resource, disabled bool, hidden bool, dynamicStates bool, state int, triggered func(int), subActions []*ActionItem) (action *ActionItem)

func (ai *ActionItem) AppendActions(subActions ...*ActionItem)

type Actionable ¶

type Actionable interface {
	GetActions() *ActionItem
	GetCanvas() fyne.Canvas
}

The Actionable interface has two methods:

- GetActions() *ActionItem - GetCanvas() Fyne.Canvas

These are implemented by types that have actions and operate on a Fyne canvas.

type ActionableMenu ¶

type ActionableMenu struct {

	// Menu represents the actual fyne menu
	Menu *fyne.Menu
	// contains filtered or unexported fields
}

ActionableMenu represents a Menu that has actions associated with it. Implements data binding listener interfaces to enable reactive behaviours to configuration changes such as name, being disabled, state changes and visibility.

func NewActionableMenu(item *ActionItem) *ActionableMenu

func NewActionableMenu2(items ...*ActionItem) *ActionableMenu

func (am *ActionableMenu) DataChanged()

type ActionableMenuItem ¶

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

func NewActionableMenuItem(item *ActionItem, parentItem binding.DataListener, rootItem binding.DataListener) *ActionableMenuItem

func (ami *ActionableMenuItem) DataChanged()

func (ami *ActionableMenuItem) GetMenu() *fyne.Menu

type EquallySpacedPaddedHBox ¶

type EquallySpacedPaddedHBox struct{}

EquallySpacedPaddedHBox is a fyne compatible layout. It defines horizontal box without padding, where all object have the same width. Height is the container height

func (d *EquallySpacedPaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *EquallySpacedPaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type EquallySpacedPaddedVBox ¶

type EquallySpacedPaddedVBox struct{}

EquallySpacedPaddedVBox is a fyne compatible layout. It defines vertical box with padding, where all object have the same height. Width is the container width

func (d *EquallySpacedPaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *EquallySpacedPaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type EquallySpacedUnpaddedHBox ¶

type EquallySpacedUnpaddedHBox struct{}

EquallySpacedUnpaddedHBox is a fyne compatible layout. It defines horizontal box without padding, where all object have the same width. Height is the container height

func (d *EquallySpacedUnpaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *EquallySpacedUnpaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type EquallySpacedUnpaddedVBox ¶

type EquallySpacedUnpaddedVBox struct{}

EquallySpacedUnpaddedVBox is a fyne compatible layout. It defines vertical box without padding, where all object have the same height. Width is the container width

func (d *EquallySpacedUnpaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *EquallySpacedUnpaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingAllProportionallyPaddedHBox ¶

type ExpandingAllProportionallyPaddedHBox struct{}

ExpandingAllProportionallyPaddedHBox is a Fyne compatible layout. It defines a horizontal box with padding, height of all elements is the container height, width of each element is calculated to keep the same ratio between width and height as from their MinSize()

func (d *ExpandingAllProportionallyPaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingAllProportionallyPaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingFirstPaddedHBox ¶

type ExpandingFirstPaddedHBox struct {
}

ExpandingFirstPaddedHBox is a Fyne compatible layout. It defines a horizontal box with padding, which keeps the width of all objects except the last at their MinSize(), and expands the last element width to fill the container height. Height of all objects is the container height.

func (d *ExpandingFirstPaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingFirstPaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingFirstPaddedVBox ¶

type ExpandingFirstPaddedVBox struct {
}

ExpandingFirstPaddedVBox is a Fyne compatible layout. It defines a vertical box with padding, which keeps the height of all objects except the first at their MinSize(), and expands the first element height to fill the container height. Width of all objects is the container width.

func (d *ExpandingFirstPaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingFirstPaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingFirstUnpaddedHBox ¶

type ExpandingFirstUnpaddedHBox struct {
}

ExpandingFirstUnpaddedHBox is a Fyne compatible layout. It defines a horizontal box without padding, which keeps the width of all objects except the first at their MinSize(), and expands the first element width to fill the container height. Height of all objects is the container height.

func (d *ExpandingFirstUnpaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingFirstUnpaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingFirstUnpaddedVBox ¶

type ExpandingFirstUnpaddedVBox struct {
}

ExpandingFirstUnpaddedVBox is a Fyne compatible layout. It defines a vertical box without any padding, which keeps the height of all objects except the first at their MinSize(), and expands the first element height to fill the container height. Width of all objects is the container width.

func (d *ExpandingFirstUnpaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingFirstUnpaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingLastPaddedVBox ¶

type ExpandingLastPaddedVBox struct {
}

ExpandingLastPaddedVBox is a Fyne compatible layout. It defines a vertical box with padding, which keeps the height of all objects except the last at their MinSize(), and expands the last element height to fill the container height. Width of all objects is the container width.

func (d *ExpandingLastPaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingLastPaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingLastUnpaddedHBox ¶

type ExpandingLastUnpaddedHBox struct {
}

ExpandingLastUnpaddedHBox is a Fyne compatible layout. It defines a horizontal box without padding, which keeps the width of all objects except the last at their MinSize(), and expands the last element width to fill the container height. Height of all objects is the container height.

func (d *ExpandingLastUnpaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingLastUnpaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ExpandingLastUnpaddedVBox ¶

type ExpandingLastUnpaddedVBox struct {
}

ExpandingLastUnpaddedVBox is a Fyne compatible layout. It defines a vertical box without any padding, which keeps the height of all objects except the last at their MinSize(), and expands the last element height to fill the container height. Width of all objects is the container width.

func (d *ExpandingLastUnpaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ExpandingLastUnpaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type FlexButton ¶

type FlexButton struct {
	widget.DisableableWidget

	OnTapped func(int)

	Texter     binding.String
	Disabler   binding.Bool
	Hider      binding.Bool
	Stater     binding.Int
	ToolTipper binding.String
	// contains filtered or unexported fields
}

FlexButton is a fyne compatible widget which defines a flexible and customizable button widget. It provides a consistent look and feel across different parts of our app, and encapsulates styles and behaviors that are commonly associated with button elements.

the NewFlexButton factory function should be used to create an instance of FlexButton

The main additional functionalities over the standard widget.Button object are the following: - image and text management: it is possible to define one or more image, and dynamic text via binding.String - dynamic layout: it is possible to define if text must be visible, and how to layout image and text. - sizable: it is possible to define image size, text will be displayed or not depending on container size - encapsulates state: the object can hold an int state value, based on binding.Int object, depending on which it will display different image - can be hidden or disabled via binding.Bool objects - when binding.String tool tip is defined, it will push its text to the binding object when mouse is over. If not, the text will be displayed on a tooltip popup - it can include a side image when the button triggers a sub-menu

It is the basic object for the MainRibbon widget

func NewFlexButton(text string, images []fyne.Resource, isTextAndIconLaidHorizontal bool, compressText bool, isImagePadded bool, hasMoreIcon bool, isMoreIconBelow bool, fullHeight float32, textHeight float32, mCanvas fyne.Canvas, onTapped func(int), texter binding.String, disabler binding.Bool, hider binding.Bool, stater binding.Int, toolTipper binding.String) *FlexButton

func (t *FlexButton) CreateRenderer() fyne.WidgetRenderer

func (t *FlexButton) DataChanged()

func (t *FlexButton) MinSize() fyne.Size

func (t *FlexButton) MouseIn(*desktop.MouseEvent)

func (t *FlexButton) MouseMoved(me *desktop.MouseEvent)

func (t *FlexButton) MouseOut()

func (t *FlexButton) Refresh()

func (t *FlexButton) SetMinSize(size fyne.Size)

func (t *FlexButton) Tapped(*fyne.PointEvent)

type FormGenKeepValueOption ¶ added in v0.0.13

type FormGenKeepValueOption int

const (
	KeepStructExceptOnFirstShow FormGenKeepValueOption = iota
	KeepStruct
	KeepEntry
	ResetStruct
)

type FormGenUtility ¶

type FormGenUtility struct {
	OnSubmit func(bool)
	// contains filtered or unexported fields
}

FormGenUtility is a struct that allows you to automatically generate a form based on the fields of any given struct. It utilizes the Fyne library to create these forms, efficiently creating a user interface for data input.

This utility is beneficial for rapidly constructing forms, providing flexibility and consistent structuring to your applications.

Currently supported types are:

• string
• int, int8, int16, int32, int64
• float32 and float64
• bool
• time.Time and time.Duration
• slice of string []string
• int alias for dropdown select entry only, e.g. type weekday int

Mainly, the Fyne form inputs are configured via the struct fields' tags. Here are the tags available for customization:

• `formGenInclude`: This tag determines whether a particular struct field should be included in the form. The value should be "true" if you want to include the field from the form. Skip it otherwise. only exported fields are allowed

• `formGenDescription`: This tag provides a descriptive label to a form field. This will be shown side of the entry on the form

• `formGenLabel`: This tag provides a descriptive label to a form field. This will be shown side of the check or radio items

• `formGenMaxVal` and `formGenMinVal`: These tags determine the maximum and minimum values for numeric form fields. If out of range, it causes a validation error.

• `formGenIsRequired`: This tag determines if a field is required. If a required field is left empty, it causes a validation error.

• `formGenDefaultValue`: This tag defines a default value for a form field. For required fields ('formGenIsRequired=true'), this value will be used if entry is left empty.

• `formGenOnEntryChange`: This tag allows defining a callback function that is triggered when the value of this form field changes. The function must be exported with struct receiver (not pointer receiver!) and must have as argument a value of same type of the field and an error. For float64, as example, callback should be: func (myStruct MyStruct) OnFloatChange(float64, error) Notice that there is no check at compile about validity of callback function: errors (e.g. spelling of the function) will result in panic

• `formGenOptions`: This tag is used to define dropdown options for dropdown form fields. Options are applied only on custom struct derived from int, e.g. type MySelection int The MySelection values can be as defined with a const, e.g. const ( Selection1 MySelection = iota, Selection2, ... ) Options as should be shown in the dropdown select entry are defined as options in this tag. Each option should be separated by "|||" for example `formGenOptions` "Selection 1|||Selection 2|||Selection 3"

• `formGenRadioGroup`, 'formGenCheckGroup': This tag allows defining a group of check or radio buttons (on a single line). The tag value should be a unique string which defines the group.

Each field of the struct corresponds to a field on the form, and the types, labels, and other behaviors of the form fields are mapped from the types, names, and tags of the struct fields.

The method ShowDialog will generate a dialog.Form and show it on the passed canvas ¶

Them method GetWidget will generate a new fyne.Widget to be shown in a custom CanvasObject

func NewFormGenDialog(s interface{}, title, confirm, dismiss string, onSubmit func(bool), w fyne.Window, minSize fyne.Size) *FormGenUtility

type User struct {
    Name string `formGenInclude:"true"`
    Age int `formGenInclude:"true"`
}

user := User{Name: "John", Age: 25}

fgu := NewFormGenDialog(user, "User Form", "OK", "Cancel", func(b bool) {
    if b {
        fmt.Println("Form Submitted")
    } else {
        fmt.Println("Form Dismissed")
    }
}, window, fyne.NewSize(300, 200))

func (fgu *FormGenUtility) DisableEntry(fieldName string)

func (fgu *FormGenUtility) EnableEntry(fieldName string)

func (fgu *FormGenUtility) FocusOnFirstEntry()

fgu := NewFormGenDialog(user, "User Form", "OK", "Cancel", onSubmitFunc, window, fyne.NewSize(300, 200))

// Focus on the first entry field of the form
fgu.FocusOnFirstEntry()

func (fgu *FormGenUtility) GetDialog(keepStructValues FormGenKeepValueOption) *dialog.FormDialog

fgu := NewFormGenDialog(user, "User Form", "OK", "Cancel", onSubmitFunc, window, fyne.NewSize(300, 200))

// Save current values and get the form dialog
dialog := fgu.GetDialog(true)

func (fgu *FormGenUtility) GetWidget(keepStructValues FormGenKeepValueOption) *widget.Form

fgu := NewFormGenDialog(user, "User Form", "OK", "Cancel", onSubmitFunc, window, fyne.NewSize(300, 200))

// Retrieve the form widget with current values
widget := fgu.GetWidget(true)

func (fgu *FormGenUtility) OverrideEntry(fieldName string)

func (fgu *FormGenUtility) OverrideField(fieldName string)

func (fgu *FormGenUtility) ShowDialog(keepStructValues FormGenKeepValueOption)

fgu := NewFormGenDialog(user, "User Form", "OK", "Cancel", onSubmitFunc, window, fyne.NewSize(300, 200))

// Show dialog with current values
fgu.ShowDialog(true)

type GiveUpLastExpandingUnpaddedHBox ¶

type GiveUpLastExpandingUnpaddedHBox struct {
}

GiveUpLastExpandingUnpaddedHBox is a Fyne compatible layout. It defines a horizontal layout of maximum 2 objects, without padding, that does not show the last element if container width is not sufficient. Its MinSize() is the MinSize() of the first element. The last element, if visible, is always kept at its MinSize() width. The first element is expanded to fill the container width. Height is the container width for all elements.

func (d *GiveUpLastExpandingUnpaddedHBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *GiveUpLastExpandingUnpaddedHBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type GiveUpLastExpandingUnpaddedVBox ¶

type GiveUpLastExpandingUnpaddedVBox struct {
}

GiveUpLastExpandingUnpaddedVBox is a Fyne compatible layout. It defines a vertical layout of maximum 2 objects, without padding, that does not show the last element if container height is not sufficient. Its MinSize() is the MinSize() of the first element. The last element, if visible, is always kept at its MinSize() height. The first element is expanded to fill the container height. Width is the container width for all elements.

func (d *GiveUpLastExpandingUnpaddedVBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *GiveUpLastExpandingUnpaddedVBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ListableSearchable ¶

type ListableSearchable interface {
	ListLen() int
	CreateListItem() fyne.CanvasObject
	UpdateListItem(int, fyne.CanvasObject)

	GetSelected() int
	OnSelectedItem(int)

	GetListableSearchableActions() *ActionItem
	GetCanvas() fyne.Canvas
	ClearSearch()
	StartSearch(string)
}

ListableSearchable defines the basic operations and behavior required for a ListableSearchableWidget.

Methods: - ListLen() int: This method returns the length of the list. - CreateListItem() fyne.CanvasObject: This method creates a list item and returns a fyne.CanvasObject. The concrete implementation of this object can vary. Note that this constructor does not need actual data to be displayed, but only the constructors fof the CanvasObjects which will hold the data - UpdateListItem(int, fyne.CanvasObject): This method updates a list item at a given index position with a fyne.CanvasObject. This will introduce actual data into the list - GetSelected() int: This method returns the index position of the currently selected item in the list. - OnSelectedItem(int): This method defines what to do when an item in the list is selected. The specific action is determined by the integer parameter, which represents the index of the item. - GetListableSearchableActions() *ActionItem: This method returns the actions related to ListableSearchable widget. If the returned *ActionItem is not nil, the widget will display a customized menu - GetCanvas() fyne.Canvas: This method must return the canvas object where the ListableSearchableWidget will be displayed. - ClearSearch(): Clears the current search results. - StartSearch(string): This method starts a search operation on the list using the input string as the query.

type ListableSearchableWidget ¶

type ListableSearchableWidget struct {
	widget.BaseWidget
	// contains filtered or unexported fields
}

The ListableSearchableWidget struct is a Fyne compatible widget. The widget can display a list of items with a search bar with a default Search and Clear button. The search bar can also include a customized menu.

it is possible to associate to a ListableSearchableWidget any object which implements ListableSearchable interface

Constructor: - NewListableSearchableWidget: Returns a new instance of the ListableSearchableWidget struct.

func NewListableSearchableWidget(iList ListableSearchable) *ListableSearchableWidget

func (t *ListableSearchableWidget) CreateRenderer() fyne.WidgetRenderer

func (t *ListableSearchableWidget) DataChanged()

func (t *ListableSearchableWidget) ResetListableSearchableAndRefresh(mList ListableSearchable)

type MainRibbon ¶

type MainRibbon struct {
	widget.BaseWidget
	// contains filtered or unexported fields
}

The MainRibbon struct is a fyne.Widget. Its main purpose is to provide a user interface element that organizes other widgets into a ribbon-like structure.

It should be added to a container.AppTabs widget. The BuildTabItemRibbon function is a factory function for creating new container.TabItem to be added to the container.AppTabs in Fyne.

It is based on ActionItem, which dictates the ribbon layout. Items can be laid out horizontally or vertically, or in context menus, depending on ActionItem depth and length

func BuildTabItemRibbon(act Actionable, maxSize, blockSize float32, toolTipper binding.String) (*container.TabItem, *MainRibbon)

func (mr *MainRibbon) AddItems(items ...*ActionItem)

func (mr *MainRibbon) CreateRenderer() fyne.WidgetRenderer

func (mr *MainRibbon) DataChanged()

func (mr *MainRibbon) MinSize() fyne.Size

type MaxMinBox ¶

type MaxMinBox struct{}

MaxMinBox is a fyne compatible layout. It must have 2 fyne.CanvasObjects and will lay them out filling the container size for the first one, and centered at its MinSize() the second one

func (d *MaxMinBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *MaxMinBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type MiniWidget ¶

type MiniWidget struct {
	widget.DisableableWidget
	// contains filtered or unexported fields
}

MiniWidget is a Fyne compatible widget. It represents a miniaturized widget structure in the GUI which can be adapted to multiple usages, such as menu ribbons, sidebars, etc. It's ideal for use-cases like notifications, small data charts, or compact control elements. It can be configured with a header or footer area, with close, minimize, move up and move down buttons An instance of a MiniWidget can be created with the factory NewMiniWidget

func NewMiniWidget(header string, headerOnTop bool, headerSize float32,
	content fyne.CanvasObject, shadowed bool,
	showMinimize bool, onMinimize func(bool), showClose bool, onClose func(), showMove bool, onMoveUp func(miniWidget *MiniWidget), onMoveDown func(miniWidget *MiniWidget), showMore bool, onMore func(fyne.CanvasObject),
	texter binding.String, disabler binding.Bool, closer binding.Bool, minimizer binding.Int, mCanvas fyne.Canvas) *MiniWidget

header: a string that sets the header of the MiniWidget.
headerOnTop: a bool that determines if the header should be on top or bottom of the MiniWidget.
headerSize: a float32 that sets the size of the header.
content: a fyne.CanvasObject which represents the content of the MiniWidget.
shadowed: a bool to enable or disable shadow for the MiniWidget.
showMinimize: a bool to show or hide minimize functionality for the MiniWidget.
onMinimize: a callback function that gets executed when the MiniWidget is minimized.
showClose: a bool to show or hide close functionality for the MiniWidget.
onClose: a callback function that gets executed when the MiniWidget is closed.
showMove: a bool to enable or disable movement functionality for the MiniWidget.
onMoveUp: a callback function that gets executed when the MiniWidget is moved upwards.
onMoveDown: a callback function that gets executed when the MiniWidget is moved downwards.
showMore: a bool to enable or disable more functionality for the MiniWidget.
onMore: a callback function that gets executed when the more button on the MiniWidget is clicked.
texter: a binding.String instance to bind header text to the MiniWidget.
disabler: a binding.Bool instance to disable the MiniWidget.
closer: a binding.Bool instance to bind custom close function to the MiniWidget.
minimizer: a binding.Int instance to bind custom minimize function to the MiniWidget.
mCanvas: a fyne.Canvas instance where the MiniWidget will be drawn.

func (t *MiniWidget) CreateRenderer() fyne.WidgetRenderer

func (t *MiniWidget) DataChanged()

func (t *MiniWidget) MinSize() fyne.Size

func (t *MiniWidget) Minimize(state int)

func (t *MiniWidget) Refresh()

type PaddedBox ¶

type PaddedBox struct{}

PaddedBox is a fyne compatible layout. It must have 2 fyne.CanvasObjects and will lay them out filling the container size for the first one, and centered with a theme.Padding() border the second one

func (d *PaddedBox) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *PaddedBox) MinSize(objects []fyne.CanvasObject) fyne.Size

type ShadowedLayout ¶

type ShadowedLayout struct{}

ShadowedLayout is a Fyne compatible layout. It defines a tiled layout of maximum 2 objects, where the first element is in the top-left corner and the second in the bottom-right. Its MinSize() is the MinSize() of the first element + one theme.Padding() for both width and height. It is the typical layout of a shadowed content where the first element is the content and the second a rectangle for the shadow.

func (d *ShadowedLayout) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *ShadowedLayout) MinSize(objects []fyne.CanvasObject) fyne.Size

type ShadowedWidget ¶

type ShadowedWidget struct {
	widget.BaseWidget
	// contains filtered or unexported fields
}

ShadowedWidget is a Fyne compatible fine.Widget. It just shows a user defined content, adding a backround rectangle as shadow. It uses ShadowedLayout layout

func NewShadowedWidget(obj fyne.CanvasObject) *ShadowedWidget

func (t *ShadowedWidget) CreateRenderer() fyne.WidgetRenderer

func (t *ShadowedWidget) MinSize() fyne.Size

func (t *ShadowedWidget) Refresh()

type SideBar ¶

type SideBar struct {
	widget.BaseWidget
	// contains filtered or unexported fields
}

SideBar is a Fyne compatible widget which acts as a container for MiniWidget components. It can manage basic functionalities such as adding content to the sidebar and moving child objects up and down

func NewSideBar(widgets ...*MiniWidget) *SideBar

func (sb *SideBar) AddWidget(widgets ...*MiniWidget)

func (sb *SideBar) CreateRenderer() fyne.WidgetRenderer

func (sb *SideBar) DataChanged()

func (sb *SideBar) MinSize() fyne.Size

func (sb *SideBar) Refresh()

type SizableLabel ¶

type SizableLabel struct {
	widget.BaseWidget
	// contains filtered or unexported fields
}

SizableLabel is a Fyne compatible widget. It is to all extents a simple label. The only difference with the built-in widget.Label is that the SizableLabel is configured by the CanvasObject size instead of the font size. This comes useful when you need to ensure certain proportions between your GUI components although readability of your text is at your risk.

func NewSizableLabel(text string, verticalSize float32, padded bool, alignCenter bool, textColor color.Color, backgroundColor color.Color) *SizableLabel

func (t *SizableLabel) CreateRenderer() fyne.WidgetRenderer

func (t *SizableLabel) GetFontSize() float32

func (t *SizableLabel) MinSize() fyne.Size

func (t *SizableLabel) Refresh()

func (t *SizableLabel) SetTextSize(size float32)

type StackFixedRatioPadded ¶

type StackFixedRatioPadded struct{}

StackFixedRatioPadded is a Fyne compatible layout. It defines a stack-like layout where elements are tiled one on top of the other filling the container size, but with the difference that it keeps the ratio between width and height as from each object MinSize() constant. It also adds an empty border around each object of 1 theme.Padding() size

func (d *StackFixedRatioPadded) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *StackFixedRatioPadded) MinSize(objects []fyne.CanvasObject) fyne.Size

type StackFixedRatioUnpadded ¶

type StackFixedRatioUnpadded struct{}

StackFixedRatioUnpadded is a Fyne compatible layout. It defines a stack-like layout where elements are tiled one on top of the other filling the container size, but with the difference that it keeps the ratio between width and height as from each object MinSize() constant.

func (d *StackFixedRatioUnpadded) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *StackFixedRatioUnpadded) MinSize(objects []fyne.CanvasObject) fyne.Size

type StackPadded ¶

type StackPadded struct{}

StackPadded is a Fyne compatible layout. It behaves like container.NewStack() but adds an empty border around each object of 1 theme.Padding() size

func (d *StackPadded) Layout(objects []fyne.CanvasObject, containerSize fyne.Size)

func (d *StackPadded) MinSize(objects []fyne.CanvasObject) fyne.Size