Current size:
`) w.Run() } ``` -------------------------------- ### Create New WebView Window in Go Source: https://context7.com/webview/webview_go/llms.txt Creates a new webview instance with an optional debug mode. This function configures the window title, size, and sets HTML content. It then runs the main event loop, which blocks until the window is closed. Dependencies include the 'webview_go' package. ```go package main import ( "log" webview "github.com/webview/webview_go" ) func main() { // Create webview with debug mode enabled w := webview.New(true) defer w.Destroy() // Configure window w.SetTitle("My Application") w.SetSize(800, 600, webview.HintNone) // Set HTML content w.SetHtml("\This is running on:
")
// Start the main event loop (blocks until window closes)
w.Run()
}
```
--------------------------------
### Inject JavaScript on Page Initialization (Go)
Source: https://context7.com/webview/webview_go/llms.txt
Uses webview.Init to inject JavaScript code that executes before the page's DOM is fully loaded and before 'window.onload'. This is ideal for setting global variables, overriding functions, or defining utility functions accessible from the web content.
```go
package main
import (
"fmt"
webview "github.com/webview/webview_go"
)
func main() {
w := webview.New(true)
defer w.Destroy()
w.SetTitle("Init JavaScript Example")
w.SetSize(640, 480, webview.HintNone)
// Inject JavaScript that runs before window.onload
// This code runs on every page navigation
w.Init(`
console.log('Initialization code running...');
// Add custom properties to window object
window.APP_VERSION = '1.0.0';
window.APP_NAME = 'My Application';
// Override console.log to also send to Go
(function() {
const originalLog = console.log;
console.log = function(...args) {
originalLog.apply(console, args);
// Could send to Go via bound function
};
})();
// Add utility functions
window.utils = {
formatDate: (date) => new Date(date).toLocaleDateString(),
capitalize: (str) => str.charAt(0).toUpperCase() + str.slice(1)
};
`)
w.SetHtml(`
Platform: %s Handle: %s This handle can be used with platform-specific APIs for advanced customization. Counter: 0 This window will automatically close in 10 seconds.JavaScript Init Example
`)
w.Run()
}
```
--------------------------------
### Embed WebView in Existing Window in Go
Source: https://context7.com/webview/webview_go/llms.txt
Creates a webview instance embedded within an existing native window handle. This is useful for integrating webview functionality into existing applications. It requires a platform-specific native window handle. The function sets the window title, size, and navigates to a URL. Dependencies include the 'webview_go' package and 'unsafe'.
```go
package main
import (
"unsafe"
webview "github.com/webview/webview_go"
)
func main() {
// Get native window handle (platform-specific)
// Linux: GtkWindow*, macOS: NSWindow*, Windows: HWND
var nativeWindow unsafe.Pointer = nil // Replace with actual window handle
// Create webview in the existing window
w := webview.NewWindow(false, nativeWindow)
defer w.Destroy()
w.SetTitle("Embedded WebView")
w.SetSize(640, 480, webview.HintFixed) // Fixed size, non-resizable
w.Navigate("https://github.com/webview/webview_go")
w.Run()
}
```
--------------------------------
### Navigate URL or Data URI in Go
Source: https://context7.com/webview/webview_go/llms.txt
Loads a URL or a data URI into the webview. This allows navigating to external websites or displaying inline HTML content directly. The function supports both standard URLs and data URIs, including base64-encoded content. Dependencies include the 'webview_go' package.
```go
package main
import webview "github.com/webview/webview_go"
func main() {
w := webview.New(false)
defer w.Destroy()
w.SetTitle("Navigation Example")
w.SetSize(1024, 768, webview.HintNone)
// Navigate to external URL
// w.Navigate("https://golang.org")
// Navigate using URL-encoded data URI
// w.Navigate("data:text/html,%3Ch1%3EHello%3C%2Fh1%3E")
// Navigate using base64-encoded data URI
w.Navigate("data:text/html;base64,PCFET0NUWVBFIGh0bWw+CjxodG1sPgo8aGVhZD4KICA8dGl0bGU+RGF0YSBVUkk8L3RpdGxlPgogIDxzdHlsZT4KICAgIGJvZHkgeyBmb250LWZhbWlseTogQXJpYWw7IHBhZGRpbmc6IDIwcHg7IH0KICAgIGgxIHsgY29sb3I6ICMzMzM7IH0KICA8L3N0eWxlPgo8L2hlYWQ+Cjxib2R5PgogIDxoMT5Mb2FkZWQgZnJvbSBCYXNlNjQgRGF0YSBVUkk8L2gxPgogIDxwPlRoaXMgY29udGVudCB3YXMgZW5jb2RlZCBhcyBiYXNlNjQgYW5kIGxvYWRlZCBkaXJlY3RseS48L3A+CjwvYm9keT4KPC9odG1sPg==")
w.Run()
}
```
--------------------------------
### Bind Go Functions to JavaScript in webview_go
Source: https://context7.com/webview/webview_go/llms.txt
This Go code snippet demonstrates how to bind various types of Go functions to JavaScript within a webview application. It covers simple function calls, functions with parameters, error handling, and complex data types. The primary dependency is the 'github.com/webview/webview_go' library. Input parameters and return types are defined by the Go function signatures, and these are mirrored in the JavaScript calls.
```go
package main
import (
"fmt"
"time"
webview "github.com/webview/webview_go"
)
type User struct {
Name string `json:"name"`
Email string `json:"email"`
}
type ApiResponse struct {
Success bool `json:"success"`
Data interface{} `json:"data"`
Error string `json:"error,omitempty"`
}
func main() {
w := webview.New(true)
defer w.Destroy()
w.SetTitle("Function Binding Example")
w.SetSize(700, 500, webview.HintNone)
// Bind function with no parameters, returns value
w.Bind("getVersion", func() string {
return "1.2.3"
})
// Bind function with parameters, returns value
w.Bind("add", func(a, b int) int {
return a + b
})
// Bind function returning value and error
w.Bind("divide", func(a, b float64) (float64, error) {
if b == 0 {
return 0, fmt.Errorf("division by zero")
}
return a / b, nil
})
// Bind function with struct parameter and return
w.Bind("saveUser", func(user User) (ApiResponse, error) {
// Simulate validation
if user.Name == "" {
return ApiResponse{
Success: false,
Error: "Name is required",
}, nil
}
// Simulate async operation
time.Sleep(100 * time.Millisecond)
return ApiResponse{
Success: true,
Data: map[string]interface{}{
"id": 12345,
"name": user.Name,
"email": user.Email,
"createdAt": time.Now().Format(time.RFC3339),
},
}, nil
})
// Bind function with only error return
w.Bind("closeApp", func() error {
w.Terminate()
return nil
})
w.SetHtml(`
Go Function Bindings
Simple Math
Save User
Results
`)
w.Run()
}
```
--------------------------------
### Dispatch Functions to UI Thread in Go
Source: https://context7.com/webview/webview_go/llms.txt
Executes a function on the main UI thread, which is essential for thread-safe UI updates when working with background goroutines. This prevents race conditions and ensures UI elements are modified correctly. It utilizes the webview_go library.
```go
package main
import (
"fmt"
"net/http"
"time"
webview "github.com/webview/webview_go"
)
func main() {
w := webview.New(false)
defer w.Destroy()
w.SetTitle("Dispatch Example")
w.SetSize(600, 400, webview.HintNone)
w.SetHtml(`
Background Task Monitor
Native Window Handle
\n Waiting...
Auto-Close Demo
Function Unbinding
`)
// Unbind after 5 seconds
go func() {
time.Sleep(5 * time.Second)
w.Dispatch(func() {
w.Unbind("getMessage")
w.Eval(`
alert('getMessage() has been unbound! Try clicking the button now.');
`)
})
}()
w.Run()
}
```
=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.