text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ltins are intentionally NOT
// populated here so only the user's own vars layer over the base.
func LoadLocal(dir string) ([]*ast.Taskfile, error) {
var result []*ast.Taskfile
for _, exts := range layers {
for _, name := range exts {
path := filepath.Join(dir, name)
if _, err := os.Stat(path); e... | fim | wailsapp/wails | go |
<|fim_suffix|>
version: "3"
tasks:
shared-task:
cmds:
- echo shared
`), 0644))
require.NoError(t, os.WriteFile(filepath.Join(project, "Taskfile.local.yml"), []byte(`
version: "3"
includes:
shared:
taskfile: ../shared.yml
`), 0644))
locals, err := LoadLocal(project)
require.NoError(t, err)
requir... | fim | wailsapp/wails | go |
<|fim_prefix|>package parse
import (
"fmt"
"regexp"
"runtime"
"strings"
"text/template"
"github.com/wailsapp/wails/v3/internal/wake/ast"
"github.com/wailsapp/wails/v3/internal/wake/platform"
)
var bareVarRegex = regexp.MustCompile(`\{\{(\s*)([A-Z_][A-Z0-9_]*)(\s*)\}\}`)
var defaultBareVarRegex = regexp.MustCo... | fim | wailsapp/wails | go |
<|fim_suffix|>r := os.Stat(path); err == nil {
info, _ := os.Stat(path)
if info.IsDir() {
candidates := []string{
filepath.Join(path, "Taskfile.yml"),
filepath.Join(path, "Taskfile.yaml"),
}
for _, c := range candidates {
if _, err := os.Stat(c); err == nil {
return c
}
}
return ... | fim | wailsapp/wails | go |
<|fim_prefix|>package parse
import (
"os"
"path/filepath"
"testing"
"github.com/stretchr/tes<|fim_suffix|>v3/internal/wake/ast"
)
func TestParseBasic(t *testing.T) {
dir := t.TempDir()
path := filepath.Join(dir, "Taskfile.yml")
err := os.WriteFile(path, []byte(`
version: "3"
tasks:
hello:
cmds:
- ... | fim | wailsapp/wails | go |
<|fim_prefix|>package platform
import "runtime"
func OS() string {
return runtime.GOOS
}
func Arch() string {
return runtime.GOARCH
}
func OSFamily() string {
switch runtime.GOOS {
case "linux", "darwin", "freebsd", "openbsd", "netbsd":
return "unix"
case "windows":
return "windows"
default:
return runt... | fim | wailsapp/wails | go |
<|fim_suffix|>script string) *exec.Cmd {
return exec.Command("sh", "-c", script)
}
<|fim_prefix|>//go:build !windows
package platform
import "os/exec"
// ShellCommand returns an *exec.Cmd that evaluates script through the
// platform's default shell<|fim_middle|>. On Unix-like systems we use `sh -c …`,
// matching ... | fim | wailsapp/wails | go |
<|fim_suffix|>: shell-out would
// fail.
//
// Users who want a POSIX shell (Git Bash, MSYS, WSL) can keep
// WAILS_USE_WAKE unset and use the embedded Task runtime instead.
func ShellCommand(script string) *exec.Cmd {
return exec.Command("cmd", "/C", script)
}
<|fim_prefix|>//go:build windows
package platform
impor... | fim | wailsapp/wails | go |
<|fim_prefix|>package resolve
import (
"fmt"
"sort"
"github.com/wailsapp/wails/v3/internal/wake/ast"
)
type DAG struct {
Tasks []*ast.Task
Edges map[string][]string
InDegree map[string]int
Order []string
}
func BuildDAG(tf *ast.Taskfile, target string) (*DAG, error) {
if _, ok := tf.Tasks[target]; ... | fim | wailsapp/wails | go |
<|fim_suffix|> Deps: []*ast.Dep{{Task: "a"}},
},
},
}
_, err := BuildDAG(tf, "a")
require.Error(t, err)
require.Contains(t, err.Error(), "cycle")
}
func TestMergeTask(t *testing.T) {
base := &ast.Task{
Name: "build",
Dir: "/base",
Summary: "base summary",
Cmds: []*ast.Cmd{
{Cmd: "echo ba... | fim | wailsapp/wails | go |
<|fim_suffix|>func FilterPlatforms(tf *ast.Taskfile) {
for _, task := range tf.Tasks {
if !platform.Filter(task.Platforms) {
task.Cmds = nil
task.Deps = nil
}
}
}
<|fim_prefix|>package resolve
import (
"github.com/wailsa<|fim_middle|>pp/wails/v3/internal/wake/ast"
"github.com/wailsapp/wails/v3/internal/w... | fim | wailsapp/wails | go |
<|fim_suffix|>ps(base, override map[string]string) map[string]string {
result := make(map[string]string)
for k, v := range base {
result[k] = v
}
for k, v := range override {
result[k] = v
}
return result
}
<|fim_prefix|>package resolve
import (
"github.com/wailsapp/wails/v3/internal/wake/ast"
)
// MergeTa... | fim | wailsapp/wails | go |
package resolve
import (
"testing"
"github.com/wailsapp/wails/v3/internal/wake/ast"
)
func TestMergeTaskReplacesCmds(t *testing.T) {
base := &ast.Task{
Name: "build",
Cmds: []*ast.Cmd{{Cmd: "echo base"}},
}
override := &ast.Task{
Name: "build",
Cmds: []*ast.Cmd{{Cmd: "echo local"}},
}
got := MergeTas... | fim | wailsapp/wails | go |
<|fim_prefix|>package wake
import (
"context"
"errors"
"fmt"
"os"
"path/filepath"
"strings"
"sync"
"time"
"github.com/wailsapp/wails/v3/internal/report"
"github.com/wailsapp/wails/v3/internal/report/pulse"
"github.com/wailsapp/wails/v3/internal/wake/ast"
"github.com/wailsapp/wails/v3/internal/wake/exec"
... | fim | wailsapp/wails | go |
<|fim_suffix|>ire.NoError(t, err)
tf, err := Parse(tfPath)
require.NoError(t, err)
require.NotNil(t, tf)
require.Len(t, tf.Tasks["build"].Deps, 2)
require.Equal(t, "deps:one", tf.Tasks["build"].Deps[0].Task)
require.Equal(t, "deps:two", tf.Tasks["build"].Deps[1].Task)
}
func TestParseWithForLoop(t *testing.T) {... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android && !production
package application
// androidVerboseLogging enables the framework's internal diag<|fim_suffix|>oseLogging = true
<|fim_middle|>nostic logging
// in debug builds. See android_logging_production.go for the release value.
const androidVerb<|endoftext|> | fim | wailsapp/wails | go |
//go:build android && production
package application
// androidVerboseLogging is disabled in production builds: the framework's
// internal diagnostic logging compiles to a no-op.
const androidVerboseLogging = false
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>ack to false.
a.runLock.Unlock()
r.Run()
}
func (a *App) handleWindowKeyEvent(event *windowKeyEvent) {
defer handlePanic()
// Get window from window map
a.windowsLock.RLock()
window, ok := a.windows[event.windowId]
a.windowsLock.RUnlock()
if !ok {
a.warning("WebviewWindow #%d not found", event.... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android && cgo && !server
package application
/*
#include <jni.h>
#include <stdlib.h>
#include <string.h>
#include <android/log.h>
// Global JavaVM reference for thread attachment
static JavaVM* g_jvm = NULL;
// Global reference to the WailsBridge object (must be a global ref, not local)
st... | fim | wailsapp/wails | go |
<|fim_suffix|>entListenersLock.Unlock()
androidEventListeners[eventID] = true
}
<|fim_prefix|>//go:build android && !cgo && !server
package application
// This file keeps GOOS=android builds compiling without cgo (used by
// tooling such as `wails3 generate bindings`). A real Android app is always
// built with CGO_... | fim | wailsapp/wails | go |
<|fim_suffix|>acosOnDragExit(windowID C.uint) {
window, ok := globalApplication.Window.GetByID(uint(windowID))
if !ok || window == nil {
return
}
// Call JavaScript to clean up drag state
window.ExecJS("window._wails.handleDragLeave();")
}
var (
// Pre-allocated buffer for drag JS calls to avoid allocations
... | fim | wailsapp/wails | go |
<|fim_suffix|>tionPolicy(int policy);
static char *getAppName(void);
#endif<|fim_prefix|>//go:build darwin && !ios
#ifndef application_h
#define application_h
static vo<|fim_middle|>id init(void);
static void run(void);
static void setActiva<|endoftext|> | fim | wailsapp/wails | c |
<|fim_suffix|>);
#endif /* appdelegate_h */
<|fim_prefix|>//go:build darwin && !ios
#ifndef appdelegate_h
#define appdelegate_h
#import <Cocoa/Cocoa.h>
@interface AppDelegate : NSResponder <NSApplicationDelegate>
@property bool shouldTerminateWhenLastWindowClosed;
@property bool shuttingDown;
- (BOOL)applicationSup... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build !production
package application
import (
"github.com/go-git/go-git/v5"
"github.com/wailsapp/wails/v3/internal/lo"
"github.com/wailsapp/wails/v3/internal/version"
"path/filepath"
"runtime/debug"
)
// BuildSettings contains the build settings for the application
var BuildSettings map[stri... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build !production
package application
import (
"net/http"
"time"
"github.com/wailsapp/wails/v3/internal/asse<|fim_suffix|>ms and try again for a maximum of 10 times. If it is
// still not available, we return an error.
// This is to allow the frontend server to start up before the backend s... | fim | wailsapp/wails | go |
<|fim_suffix|>leJSMessage
func HandleJSMessage(windowID C.uint, message *C.char) {
msg := C.GoString(message)
if msg == "" {
return
}
iosDebugLogf("[iOS-message] window %d: %s", windowID, msg)
// Structured payloads carry the message in a "name" or "message" field;
// plain strings (e.g. "wails:runtime:ready"... | fim | wailsapp/wails | go |
<|fim_suffix|>ion main loop
void ios_app_run(void);
// Quit the iOS application
void ios_app_quit(void);
// Check if dark mode is enabled
bool ios_is_dark_mode(void);
// Configure/show state for iOS WKWebView input accessory view (keyboard toolbar)
// If disabled, the accessory view will be hidden.
void ios_set_disa... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build ios
#ifndef application_ios_delegate_h
#define application_ios_delegate_h
#import <UIKit/UIKit.h>
@class WailsViewController;
@interface WailsAppDelegate : UIResponder <UIApplicationDelegate>
@property (<|fim_suffix|>Controllers;
@end
#endif /* application_ios_delegate_h */<|fim_middle|>st... | fim | wailsapp/wails | c |
<|fim_suffix|>
".mp4": "video-x-generic",
".avi": "video-x-generic",
".html": "text-html",
".css": "text-css",
".js": "text-javascript",
".json": "text-json",
".xml": "text-xml",
}
iconName := "application-x-generic"
if name, ok := iconMap[ext]; ok {
iconName = name
}
return getIconBytes(ic... | fim | wailsapp/wails | go |
<|fim_suffix|>og a warning and exit cleanly so
// the rest of the app keeps working.
func (a *linuxApp) monitorPowerEvents() {
go func() {
defer handlePanic()
conn, err := dbus.ConnectSystemBus()
if err != nil {
a.parent.warning(
"[WARNING] Failed to connect to system bus; sleep/wake events will not fire:... | fim | wailsapp/wails | go |
<|fim_suffix|>11") {
_ = os.Setenv("GDK_BACKEND", "x11")
}
// Disable DMA-BUF renderer on any session type with NVIDIA to prevent blank windows and
// "Error 71 (Protocol error)" crashes. NVIDIA proprietary drivers fail gbm_bo_map() when
// importing DMA-BUF, causing blank/white screens on both X11 and Wayland.
... | fim | wailsapp/wails | go |
<|fim_suffix|>"--" prefix, e.g. "--remote-debugging-port=9222"
EnabledFeatures []string
DisabledFeatures []string
AdditionalBrowserArgs []string
}
/********* Linux Options *********/
// LinuxOptions contains options for Linux applications.
type LinuxOptions struct {
// DisableQuitOnLastWindowClosed dis... | fim | wailsapp/wails | go |
<|fim_suffix|>"bell"},
{"NativeTabIconMagnify", NativeTabIconMagnify, "magnifyingglass"},
{"NativeTabIconList", NativeTabIconList, "list.bullet"},
{"NativeTabIconFolder", NativeTabIconFolder, "folder"},
}
for _, tt := range tests {
if string(tt.icon) != tt.expected {
t.Errorf("%s = %q, want %q", tt.name, ... | fim | wailsapp/wails | go |
//go:build production
package application
func newApplication(options Options) *App {
result := &App{
isDebugMode: false,
options: options,
}
result.init()
return result
}
func (a *App) logStartup() {}
func (a *App) preRun() error { return nil }
func (a *App) postQuit() error { return nil }
<|endoftext... | fim | wailsapp/wails | go |
//go:build server
package application
import (
"context"
"errors"
"fmt"
"net"
"net/http"
"os"
"os/signal"
"strconv"
"syscall"
"time"
"unsafe"
)
// serverApp implements platformApp for server mode.
// It provides a minimal implementation that runs an HTTP server
// without any GUI components.
//
// Server ... | fim | wailsapp/wails | go |
<|fim_suffix|>http.Request) {
w.WriteHeader(http.StatusOK)
}),
},
})
errCh := make(chan error, 1)
go func() {
errCh <- app.Run()
}()
time.Sleep(200 * time.Millisecond)
// Should be listening on localhost:18083
resp, err := http.Get("http://localhost:18083/health")
if err != nil {
t.Fatalf("reque... | fim | wailsapp/wails | go |
<|fim_suffix|>)
if isDarkMode != m.isCurrentlyDarkMode {
eventContext := newApplicationEventContext()
eventContext.setIsDarkMode(isDarkMode)
applicationEvents <- &ApplicationEvent{
Id: uint(events.Windows.SystemThemeChanged),
ctx: eventContext,
}
m.isCurrentlyDarkMode = isDarkMode
}... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
)
// resolvedExecutable returns os.Executable() after resolving symlinks so
// registrations don't break when the binary is installed via a symlink farm
// (Homebrew, Scoop). Falls back to the unresolved path if EvalSy... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build and<|fim_suffix|>tartStatus, error) {
return AutostartStatus{}, ErrAutostartNotSupported
}
<|fim_middle|>roid
package application
type unsupportedAutostart struct{}
func newAutostartImpl(_ *App) autostartImpl { return unsupportedAutostart{} }
func (unsupportedAutostart) enable(AutostartOpt... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
import (
"encoding/xml"
"errors"
"fmt"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"github.com/wailsapp/wails/v3/pkg/mac"
)
type darwinAutostart struct {
app *App
}
func newAutostartImpl(app *App) autostartImpl {
return &darwi... | fim | wailsapp/wails | go |
<|fim_suffix|>cMsg != nil {
return errors.New(C.GoString(cMsg))
}
return errors.New("SMAppService register failed")
}
}
func smAppServiceUnregister() error {
var cMsg *C.char
rc := C.smAppServiceUnregister(&cMsg)
if cMsg != nil {
defer C.free(unsafe.Pointer(cMsg))
}
switch rc {
case 0:
return nil
ca... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
import (
"os"
"path/filepath"
"strings"
"testing"
)
// newDarwinAutostartForTest builds an impl rooted at a temp HOME with a known
// Options.Name. The returned impl always uses the LaunchAgent fallback path
// (running under `go test` we're ... | fim | wailsapp/wails | go |
//go:build ios
package application
type unsupportedAutostart struct{}
func newAutostartImpl(_ *App) autostartImpl { return unsupportedAutostart{} }
func (unsupportedAutostart) enable(AutostartOptions) error { return ErrAutostartNotSupported }
func (unsupportedAutostart) disable() error { return Err... | fim | wailsapp/wails | go |
<|fim_suffix|>d=true
Hidden=false
NoDisplay=false
Terminal=false
`, escapeDesktopValue(appName), execLine)
}
// validateDesktopExecToken rejects control characters that would break the
// .desktop file format or allow Desktop Entry key injection when interpolated
// into an Exec= line. Allowed: spaces and tabs (which ... | fim | wailsapp/wails | go |
<|fim_suffix|>()
if st.Enabled {
t.Fatalf("expected disabled before enable, got %+v", st)
}
if err := a.enable(AutostartOptions{Arguments: []string{"--hidden"}}); err != nil {
t.Fatalf("enable: %v", err)
}
st, err := a.status()
if err != nil {
t.Fatalf("status: %v", err)
}
if !st.Enabled {
t.Fatalf("e... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
// AutostartManager provides cross-platform con<|fim_suffix|>s the full registration state, including the path of the
// on-disk artefact and the platform mechanism used.
func (am *AutostartManager) Status() (AutostartStatus, error) {
return am.impl.status()
}
<|fim_middle|>trol over... | fim | wailsapp/wails | go |
<|fim_suffix|> ErrAutostartNotSupported }
func (unsupportedAutostart) status() (AutostartStatus, error) {
return AutostartStatus{}, ErrAutostartNotSupported
}
<|fim_prefix|>//go:build server
package application
type unsupportedAutostart struct{}
func newAutostartImpl(_ *App)<|fim_middle|> autostartImpl { return uns... | fim | wailsapp/wails | go |
<|fim_suffix|>tries {
names = append(names, e.Name())
}
t.Errorf("expected exactly out.txt in dir, got %v", names)
}
data, err := os.ReadFile(target)
if err != nil {
t.Fatal(err)
}
if string(data) != "world" {
t.Errorf("contents=%q want %q", string(data), "world")
}
}
<|fim_prefix|>package application
... | fim | wailsapp/wails | go |
//go:build windows && !server
package application
import (
"errors"
"fmt"
"strings"
"golang.org/x/sys/windows/registry"
)
const defaultAutostartRegistrySubKey = `Software\Microsoft\Windows\CurrentVersion\Run`
type windowsAutostart struct {
app *App
// registrySubKey is overridable for tests; production code... | fim | wailsapp/wails | go |
//go:build windows && !server
package application
import (
"testing"
"golang.org/x/sys/windows/registry"
)
// newWindowsAutostartForTest returns a windowsAutostart that reads and writes
// under HKCU\Software\Wails\Tests\Autostart-<test-id>. The test creates the
// key, runs, and deletes it on cleanup so producti... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"context"
"encoding/json"
"errors"
"fmt"
"reflect"
"runtime"
"strings"
"sync"
"github.com/wailsapp/wails/v3/internal/hash"
"github.com/wailsapp/wails/v3/internal/sliceutil"
)
// CallOptions defines the options for a method call.
// Field order is optimized to mini... | fim | wailsapp/wails | go |
<|fim_suffix|>D
callOptions := &application.CallOptions{
MethodName: "github.com/wailsapp/wails/v3/pkg/application_test.BenchmarkService.StringArg",
}
method := bindings.Get(callOptions)
if method == nil {
b.Fatal("method not found")
}
methodID := method.ID
b.ResetTimer()
for b.Loop() {
_ = bindings.GetB... | fim | wailsapp/wails | go |
<|fim_suffix|>gs := make([]reflect.Value, argCount)
base := 0
if b.needsContext {
callArgs[0] = reflect.ValueOf(ctx)
base++
}
// Iterate over given arguments - use JSON v2 for unmarshaling
for index, arg := range args {
value := reflect.New(b.Inputs[base+index].ReflectType)
err = jsonv2.Unmarshal(arg, va... | fim | wailsapp/wails | go |
<|fim_prefix|>package application_test
import (
"context"
"encoding/json"
"errors"
"reflect"
"strings"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
)
type TestService struct {
}
type Person struct {
Name string `json:"name"`
}
func (t *TestService) Nil() {}
func (t *TestService) String(s strin... | fim | wailsapp/wails | go |
<|fim_suffix|>er.OpenFile(path)
}
<|fim_prefix|>package application
import (
"github.com/wailsapp/wails/v3/internal/browser"
)
// BrowserManager manages browser-related operations
type BrowserManager struct {
app *App
}
// newBrowserManager creates a new BrowserManager instance
func newBrowserManager(app *App) *Br... | fim | wailsapp/wails | go |
<|fim_suffix|>erWindow) SetPosition(x, y int) {}
func (b *BrowserWindow) SetAlwaysOnTop(b2 bool) Window { return b }
func (b *BrowserWindow) SetBackgroundColour(colour RGBA) Window { return b }
func (b *BrowserWindow) SetFrameless(frameless bool) Window ... | fim | wailsapp/wails | go |
package application
type clipboardImpl interface {
setText(text string) bool
text() (string, bool)
}
type Clipboard struct {
impl clipboardImpl
}
func newClipboard() *Clipboard {
return &Clipboard{
impl: newClipboardImpl(),
}
}
func (c *Clipboard) SetText(text string) bool {
return InvokeSyncWithResult(func... | fim | wailsapp/wails | go |
<|fim_suffix|>turn &androidClipboardImpl{}
}
func (c *androidClipboardImpl) setText(text string) bool {
androidBridgeVoidString("setClipboardText", text)
return true
}
func (c *androidClipboardImpl) text() (string, bool) {
return androidBridgeString("getClipboardText")
}
<|fim_prefix|>//go:build android
package a... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
/*
#cgo CFLAGS: -mmacosx-version-min=10.13 -x objective-c
#cgo LDFLAGS: -framework Cocoa -mmacosx-version-min=10.13
#import <Cocoa/Cocoa.h>
#import <stdlib.h>
bool setClipboardText(const char* text) {
NSPasteboard *pasteB<|fim_suffix|>unc (m ma... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
/*
#include <stdlib.h>
#include "application_ios.h"
*/
import "C"
import "unsafe"
type iosClipboardImpl struct{}
func newClipboardImpl() clipboardImpl {
return &iosClipboardImpl{}
}
func (c *iosClipboardImpl) setText(text string) bool {
ctext := C.CString(text)
... | fim | wailsapp/wails | go |
<|fim_suffix|>lock()
return clipboardGet(), true
}
func newClipboardImpl() *linuxClipboard {
return &linuxClipboard{}
}
<|fim_prefix|>//go:build linux && !android && !server
package application
import (
"sync"
)
var clipboardLock sync.RWMutex
type linuxClipboard struct{}
func (m linuxClipboard) setText(text st... | fim | wailsapp/wails | go |
<|fim_suffix|>oard instance, creating it if needed (lazy initialization)
func (cm *ClipboardManager) getClipboard() *Clipboard {
if cm.clipboard == nil {
cm.clipboard = newClipboard()
}
return cm.clipboard
}
<|fim_prefix|>package application
// ClipboardManager manages clipboard operations
type ClipboardManager s... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package application
import (
"github.com/wailsapp/wails/v3/pkg/w32"
"sync"
)
type wind<|fim_suffix|>ard{}
}
<|fim_middle|>owsClipboard struct {
lock sync.RWMutex
}
func (m *windowsClipboard) setText(text string) bool {
m.lock.Lock()
defer m.lock.Unlock()
return w32.SetClipboar... | fim | wailsapp/wails | go |
<|fim_suffix|>enuData] = data.Data
return c
}
<|fim_prefix|>package application
type Context struct {
// contains filtered or unexported fields
data map[string]any
}
func new<|fim_middle|>Context() *Context {
return &Context{
data: make(map[string]any),
}
}
const (
clickedMenuItem string = "clickedMenuItem... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import "log"
var blankApplicationEventContext = &ApplicationEventContext{}
const (
CONTEXT_OPENED_FILES = "openedFiles"
CONTEXT_FILENAME = "filename"
CONTEXT_URL = "url"
)
// ApplicationEventContext is the context of an application event
type ApplicationEventContext... | fim | wailsapp/wails | go |
package application
// ContextMenuManager manages all context menu operations
type ContextMenuManager struct {
app *App
}
// newContextMenuManager creates a new ContextMenuManager instance
func newContextMenuManager(app *App) *ContextMenuManager {
return &ContextMenuManager{
app: app,
}
}
// New creates a new c... | fim | wailsapp/wails | go |
<|fim_suffix|>Chaining(t *testing.T) {
ctx := newContext()
menuItem := &MenuItem{label: "Test"}
returnedCtx := ctx.withClickedMenuItem(menuItem)
if returnedCtx != ctx {
t.Error("withClickedMenuItem should return the same context for chaining")
}
}
func TestContext_WithContextMenuData_Chaining(t *testing.T) {
... | fim | wailsapp/wails | go |
<|fim_suffix|>EventContext) DroppedFiles() []string {
if c.data == nil {
c.data = make(map[string]any)
}
files, ok := c.data[droppedFiles]
if !ok {
return nil
}
result, ok := files.([]string)
if !ok {
return nil
}
return result
}
func (c WindowEventContext) setDroppedFiles(files []string) {
if c.data =... | fim | wailsapp/wails | go |
<|fim_suffix|>nager) Warning() *MessageDialog {
return newMessageDialog(WarningDialogType)
}
// Error creates an error dialog
func (dm *DialogManager) Error() *MessageDialog {
return newMessageDialog(ErrorDialogType)
}
<|fim_prefix|>package application
// DialogManager manages dialog-related operations
type DialogM... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"strings"
"sync"
)
type DialogType int
var dialogMapID = make(map[uint]struct{})
var dialogIDLock sync.RWMutex
func getDialogID() uint {
dialogIDLock.Lock()
defer dialogIDLock.Unlock()
var dialogID uint
for {
if _, ok := dialogMapID[dialogID]; !ok {
dialogMapID[... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package application
import (
"encoding/json"
"fmt"
"sync"
)
// Message dialogs are backed by AlertDialog, file dialogs by the Storage
// Access Framework document picker (selected documents are copied into the
// app's cache directory so callers receive real filesystem paths). Sav... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
/*
#cgo CFLAGS: -mmacosx-version-min=10.13 -x objective-c
#cgo LDFLAGS: -framework Cocoa -mmacosx-version-min=10.13 -framework UniformTypeIdentifiers
#import <Cocoa/Cocoa.h>
#import <UniformTypeIdentifiers/UTType.h>
#import "dialogs_darwin_deleg... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios
#ifndef _DIALOGS_DELEGATE_H_
#define _DIALOGS_DELEGATE_H_
#import <Cocoa/Cocoa.h>
// Conditionally import UniformTypeIdentifiers base<|fim_suffix|>legate : NSObject <NSOpenSavePanelDelegate>
@property (nonatomic, strong) NSArray *allowedExtensions;
@end
#endif<|fim_middle|>d ... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build ios
package application
/*
#include <stdlib.h>
#include "application_ios.h"
*/
import "C"
import (
"encoding/json"
"fmt"
"sync"
"unsafe"
)
// Message dialogs are backed by UIAlertController, file dialogs by
// UIDocumentPickerViewController. Save dialogs have no iOS counterpart
// (apps... | fim | wailsapp/wails | go |
//go:build linux && !android && !server
package application
func (a *linuxApp) showAboutDialog(title string, message string, icon []byte) {
window, _ := globalApplication.Window.GetByID(a.getCurrentWindowID())
var parent uintptr
if window != nil {
nativeWindow := window.NativeWindow()
if nativeWindow != nil {
... | fim | wailsapp/wails | go |
<|fim_suffix|> ButtonText: "Choose",
Directory: "/home",
Filters: []FileFilter{
{DisplayName: "All Files", Pattern: "*"},
},
}
if !opts.CanChooseDirectories {
t.Error("CanChooseDirectories not set correctly")
}
if !opts.CanChooseFiles {
t.Error("CanChooseFiles not set correc... | fim | wailsapp/wails | go |
<|fim_suffix|>
for i, path := range paths {
paths[i] = filepath.Clean(path)
}
return paths, nil
}
path, err := dlg.ShowAndGetResult()
if err != nil {
return nil, err
}
return filepath.Clean(path), nil
}
<|fim_prefix|>//go:build windows
package application
import (
"path/filepath"
"strings"
"githu... | fim | wailsapp/wails | go |
<|fim_suffix|> expected: `\\\\host\share\test.txt`,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
cleaned := filepath.Clean(tt.inputPath)
i.Equal(cleaned, tt.expected)
})
}
}
<|fim_prefix|>//go:build windows
package application_test
import (
"path/filepath"
"testing"
"gith... | fim | wailsapp/wails | go |
<|fim_suffix|>ogram is running on.
// - Arch: the architecture of the operating system.
// - Debug: indicates whether debug mode is enabled.
// - OSInfo: information about the operating system.
type EnvironmentInfo struct {
OS string `json:"OS"`
Arch string `json:"Arch"`
D... | fim | wailsapp/wails | go |
<|fim_suffix|>il {
return "", err
}
respLen := uint32(respHeader[6]) | uint32(respHeader[7])<<8 | uint32(respHeader[8])<<16 | uint32(respHeader[9])<<24
respBody := make([]byte, respLen)
_, err = conn.Read(respBody)
if err != nil {
return "", err
}
return string(respBody), nil
}
<|fim_prefix|>//go:build lin... | fim | wailsapp/wails | go |
<|fim_suffix|>bool); ok {
return ffm
}
return false
}
<|fim_prefix|>package application
import (
"runtime"
"github.com/wailsapp/wails/v3/internal/fileexplorer"
"github.com/wailsapp/wails/v3/internal/operatingsystem"
)
// EnvironmentManager manages environment-related operations
type EnvironmentManager struct ... | fim | wailsapp/wails | go |
package application
import (
"fmt"
"os"
"strings"
)
// FatalError instances are passed to the registered error handler
// in case of catastrophic, unrecoverable failures that require immediate termination.
// FatalError wraps the original error value in an informative message.
// The underlying error may be retrie... | fim | wailsapp/wails | go |
<|fim_suffix|> *CustomEvent), counter int) {
em.app.customEventProcessor.OnMultiple(name, callback, counter)
}
// Reset removes all custom event listeners
func (em *EventManager) Reset() {
em.app.customEventProcessor.OffAll()
}
// OnApplicationEvent registers a listener for application events
func (em *EventManager... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"fmt"
"reflect"
"slices"
"sync"
"sync/atomic"
"encoding/json"
"github.com/wailsapp/wails/v3/pkg/events"
)
type ApplicationEvent struct {
Id uint
ctx *ApplicationEventContext
cancelled atomic.Bool
}
func (w *ApplicationEvent) Context() *ApplicationEv... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build bench
package application_test
import (
"fmt"
"sync"
"sync/atomic"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
)
// mockWindowDispatcher implements a no-op dispatcher for benchmarking
type mockWindowDispatcher struct {
count atomic.Int64
}
func (m *mockWindowDispatcher) ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package application
import "github<|fim_suffix|>pCommonEvents() {
for sourceEvent, targetEvent := range commonApplicationEventMap {
sourceEvent := sourceEvent
targetEvent := targetEvent
a.parent.Event.OnApplicationEvent(sourceEvent, func(event *ApplicationEvent) {
androidDeb... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
import "github.com/wailsapp/wails/v3/pkg/events"
var commonApplicationEventMap = map[events.ApplicationEventType]events.ApplicationEventType{
events.Mac.ApplicationDidFinishLaunching: events.Common.ApplicationStarted,
events.Mac.ApplicationDidC... | fim | wailsapp/wails | go |
<|fim_suffix|>Forwarding iOS event %d → common %d", sourceEvent, targetEvent)
applicationEvents <- &ApplicationEvent{
Id: uint(targetEvent),
ctx: event.ctx,
}
})
}
}<|fim_prefix|>//go:build ios
package application
import "github.com/wailsapp/wails/v... | fim | wailsapp/wails | go |
<|fim_suffix|>onEvents <- &ApplicationEvent{
Id: uint(targetEvent),
ctx: event.ctx,
}
})
}
}
<|fim_prefix|>//go:build linux && !android && !server
package application
import "github.com/wailsapp/wails/v3/pkg/events"
var commonApplicationEventMap = map[events.ApplicationEventType]events.ApplicationEven... | fim | wailsapp/wails | go |
<|fim_suffix|>plication events for server mode.
// In server mode, there are no platform-specific events to map,
// so this is a no-op.
func (h *serverApp) setupCommonEvents() {
// No-op: server mode has no platform-specific events to map
}
<|fim_prefix|>//go:build server
package application
// setupCommonEv<|fim_mi... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package application
imp<|fim_suffix|>monApplicationEventMap {
sourceEvent := sourceEvent
targetEvent := targetEvent
m.parent.Event.OnApplicationEvent(sourceEvent, func(event *ApplicationEvent) {
applicationEvents <- &ApplicationEvent{
Id: uint(targetEvent),
ctx: even... | fim | wailsapp/wails | go |
<|fim_suffix|>ing) {}
func warnAboutUnregisteredEvent(name string) {}
<|fim_prefix|>//go:build production || !strictevents
package application
f<|fim_middle|>unc eventRegistered(name str<|endoftext|> | fim | wailsapp/wails | go |
//go:build !production && strictevents
package application
import (
"sync"
)
var knownUnregisteredEvents sync.Map
func eventRegistered(name string) {
knownUnregisteredEvents.Delete(name)
}
func warnAboutUnregisteredEvent(name string) {
// Perform a load first to avoid thrashing the map with unnecessary swaps.
... | fim | wailsapp/wails | go |
<|fim_prefix|>package application_test
import (
"sync"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
"github.com/matryer/is"
)
type mockNotifier struct {
Events []*application.CustomEvent
}
func (m *mockNotifier) dispatchEventToWindows(event *application.CustomEvent) {
m.Events = append(m.Events, ... | fim | wailsapp/wails | go |
<|fim_suffix|>ld not capture", false, false},
}
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
result := shouldCaptureHitTest(tc.isFullscreen)
if result != tc.expectedCapture {
t.Errorf("shouldCaptureHitTest(%v) = %v, want %v",
tc.isFullscreen, result, tc.expectedCapture)
}
... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !gtk3 && !android && !server
package<|fim_suffix|>}()
}
<|fim_middle|> application
func gtkDispatch(fn func()) {
go func() {
defer handlePanic()
fn()
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>&& !server
package application
func gtkDispatch(fn func()) {
InvokeAsync(fn)
}
<|fim_prefix|>//go:build linux <|fim_middle|>&& gtk3 && !android <|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>, y).RGBA()
data[i] = byte(a)
data[i+1] = byte(r)
data[i+2] = byte(g)
data[i+3] = byte(b)
i += 4
}
}
return w, h, data
}
<|fim_prefix|>package application
import (
"bytes"
"image"
"image/draw"
"image/png"
)
func pngToImage(data []byte) (*image.RGBA, error) {
img, err := png.Decod... | fim | wailsapp/wails | go |
<|fim_suffix|> calling LockOSThread can interfere with the JNI environment
}
<|fim_prefix|>//go:build android
package application
func init() {
// On Android, we don't call runtime<|fim_middle|>.LockOSThread()
// The Android runtime handles thread management via JNI
// and<|endoftext|> | fim | wailsapp/wails | go |
//go:build !ios
package application
import "runtime"
func init() {
// Lock the main thread for desktop platforms
// This ensures UI operations happen on the main thread
runtime.LockOSThread()
}<|endoftext|> | fim | wailsapp/wails | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.