text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
package goversion
const MinRequirement string = "1.20"
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>package logger
import (
"fmt"
)
// CustomLogger defines what a user can do with a logger
type CustomLogger interface {
// Writeln writes directly to the output with no log level plus line ending
Writeln(message string)
// Write writes directly to the output with no log level
Write(message string)
... | fim | wailsapp/wails | go |
<|fim_suffix|>rites directly to the output with no log level
// Appends a carriage return to the message
func (l *Logger) Writeln(message string) {
l.output.Print(message)
}
// Write writes directly to the output with no log level
func (l *Logger) Write(message string) {
l.output.Print(message)
}
// Print writes di... | fim | wailsapp/wails | go |
<|fim_suffix|>oGroups(m.processedApplicationMenu, m.applicationMenuItemMap)
applicationMenuJSON, err := m.processedApplicationMenu.AsJSON()
if err != nil {
return err
}
m.applicationMenuJSON = applicationMenuJSON
return nil
}
<|fim_prefix|>package menumanager
import "github.com/wailsapp/wails/v2/pkg/menu"
func... | fim | wailsapp/wails | go |
<|fim_prefix|>package menumanager
import (
"encoding/json"
"fmt"
"github.com/wailsapp/wails/v2/pkg/menu"
)
type ContextMenu struct {
ID string
ProcessedMenu *WailsMenu
menuItemMap *MenuItemMap
menu *menu.Menu
}
func (t *ContextMenu) AsJSON() (string, error) {
data, err := json.Marshal(... | fim | wailsapp/wails | go |
<|fim_prefix|>package menumanager
import (
"fmt"
"strconv"
"sync"
"github.com/wailsapp/wails/v2/pkg/menu"
)
// MenuItemMap holds a mapping between menuIDs and menu items
type MenuItemMap struct {
idToMenuItemMap map[string]*menu.MenuItem
menuItemToIDMap map[*menu.MenuItem]string
// We use a simple counter to... | fim | wailsapp/wails | go |
<|fim_suffix|>oGroupMenuItems, item)
}
for _, radioGroupMenuItem := range radioGroupMenuItems {
m.radioGroups[radioGroupMenuItem] = radioGroupMenuItems
}
}
}
<|fim_prefix|>package menumanager
import (
"fmt"
"github.com/wailsapp/wails/v2/pkg/menu"
)
type Manager struct {
// The application menu.
applica... | fim | wailsapp/wails | go |
<|fim_prefix|>package menumanager
import (
"encoding/json"
"github.com/wailsapp/wails/v2/pkg/m<|fim_suffix|>eys"
)
type ProcessedMenuItem struct {
ID string
// Label is what appears as the menu text
Label string `json:",omitempty"`
// Role is a predefined menu type
// Role menu.Role `json:",omitempty"`
// Ac... | fim | wailsapp/wails | go |
<|fim_prefix|>package menumanager
import (
"encoding/json"
"fmt"
"strconv<|fim_suffix|>/wails/v2/pkg/menu"
)
var (
trayMenuID int
trayMenuIDMutex sync.Mutex
)
func generateTrayID() string {
var idStr string
trayMenuIDMutex.Lock()
idStr = strconv.Itoa(trayMenuID)
trayMenuID++
trayMenuIDMutex.Unlock()
... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package menu
import (
"github.com/wailsapp/wails/v2/pkg/menu"
)
// MenuManager manages the menus for the application
var MenuManager = NewManager()
type radioGroup []*menu.MenuItem
// Click updates the radio group state based on the item clicked
func (g *radioGroup) Click(item *me... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package menu_test
import (
"github.com/stretchr/testify/require"
platformMenu "github.com/wailsapp/wails/v2/internal/platform/menu"
"github.com/wailsapp/wails/v2/pkg/menu"
"testing"
)
func TestManager_ProcessClick_Checkbox(t *testing.T) {
checkbox := menu.Label("Checkbox").SetC... | fim | wailsapp/wails | go |
<|fim_suffix|>ails/v2/internal/platform/win32"
type Menu struct {
menu win32.HMENU
}
<|fim_prefix|>//go:build<|fim_middle|> windows
package menu
import "github.com/wailsapp/w<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package win32
import (
"fmt"
"syscall"
"unsafe"
"github.com/wailsapp/wails/v2/internal/system/operatingsystem"
"golang.org/x/sys/windows"
)
var (
modKernel32 = syscall.NewLazyDLL("kernel32.dll")
procGetModuleHandle = modKernel32.NewProc("GetModuleHandleW")
moduser32... | fim | wailsapp/wails | go |
//go:build windows
package win32
import "unsafe"
func GetCursorPos() (x, y int, ok bool) {
pt := POINT{}
ret, _, _ := procGetCursorPos.Call(uintptr(unsafe.Pointer(&pt)))
return int(pt.X), int(pt.Y), ret != 0
}
<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>Data)),
true,
0x00030000,
0,
0,
LR_DEFAULTSIZE)
return HICON(icon), err
}
<|fim_prefix|>//go:build windows
package win32
import (
"unsafe"
)
func CreateIconFromResourceEx(presbits uintptr, dwResSize uint32, isIcon bool, version uint32, cxDesired int, cyDesired int, flags uint) (uintptr, err... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
/*
* Copyright (C) 2019 The Winc Authors. All Rights Reserved.
* Copyright (C) 2010-2013 Allen Dang. All Rights Reserved.
*/
package win32
import (
"bytes"
"github.com/wailsapp/wails/v2/pkg/menu/keys"
"strings"
"unsafe"
)
type Key uint16
func (k Key) String() string {
retur... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package win32
type Menu HMENU
type PopupMenu Menu
func CreatePopupMenu() PopupMenu {
ret, _, _ := procCreatePopupMenu.Call(0, 0, 0, 0)
return PopupMenu(ret)
}
func (m Menu) Destroy() bool {
ret, _, _ := procDestroyMenu.Call(uintptr(m))
return ret != 0
}
func (p PopupMenu) Destr... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
<|fim_suffix|>ssage uint32
HIcon HICON
SzTip [128]uint16
DwState uint32
DwStateMask uint32
SzInfo [256]uint16
UVersion uint32
SzInfoTitle [64]uint16
DwInfoFlags uint32
GuidItem windows.GUID
HBalloonIcon ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package win32
import (<|fim_suffix|>ype ACCENT_STATE DWORD
const (
ACCENT_DISABLED ACCENT_STATE = 0
ACCENT_ENABLE_GRADIENT ACCENT_STATE = 1
ACCENT_ENABLE_TRANSPARENTGRADIENT ACCENT_STATE = 2
ACCENT_ENABLE_BLURBEHIND ACCENT_STATE = 3
ACCENT_E... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package win32
import (
"fmt"
"github.com/samber/lo"
"golang.org/x/sys/windows"
"syscall"
"unsafe"
)
func LoadIconWithResourceID(instance HINSTANCE, res uintptr) HICON {
ret, _, _ := procLoadIcon.Call(
uintptr(instance),
res)
return HICON(ret)
}
func LoadCursorWithResourc... | fim | wailsapp/wails | go |
<|fim_suffix|>d to exit properly
<-p.exitChannel
return err
}
// PID returns the process PID
func (p *Process) PID() int {
return p.cmd.Process.Pid
}
func (p *Process) SetDir(dir string) {
p.cmd.Dir = dir
}
<|fim_prefix|>package process
import (
"os"
"os/exec"
)
// Process defines a process that can be execu... | fim | wailsapp/wails | go |
<|fim_prefix|>package project
import (
"encoding/json"
"os"
"path/filepath"
"runtime"
"strings"
"github.com/samber/lo"
)
// Project holds the data related to a Wails project
type Project struct {
/*** Application Data ***/
Name string `json:"name"`
AssetDirectory string `json:"assetdir,omitempty"`... | fim | wailsapp/wails | go |
<|fim_suffix|>want %v", got, tt.want)
}
})
}
}
<|fim_prefix|>package project_test
import (
"os"
"path/filepath"
"runtime"
"testing"
"github.com/samber/lo"
"github.com/wailsapp/wails/v2/internal/project"
)
func TestProject_GetFrontendDir(t *testing.T) {
cwd := lo.Must(os.Getwd())
tests := []struct {
n... | fim | wailsapp/wails | go |
<|fim_suffix|>unc REPLACEALL(filename string, substitutions Sub) {
log("REPLACEALL %s (%v)", filename, substitutions)
data := LOADSTRING(filename)
for old, newText := range substitutions {
data = strings.ReplaceAll(data, old, newText)
}
SAVESTRING(filename, data)
}
<|fim_prefix|>package s
import (
"crypto/md5"... | fim | wailsapp/wails | go |
<|fim_prefix|>package shell
import (
"fmt"
"strings"
)
func UpsertEnv(env []string, key string, update func(v string) st<|fim_suffix|>!found {
newEnv = append(newEnv, fmt.Sprintf("%s=%v", key, update("")))
}
return newEnv
}
func RemoveEnv(env []string, key string) []string {
newEnv := make([]string, 0, len(en... | fim | wailsapp/wails | go |
package shell
import "testing"
func TestUpdateEnv(t *testing.T) {
env := []string{"one=1", "two=a=b", "three="}
newEnv := UpsertEnv(env, "two", func(v string) string {
return v + "+added"
})
newEnv = UpsertEnv(newEnv, "newVar", func(v string) string {
return "added"
})
newEnv = UpsertEnv(newEnv, "three", f... | fim | wailsapp/wails | go |
<|fim_prefix|>package shell
import (
"bytes"
"os"
"os/exec"
)
type Command struct {
command string
args []string
env []string
dir string
stdo, stde bytes.Buffer
}
func NewCommand(command string) *Command {
return &Command{
command: command,
env: os.Environ(),
}
}
func (c *Co... | fim | wailsapp/wails | go |
<|fim_prefix|>package signal
import (
"os"
gosignal "os/signal"
"sync"
"syscall"
)
var signalChannel = make(chan os.Signal, 2)
var (
callbacks []func()
lock sync.Mutex
)
func OnShutdown(callback func()) {
lock.L<|fim_suffix|>ted. Shutting down...")
for _, callback := range callbacks {
callback()
... | fim | wailsapp/wails | go |
<|fim_suffix|> EmbedPath: strings.TrimPrefix(embedPath, "all:"),
All: true,
BaseDir: baseDir,
})
} else {
result = append(result, &EmbedDetails{
EmbedPath: embedPath,
All: false,
BaseDir: baseDir,
})
}
}
}
}
}
return result
}
... | fim | wailsapp/wails | go |
<|fim_suffix|>Equal(t, len(tt.want), len(got))
for index, g := range got {
require.Equal(t, tt.want[index].EmbedPath, g.EmbedPath)
require.Equal(t, tt.want[index].All, g.All)
}
})
}
}
<|fim_prefix|>package staticanalysis
import (
"testing"
"gi<|fim_middle|>thub.com/stretchr/testify/require"
)
func... | fim | wailsapp/wails | go |
<|fim_suffix|>he app starts. The context is saved
// so we can call the runtime methods
func (a *App) startup(ctx context.Context) {
a.ctx = ctx
}
// Greet returns a greeting for the given name
func (a *App) Greet(name string) string {
return fmt.Sprintf("Hello %s, It's show time!", name)
}
<|fim_prefix|>package mai... | fim | wailsapp/wails | go |
<|fim_suffix|> []interface{}{
app,
},
})
if err != nil {
println("Error:", err.Error())
}
}
<|fim_prefix|>package main
import (
"embed"
"github.com/wailsapp/wails/v2"
"github.com/wailsapp/wails/v2/pkg/options"
"github.com/wailsapp/wails/v2/pkg/options/assetserver"
)
//go:embed all:frontend/dist fronte... | fim | wailsapp/wails | go |
<|fim_prefix|>package operatingsystem
// OS contains information ab<|fim_suffix|>ion string
Branding string
}
// Info retrieves information about the current platform
func Info() (*OS, error) {
return platformInfo()
}
<|fim_middle|>out the operating system
type OS struct {
ID string
Name string
Vers<|... | fim | wailsapp/wails | go |
package operatingsystem
import (
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
)
func getSysctlValue(key string) (string, error) {
stdout, _, err := shell.RunCommand(".", "sysctl", key)
if err != nil {
return "", err
}
version := strings.TrimPrefix(stdout, key+": ")
return strings.TrimSpace(versio... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
// +build linux
package operatingsystem
import (
"fmt"
"os"
"strings"
)
// platformInfo is the platform specific method to get system information
func platformInfo() (*OS, error) {
_, err := os.Stat("/etc/os-release")
if os.IsNotExist(err) {
return nil, fmt.Errorf("unable to rea... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
package operatingsystem
import (
"fmt"
"strings"
"syscall"
"unsafe"
"golang.org/x/sys/windows"
"golang.org/x/sys/windows/registry"
)
func stripNulls(str string) string {
// Split the string into substrings at each null character
substrings := strings.Split(str, "\x00")
// ... | fim | wailsapp/wails | go |
<|fim_suffix|>urn -1
}
return int(result)
}
func regStringKeyAsInt(key registry.Key, name string) int {
resultStr, _, err := key.GetStringValue(name)
if err != nil {
return -1
}
result, err := strconv.Atoi(resultStr)
if err != nil {
return -1
}
return result
}
func regKeyAsString(key registry.Key, name s... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
// +build linux
package packagemanager
import (
"bytes"
"os"
"os/exec"
"regexp"
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
)
// Apt represents the Apt manager
type Apt struct {
name string
osid string
}
// NewApt creates a new Apt instance
func NewApt(osid string... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
// +build linux
package packagemanager
import (
"os/exec"
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
)
// Dnf represents the Dnf manager
type Dnf struct {
name string
osid string
}
// NewDnf creates a new Dnf instance
func NewDnf(osid string) *Dnf {
return &Dnf{
... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
// +build linux
package packagemanager
import (
"os/exec"
"regexp"
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
)
// Emerge represents the Emerge package manager
type Emerge struct {
name string
osid string
}
// NewEmerge creates a new Emerge instance
func NewEmerge(... | fim | wailsapp/wails | go |
<|fim_suffix|>kage found in Solus repository")
e.getPackageVersion(pkg, output)
return installed, err
}
// InstallCommand returns the package manager specific command to install a package
func (e *Eopkg) InstallCommand(pkg *Package) string {
if pkg.SystemPackage == false {
return pkg.InstallCommand[e.osid]
}
re... | fim | wailsapp/wails | go |
<|fim_suffix|>f err != nil {
return false, err
}
// Grab first version.
for attribute, detail := range attributes {
pkg.Version = detail.Version
available[attribute] = detail
break
}
return len(pkg.Version) > 0, nil
}
// InstallCommand returns the package manager specific command to install a package
fu... | fim | wailsapp/wails | go |
//go:build linux
// +build linux
package packagemanager
import (
"sort"
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
)
// A list of package manager commands
var pmcommands = []string{
"eopkg",
"apt",
"dnf",
"pacman",
"emerge",
"zypper",
"nix-env",
"xbps-install",
}
// Find will attempt to fin... | fim | wailsapp/wails | go |
<|fim_suffix|>ure we get a full match, not partial match
if err != nil {
_, ok := err.(*exec.ExitError)
if ok {
return false, nil
}
return false, err
}
reg := regexp.MustCompile(`.*Version.*?:\s+(.*)`)
matches := reg.FindStringSubmatch(output)
pkg.Version = ""
noOfMatches := len(matches)
if noOfMatch... | fim | wailsapp/wails | go |
<|fim_prefix|>package packagemanager
// Package contains information about a system package
type Package struct {
Name string
Version string
InstallCommand map[string]string
SystemPackage bool
Library bool
Optional bool
}
type packagemap = map[string][]*Package
// PackageManager ... | fim | wailsapp/wails | go |
<|fim_suffix|>mmand[x.osid]
}
return "sudo xbps-install -S " + pkg.Name
}
func (x *Xbps) getPackageVersion(pkg *Package, output string) {
// xbps-query output: "pkgname-version_revision" or inline in -Rs output
for _, line := range strings.Split(output, "\n") {
if strings.Contains(line, pkg.Name) {
fields := ... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
// +build linux
package packagemanager
import (
"os/exec"
"regexp"
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
)
// Zypper represents the Zypper package manager
type Zypper struct {
name string
osid string
}
// NewZypper creates a new Zypper instance
func NewZypper(... | fim | wailsapp/wails | go |
<|fim_prefix|>package system
import (
"os/exec"
"strings"
"github.com/wailsapp/wails/v2/internal/shell"
"github.com/wailsapp/wails/v2/internal/system/operatingsystem"
"github.com/wailsapp/wail<|fim_suffix|> version = strings.TrimSpace(strings.Split(string(output), "\n")[0])
}
return &packagemanager.Dependency... | fim | wailsapp/wails | go |
//go:build darwin
// +build darwin
package system
import (
"fmt"
"os/exec"
"strings"
"syscall"
"github.com/wailsapp/wails/v2/internal/system/operatingsystem"
"github.com/wailsapp/wails/v2/internal/system/packagemanager"
)
// Determine if the app is running on Apple Silicon
// Credit: https://www.yellowduck.be... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux
// +build linux
package system
import (
"github.com/wailsapp/wails/v2/internal/system/operatingsystem"
"github.com/wailsapp/wails/v2/internal/system/packagemanager"
)
func checkGCC() *packagemanager.Dependency {
version := packagemanager.AppVersion("gcc")
return &packagemanager.D... | fim | wailsapp/wails | go |
<|fim_suffix|>w2() *packagemanager.Dependency {
version, _ := webviewloader.GetAvailableCoreWebView2BrowserVersionString("")
installed := version != ""
return &packagemanager.Dependency{
Name: "WebView2 ",
PackageName: "N/A",
Installed: installed,
InstallCommand: "Available at https://deve... | fim | wailsapp/wails | go |
<|fim_suffix|>",
"private",
"protected",
"public",
"return",
"short",
"static",
"super",
"switch",
"synchronized",
"this",
"throw",
"throws",
"transient",
"true",
"try",
"typeof",
"var",
"void",
"volatile",
"while",
"with",
"yield",
"object",
}
<|fim_prefix|>package typescriptify
var jsReservedK... | fim | wailsapp/wails | go |
<|fim_prefix|>package typescriptify
import (
"bufio"
"cmp"
"fmt"
"io"
"log"
"os"
"path"
"reflect"
"regexp"
"slices"
"strings"
"time"
"github.com/leaanthony/slicer"
"github.com/tkrajina/go-reflector/reflector"
)
const (
tsTransformTag = "ts_transform"
tsType = "ts_type"
tsConvertVa... | fim | wailsapp/wails | go |
<|fim_suffix|>ile(targetFile string) error {
return os.WriteFile(targetFile, setupexe, 0o755)
}
// WriteInstaller writes the installer exe file to the given directory and returns the path to it.
func WriteInstaller(targetPath string) (string, error) {
installer := filepath.Join(targetPath, `MicrosoftEdgeWebview2Setu... | fim | wailsapp/wails | go |
<|fim_suffix|>and("rundll32", "url.dll,FileProtocolHandler", "https://developer.microsoft.com/en-us/microsoft-edge/webview2/")
return cmd.Run()
}
<|fim_prefix|>//go:build windows
// +build windows
package webview2runtime
import (
_ "embed"
"io"
"net/http"
"os"
"os/exec"
"path/filepath"
"syscall"
"unsafe"
)
... | fim | wailsapp/wails | go |
//go:build windows && wv2runtime.browser
// +build windows,wv2runtime.browser
package wv2installer
import (
"fmt"
"github.com/wailsapp/wails/v2/internal/webview2runtime"
"github.com/wailsapp/wails/v2/pkg/options/windows"
)
func doInstallationStrategy(installStatus installationStatus, messages *windows.Messages) e... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:<|fim_suffix|>edsUpdating {
message = messages.UpdateRequired
}
confirmed, err := webview2runtime.Confirm(message, messages.MissingRequirements)
if err != nil {
return err
}
if !confirmed {
return errors.New(messages.Webview2NotInstalled)
}
installedCorrectly, err := webview2runtime.Inst... | fim | wailsapp/wails | go |
<|fim_suffix|>b.com/wailsapp/wails/v2/pkg/options/windows"
)
func doInstallationStrategy(installStatus installationStatus, messages *windows.Messages) error {
message := messages.InstallationRequired
if installStatus == needsUpdating {
message = messages.UpdateRequired
}
message += messages.PressOKToInstall
con... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build w<|fim_suffix|>llStatus installationStatus, messages *windows.Messages) error {
_ = webview2runtime.Error(messages.ContactAdmin, messages.Error)
return fmt.Errorf(messages.Webview2NotInstalled)
}
<|fim_middle|>indows && wv2runtime.error
// +build windows,wv2runtime.error
package wv2installer... | fim | wailsapp/wails | go |
//go:build windows
package wv2installer
import (
"errors"
"github.com/wailsapp/go-webview2/webviewloader"
"github.com/wailsapp/wails/v2/pkg/options"
"github.com/wailsapp/wails/v2/pkg/options/windows"
)
const MinimumRuntimeVersion string = "94.0.992.31" // WebView2 SDK 1.0.992.28
type installationStatus int
co... | fim | wailsapp/wails | go |
<|fim_suffix|>re Run, or after Run returns early (e.g. CreateApp failed).
// Without the nil guard, Quit() in those situations dereferences an unset
// a.application and crashes (#5452).
func (a *Application) Quit() {
a.shutdown.Do(func() {
if a.application != nil {
a.application.Shutdown()
}
})
}
// Bind the... | fim | wailsapp/wails | go |
<|fim_suffix|>hutDown
DomReady
)
<|fim_prefix|>package application
type EventType int
const (
StartUp EventType = i<|fim_middle|>ota
S<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build !windows
// +bui<|fim_suffix|>
return nil
}
<|fim_middle|>ld !windows
package application
func applicationInit() error {<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>re").Call()
if status == 0 {
return fmt.Errorf("exit status %d: %v %v", status, r, err)
}
return nil
}
<|fim_prefix|>//go:build windows
package application
import (
"fmt"
"syscall"
)
func applicationInit() error {
status, r, err := syscall.NewLazyDLL("user32.dll").NewProc("<|fim_middle|>SetProc... | fim | wailsapp/wails | go |
<|fim_suffix|> != nil {
return err
}
} else if isDirectoryPath {
return fmt.Errorf("a file has been requested with a trailing slash, please remove the trailing slash from your request")
}
var buf [512]byte
var n int
if _, haveType := rw.Header()[HeaderContentType]; !haveType {
// Detect MimeType by sniff... | fim | wailsapp/wails | go |
<|fim_suffix|>, req)
return
}
if baseHandler != nil {
baseHandler.ServeHTTP(rw, req)
return
}
rw.WriteHeader(http.StatusMethodNotAllowed)
})
if middleware := options.Middleware; middleware != nil {
result = middleware(result)
}
return result
}
<|fim_prefix|>package assetserver
import... | fim | wailsapp/wails | go |
<|fim_suffix|>ntimeJSPath); err != nil {
return nil, err
}
if err := insertScriptInHead(htmlNode, ipcJSPath); err != nil {
return nil, err
}
// Inject plugins
for scriptName := range d.pluginScripts {
if err := insertScriptInHead(htmlNode, scriptName); err != nil {
return nil, err
}
}
var buffer by... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build dev
// +build dev
package assetserver
import (
"net/http"
"strings"
)
/*
T<|fim_suffix|>eturn nil, err
}
result.appendSpinnerToBody = true
result.ipcJS = func(req *http.Request) []byte {
if strings.Contains(req.UserAgent(), WailsUserAgentValue) {
return runtime.DesktopIPC()
}
... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"fmt"
"net/http"
"net/url"
"strconv"
"strings"
"sync"
"github.com/wailsapp/wails/v2/pkg/assetserver/webview"
)
type assetServerWebView struct {
// ExpectedWebViewHost is checked against the Request Host of every WebViewRequest, other hosts won't be processed.
Expec... | fim | wailsapp/wails | go |
<|fim_suffix|>n rw.code
}
func (rw *bodyRecorder) Body() *bytes.Buffer {
return rw.body
}
func (rw *bodyRecorder) writeHeader(buf []byte, code int) {
if rw.wroteHeader {
return
}
if rw.doRecord != nil {
header := rw.Header()
if len(buf) != 0 {
if _, hasType := header[HeaderContentType]; !hasType {
h... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"bytes"
"errors"
"io"
"net/http"
"strconv"
"strings"
"github.com/wailsapp/wails/v2/pkg/options"
"github.com/wailsapp/wails/v2/pkg/options/assetserver"
"golang.org/x/net/html"
)
func BuildAssetServerConfig(appOptions *options.App) (assetserver.Options, error) {
var... | fim | wailsapp/wails | go |
<|fim_suffix|>tp.DetectContentType(b))
}
rw.WriteHeader(http.StatusOK)
}
<|fim_prefix|>package assetserver
import (
"net/http"
)
type contentTypeSniffer struct {
rw http.ResponseWriter
wroteHeader bool
}
func (rw *contentTypeSniffer) Header() http.Header {
return rw.rw.Header()
}
func (rw *contentTypeSniffe... | fim | wailsapp/wails | go |
<|fim_suffix|>file)
if stat != nil {
return ".", nil
}
var indexFiles []string
err := fs.WalkDir(fsys, ".", func(path string, d fs.DirEntry, err error) error {
if err != nil {
return err
}
if strings.HasSuffix(path, file) {
indexFiles = append(indexFiles, path)
}
return nil
})
if err != nil {
... | fim | wailsapp/wails | go |
<|fim_suffix|>application/wasm",
".webp": "image/webp",
".xml": "text/xml; charset=utf-8",
}
)
func GetMimetype(filename string, data []byte) string {
mimeMutex.Lock()
defer mimeMutex.Unlock()
result := mimeTypesByExt[filepath.Ext(filename)]
if result != "" {
return result
}
result = mimeCache[filename... | fim | wailsapp/wails | go |
<|fim_prefix|>package assetserver
import (
"testing"
)
func TestGetMimetype(t *testing.T) {
type args struct {
filename string
data []byte
}
bomUTF8 := []byte{0xef, 0xbb, 0xbf}
var emptyMsg []byte
css := []byte("body{margin:0;padding:0;background-color:#d579b2}#app{font-family:Avenir,Helvetica,Arial,san... | fim | wailsapp/wails | go |
<|fim_suffix|>ruct {
nodes []T
head int
tail int
cnt int
minSize int
}
func newRingqueue[T any](minSize uint) *ringqueue[T] {
if minSize < 2 {
minSize = 2
}
return &ringqueue[T]{
nodes: make([]T, minSize),
minSize: int(minSize),
}
}
func (q *ringqueue[T]) resize(n int) {
nodes := make([]T, n)
... | fim | wailsapp/wails | go |
<|fim_suffix|>et()
document.getElementById("result").innerText = result;
});
};
});<|fim_prefix|>import {ready} from '@wails/runtime';
ready(() => {
// Get input + focus
let nameElement = document.getElementById("name");
nameElement.focus();
// Setup the greet function
wind... | fim | wailsapp/wails | javascript |
<|fim_prefix|>import {ready} from '@wails/runtime';
ready(() => {
// Get input + f<|fim_suffix|>ion
window.greet = function () {
// Get name
let name = nameElement.value;
// Call App.Greet(name)
window.backend.main.App.Greet(name).then((result) => {
// Update resul... | fim | wailsapp/wails | javascript |
<|fim_suffix|>css main.js
var TopLevelFS embed.FS
<|fim_prefix|>package testdata
import "embed"
//go:embed index.h<|fim_middle|>tml main.<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>package webview
impor<|fim_suffix|>hod() (string, error)
Header() (http.Header, error)
Body() (io.ReadCloser, error)
Response() ResponseWriter
Close() error
}
<|fim_middle|>t (
"io"
"net/http"
)
type Request interface {
URL() (string, error)
Met<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|>
if body != nil && bodyLen > 0 {
r.body = io.NopCloser(bytes.NewReader(C.GoBytes(body, bodyLen)))
} else {
r.body = http.NoBody
}
} else if C.URLSchemeTaskRequestBodyStreamOpen(r.task) {
r.body = &requestBodyStreamReader{task: r.task}
}
return r.body, nil
}
func (r *request) Response() ... | fim | wailsapp/wails | go |
<|fim_suffix|>
} else {
return r.Request.Close()
}
}
return nil
}
<|fim_prefix|>package webview
import (
"runtime"
"sync/atomic"
)
var _ Request = &requestFinalizer{}
type requestFinalizer struct {
Request
closed int32
}
// newRequestFinalizer returns a request with a runtime finalizer to make sure it ... | fim | wailsapp/wails | go |
<|fim_suffix|>req}
return r.rw
}
func (r *request) Close() error {
var err error
if r.body != nil {
err = r.body.Close()
}
r.Response().Finish()
C.g_object_unref(C.gpointer(r.req))
return err
}
<|fim_prefix|>//go:build linux
// +build linux
package webview
/*
#cgo linux pkg-config: gtk+-3.0 gio-unix-2.0
#cg... | fim | wailsapp/wails | go |
<|fim_suffix|>body.Close(); err != nil {
errs = append(errs, err)
}
r.body = nil
}
if err := r.Response().Finish(); err != nil {
errs = append(errs, err)
}
return combineErrs(errs)
}
// finishResponse must be called on the main-thread
func (r *request) finishResponse() error {
var errs []error
if r.re... | fim | wailsapp/wails | go |
<|fim_prefix|>package webview
import (
"errors"
"net/http"
)
const (
HeaderContentLength = "Content-Length"
HeaderContentType = "Content-Type"
)
var (
errRequestStopped = errors.New("request has been stopped")
errResponseFinished = errors.New("response has been f<|fim_suffix|>ffect.
Finish() error
}
<|fim... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build darwin
package webview
/*
#cgo CFLAGS: -x objective-c
#cgo LDFLAGS: -framework Foundation -framework WebKit
#import <Foundation/Foundation.h>
#import <WebKit/WebKit.h>
typedef void (^schemeTaskCaller)(id<WKURLSchemeTask>);
static bool urlSchemeTaskCall(void *wkUrlSchemeTask, schemeTaskCall... | fim | wailsapp/wails | go |
<|fim_suffix|>p.StatusNotImplemented)
}
if rw.finished {
return nil
}
rw.finished = true
if rw.w != nil {
rw.w.Close()
}
return nil
}
func (rw *responseWriter) finishWithError(code int, err error) {
if rw.w != nil {
rw.w.Close()
rw.w = &nopCloser{io.Discard}
}
rw.wErr = err
msg := C.CString(err.Er... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build windows
// +build windows
package webview
import (
"bytes"
"fmt"
"net/http"
"strings"
)
var _ http.ResponseWriter = &responseWriter{}
type responseWriter struct {
req *request
header http.Header
wroteHeader bool
code int
body *bytes.Buffer
finished bool
}
fun... | fim | wailsapp/wails | go |
<|fim_suffix|>it_uri_scheme_request_get_http_method(req))
return strings.ToUpper(method)
}
func webkit_uri_scheme_request_get_http_headers(req *C.WebKitURISchemeRequest) http.Header {
hdrs := C.webkit_uri_scheme_request_get_http_headers(req)
var iter C.SoupMessageHeadersIter
C.soup_message_headers_iter_init(&iter... | fim | wailsapp/wails | go |
<|fim_prefix|>//go:build linux && webkit2_36
packa<|fim_suffix|>kit2/webkit2.h"
*/
import "C"
import (
"io"
"net/http"
)
const Webkit2MinMinorVersion = 36
func webkit_uri_scheme_request_get_http_body(_ *C.WebKitURISchemeRequest) io.ReadCloser {
return http.NoBody
}
<|fim_middle|>ge webview
/*
#cgo linux pkg-con... | fim | wailsapp/wails | go |
<|fim_suffix|>hen the last reference is dropped, but you might want to call this function
// to make sure resources are released as early as possible.
var err error
var gErr *C.GError
if C.g_input_stream_close(r.stream, nil, &gErr) == 0 {
err = formatGError("stream close failed", gErr)
}
C.g_object_unref(C.gpoi... | fim | wailsapp/wails | go |
<|fim_suffix|>bkit2MinMinorVersion = 40
<|fim_prefix|>//go:build linux && webkit2_40
package webview
co<|fim_middle|>nst We<|endoftext|> | fim | wailsapp/wails | go |
<|fim_prefix|>//go:bui<|fim_suffix|>ckage webview
const Webkit2MinMinorVersion = 41
<|fim_middle|>ld linux && webkit2_41
pa<|endoftext|> | fim | wailsapp/wails | go |
<|fim_suffix|> basic default headers that are needed if e.g. request are being proxied to the an external sever, like
// we do in the devserver.
h := http.Header{}
h.Add("Accept", "*/*")
h.Add("User-Agent", "wails.io/605.1.15")
return h
}
func webkit_uri_scheme_request_get_http_body(_ *C.WebKitURISchemeRequest) i... | fim | wailsapp/wails | go |
<|fim_suffix|>content, 0o644); err != nil {
return err
}
return nil
}
<|fim_prefix|>package buildassets
import (
"bytes"
"embed"
"errors"
"fmt"
iofs "io/fs"
"os"
"path/filepath"
"regexp"
"strings"
"text/template"
"github.com/leaanthony/gosod"
"github.com/samber/lo"
"github.com/wailsapp/wails/v2/inter... | fim | wailsapp/wails | go |
<|fim_suffix|>{"App@#$%^&*()", "app"},
{"123App", "123app"},
{" Spaces ", "spaces"},
{"already-lowercase", "already-lowercase"},
}
for _, tt := range tests {
got := safeBundleID(tt.input)
if got != tt.expected {
t.Errorf("safeBundleID(%q) = %q, want %q", tt.input, got, tt.expected)
}
}
}
<|fim_prefi... | fim | wailsapp/wails | go |
<|fim_prefix|>package clilogger
import (
"fmt"
"io"
"os"
"github.com/wailsapp/wails/<|fim_suffix|>ssage, args...)
_, err := fmt.Fprintln(c.Writer, colour.Red("FATAL: "+temp))
if err != nil {
println(colour.Red("FATAL: " + err.Error()))
}
os.Exit(1)
}
<|fim_middle|>v2/internal/colour"
)
// CLILogger is used... | fim | wailsapp/wails | go |
package bindings
import (
"fmt"
"log"
"os"
"path/filepath"
"runtime"
"github.com/samber/lo"
"github.com/wailsapp/wails/v2/internal/colour"
"github.com/wailsapp/wails/v2/internal/shell"
"github.com/wailsapp/wails/v2/pkg/commands/buildtags"
)
// Options for generating bindings
type Options struct {
Filename ... | fim | wailsapp/wails | go |
<|fim_suffix|>ngDirectory, "test")
_ = os.RemoveAll(projectDir)
_, _, err := templates.Install(&templates.Options{
ProjectName: "test",
TemplateName: "plain",
WailsVersion: "latest",
})
if err != nil {
println(err.Error())
t.Fail()
}
defer func() {
_ = os.RemoveAll(projectDir)
}()
// Make the g... | fim | wailsapp/wails | go |
<|fim_suffix|>rimSpace(tag)
if thisTag != "" {
userTags = append(userTags, thisTag)
}
}
return userTags, nil
}
// Stringify converts the given tags slice to a string compatible
// with the go build -tags flag
func Stringify(tags []string) string {
tags = lo.Map(tags, func(tag string, _ int) string {
return... | fim | wailsapp/wails | go |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.