text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>//go:build ios
package application
func init() {
// On iOS, we don't call runtime.LockOSThread()
// The iO<|fim_suffix|>l handling
}
<|fim_middle|>S runtime handles thread management differently
// and calling LockOSThread can interfere with signa<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|> inlineEventShimJS + "\n</script>\n"
// If the body starts with <!doctype …>, keep the doctype on line 1 and
// drop the script immediately after; otherwise just prepend.
lower := strings.ToLower(html)
if idx := strings.Index(lower, "<!doctype"); idx >= 0 {
closing := strings.Index(html[idx:], ">")
... | fim | wailsapp/wails | go |
// Inline Wails events shim for InitialHTML windows.
//
// Pages loaded via WebviewWindowOptions.HTML are served with
// `window.location.origin === "null"`, so the modern HTTP runtime at
// /wails/runtime.js can never be imported (fetch fails). This shim
// installs the minimum subset of the runtime that postMessage-b... | fim | wailsapp/wails | javascript |
<|fim_suffix|>im(once, true)
if strings.Count(twice, "data-wails-inline-event-shim") != 1 {
t.Errorf("re-running the helper must not inject a second copy; got %d markers",
strings.Count(twice, "data-wails-inline-event-shim"))
}
}
<|fim_prefix|>package application
import (
"strings"
"testing"
)
func TestInjec... | fim | wailsapp/wails | go |
<|fim_suffix|>q.Add(1)
if s.ShutdownErr {
return &Error{Id: s.Id()}
} else {
return nil
}
}
type StartupShutdowner struct {
Config
startup int64
shutdown int64
ctx context.Context
}
func (s *StartupShutdowner) Configure(c Config) {
s.Config = c
}
func (s *StartupShutdowner) Id() int {
return s.Co... | fim | wailsapp/wails | go |
<|fim_prefix|>package shutdown
import (
"sync"
"sync/atomic"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
apptest "github.com/wailsapp/wails/v3/pkg/application/internal/tests"
<|fim_suffix|>
Service2 struct{ svctest.Shutdowner }
Service3 struct{ svctest.Shutdowner }
Service4 struct{ svctest.Shutd... | fim | wailsapp/wails | go |
<|fim_suffix|>or service #%d", mock.Id)
}
},
})
var wg sync.WaitGroup
wg.Add(2)
go func() {
app.RegisterService(services[3])
wg.Done()
}()
go func() {
app.RegisterService(services[4])
wg.Done()
}()
wg.Wait()
app.RegisterService(services[5])
app.Event.OnApplicationEvent(events.Common.Applicatio... | fim | wailsapp/wails | go |
<|fim_prefix|>package startup
import (
"sync"
"sync/atomic"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
apptest "github.com/wailsapp/wails/v3/pkg/application/internal/tests"
svctest "github.com/wailsapp/wails/v3/pkg/application/internal/tests/services"
"github.com/wailsapp/wails/v3/pkg/events"
)
... | fim | wailsapp/wails | go |
<|fim_prefix|>package startuperror
import (
"errors"
"sync"
"sync/atomic"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
apptest "github.com/wailsapp/wails/v3/pkg/application/internal/tests"
svctest "github.com/wailsapp/wails/v3/pkg/application/internal/tests/services"
"github.com/wailsapp/wails/v3/... | fim | wailsapp/wails | go |
<|fim_prefix|>package startupshutdown
import (
"sync"
"sync/atomic"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
apptest "github.com/wailsapp/wails/v3/pkg/application/internal/tests"
svctest "github.com/wailsapp/wails/v3/pkg/application/internal/tests/services"
"github.com/wailsapp/wails/v3/pkg/eve... | fim | wailsapp/wails | go |
<|fim_prefix|>package startupshutdownerror
import (
"errors"
"slices"
"sync"
"sync/atomic"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
apptest "github.com/wailsapp/wails/v3/pkg/application/internal/tests"
svctest "github.com/wailsapp/wails/v3/pkg/application/internal/tests/services"
"github.com/... | fim | wailsapp/wails | go |
<|fim_suffix|>
case fatal := <-endChan:
if fatal != nil {
t.Fatal(fatal)
}
return fatal
}
}
func Main(m *testing.M) {
go func() {
os.Exit(m.Run())
}()
errChan <- (<-appChan).Run()
select {} // Block forever
}
<|fim_prefix|>package tests
import (
"errors"
"os"
"runtime"
"testing"
"github.com/wa... | fim | wailsapp/wails | go |
<|fim_suffix|>ompile these call sites away via the constant.
const iosVerboseLogging = true
<|fim_prefix|>//go:build ios && !production
package application
// iosVerboseLogging en<|fim_middle|>ables the framework's internal iOS diagnostics
// (request tracing, bridge messages, lifecycle markers). Debug builds only;
/... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios && produ<|fim_suffix|>iosVerboseLogging = false
<|fim_middle|>ction
package application
const <|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>IOSSetCustomUserAgent(ua string) { iosSetCustomUserAgent(ua) }
<|fim_prefix|>//go:build ios
package application
// Exported API for use by applications to mutate iOS WKWebView at runtime.
// These call into the internal platform-specific implementations.
func IOSSetScrollEnabled(enabled b... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
/*
#cgo CFLAGS: -x objective-c -fmodules -fobjc-arc
#cgo LDFLAGS: -framework UIKit
#include <stdlib.h>
#include "application_ios.h"
*/
import "C"
import (
"unsafe"
"encoding/json"
)
// iosHapticsImpact triggers an iOS haptic impact using the provided style.
// The ... | fim | wailsapp/wails | go |
//go:build !ios
package application
func iosHapticsImpact(style string) {
// no-op on non-iOS
}
type deviceInfo struct {
Model string `json:"model"`
SystemName string `json:"systemName"`
SystemVersion string `json:"systemVersion"`
IsSimulator bool `json:"isSimulator"`
}
func iosDeviceInfo() devi... | fim | wailsapp/wails | go |
//go:build bench
// Disabled: goccy/go-json causes Windows panics. See PR #4859.
package application_test
/*
import (
"encoding/json"
"testing"
"github.com/bytedance/sonic"
gojson "github.com/goccy/go-json"
jsoniter "github.com/json-iterator/go"
)
// Test structures matching real Wails binding patterns
type ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build bench && goexperiment.jsonv2
package application_test
import (
"encoding/json"
"encoding/json/jsontext"
jsonv2 "encoding/json/v2"
"testing"
)
// Benchmark structures matching real Wails usage patterns
type SimpleArg struct {
Name string `json:"name"`
Value int `json:"value"`
}
ty... | fim | wailsapp/wails | go |
<|fim_suffix|>pp.keyBindingsLock.Lock()
defer kbm.app.keyBindingsLock.Unlock()
delete(kbm.app.keyBindings, accelerator)
}
// Process processes a key binding and returns true if handled
func (kbm *KeyBindingManager) Process(accelerator string, window Window) bool {
kbm.app.keyBindingsLock.RLock()
callback, exists :... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"fmt"
"runtime"
"slices"
"strconv"
"strings"
)
// modifier is actually a string
type modifier int
const (
// CmdOrCtrlKey represents Command on Mac and Control on other platforms
CmdOrCtrlKey modifier = 0 << iota
// OptionOrAltKey represents Option on Mac and Alt on... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
pa<|fim_suffix|>ator) string {
return ""
}
<|fim_middle|>ckage application
// Android keyboard handling stub
func acceleratorToString(accelerator *acceler<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
const (
NSEventModifierFlagShift = 1 << 17 // Set if Shift key is pressed.
NSEventModifierFlagControl = 1 << 18 // Set if Control key is pressed.
NSEventModifierFlagOption = 1 << 19 // Set if Option or Alternate key is pressed.
NSEventModif... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
// iOS key c<|fim_suffix|>"
KeyEscape = "Escape"
KeyDelete = "Delete"
KeyTab = "Tab"
KeySpace = "Space"
KeyUp = "Up"
KeyDown = "Down"
KeyLeft = "Left"
KeyRight = "Right"
KeyHome = "Home"
KeyEnd = "End"
KeyPageUp = "Pag... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !android && !server
package application
var VirtualKeyCodes = map[uint]string{
0xff08: "backspace",
0xff09: "tab",
0xff0a: "linefeed"<|fim_suffix|>",
0x48: "h",
0x49: "i",
0x4a: "j",
0x4b: "k",
0x4c: "l",
0x4d: "m",
0x4e: "n",
0x4f: "o",
0x50: "p",
0x51: "q",
0x52: "r",... | fim | wailsapp/wails | go |
<|fim_suffix|>difierMap_Contains(t *testing.T) {
expectedMappings := map[string]modifier{
"cmdorctrl": CmdOrCtrlKey,
"cmd": CmdOrCtrlKey,
"command": CmdOrCtrlKey,
"ctrl": ControlKey,
"optionoralt": OptionOrAltKey,
"alt": OptionOrAltKey,
"option": OptionOrAltKey,
"shift... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package application
var VirtualKeyCodes = map[uint]string{
0x01: "lbutton",
0x02: "rbutton",
0x03: "cancel",
0x04: "mbutton",
0x05: "xbutton1",
0x06: "xbutton2",
0x08: "back",
0x09: "tab",
0x0C: "clear",
0x0D: "return",
0x10: "shift",
0x11: "ctrl",
0x12: "menu",
0x13: "p... | fim | wailsapp/wails | go |
<|fim_suffix|>ount,
int default_button, int cancel_button, int destructive_button,
guint request_id) {
GtkWidget *dialog = gtk_window_new();
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_win... | fim | wailsapp/wails | c |
<|fim_suffix|>ess=%v;", frameless))
}
func (w *linuxWebviewWindow) setTransparent() {
// GTK4: Transparency via CSS - different from GTK3
}
func (w *linuxWebviewWindow) setBackgroundColour(colour RGBA) {
rgba := C.GdkRGBA{C.float(colour.Red) / 255.0, C.float(colour.Green) / 255.0, C.float(colour.Blue) / 255.0, C.fl... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !android && !gtk3 && !server
#ifndef LINUX_CGO_H
#define LINUX_CGO_H
#include <gtk/gtk.h>
#include <webkit/webkit.h>
#include <jsc/jsc.h>
#include <stdio.h>
#include <limits.h>
#include <stdint.h>
#include <errno.h>
#include <signal.h>
#include <string.h>
// Application flags for GT... | fim | wailsapp/wails | c |
<|fim_suffix|>GtkApplication)(application)))
C.g_object_ref_sink(C.gpointer(window))
webview = windowNewWebview(windowId, gpuPolicy)
vbox = pointer(C.gtk_box_new(C.GTK_ORIENTATION_VERTICAL, 0))
name := C.CString("webview-box")
defer C.free(unsafe.Pointer(name))
C.gtk_widget_set_name((*C.GtkWidget)(vbox), name)
... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && purego
package application
import (
"fmt"
"os"
"unsafe"
"github.com/ebitengine/purego"
"github.com/wailsapp/wails/v3/internal/assetserver/webview"
"github.com/wailsapp/wails/v3/pkg/events"
)
type windowPointer uintptr
type identifier uint
type pointer uintptr
// type GSList ... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"os"
"strings"
"testing"
)
func TestLinuxPuregoOpenFileDialogUsesComputedAction(t *testing.T) {
data, err := os.ReadFile("linux_purego.go")
if err != nil {
t.Sk<|fim_suffix|>ialog && strings.Contains(trimmed, "GtkFileChooserActionOpen") && strings.Contains(trimmed, "r... | fim | wailsapp/wails | go |
<|fim_suffix|>t := string(data)
if !strings.Contains(content, `"key-press-event"`) {
t.Error("windowSetupSignalHandlers must connect \"key-press-event\" on the webview in the purego build path")
}
if !strings.Contains(content, "gSignalConnectData") || !strings.Contains(content, "keyPressCallback") {
t.Error("wi... | fim | wailsapp/wails | go |
//go:build android
package application
import (
"bytes"
"context"
"log/slog"
"time"
"encoding/json"
)
// androidConsoleHandler implements slog.Handler and forwards records to logcat
// via androidLogf. Go's stdout/stderr are not routed anywhere on Android, so
// this is how app.Logger output becomes visible in... | fim | wailsapp/wails | go |
<|fim_suffix|>Logger(level slog.Leveler) *slog.Logger {
return slog.New(tint.NewHandler(os.Stderr, &tint.Options{
TimeFormat: time.Kitchen,
NoColor: !isatty.IsTerminal(os.Stderr.Fd()),
Level: level,
}))
}
<|fim_prefix|>//go:build !windows && !production && !ios && !android
package application
import (... | fim | wailsapp/wails | go |
<|fim_suffix|>}
<|fim_prefix|>/<|fim_middle|>/go:build windows && !production
package application
import (
"log/slog"
"os"
"time"
"github.com/wailsapp/wails/v3/internal/tint"
"github.com/mattn/go-colorable"
"github.com/mattn/go-isatty"
)
func DefaultLogger(level slog.Leveler) *slog.Logger {
return slog.New(t... | fim | wailsapp/wails | go |
<|fim_suffix|> return true
}
return lvl >= h.level.Level()
}
func (h *iosConsoleHandler) Handle(_ context.Context, r slog.Record) error {
// Build a compact log line
var b bytes.Buffer
b.WriteString(r.Time.Format(time.Kitchen))
b.WriteString(" ")
if h.group != "" {
b.WriteString("[")
b.WriteString(h.group)
... | fim | wailsapp/wails | go |
<|fim_suffix|>rt (
"io"
"log/slog"
)
func DefaultLogger(level slog.Leveler) *slog.Logger {
return slog.New(slog.NewTextHandler(io.Discard, nil))
}
<|fim_prefix|>//go:build production && !ios && !android
package applicatio<|fim_middle|>n
impo<|endoftext|> | fim | wailsapp/wails | go |
package application
import (
"sync"
)
var mainThreadFunctionStore = make(map[uint]func())
var mainThreadFunctionStoreLock sync.RWMutex
func generateFunctionStoreID() uint {
startID := 0
for {
if _, ok := mainThreadFunctionStore[uint(startID)]; !ok {
return uint(startID)
}
startID++
if startID == 0 {
... | fim | wailsapp/wails | go |
<|fim_suffix|>tionStoreLock.Unlock()
Fatal("dispatchOnMainThread called with invalid id: %v", callbackID)
return
}
delete(mainThreadFunctionStore, callbackID)
mainThreadFunctionStoreLock.Unlock()
fn()
}
<|fim_prefix|>//go:build android
package application
// Main-thread dispatch is routed through the WailsBri... | fim | wailsapp/wails | go |
<|fim_suffix|>adFunctionStoreLock.Unlock()
Fatal("dispatchCallback called with invalid id: %v", id)
return
}
delete(mainThreadFunctionStore, id)
mainThreadFunctionStoreLock.Unlock()
fn()
}
<|fim_prefix|>//go:build darwin && !ios && !server
package application
/*
#cgo CFLAGS: -mmacosx-version-min=10.13 -x obje... | fim | wailsapp/wails | go |
<|fim_suffix|>onStore, id)
mainThreadFunctionStoreLock.Unlock()
fn()
}
<|fim_prefix|>//go:build ios
<|fim_middle|>package application
/*
#cgo CFLAGS: -x objective-c
#cgo LDFLAGS: -framework Foundation -framework UIKit
#import <Foundation/Foundation.h>
#import <dispatch/dispatch.h>
extern void dispatchOnMainThreadC... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !android && !server
package application
func (a *linuxApp) dispatchOnMainThread(id uint) {
dispatchOnMainThread(id)
}
func executeOnMainThread(callbackID uint) {
mainThreadFunctionStoreLock.Lock()
fn := mainThreadFunctionStore[callbackID]
if fn == nil {
<|fim_suffix|> delete(ma... | fim | wailsapp/wails | go |
<|fim_suffix|> MainOSThread")
}
mainThreadFunctionStoreLock.Lock()
fnIDs := make([]uint, 0, len(mainThreadFunctionStore))
for id := range mainThreadFunctionStore {
fnIDs = append(fnIDs, id)
}
sort.Slice(fnIDs, func(i, j int) bool { return fnIDs[i] < fnIDs[j] })
fns := make([]func(), len(fnIDs))
for i, id :=... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
type menuImpl interface {
update()
}
type ContextMenu struct {
*Menu
name string
}
func NewContextMenu(name string) *ContextMenu {
result := &ContextMenu{
Menu: NewMenu(),
name: name,
}
result.Update()
return result
}
func (m *ContextMenu) Update() {
m.Menu.Update()
if... | fim | wailsapp/wails | go |
<|fim_suffix|>ation menu on Android
return nil
}
<|fim_prefix|>//go:build android
package<|fim_middle|> application
// Android menu stubs - Android doesn't have traditional application menus
func (m *Menu) handleStyleChange() {}
type androidMenu struct {
menu *Menu
}
func newMenuImpl(menu *Menu) *androidMenu {
... | fim | wailsapp/wails | go |
<|fim_suffix|>el))
} else {
C.clearMenu(m.nsMenu)
}
m.processMenu(m.nsMenu, m.menu)
})
}
func (m *macosMenu) processMenu(parent unsafe.Pointer, menu *Menu) {
for _, item := range menu.items {
switch item.itemType {
case submenu:
submenu := item.submenu
nsSubmenu := C.createNSMenu(C.CString(item.la... | fim | wailsapp/wails | go |
<|fim_suffix|>u1.Append(menu2)
if len(menu1.items) != 3 {
t.Errorf("items count = %d, want 3", len(menu1.items))
}
// Clean up
menu1.Destroy()
}
func TestMenu_Append_Nil(t *testing.T) {
menu := NewMenu()
menu.Add("Item")
menu.Append(nil)
if len(menu.items) != 1 {
t.Error("Append(nil) should not change me... | fim | wailsapp/wails | go |
<|fim_suffix|>e traditional menus
}<|fim_prefix|>//go:build ios
package application
// iOS menu stubs - iOS doesn't have traditional menus
// iOS doesn't have traditional menus like desktop platforms
// These are placeholder implement<|fim_middle|>ations
func (m *Menu) handleStyleChange() {}
type iosMenu struct {
... | fim | wailsapp/wails | go |
<|fim_suffix|>, item)
}
func (m *linuxMenu) addServicesMenu(menu *Menu) {
}
func (l *linuxMenu) createMenu(name string, items []*MenuItem) *Menu {
impl := newMenuImpl(&Menu{label: name})
menu := &Menu{
label: name,
items: items,
impl: impl,
}
impl.menu = menu
return menu
}
func DefaultApplicationMenu() *... | fim | wailsapp/wails | go |
<|fim_suffix|>
return menu
}
func DefaultApplicationMenu() *Menu {
menu := NewMenu()
menu.AddRole(AppMenu)
menu.AddRole(FileMenu)
menu.AddRole(EditMenu)
menu.AddRole(ViewMenu)
menu.AddRole(WindowMenu)
menu.AddRole(HelpMenu)
return menu
}
<|fim_prefix|>//go:build linux && !android && gtk3 && !server
package a... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
// MenuManager manages menu-related operations
type MenuManager struct {
app *App
}
// newMenuManager creates a new MenuManager instance
func newMenuManager(app *App) *MenuManager {
return &MenuManager{
app<|fim_suffix|>nu
func (mm *MenuManager) GetApplicationMenu() *Menu {
retu... | fim | wailsapp/wails | go |
<|fim_prefix|>pac<|fim_suffix|>enuFromItems(
application.NewMenuItem("Item 1"),
application.NewMenuItem("Item 2"),
),
index: -1,
shouldError: true,
},
{
name: "Index out of bounds (too large)",
menu: application.NewMenuFromItems(
application.NewMenuItem("Item 1"),
application.Ne... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows && !server
package application
import (
"fmt"
"syscall"
"github.com/wailsapp/wails/v3/pkg/w32"
)
type windowsMenu struct {
menu *Menu
parentWindow *windowsWebviewWindow
hWnd <|fim_suffix|>); !ok {
return fmt.Errorf("AppendMenu failed for %q: %v", thisText, s... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"sync"
"sync/atomic"
)
type menuItemType int
const (
text menuItemType = iota
separator
checkbox
radio
submenu
)
var menuItemID uintptr
var menuItemMap = make(map[uint]*MenuItem)
var menuItemMapLock sync.Mutex
func addToMenuItemMap(menuItem *MenuItem) {
menuItemMa... | fim | wailsapp/wails | go |
<|fim_suffix|>ndleEnabledChange() {}
func (m *MenuItem) handleTooltipChange() {}
func (m *MenuItem) handleSubmenuChange() {}
func (m *MenuItem) nativeMenuItem() unsafe.Pointer {
return nil
}
<|fim_prefix|>//go:build android
packa<|fim_middle|>ge application
import "unsafe"
// Android doesn't have traditional men... | fim | wailsapp/wails | go |
<|fim_suffix|> the next runloop turn, which can
// land *after* the menu has already been rendered if the user reopens the menu
// quickly (see wailsapp/wails#5002). dispatch_sync from the main thread would
// deadlock, so short-circuit when we are already on the main thread.
void setMenuItemChecked(void* nsMenuItem, b... | fim | wailsapp/wails | go |
<|fim_suffix|>@end
#endif /* MenuItemDelegate_h */
<|fim_prefix|>#ifndef MenuItemDelegate_h
#define MenuItemDelegate_h
#import <Cocoa/Cocoa.h>
extern void processMenuItemClick(unsigned int);
@interface<|fim_middle|> MenuItem : NSMenuItem
@property unsigned int menuItemID;
- (void) handleClick;
<|endoftext|> | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build !production || devtools
package application
func NewOpenDevToolsMenuItem() *MenuItem {
return NewMenuItem("Open Developer Tools").
Se<|fim_suffix|>{
currentWindow.OpenDevTools()
}
})
}
<|fim_middle|>tAccelerator("Alt+Command+I").
OnClick(func(ctx *Context) {
currentWindow := ... | fim | wailsapp/wails | go |
<|fim_suffix|>itemType should be submenu")
}
if item.submenu == nil {
t.Error("submenu should not be nil")
}
if item.submenu.label != "Submenu" {
t.Errorf("submenu.label = %q, want %q", item.submenu.label, "Submenu")
}
// Clean up
removeMenuItemByID(item.id)
}
func TestMenuItemMap_AddGetRemove(t *testing.T... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
import "unsafe"
// iOS doesn't have traditional menu items like desktop platforms
// These are placeholder implementations
func (m *MenuItem) handleStyleChange() {}
func (m *MenuItem) handleLabelChange() {}
<|fim_suffix|>return nil
}<|fim_middle|>
func (m *MenuItem)... | fim | wailsapp/wails | go |
//go:build linux && !android && !gtk3 && !server
package application
import (
"fmt"
"runtime"
)
type linuxMenuItem struct {
menuItem *MenuItem
native pointer
handlerId uint
parentMenu pointer
menuIndex int
isHidden bool
}
func (l linuxMenuItem) setTooltip(tooltip string) {
InvokeSync(func() {
m... | fim | wailsapp/wails | go |
<|fim_suffix|>
func newAboutMenuItem() *MenuItem {
return NewMenuItem("About " + globalApplication.options.Name).
OnClick(func(ctx *Context) {
globalApplication.Menu.ShowAbout()
})
}
func newCloseMenuItem() *MenuItem {
return NewMenuItem("Close").
SetAccelerator("CmdOrCtrl+w").
OnClick(func(ctx *Context)... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build producti<|fim_suffix|>ools
package application
func NewOpenDevToolsMenuItem() *MenuItem {
return nil
}
<|fim_middle|>on && !devt<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>.
OnClick(func(ctx *Context) {
currentWindow := globalApplication.Window.Current()
if currentWindow != nil {
currentWindow.Minimise()
}
})
}
func NewZoomMenuItem() *MenuItem {
return NewMenuItem("Zoom").
OnClick(func(ctx *Context) {
currentWindow := globalApplication.Window.Current... | fim | wailsapp/wails | go |
// File: v3/pkg/application/menuitem_selectors_darwin.go
//go:build darwin && !server
package application
import "C"
var roleToSelector = map[Role]string{
//AppMenu: "", // This is a special case, handled separately
About: "orderFrontStandardAboutPanel:",
//ServicesMenu: "", // This is a subme... | fim | wailsapp/wails | go |
<|fim_suffix|>{
t.Errorf("Expected accelerator to be %v, but got %v", test.expectedAcc, acc)
}
})
}
}
func TestMenuItem_RemoveAccelerator(t *testing.T) {
tests := []struct {
name string
menuItem *application.MenuItem
}{
{
name: "Remove existing accelerator",
menuItem: application.NewMen... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package application
import (
"unsafe"
"github.com/wailsapp/wails/v3/pkg/w32"
)
type windowsMenuItem struct {
parent *Menu
menuItem *MenuItem
hMenu w32.HMENU
id int
label string
disabled bool
checked bool
itemType menuItemType
hidden bool
submenu w32.HM... | fim | wailsapp/wails | go |
<|fim_suffix|>wMethod(req, targetWindow)
case clipboardRequest:
return m.processClipboardMethod(req)
case dialogRequest:
return m.processDialogMethod(req, targetWindow)
case eventsRequest:
return m.processEventsMethod(req, targetWindow)
case applicationRequest:
return m.processApplicationMethod(req)
case c... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package application
import (
"encoding/json"
"github.com/wailsapp/wails/v3/pkg/errs"
)
const (
AndroidHapticsVibrate = 0
AndroidDeviceInfo = 1
AndroidToast = 2
)
var androidMethodNames = map[int]string{
AndroidHapticsVibrate: "Haptics.Vibrate",
AndroidDeviceInfo... | fim | wailsapp/wails | go |
<|fim_suffix|>urn unit, nil
case ApplicationHide:
globalApplication.Hide()
return unit, nil
case ApplicationShow:
globalApplication.Show()
return unit, nil
default:
return nil, errs.NewInvalidApplicationCallErrorf("unknown method %d", req.Method)
}
}
<|fim_prefix|>package application
import (
"github.co... | fim | wailsapp/wails | go |
<|fim_suffix|> {
case T:
result = v
case float64:
result = T(v)
default:
return nil
}
return &result
}
func (a *MapArgs) UInt8(s string) *uint8 {
if a == nil {
return nil
}
if val := a.data[s]; val != nil {
return convertNumber[uint8](val)
}
return nil
}
func (a *MapArgs) UInt(s string) *uint {
i... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"github.com/wailsapp/wails/v3/internal/browser"
"github.com/wailsapp/wails/v3/pkg/errs"
)
const (
BrowserOpenURL = 0
)
var browserMethodNames = map[int]string{
BrowserOpenUR<|fim_suffix|>rCallErrorf("missing argument 'url'")
}
sanitizedURL, err := ValidateAndSaniti... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"context"
"errors"
"encoding/json"
"github.com/wailsapp/wails/v3/pkg/errs"
)
type contextKey string
const (
CallBinding = 0
WindowKey contextKey = "Window"
)
func (m *MessageProcessor) processCallCancelMethod(req *RuntimeRequest) (any, error) {
callID... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"github.com/wailsapp/wails/v3/pkg/errs"
)
const (
ClipboardSetText = 0
ClipboardText = 1
)
var clipboardMethods = map[int]string{
ClipboardSetText: "SetText",
ClipboardText: "Text",
}
func (m *MessageProcessor) processClipboardMethod(req *RuntimeRequest) (any, e... | fim | wailsapp/wails | go |
<|fim_suffix|>ContextMenuCallErrorf(err, "error parsing parameters")
}
window.OpenContextMenu(&data)
return unit, err
default:
return nil, errs.NewInvalidContextMenuCallErrorf("unknown method: %d", req.Method)
}
}
<|fim_prefix|>package application
import (
"github.com/wailsapp/wails/v3/pkg/errs"
)
type C... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"runtime"
"github.com/wailsapp/wails/v3/pkg/errs"
)
const (
DialogInfo = 0
DialogWarning = 1
DialogError = 2
DialogQuestion = 3
DialogOpenFile = 4
DialogSaveFile = 5
)
var dialogMethodNames = map[int]string{
DialogInfo: "Info",
DialogWarning: "Warnin... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"encoding/json"
"github.com/wailsapp/wails/v3/pkg/errs"
)
const (
EventsEmit = 0
)
var eventsMethodNames = map[int]string{
EventsEmit: "Emit",
}
func (m *MessageProcessor) processEventsMethod(req *RuntimeRequest, window Window) (any, error) {
switch req.Method {
cas... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
import (
"github.com/wailsapp/wails/v3/pkg<|fim_suffix|>.Method)
}
}
// processAndroidMethod is a stub on iOS
func (m *MessageProcessor) processAndroidMethod(req *RuntimeRequest, window Window) (any, error) {
return nil, errs.NewInvalidAndroidCallErrorf("Android me... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build !ios && !android
package application
import (
"github.com/wailsapp/wails/v3/pkg/errs"
)
// Empty method name maps for logging on non-mobile platforms
var iosMethodNames = map[int]string{}
var androidMethodNames = map[int]string{}
// processIOSMethod is a stub for non-mobile platforms
func ... | fim | wailsapp/wails | go |
<|fim_suffix|>reen.GetByIndex(*index)
if screen == nil {
return nil, errs.NewInvalidScreensCallErrorf("screen not found at index: %d", *index)
}
return screen, nil
default:
return nil, errs.NewInvalidScreensCallErrorf("Unknown method: %d", req.Method)
}
}
<|fim_prefix|>package application
import (
"githu... | fim | wailsapp/wails | go |
<|fim_suffix|>n globalApplication.capabilities, nil
case Flags:
flags := globalApplication.impl.GetFlags(globalApplication.options)
return flags, nil
default:
return nil, errs.NewInvalidSystemCallErrorf("unknown method: %d", req.Method)
}
}
<|fim_prefix|>package application
import (
"github.com/wailsapp/wail... | fim | wailsapp/wails | go |
<|fim_suffix|>n)
return unit, nil
default:
return nil, errs.NewInvalidWindowCallErrorf("Unknown method %d", req.Method)
}
}
// ElementDetailsPayload holds detailed information about the drop target element.
type ElementDetailsPayload struct {
ID string `json:"id"`
ClassList []string ... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"testing"
)
func TestEnforceMinSizeConstraintsBelowMinimum(t *testing.T) {
testCases := []struct {
name string
width int
height int
minWidth int
minHeight int
expectedW int
expectedH int
shouldEnforce bool
}{
{"bo... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package application
// Genuinely-mobile native capabilities for Android, mirroring the iOS surface
// in mobile_features_ios.go. Each call is forwarded to a matching me<|fim_suffix|>lsBridge via the reflective bridge helpers. Asynchronous results
// (biometric prompts, torch availabil... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
/*
#cgo CFLAGS: -x objective-c -fmodules -fobjc-arc
#cgo LDFLAGS: -framework UIKit -framework LocalAuthentication -framework UserNotifications -framework AVFoundation -framework Security -framework CoreLocation -framework CoreMotion -framework SystemConfiguration
#incl... | fim | wailsapp/wails | go |
<|fim_prefix|>#ifndef WAILS_MOBILE_FEATURES_IOS_H
#define WAILS_MOBILE_FEATURES_IOS_H
#include <stdbool.h>
// Phase A — one-way actions
void ios_share(const char* json);
void ios_open_url(const char* url);
void ios_set_keep_awake(bool enabled);
void ios_set_torch(bool enabled);
// Phase B — state / query
const char*... | fim | wailsapp/wails | c |
<|fim_prefix|>// ObjC-only helpers shared between mobile_features_ios.m and
// webview_window_ios.m. NOT included by cgo (.go) files — it exposes UI<|fim_suffix|>rfaceOrientationMask mfSupportedOrientations(void);
UIStatusBarStyle mfStatusBarStyle(void);
BOOL mfStatusBarHidden(void);
#endif
<|fim_middle|>Kit
// types ... | fim | wailsapp/wails | c |
<|fim_suffix|> // Remove frames from the end
if len(allFrames) > skipEnd {
allFrames = allFrames[:len(allFrames)-skipEnd]
}
// Build the output string
var builder strings.Builder
for _, frame := range allFrames {
fmt.Fprintf(&builder, "%s\n\tat %s:%d\n",
frame.Function, frame.File, frame.Line)
}
return b... | fim | wailsapp/wails | go |
<|fim_suffix|>if opts.MethodID != 12345 {
t.Error("MethodID not set correctly")
}
if opts.MethodName != "TestService.Method" {
t.Error("MethodName not set correctly")
}
}
<|fim_prefix|>package application
import (
"reflect"
"testing"
)
func TestParameter_IsType(t *testing.T) {
param := &Parameter{
Name: ... | fim | wailsapp/wails | go |
package application
import "github.com/adrg/xdg"
type PathType int
const (
// PathHome is the user's home directory.
PathHome PathType = iota
// PathDataHome defines the base directory relative to which user-specific
// data files should be stored. This directory is defined by the
// $XDG_DATA_HOME environment... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && cgo && !android && !server
package application
// resolvePermission returns the configured Permission for the given type on the
// window identified by windowID, defaulting to PermissionDefault when the
// window or an entry is not found.
func resolvePermission(windowID uint, kind Pe... | fim | wailsapp/wails | go |
<|fim_suffix|>.MonitorFromWindow(p.parent, w32.MONITOR_DEFAULTTONEAREST)
var monitorInfo w32.MONITORINFO
monitorInfo.CbSize = uint32(unsafe.Sizeof(monitorInfo))
if !w32.GetMonitorInfo(monitor, &monitorInfo) {
globalApplication.fatal("GetMonitorInfo failed")
}
// Set flags to always position the menu above the c... | fim | wailsapp/wails | go |
package application
import "runtime"
// Heavily inspired by Electron (c) 2013-2020 Github Inc.
// Electron License: https://github.com/electron/electron/blob/master/LICENSE
// Role is a type to identify menu roles
type Role uint
// These constants need to be kept in sync with `v2/internal/frontend/desktop/darwin/Ro... | fim | wailsapp/wails | go |
<|fim_suffix|>
viewMenu.AddRole(OpenDevTools)
}
<|fim_prefix|>//go:build !production || devtools
package applicatio<|fim_middle|>n
func addDevToolMenuItem(viewMenu *Menu) {<|endoftext|> | fim | wailsapp/wails | go |
//go:build production && !devtools
package application
func addDevToolMenuItem(viewMenu *Menu) {}
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>op) - dp(info.InsetBottom),
}
return []*Screen{
{
ID: "main",
Name: "Main Display",
IsPrimary: true,
ScaleFactor: float32(scale),
Size: Size{Width: width, Height: height},
Bounds: Rect{X: 0, Y: 0, Width: width, Height: heig... | fim | wailsapp/wails | go |
<|fim_suffix|>}
func getScreenForSystray(systray *macosSystemTray) (*Screen, error) {
// Get the Window for the status item
// https://stackoverflow.com/a/5875019/4188138
window := C.getWindowForSystray(systray.nsStatusItem)
cScreen := C.getScreenForWindow(window)
return cScreenToScreen(cScreen), nil
}
<|fim_pref... | fim | wailsapp/wails | go |
<|fim_suffix|>8.ValidString(screen.Name) {
t.Errorf("screen %d: Name %q is not valid UTF-8 — points at freed memory?", i, screen.Name)
}
t.Logf("screen %d: ID=%q Name=%q primary=%v", i, screen.ID, screen.Name, screen.IsPrimary)
}
}
<|fim_prefix|>//go:build darwin && !ios && !server
package application
import ... | fim | wailsapp/wails | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.