text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
//go:build ios
package application
/*
#include <stdlib.h>
#include "application_ios.h"
*/
import "C"
import (
"encoding/json"
"unsafe"
)
type iosScreenInfo struct {
PointWidth int `json:"pointWidth"`
PointHeight int `json:"pointHeight"`
PixelWidth int `json:"pixelWidth"`
PixelHeight int `jso... | fim | wailsapp/wails | go |
<|fim_suffix|> 0.
hasPrimary := false
for _, s := range screens {
if s.IsPrimary {
hasPrimary = true
break
}
}
if !hasPrimary && len(screens) > 0 {
screens[0].IsPrimary = true
}
return a.parent.Screen.LayoutScreens(screens)
}
func (a *linuxApp) getPrimaryScreen() (*Screen, error) {
return a.parent.S... | fim | wailsapp/wails | go |
<|fim_suffix|>*App after DPI is implemented in all platforms
func (m *windowsApp) getScreens() ([]*Screen, error) {
return m.parent.Screen.GetAll(), nil
}
// NOTE: should be moved to *App after DPI is implemented in all platforms
func (m *windowsApp) getPrimaryScreen() (*Screen, error) {
return m.parent.Screen.GetPr... | fim | wailsapp/wails | go |
package application
import (
"errors"
"math"
"sort"
"sync"
)
// Heavily inspired by the Chromium project (Copyright 2015 The Chromium Authors)
// Chromium License: https://chromium.googlesource.com/chromium/src/+/HEAD/LICENSE
type ScreenManager struct {
app *App
mu sync.RWMutex // guards s... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"testing"
)
func TestAlignment_Constants(t *testing.T) {
if TOP != 0 {
t.Error("TOP should be 0")
}
if RIGHT != 1 {
t.Error("RIGHT should be 1")
}
if BOTTOM != 2 {
t.Error("BOTTOM should be 2")
}
if LEFT != 3 {
t.Error("LEFT should be 3")
}
}
func TestOffse... | fim | wailsapp/wails | go |
<|fim_suffix|>ical) // DipToPhysicalPoint screen2
is.Equal(sm.PhysicalToDipPoint(ptPhysical), ptDip) // PhysicalToDipPoint screen2
rect := application.Rect{X: 100, Y: 100, Width: 200, Height: 300}
is.Equal(sm.DipToPhysicalRect(rect), rect) // DipToPhysicalRect screen1
is.Equal(sm.PhysicalToDipRect(rect), rect) // ... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"context"
"reflect"
)
// Service wraps a bound type instance.
// The zero value of Service is invalid.
// Valid values may only be obtained by calling [NewService].
type Service struct {
instance any
options ServiceOptions
}
// ServiceOptions provides optional paramete... | fim | wailsapp/wails | go |
<|fim_suffix|> := service.options.MarshalError(nil)
expected := `{"error": "custom"}`
if string(result) != expected {
t.Errorf("MarshalError result = %q, want %q", string(result), expected)
}
}
func TestServiceStartupInterface(t *testing.T) {
svc := &testServiceWithStartup{}
service := NewService(svc)
// Veri... | fim | wailsapp/wails | go |
//go:build android
package application
import (
"os"
)
// setupSignalHandler sets up signal handling for Android
// On Android, we don't handle Unix signals directly as the app lifecycle
// is managed by the Android runtime
func setupSignalHandler() {
// No-op on Android - lifecycle managed by Android framework
}
... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build <|fim_suffix|>}
<|fim_middle|>!ios
package application
import (
"os"
"github.com/wailsapp/wails/v3/internal/signal"
)
// setupSignalHandler sets up signal handling for desktop platforms
func (a *App) setupSignalHandler(options Options) {
if !options.DisableDefaultSignalHandler {
a.sign... | fim | wailsapp/wails | go |
//go:build ios
package application
// setupSignalHandler is a no-op on iOS as signal handling is not supported
// iOS apps run in a sandboxed environment where signal handling is restricted
// and can cause crashes if attempted
func (app *App) setupSignalHandler(options Options) {
// No signal handling on iOS - the ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package application
import "os"
// signalType is a placeholder typ<|fim_suffix|>used
type signalType = os.Signal
<|fim_middle|>e for Android where signals are not <|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>ndler
}<|fim_prefix|>//go<|fim_middle|>:build !ios
package application
import "github.com/wailsapp/wails/v3/internal/signal"
// platformSignalHandler holds the signal handler for desktop platforms
type platformSignalHandler struct {
signalHandler *signal.SignalHa<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>
// No signal handler on iOS
}<|fim_prefix|>//go:build ios
package application
// platformSignalHandler is empty on iOS as signal han<|fim_middle|>dling is not supported
type platformSignalHandler struct {<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>dInstanceBuffer {
var secondInstanceData SecondInstanceData
var jsonData []byte
var err error
// Check if encryption key is non-zero
var zeroKey [32]byte
if options.EncryptionKey != zeroKey {
// Try to decrypt the data
jsonData, err = decrypt(options.EncryptionKey, encry... | fim | wailsapp/wails | go |
<|fim_suffix|> handle single instance via launch mode in manifest
return nil
}
func (l *androidLock) release() {
// Android apps handle single instance via launch mode in manifest
}
func (l *androidLock) notify(data string) error {
// Android apps handle single instance via launch mode in manifest
return nil
}
<|... | fim | wailsapp/wails | go |
<|fim_suffix|>l {
return alreadyRunningError
}
return nil
}
func (l *darwinLock) release() {
if l.file != nil {
syscall.Flock(int(l.file.Fd()), syscall.LOCK_UN)
l.file.Close()
os.Remove(l.file.Name())
l.file = nil
}
}
func (l *darwinLock) notify(data string) error {
singleInstanceUniqueId := C.CString(... | fim | wailsapp/wails | go |
//go:build darwin && !ios && !server
package application
/*
#cgo CFLAGS: -mmacosx-version-min=10.13 -x objective-c -fblocks
#cgo LDFLAGS: -mmacosx-version-min=10.13 -framework Foundation -framework Cocoa
#include <stdlib.h>
#import <Foundation/Foundation.h>
#import <Cocoa/Cocoa.h>
#import <dispatch/dispatch.h>
stat... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
// setupSingleInstance sets up single instance on iOS
func (a *App) setupSingleInstance() error {
// iOS apps are always single instance
return nil
}
type iosLock struct {
manager *singleInstanceManager
}
func newPlatformLock(manager *singleInstanceManager) (platf... | fim | wailsapp/wails | go |
<|fim_suffix|>{
return ""
}
<|fim_prefix|>//go:build !darwin || ios || server
packag<|fim_middle|>e application
// captureLaunchURL is a no-op on non-macOS platforms. On Windows and Linux
// the URL is already present in os.Args, so no extra capture is needed.
func captureLaunchURL() string <|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !android && !server
package application
import (
"errors"
"os"
"strings"
"sync"
"syscall"
"github.com/godbus/dbus/v5"
)
type dbusHandler func(string)
var setup sync.Once
func (f dbusHandler) SendMessage(message string) *dbus.Error {
f(message)
return nil
}
type linuxLock... | fim | wailsapp/wails | go |
<|fim_suffix|>dditionalData) != 2 {
t.Error("AdditionalData not set correctly")
}
}
func TestSingleInstanceOptions_Defaults(t *testing.T) {
opts := SingleInstanceOptions{}
if opts.UniqueID != "" {
t.Error("UniqueID should default to empty string")
}
if opts.OnSecondInstanceLaunch != nil {
t.Error("OnSecond... | fim | wailsapp/wails | go |
//go:build windows
package application
import (
"errors"
"syscall"
"unsafe"
"github.com/wailsapp/wails/v3/pkg/w32"
"golang.org/x/sys/windows"
)
var (
user32 = syscall.NewLazyDLL("user32.dll")
)
type windowsLock struct {
handle syscall.Handle
uniqueID string
msgString string
hwnd w32.HWND
ma... | fim | wailsapp/wails | go |
<|fim_suffix|>systemTrayID++
return stm.app.systemTrayID
}
// destroy destroys a system tray (internal use)
func (stm *SystemTrayManager) destroy(tray *SystemTray) {
// Remove the system tray from the app.systemTrays map
stm.app.systemTraysLock.Lock()
delete(stm.app.systemTrays, tray.id)
stm.app.systemTraysLock.U... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"errors"
"runtime"
"strings"
"sync"
"time"
)
// SystemTrayLabelPart is a segment of a system tray label with optional colour information.
// FgColor and BgColor are hex strings (e.g. "#ff0000") or empty strings when not set.
type SystemTrayLabelPart struct {
Text st... | fim | wailsapp/wails | go |
<|fim_suffix|>ave system tray
}
func (s *androidSystemTray) setDarkModeIcon(_ []byte) {
// Android doesn't have system tray
}
func (s *androidSystemTray) destroy() {
// Android doesn't have system tray
}
func (s *androidSystemTray) setIconPosition(_ IconPosition) {
// Android doesn't have system tray
}
func (s *... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build bench
package application
import (
"testing"
"time"
)
// Note: SystemTray benchmarks are limited since actual system tray operations
// require platform-specific GUI initialization. These benchmarks focus on
// the Go-side logic that can be tested without a running GUI.
// BenchmarkSystem... | fim | wailsapp/wails | go |
<|fim_suffix|>Pointer(bg))
}
}
func (s *macosSystemTray) destroy() {
// Remove the status item from the status bar and its associated menu
C.systemTrayDestroy(s.nsStatusItem)
}
func (s *macosSystemTray) processClick(b button) {
switch b {
case leftButtonDown:
// Check if we have a callback
if s.parent.clickH... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios
#include <Cocoa/Cocoa.h>
@interface StatusItemController : NSObject <<|fim_suffix|>tusItem, void* attributedString);
void systemTraySetLabelColor(void* nsStatusItem, char *fg, char *bg);
void* createAttributedString(char *title, char *FG, char *BG);
void* appendAttributedString... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build ios
package application
// iOS doesn't have system tray support
// These are placeholder implementations
func (t *SystemTray) update() {}
func (t *SystemTray) setMenu(menu *Menu) {
// iOS doesn't have system tray
}
func (t *SystemTray) close() {
// iOS doesn't have system tray
}
func (... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !android && !server
/*
Portions of this code are derived from the project:
- https://github.com/fyne-io/systray
*/
package application
import "C"
import (
"fmt"
"os"
"sync"
"sync/atomic"
"github.com/godbus/dbus/v5"
"github.com/godbus/dbus/v5/introspect"
"github.com/godbus/dbu... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !android && !server
package application
import (
"fmt"
"sync"
"sync/atomic"
"testing"
"time"
)
// resolveSystrayMenuItem returns the *systrayMenuItem impl bound to item by
// linuxSystemTray.setMenu, failing the test (with name in the message) if the
// type assertion fails.
fu... | fim | wailsapp/wails | go |
//go:build windows
package application
import (
"errors"
"fmt"
"syscall"
"unsafe"
"github.com/wailsapp/wails/v3/pkg/icons"
"github.com/wailsapp/wails/v3/pkg/events"
"github.com/wailsapp/wails/v3/pkg/w32"
)
const (
wmUserSystray = w32.WM_USER + 1
)
type windowsSystemTray struct {
parent *SystemTray
menu... | fim | wailsapp/wails | go |
<|fim_suffix|> /wails/runtime.js - The Wails runtime library
//
// The transport should integrate this handler into its HTTP server.
// Typically this means mounting it at "/" and ensuring the IPC endpoint
// (e.g., /wails/ws for WebSocket) is handled separately.
//
// This method is called after Start() complete... | fim | wailsapp/wails | go |
package application
type EventIPCTransport struct {
app *App
}
func (t *EventIPCTransport) DispatchWailsEvent(event *CustomEvent) {
// Snapshot the window list under the lock, then release before dispatching.
// DispatchWailsEvent calls ExecJS → InvokeSync which blocks until the main
// thread executes the JS. Ho... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"sync"
"testing"
"time"
)
// lockProbeWindow is a minimal Window implementation that captures whether
// app.windowsLock could be exclusively acquired during the per-window
// dispatch. Embedding the Window interface gives nil-bodied placeholders
// for every other method... | fim | wailsapp/wails | go |
<|fim_suffix|>usUnprocessableEntity)
_, err = rw.Write(bytes)
if err != nil {
t.error("Unable to write error response:", "error", err)
}
}
func (t *HTTPTransport) error(message string, args ...any) {
t.logger.Error(message, args...)
}
<|fim_prefix|>package application
import (
"bytes"
"context"
"errors"
"i... | fim | wailsapp/wails | go |
package application
import (
"github.com/wailsapp/wails/v3/pkg/updater"
)
// updaterHost adapts the application's EventManager and window factory to
// the small interface the updater package needs. Defined here (and not in
// the updater package) to keep the dependency direction clean: application
// imports update... | fim | wailsapp/wails | go |
package application
import (
"errors"
"fmt"
"net/url"
"regexp"
"strings"
)
func ValidateAndSanitizeURL(rawURL string) (string, error) {
if strings.Contains(rawURL, "\x00") {
return "", errors.New("null bytes not allowed in URL")
}
for i, r := range rawURL {
if r < 32 && r != 9 {
return "", fmt.Errorf(... | fim | wailsapp/wails | go |
<|fim_prefix|>package application_test
import (
"strings"
"testing"
"github.com/wailsapp/wails/v3/pkg/application"
)
func TestValidateURL(t *testing.T) {
testCases := []struct {
name string
url string
shouldErr bool
errMsg string
expected string
}{
{
name: "valid https URL",
... | fim | wailsapp/wails | go |
<|fim_suffix|>y: true,
})
if err != nil {
b.app.error("WebSocket accept error", "error", err)
return
}
// Get runtime's clientId from query parameter
runtimeClientID := r.URL.Query().Get("clientId")
// Create BrowserWindow for this connection
browserWindow := NewBrowserWindow(uint(b.nextID.Add(1)), runtime... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build !server
package application
// GetBrowserWindow is a stub for <|fim_suffix|>able in server mode.
func GetBrowserWindow(clientId string) Window {
return nil
}
<|fim_middle|>non-server builds.
// Returns nil as browser windows are only avail<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>oadFinished fires before
// the JavaScript runtime has mounted dispatchWailsEvent on window._wails
msg := fmt.Sprintf("if(window._wails&&window._wails.dispatchWailsEvent){window._wails.dispatchWailsEvent(%s);}", event.ToJSON())
w.ExecJS(msg)
}
func (w *WebviewWindow) dispatchWindowEvent(id uint) {
//... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build android
package application
import (
"fmt"
"unsafe"
)
// androidWebviewWindow implements the webviewWindowImpl interface for Android
type androidWebviewWindow struct {
windowID uint32 // Wails window ID for tracking
parent *WebviewWindow
}
func newWindowImpl(parent *WebviewWindow) *an... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin && !ios && !server
package application
/*
#include <stdbool.h>
*/
import "C"
//export windowShouldUnconditionallyClose
func windowShouldUnconditionallyClose(windowId C.uint) C.bool {
window, _ := globalApplication.Window.GetByID(uint(windowId))
if window == nil {
globalApplication... | fim | wailsapp/wails | go |
<|fim_suffix|>ndowClose(void *window) {
[(WebviewWindow*)window close];
}
// windowZoom
static void windowZoom(void *window) {
[(WebviewWindow*)window zoom:nil];
}
// webviewRenderHTML renders the given HTML
static void windowRenderHTML(void *window, const char *html) {
WebviewWindow* nsWindow = (WebviewWindow*)wi... | fim | wailsapp/wails | go |
<|fim_suffix|>gate_h */
<|fim_prefix|>//go:build darwin && !ios
#ifndef WebviewWindowDelegate_h
#define WebviewWindowDelegate_h
#import <Cocoa/Cocoa.h>
#import <WebKit/WebKit.<|fim_middle|>h>
@interface WebviewWindow : NSWindow
- (BOOL) canBecomeKeyWindow;
- (BOOL) canBecomeMainWindow;
- (BOOL) acceptsFirstResponder... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build darwin && !ios && !server && (!production || devtools)
package application
/*
#cgo CFLAGS: -mmacosx-version-min=10.13 -x objective-c
#cgo LDFLAGS: -framework Cocoa
#import <Cocoa/Cocoa.h>
#include "webview_window_darwin.h"
@interface _WKInspector : NSObject
- (void)show;
- (void)detach;
@e... | fim | wailsapp/wails | go |
<|fim_suffix|>nt windowId;
@end<|fim_prefix|>//go:build darwin && !ios
#import <AppKit/AppKit.h>
@interface WebviewDrag : NSView <NSDraggingDestination>
@prop<|fim_middle|>erty unsigned i<|endoftext|> | fim | wailsapp/wails | c |
<|fim_prefix|>//go:bui<|fim_suffix|> !ios && production && !devtools && !server
package application
func (w *macosWebviewWindow) enableDevTools() {}
func (w *macosWebviewWindow) openDevTools() {}
<|fim_middle|>ld darwin &&<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build ios
package application
/*
#include <stdlib.h>
// Forward declarations of C functions for window management
void* ios_create_webview_with_id(unsigned int wailsID);
void ios_window_exec_js(void* viewController, const char* js);
unsigned int ios_window_get_id(void* viewController);
void ios_wi... | fim | wailsapp/wails | go |
<|fim_suffix|>dow_get_id(void* viewController);
void ios_window_release_handle(void* viewController);
// Console logging bridge (broadcast to all WKWebViews)
void ios_console_log(const char* level, const char* message);
// Set background color (RGBA 0-255) for a specific window's root view and webview
void ios_window... | fim | wailsapp/wails | c |
<|fim_suffix|> {
w.setTransparent()
w.setBackgroundColour(w.parent.options.BackgroundColour)
}
w.setFrameless(w.parent.options.Frameless)
w.applyScreenPlacement()
switch w.parent.options.StartState {
case WindowStateMaximised:
w.maximise()
case WindowStateMinimised:
w.minimise()
case WindowStateFullsc... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && !production && !android && !server
package application
func (w *linuxWebviewWindow) openDevTools() {
openDevTools(w.webview)
}
func (w *linuxWebviewWindow) enableDevTools() {
enableDevTools(w.w<|fim_suffix|>}
<|fim_middle|>ebview)
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go<|fim_suffix|>vTools() {}
<|fim_middle|>:build linux && production && !devtools && !android && !server
package application
func (w *linuxWebviewWindow) openDevTools() {}
func (w *linuxWebviewWindow) enableDe<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|> should be 0, got %d", minH)
}
if maxW <= 0 {
t.Errorf("max width should be positive, got %d", maxW)
}
if maxH <= 0 {
t.Errorf("max height should be positive, got %d", maxH)
}
}
<|fim_prefix|>package application
import "testing"
func <|fim_middle|>TestDisableSizeConstraintsDoesNotUsePositionAsD... | fim | wailsapp/wails | go |
<|fim_suffix|>lows window to overlay fullscreen apps
MacWindowCollectionBehaviorFullScreenAuxiliary MacWindowCollectionBehavior = 1 << 8 // 256
// MacWindowCollectionBehaviorFullScreenNone prevents window from entering fullscreen (macOS 10.7+)
MacWindowCollectionBehaviorFullScreenNone MacWindowCollectionBehavior = 1... | fim | wailsapp/wails | go |
package application
import (
"testing"
)
func TestNewRGBA(t *testing.T) {
rgba := NewRGBA(100, 150, 200, 255)
if rgba.Red != 100 {
t.Errorf("Red = %d, want 100", rgba.Red)
}
if rgba.Green != 150 {
t.Errorf("Green = %d, want 150", rgba.Green)
}
if rgba.Blue != 200 {
t.Errorf("Blue = %d, want 200", rgba.B... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import (
"testing"
)
type mockWindowImpl struct {
minW, minH, maxW, maxH int
}
func (m *mockWindowImpl) setMinSize(width, height int) {
m.minW, m.minH = width, height
}
func (m *mockWindowImpl) setMaxSize(width, height int) {
m.maxW, m.maxH = width, height
}
func TestDisableSi... | fim | wailsapp/wails | go |
<|fim_suffix|>issionKind(CoreWebView2PermissionKindNotifications)
case PermissionClipboardRead:
return edge.CoreWebView2PermissionKind(CoreWebView2PermissionKindClipboardRead)
default:
return edge.CoreWebView2PermissionKind(CoreWebView2PermissionKindUnknownPermission)
}
}
func (w *windowsWebviewWindow) DPI() (w... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:buil<|fim_suffix|>rr != nil {
globalApplication.handleFatalError(err)
}
}
<|fim_middle|>d windows && (!production || devtools)
package application
import "github.com/wailsapp/wails/webview2/pkg/edge"
func (w *windowsWebviewWindow) openDevTools() {
w.chromium.OpenDevToolsWindow()
}
func (w *wi... | fim | wailsapp/wails | go |
<|fim_suffix|>wSettings) {
err := settings.PutAreDevToolsEnabled(false)
if err != nil {
globalApplication.handleFatalError(err)
}
}
<|fim_prefix|>//go:build windows && production && !devtools
package application
import "github.com/wailsapp/wails/webview2/pkg/edge"
func (w *windowsWebviewWindow) openDevTools() {... | fim | wailsapp/wails | go |
<|fim_suffix|>Width, minHeight int) Window
SetRelativePosition(x, y int) Window
SetScreen(screen *Screen) Window
SetResizable(b bool) Window
SetIgnoreMouseEvents(ignore bool) Window
SetSize(width, height int) Window
SetTitle(title string) Window
SetURL(s string) Window
SetZoom(magnification float64) Window
Sho... | fim | wailsapp/wails | go |
//go:build bench
package application
import (
"fmt"
"sync"
"testing"
"github.com/wailsapp/wails/v3/pkg/events"
)
// Note: This file uses internal package access to benchmark window internals
// without requiring GUI initialization.
// BenchmarkWindowEventRegistration measures the cost of registering window eve... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
// WindowManager manages all window-related operations
type WindowManager struct {
app *App
}
// newWindowManager creates a new WindowManager instance
func newWindowManager(app *App) *WindowManager {
return &WindowManager{
app: <|fim_suffix|>t) {
wm.Remove(windowID)
}
// GetAll... | fim | wailsapp/wails | go |
<|fim_prefix|>package application
import "testing"
func TestZoomClamp(t *testing.T) {
tests := []struct {
name string
input float64
expected float64
}{
{"zero clamped to 1.0", 0.0, 1.0},
{"negative clamped to 1.0", -0.5, 1.0},
{"0.5 clamped to 1.0", 0.5, 1.0},
{"0.99 clamped to 1.0", 0.99, 1.0}... | fim | wailsapp/wails | go |
<|fim_prefix|>package doctorng
import (
"path/filepath"
"runtime"
"runtime/debug"
"strings"
"github.com/go-git/go-git/v5"
"github.com/wailsapp/wails/v3/internal/lo"
"github.com/wailsapp/wails/v3/internal/operatingsystem"
"github.com/wailsapp/wails/v3/internal/version"
)
type Doctor struct {
report *Report
}... | fim | wailsapp/wails | go |
<|fim_suffix|>"Apple GPU"
if numCores != "" {
name = numCores + " cores"
}
if metalSupport != "" {
name += ", " + metalSupport
}
return []GPUInfo{{Name: name}}
}
func collectMemory() string {
memory, err := ghw.Memory()
if err == nil && memory != nil {
return strconv.Itoa(int(memory.TotalPhysicalBytes/10... | fim | wailsapp/wails | go |
<|fim_suffix|>.Name
}
func (a *Apt) getPackageVersion(pkg *Package, output string) {
splitOutput := strings.Split(output, " ")
if len(splitOutput) > 1 {
pkg.Version = splitOutput[1]
}
}
<|fim_prefix|>//go:build linux
package packagemanager
import (
"regexp"
"strings"
)
// Apt represents the Apt manager
type ... | fim | wailsapp/wails | go |
<|fim_suffix|>or) {
if pkg.SystemPackage == false {
return false, nil
}
stdout, err := execCmd("dnf", "info", pkg.Name)
// We add a space to ensure we get a full match, not partial match
if err != nil {
_, ok := err.(*exec.ExitError)
if ok {
return false, nil
}
return false, err
}
splitoutput := str... | fim | wailsapp/wails | go |
<|fim_suffix|>en package name is installed
func (e *Emerge) PackageInstalled(pkg *Package) (bool, error) {
if pkg.SystemPackage == false {
return false, nil
}
stdout, err := execCmd("emerge", "-s", pkg.Name+"$")
if err != nil {
_, ok := err.(*exec.ExitError)
if ok {
return false, nil
}
return false, er... | fim | wailsapp/wails | go |
<|fim_suffix|>, err := execCmd("eopkg", "info", pkg.Name)
// We add a space to ensure we get a full match, not partial match
output := e.removeEscapeSequences(stdout)
installed := strings.Contains(output, "Package found in Solus repository")
e.getPackageVersion(pkg, output)
return installed, err
}
// InstallComma... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
package packagemanager
import (
"encoding/json"
)
// Nixpkgs represents the Nixpkgs manager
type Nixpkgs struct {
name string
osid string
}
type NixPackageDetail struct {
Name string
Pname string
Version string
}
var available map[string]NixPackageDetail
// NewNixpkgs cre... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
package packagemanager
import (
"bytes"
"os"
"os/exec"
"sort"
"strings"
)
func execCmd(co<|fim_suffix|> case "nix-env":
return NewNixpkgs(osid)
case "xbps-install":
return NewXbps(osid)
}
return nil
}
func Dependencies(p PackageManager) (DependencyList, error) {
var depen... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
package packagemanager
import (
"os/exec"
"regexp"
"strings"
)
// Pacman represents the Pacman package manager
type Pacman struct {
name string
osid string
}
// NewPacman creates a new Pacman instance
func NewPacman(osid string) *Pacman {
return &Pacman{
name: "pacman",
osid... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
package packagemanager
type Package struct {
Name string
Version string
InstallCommand string
InstallCheck func() bool
SystemPackage bool
Library bool
Optional bool
}
type Packagemap = map[string][]*Package
type PackageManager interface {
Name(... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
package packagemanager
import (
"strings"
)
// Xbps represents the Xbps manager
type Xbps struct {
name string
osid string
}
// NewXbps creates a new Xbps instance
func NewXbps(osid string) *Xbps {
return &Xbps{
name: "xbps",
osid: osid,
}
}
// Packages returns the libraries... | fim | wailsapp/wails | go |
<|fim_suffix|>!= nil {
return pkg.InstallCheck(), nil
}
return false, nil
}
stdout, err := execCmd("zypper", "info", pkg.Name)
if err != nil {
_, ok := err.(*exec.ExitError)
if ok {
return false, nil
}
return false, err
}
reg := regexp.MustCompile(`.*Installed\s*:\s*(Yes)\s*`)
matches := reg.Fin... | fim | wailsapp/wails | go |
//go:build darwin && !ios
package doctorng
import (
"bytes"
"os/exec"
"strings"
"syscall"
"github.com/wailsapp/wails/v3/internal/lo"
)
type macPackageManager int
const (
macPMNone macPackageManager = iota
macPMBrew
macPMMacPorts
macPMNix
)
var detectedMacPM macPackageManager
var macPMDetected bool
func ... | fim | wailsapp/wails | go |
<|fim_suffix|>error {
return nil
}
func (d *Doctor) runDiagnostics() {
}
<|fim_prefix|>//go:build ios
package doctorng
// The doctor runs on development machines, not on iOS devices. These stubs
// exist so the package (and anything importing it) still compiles under
// GOOS=ios.
func collectPlat<|fim_middle|>form... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
package doctorng
import (
"os"
"strings"
"github.com/wailsapp/wails/v3/internal/operatingsystem"
"github.com/wailsapp/wails/v3/pkg/doctor-ng/packagemanager"
)
func collectPlatformExtras() map[string]string {
extras := make(map[string]string)
extras["XDG_SESSION_TYPE"] = getEnvO... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package doctorng
import (
"os/exec"
"strings"
"github.com/wailsapp/wails/v3/internal/lo"
"github.com/wailsapp/wails/webview2/webviewloader"
)
type windowsPackageManager int
const (
pmNone windowsPackageManager = iota
pmWinget
pmChoco
pmScoop
)
var detectedPM windowsPackage... | fim | wailsapp/wails | go |
<|fim_suffix|>w[0]) > maxKeyLen {
maxKeyLen = len(row[0])
}
}
for _, row := range rows {
key := tableCellStyle.Render(fmt.Sprintf("%-*s", maxKeyLen, row[0]))
val := row[1]
b.WriteString(fmt.Sprintf(" %s %s\n", mutedStyle.Render(key), val))
}
return b.String()
}
func createInstallCmd(deps doctorng.De... | fim | wailsapp/wails | go |
<|fim_suffix|>.Stdout, m.View())
return nil
}
<|fim_prefix|>package tui
import (
"fmt"
"os"
tea "github.com/charmbracelet/bubbletea"
)
<|fim_middle|>func Run() error {
p := tea.NewProgram(NewModel(), tea.WithAltScreen())
if _, err := p.Run(); err != nil {
return fmt.Errorf("error running TUI: %w", err)
}
r... | fim | wailsapp/wails | go |
<|fim_prefix|>package tui
import "github.com/charmbracelet/lipgloss"
var (
primaryColor = lipgloss.Color("#7C3AED")
successColor = lipgloss.Color("#10B981")
warningColor = lipgloss.Color("#F59E0B")
errorColor = lipgloss.Color("#EF4444")
mut<|fim_suffix|>itleStyle = lipgloss.NewStyle().
Bold(true... | fim | wailsapp/wails | go |
<|fim_prefix|>// Package doctorng provides system diagnostics and dependency checking for Wails.
// It exposes a public API suitable for both CLI and GUI consumption.
package doctorng
import (
"encoding/json"
"time"
)
// Status represents the health status of a check
type Status int
const (
StatusUnknown Status =... | fim | wailsapp/wails | go |
<|fim_prefix|>package main
import (
"go/ast"
"go/parser"
"go/token"
"os"
"text/template"
)
const tmpl = `package errs
import (
"fmt"
)
type wailsError struct {
cause error
msg string
errorType E<|fim_suffix|>rorType: {{ . }},
}
}
func Is{{ . }}(err error) bool {
return ... | fim | wailsapp/wails | go |
<|fim_suffix|>:= fmt.Sprintf(message, args...)
return &wailsError{
cause: err,
msg: msg,
errorType: InvalidBindingCallError,
}
}
func IsInvalidBindingCallError(err error) bool {
return Is(err, InvalidBindingCallError)
}
func HasInvalidBindingCallError(err error) bool {
return Has... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:generate go run codegen/error_functions/main.go
package errs
type ErrorType string
type WailsError interface {
Cause() error
Error() string
Msg() string
ErrorType() ErrorType
}
const (
InvalidWindowCallError ErrorType = "Invalid window call"
InvalidApplicationCallError ErrorType = "Inva... | fim | wailsapp/wails | go |
<|fim_suffix|>return true
}
cause := Cause(err)
if errors.Is(cause, err) || cause == nil {
break
}
err = cause
}
return false
}
<|fim_prefix|>//go:generate go run codegen/error_functions/main.go
package errs
import (
"errors"
)
func Is(err error, errorType ErrorType) bool {
if err == nil {
return... | fim | wailsapp/wails | go |
package events
import "runtime"
var defaultWindowEventMapping = map[string]map[WindowEventType]WindowEventType{
"windows": {
Windows.WindowClosing: Common.WindowClosing,
Windows.WindowInactive: Common.WindowLostFocus,
Windows.WindowClickActive: Common.WindowFocus,
Windows.WindowActive: Common... | fim | wailsapp/wails | go |
<|fim_suffix|>wDidChangeBackingProperties: 1123,
WindowDidChangeCollectionBehavior: 1124,
WindowDidChangeEffectiveAppearance: 1125,
WindowDidChangeOcclusionState: 1126,
WindowDidChangeOrderingMode: ... | fim | wailsapp/wails | go |
<|fim_suffix|>98
#define EventWindowWillEnterFullScreen 1099
#define EventWindowWillEnterVersionBrowser 1100
#define EventWindowWillExitFullScreen 1101
#define EventWindowWillExitVersionBrowser 1102
#define EventWindowWillFocus 1103
#define EventWindowWillMiniaturize 1104
#define EventWindowWillMove 1105
#define EventW... | fim | wailsapp/wails | c |
<|fim_suffix|>gned int event) {
//return hasListener[event];
return true;
}
*/
import "C"
<|fim_prefix|>//go:build darwin && !ios
package events
/*
#cgo CFLAGS: -x objective-c
#cgo LDFLAGS: -framework Cocoa -mmacosx-version-min=10.13
#include "events_darwin.h"
#include <stdlib.h>
#include <stdbool.h>
bool hasLi... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin
#ifndef _events_h
#define _events_h
extern void processApplicationEvent(unsigned int, void* data);
extern void processWindowEvent(unsigned int, unsigned int);
#define EventApplicationDidBecomeActive 1065
#define EventApplicationDidChangeBackingProperties 1066
#define EventApplicationD... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build ios
#ifndef _events_h
#define _events_h
extern void processApplicationEvent(unsigned int, void* data);
extern void processWindowEvent(unsigned int, unsigned int);
#define EventApplicationDidBecomeActive 1245
#define EventApplicationDidEnterBackground 1246
#define EventApplicationDidFinishLau... | fim | wailsapp/wails | c |
<|fim_prefix|>//go:build linux && !android
package events
/*
#include "events_linux.h"
#include <stdlib.h>
#include<|fim_suffix|>ned int event) {
//return hasListener[event];
return true;
}
*/
import "C"
<|fim_middle|> <stdbool.h>
bool hasListener[MAX_EVENTS] = {false};
void registerListener(unsigned int event) ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
#ifndef _events_h
#define _events_h
extern void processApplicationEvent(unsigned int, void* data);
extern void processWindowEvent(unsigned int, unsigned int);
#define EventApplicationStartup 1052
#define EventSystemDidW<|fim_suffix|>fine EventWindowLoadFinished 1064
#define MAX_EVENTS... | fim | wailsapp/wails | c |
<|fim_suffix|>"ios:WindowTouchEnded": {},
"ios:WindowTouchCancelled": {},
"ios:WebViewDidStartNavigation": {},
"ios:WebViewDidFinishNavigation": {},
"ios:WebViewDidFailNavigation": ... | fim | wailsapp/wails | go |
<|fim_suffix|>sparent.png
var WailsLogoWhiteTransparent []byte
<|fim_prefix|>package icons
import _ "embed"
//go:embed DefaultMacTemplateIcon.png
var SystrayMacTemplate []byte
//go:embed systray-light.png
var SystrayLight []byte
//go:embed icon.ico
var DefaultWindowsIcon []byte
//go:embed systray-dark.png
var Syst... | fim | wailsapp/wails | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.