github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-22 03:11:40 +00:00
Code Issues Projects Releases Wiki Activity

Implement metrics for Windows Nodes

Browse Source 
This implements stats for windows nodes in a new package, winstats.
WinStats exports methods to get cadvisor like datastructures, however
with windows specific metrics. WinStats only gets node level metrics and
information, container stats will go via the CRI. This enables the
use of the summary api to get metrics for windows nodes.
This commit is contained in:
David Porter 2017-08-08 19:18:42 +00:00
parent 629fea3ef6
commit a854ddb358
50 changed files with 11149 additions and 4 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Godeps/Godeps.json generated
View File

@ -1939,6 +1939,10 @@
"Comment": "v1.0-1-g9577782",
"Rev": "9577782540c1398b710ddae1b86268ba03a19b0c"
},
{
"ImportPath": "github.com/lxn/win",
"Rev": "712da405e3eb60e148bf5086991cd1e9eb570001"
},
{
"ImportPath": "github.com/magiconair/properties",
"Comment": "v1.7.0-4-g61b492c",

31
Godeps/LICENSES generated
View File

@ -67663,6 +67663,37 @@ Apache License
================================================================================
================================================================================
= vendor/github.com/lxn/win licensed under: =
Copyright (c) 2010 The win Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
= vendor/github.com/lxn/win/LICENSE 794c9d5b17cb1deeb131552549b6e7f2
================================================================================
================================================================================
= vendor/github.com/magiconair/properties licensed under: =

1
pkg/kubelet/BUILD
View File

@ -286,6 +286,7 @@ filegroup(
"//pkg/kubelet/types:all-srcs",
"//pkg/kubelet/util:all-srcs",
"//pkg/kubelet/volumemanager:all-srcs",
"//pkg/kubelet/winstats:all-srcs",
],
tags = ["automanaged"],
)

3
pkg/kubelet/cadvisor/BUILD
View File

@ -46,6 +46,9 @@ go_library(
"//vendor/github.com/google/cadvisor/utils/sysfs:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/runtime:go_default_library",
],
"@io_bazel_rules_go//go/platform:windows_amd64": [
"//pkg/kubelet/winstats:go_default_library",
],
"//conditions:default": [],
}),
)

11
pkg/kubelet/cadvisor/cadvisor_windows.go
View File

@ -22,16 +22,19 @@ import (
"github.com/google/cadvisor/events"
cadvisorapi "github.com/google/cadvisor/info/v1"
cadvisorapiv2 "github.com/google/cadvisor/info/v2"
"k8s.io/kubernetes/pkg/kubelet/winstats"
)
type cadvisorClient struct {
winStatsClient winstats.Client
}
var _ Interface = new(cadvisorClient)
// New creates a cAdvisor and exports its API on the specified port if port > 0.
func New(address string, port uint, imageFsInfoProvider ImageFsInfoProvider, rootPath string) (Interface, error) {
return &cadvisorClient{}, nil
client, err := winstats.NewPerfCounterClient()
return &cadvisorClient{winStatsClient: client}, err
}
func (cu *cadvisorClient) Start() error {
@ -47,7 +50,7 @@ func (cu *cadvisorClient) ContainerInfo(name string, req *cadvisorapi.ContainerI
}
func (cu *cadvisorClient) ContainerInfoV2(name string, options cadvisorapiv2.RequestOptions) (map[string]cadvisorapiv2.ContainerInfo, error) {
return make(map[string]cadvisorapiv2.ContainerInfo), nil
return cu.winStatsClient.WinContainerInfos()
}
func (cu *cadvisorClient) SubcontainerInfo(name string, req *cadvisorapi.ContainerInfoRequest) (map[string]*cadvisorapi.ContainerInfo, error) {
@ -55,11 +58,11 @@ func (cu *cadvisorClient) SubcontainerInfo(name string, req *cadvisorapi.Contain
}
func (cu *cadvisorClient) MachineInfo() (*cadvisorapi.MachineInfo, error) {
return &cadvisorapi.MachineInfo{}, nil
return cu.winStatsClient.WinMachineInfo()
}
func (cu *cadvisorClient) VersionInfo() (*cadvisorapi.VersionInfo, error) {
return &cadvisorapi.VersionInfo{}, nil
return cu.winStatsClient.WinVersionInfo()
}
func (cu *cadvisorClient) ImagesFsInfo() (cadvisorapiv2.FsInfo, error) {

53
pkg/kubelet/winstats/BUILD Normal file
View File

@ -0,0 +1,53 @@
package(default_visibility = ["//visibility:public"])
licenses(["notice"])
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
)
load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
go_library(
name = "go_default_library",
srcs = [
"winstats.go",
] + select({
"@io_bazel_rules_go//go/platform:windows_amd64": [
"perfcounter_nodestats.go",
"perfcounters.go",
],
"//conditions:default": [],
}),
deps = [
"//vendor/github.com/google/cadvisor/info/v1:go_default_library",
"//vendor/github.com/google/cadvisor/info/v2:go_default_library",
] + select({
"@io_bazel_rules_go//go/platform:windows_amd64": [
"//vendor/github.com/golang/glog:go_default_library",
"//vendor/github.com/lxn/win:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/util/wait:go_default_library",
],
"//conditions:default": [],
}),
)
go_test(
name = "go_default_test",
srcs = ["winstats_test.go"],
library = ":go_default_library",
deps = [
"//vendor/github.com/google/cadvisor/info/v1:go_default_library",
"//vendor/github.com/google/cadvisor/info/v2:go_default_library",
"//vendor/github.com/stretchr/testify/assert:go_default_library",
],
)

166
pkg/kubelet/winstats/perfcounter_nodestats.go Normal file
View File

@ -0,0 +1,166 @@
// +build windows
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package winstats
import (
"errors"
"os"
"os/exec"
"runtime"
"strings"
"sync"
"time"
"github.com/golang/glog"
cadvisorapi "github.com/google/cadvisor/info/v1"
"github.com/lxn/win"
"k8s.io/apimachinery/pkg/util/wait"
)
// NewPerfCounterClient creates a client using perf counters
func NewPerfCounterClient() (Client, error) {
return newClient(&perfCounterNodeStatsClient{})
}
// perfCounterNodeStatsClient is a client that provides Windows Stats via PerfCounters
type perfCounterNodeStatsClient struct {
nodeMetrics
mu sync.RWMutex // mu protects nodeMetrics
nodeInfo
}
func (p *perfCounterNodeStatsClient) startMonitoring() error {
memory, err := getPhysicallyInstalledSystemMemoryBytes()
if err != nil {
return err
}
version, err := exec.Command("cmd", "/C", "ver").Output()
if err != nil {
return err
}
osImageVersion := strings.TrimSpace(string(version))
kernelVersion := extractVersionNumber(osImageVersion)
p.nodeInfo = nodeInfo{
kernelVersion: kernelVersion,
osImageVersion: osImageVersion,
memoryPhysicalCapacityBytes: memory,
startTime: time.Now(),
}
cpuCounter, err := newPerfCounter(cpuQuery)
if err != nil {
return err
}
memWorkingSetCounter, err := newPerfCounter(memoryPrivWorkingSetQuery)
if err != nil {
return err
}
memCommittedBytesCounter, err := newPerfCounter(memoryCommittedBytesQuery)
if err != nil {
return err
}
go wait.Forever(func() {
p.collectMetricsData(cpuCounter, memWorkingSetCounter, memCommittedBytesCounter)
}, perfCounterUpdatePeriod)
return nil
}
func (p *perfCounterNodeStatsClient) getMachineInfo() (*cadvisorapi.MachineInfo, error) {
hostname, err := os.Hostname()
if err != nil {
return nil, err
}
return &cadvisorapi.MachineInfo{
NumCores: runtime.NumCPU(),
MemoryCapacity: p.nodeInfo.memoryPhysicalCapacityBytes,
MachineID: hostname,
}, nil
}
func (p *perfCounterNodeStatsClient) getVersionInfo() (*cadvisorapi.VersionInfo, error) {
return &cadvisorapi.VersionInfo{
KernelVersion: p.nodeInfo.kernelVersion,
ContainerOsVersion: p.nodeInfo.osImageVersion,
}, nil
}
func (p *perfCounterNodeStatsClient) getNodeMetrics() (nodeMetrics, error) {
p.mu.RLock()
defer p.mu.RUnlock()
return p.nodeMetrics, nil
}
func (p *perfCounterNodeStatsClient) getNodeInfo() nodeInfo {
return p.nodeInfo
}
func (p *perfCounterNodeStatsClient) collectMetricsData(cpuCounter, memWorkingSetCounter, memCommittedBytesCounter *perfCounter) {
cpuValue, err := cpuCounter.getData()
if err != nil {
glog.Errorf("Unable to get cpu perf counter data; err: %v", err)
return
}
memWorkingSetValue, err := memWorkingSetCounter.getData()
if err != nil {
glog.Errorf("Unable to get memWorkingSet perf counter data; err: %v", err)
return
}
memCommittedBytesValue, err := memCommittedBytesCounter.getData()
if err != nil {
glog.Errorf("Unable to get memCommittedBytes perf counter data; err: %v", err)
return
}
p.mu.Lock()
defer p.mu.Unlock()
p.nodeMetrics = nodeMetrics{
cpuUsageCoreNanoSeconds: p.convertCPUValue(cpuValue),
memoryPrivWorkingSetBytes: memWorkingSetValue,
memoryCommittedBytes: memCommittedBytesValue,
timeStamp: time.Now(),
}
}
func (p *perfCounterNodeStatsClient) convertCPUValue(cpuValue uint64) uint64 {
cpuCores := runtime.NumCPU()
// This converts perf counter data which is cpu percentage for all cores into nanoseconds.
// The formula is (cpuPercentage / 100.0) * #cores * 1e+9 (nano seconds). More info here:
// https://github.com/kubernetes/heapster/issues/650
newValue := p.nodeMetrics.cpuUsageCoreNanoSeconds + uint64((float64(cpuValue)/100.0)*float64(cpuCores)*1e9)
return newValue
}
func getPhysicallyInstalledSystemMemoryBytes() (uint64, error) {
var physicalMemoryKiloBytes uint64
if ok := win.GetPhysicallyInstalledSystemMemory(&physicalMemoryKiloBytes); !ok {
return 0, errors.New("unable to read physical memory")
}
return physicalMemoryKiloBytes * 1024, nil // convert kilobytes to bytes
}

102
pkg/kubelet/winstats/perfcounters.go Normal file
View File

@ -0,0 +1,102 @@
// +build windows
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package winstats
import (
"errors"
"fmt"
"time"
"unsafe"
"github.com/lxn/win"
)
const (
cpuQuery = "\\Processor(_Total)\\% Processor Time"
memoryPrivWorkingSetQuery = "\\Process(_Total)\\Working Set - Private"
memoryCommittedBytesQuery = "\\Memory\\Committed Bytes"
// Perf counters are updated every second. This is the same as the default cadvisor collection period
// see https://github.com/google/cadvisor/blob/master/docs/runtime_options.md#housekeeping
perfCounterUpdatePeriod = 1 * time.Second
)
type perfCounter struct {
queryHandle win.PDH_HQUERY
counterHandle win.PDH_HCOUNTER
}
func newPerfCounter(counter string) (*perfCounter, error) {
var queryHandle win.PDH_HQUERY
var counterHandle win.PDH_HCOUNTER
ret := win.PdhOpenQuery(0, 0, &queryHandle)
if ret != win.ERROR_SUCCESS {
return nil, errors.New("unable to open query through DLL call")
}
ret = win.PdhValidatePath(counter)
if ret != win.ERROR_SUCCESS {
return nil, fmt.Errorf("unable to valid path to counter. Error code is %x", ret)
}
ret = win.PdhAddEnglishCounter(queryHandle, counter, 0, &counterHandle)
if ret != win.ERROR_SUCCESS {
return nil, fmt.Errorf("unable to add process counter. Error code is %x", ret)
}
ret = win.PdhCollectQueryData(queryHandle)
if ret != win.ERROR_SUCCESS {
return nil, fmt.Errorf("unable to collect data from counter. Error code is %x", ret)
}
return &perfCounter{
queryHandle: queryHandle,
counterHandle: counterHandle,
}, nil
}
func (p *perfCounter) getData() (uint64, error) {
ret := win.PdhCollectQueryData(p.queryHandle)
if ret != win.ERROR_SUCCESS {
return 0, fmt.Errorf("unable to collect data from counter. Error code is %x", ret)
}
var bufSize, bufCount uint32
var size = uint32(unsafe.Sizeof(win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE{}))
var emptyBuf [1]win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE // need at least 1 addressable null ptr.
var data uint64
ret = win.PdhGetFormattedCounterArrayDouble(p.counterHandle, &bufSize, &bufCount, &emptyBuf[0])
if ret != win.PDH_MORE_DATA {
return 0, fmt.Errorf("unable to collect data from counter. Error code is %x", ret)
}
filledBuf := make([]win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE, bufCount*size)
ret = win.PdhGetFormattedCounterArrayDouble(p.counterHandle, &bufSize, &bufCount, &filledBuf[0])
if ret != win.ERROR_SUCCESS {
return 0, fmt.Errorf("unable to collect data from counter. Error code is %x", ret)
}
for i := 0; i < int(bufCount); i++ {
c := filledBuf[i]
data = uint64(c.FmtValue.DoubleValue)
}
return data, nil
}

145
pkg/kubelet/winstats/winstats.go Normal file
View File

@ -0,0 +1,145 @@
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Package winstats provides a client to get node and pod level stats on windows
package winstats
import (
"regexp"
"time"
cadvisorapi "github.com/google/cadvisor/info/v1"
cadvisorapiv2 "github.com/google/cadvisor/info/v2"
)
// Client is an interface that is used to get stats information.
type Client interface {
WinContainerInfos() (map[string]cadvisorapiv2.ContainerInfo, error)
WinMachineInfo() (*cadvisorapi.MachineInfo, error)
WinVersionInfo() (*cadvisorapi.VersionInfo, error)
}
// StatsClient is a client that implements the Client interface
type statsClient struct {
client winNodeStatsClient
}
type winNodeStatsClient interface {
startMonitoring() error
getNodeMetrics() (nodeMetrics, error)
getNodeInfo() nodeInfo
getMachineInfo() (*cadvisorapi.MachineInfo, error)
getVersionInfo() (*cadvisorapi.VersionInfo, error)
}
type nodeMetrics struct {
cpuUsageCoreNanoSeconds uint64
memoryPrivWorkingSetBytes uint64
memoryCommittedBytes uint64
timeStamp time.Time
}
type nodeInfo struct {
memoryPhysicalCapacityBytes uint64
kernelVersion string
osImageVersion string
// startTime is the time when the node was started
startTime time.Time
}
// newClient constructs a Client.
func newClient(statsNodeClient winNodeStatsClient) (Client, error) {
statsClient := new(statsClient)
statsClient.client = statsNodeClient
err := statsClient.client.startMonitoring()
if err != nil {
return nil, err
}
return statsClient, nil
}
// WinContainerInfos returns a map of container infos. The map contains node and
// pod level stats. Analogous to cadvisor GetContainerInfoV2 method.
func (c *statsClient) WinContainerInfos() (map[string]cadvisorapiv2.ContainerInfo, error) {
infos := make(map[string]cadvisorapiv2.ContainerInfo)
rootContainerInfo, err := c.createRootContainerInfo()
if err != nil {
return nil, err
}
infos["/"] = *rootContainerInfo
return infos, nil
}
// WinMachineInfo returns a cadvisorapi.MachineInfo with details about the
// node machine. Analogous to cadvisor MachineInfo method.
func (c *statsClient) WinMachineInfo() (*cadvisorapi.MachineInfo, error) {
return c.client.getMachineInfo()
}
// WinVersionInfo returns a cadvisorapi.VersionInfo with version info of
// the kernel and docker runtime. Analogous to cadvisor VersionInfo method.
func (c *statsClient) WinVersionInfo() (*cadvisorapi.VersionInfo, error) {
return c.client.getVersionInfo()
}
func (c *statsClient) createRootContainerInfo() (*cadvisorapiv2.ContainerInfo, error) {
nodeMetrics, err := c.client.getNodeMetrics()
if err != nil {
return nil, err
}
var stats []*cadvisorapiv2.ContainerStats
stats = append(stats, &cadvisorapiv2.ContainerStats{
Timestamp: nodeMetrics.timeStamp,
Cpu: &cadvisorapi.CpuStats{
Usage: cadvisorapi.CpuUsage{
Total: nodeMetrics.cpuUsageCoreNanoSeconds,
},
},
Memory: &cadvisorapi.MemoryStats{
WorkingSet: nodeMetrics.memoryPrivWorkingSetBytes,
Usage: nodeMetrics.memoryCommittedBytes,
},
})
nodeInfo := c.client.getNodeInfo()
rootInfo := cadvisorapiv2.ContainerInfo{
Spec: cadvisorapiv2.ContainerSpec{
CreationTime: nodeInfo.startTime,
HasCpu: true,
HasMemory: true,
Memory: cadvisorapiv2.MemorySpec{
Limit: nodeInfo.memoryPhysicalCapacityBytes,
},
},
Stats: stats,
}
return &rootInfo, nil
}
// extractVersionNumber gets the version number from the full version string on Windows
// e.g. extracts "10.0.14393" from "Microsoft Windows [Version 10.0.14393]"
func extractVersionNumber(fullVersion string) string {
re := regexp.MustCompile("[^0-9.]")
version := re.ReplaceAllString(fullVersion, "")
return version
}

132
pkg/kubelet/winstats/winstats_test.go Normal file
View File

@ -0,0 +1,132 @@
/*
Copyright 2017 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package winstats
import (
"testing"
"time"
cadvisorapi "github.com/google/cadvisor/info/v1"
cadvisorapiv2 "github.com/google/cadvisor/info/v2"
"github.com/stretchr/testify/assert"
)
var timeStamp = time.Now()
type fakeWinNodeStatsClient struct{}
func (f fakeWinNodeStatsClient) startMonitoring() error {
return nil
}
func (f fakeWinNodeStatsClient) getNodeMetrics() (nodeMetrics, error) {
return nodeMetrics{
cpuUsageCoreNanoSeconds: 123,
memoryPrivWorkingSetBytes: 1234,
memoryCommittedBytes: 12345,
timeStamp: timeStamp,
}, nil
}
func (f fakeWinNodeStatsClient) getNodeInfo() nodeInfo {
return nodeInfo{
kernelVersion: "v42",
memoryPhysicalCapacityBytes: 1.6e+10,
}
}
func (f fakeWinNodeStatsClient) getMachineInfo() (*cadvisorapi.MachineInfo, error) {
return &cadvisorapi.MachineInfo{
NumCores: 4,
MemoryCapacity: 1.6e+10,
MachineID: "somehostname",
}, nil
}
func (f fakeWinNodeStatsClient) getVersionInfo() (*cadvisorapi.VersionInfo, error) {
return &cadvisorapi.VersionInfo{
KernelVersion: "v42",
}, nil
}
func TestWinContainerInfos(t *testing.T) {
c := getClient(t)
actualRootInfos, err := c.WinContainerInfos()
assert.NoError(t, err)
var stats []*cadvisorapiv2.ContainerStats
stats = append(stats, &cadvisorapiv2.ContainerStats{
Timestamp: timeStamp,
Cpu: &cadvisorapi.CpuStats{
Usage: cadvisorapi.CpuUsage{
Total: 123,
},
},
Memory: &cadvisorapi.MemoryStats{
WorkingSet: 1234,
Usage: 12345,
},
})
infos := make(map[string]cadvisorapiv2.ContainerInfo)
infos["/"] = cadvisorapiv2.ContainerInfo{
Spec: cadvisorapiv2.ContainerSpec{
HasCpu: true,
HasMemory: true,
Memory: cadvisorapiv2.MemorySpec{
Limit: 1.6e+10,
},
},
Stats: stats,
}
assert.Equal(t, actualRootInfos, infos)
}
func TestWinMachineInfo(t *testing.T) {
c := getClient(t)
machineInfo, err := c.WinMachineInfo()
assert.NoError(t, err)
assert.Equal(t, machineInfo, &cadvisorapi.MachineInfo{
NumCores: 4,
MemoryCapacity: 1.6e+10,
MachineID: "somehostname"})
}
func TestWinVersionInfo(t *testing.T) {
c := getClient(t)
versionInfo, err := c.WinVersionInfo()
assert.NoError(t, err)
assert.Equal(t, versionInfo, &cadvisorapi.VersionInfo{
KernelVersion: "v42"})
}
func TestExtractVersionNumber(t *testing.T) {
fullVersion := "Microsoft Windows [Version 10.0.14393]"
versionNumber := extractVersionNumber(fullVersion)
expected := "10.0.14393"
assert.Equal(t, expected, versionNumber)
}
func getClient(t *testing.T) Client {
f := fakeWinNodeStatsClient{}
c, err := newClient(f)
assert.NoError(t, err)
assert.NotNil(t, c)
return c
}

1
vendor/BUILD vendored
View File

@ -260,6 +260,7 @@ filegroup(
"//vendor/github.com/libopenstorage/openstorage/pkg/units:all-srcs",
"//vendor/github.com/libopenstorage/openstorage/volume:all-srcs",
"//vendor/github.com/lpabon/godbc:all-srcs",
"//vendor/github.com/lxn/win:all-srcs",
"//vendor/github.com/magiconair/properties:all-srcs",
"//vendor/github.com/mailru/easyjson/buffer:all-srcs",
"//vendor/github.com/mailru/easyjson/jlexer:all-srcs",

24
vendor/github.com/lxn/win/AUTHORS generated vendored Normal file
View File

@ -0,0 +1,24 @@
# This is the official list of 'win' authors for copyright purposes.
# Names should be added to this file as
# Name or Organization <email address>
# The email address is not required for organizations.
# Please keep the list sorted.
# Contributors
# ============
Alexander Neumann <an2048@googlemail.com>
Anton Lahti <antonlahti@gmail.com>
Benny Siegert <bsiegert@gmail.com>
Bruno Bigras <bigras.bruno@gmail.com>
Carlos Cobo <toqueteos@gmail.com>
Cary Cherng <ccherng@gmail.com>
David Porter <david@porter.me>
Hill <zhubicen@gmail.com>
Joseph Watson <jtwatson@linux-consulting.us>
Kevin Pors <krpors@gmail.com>
ktye <ktye@users.noreply.github.com>
mycaosf <mycaosf@gmail.com>
wsf01 <wf1337@sina.com>

58
vendor/github.com/lxn/win/BUILD generated vendored Normal file
View File

@ -0,0 +1,58 @@
load("@io_bazel_rules_go//go:def.bzl", "go_library")
go_library(
name = "go_default_library",
srcs = select({
"@io_bazel_rules_go//go/platform:windows_amd64": [
"advapi32.go",
"combobox.go",
"comctl32.go",
"comdlg32.go",
"datetimepicker.go",
"edit.go",
"gdi32.go",
"gdiplus.go",
"header.go",
"kernel32.go",
"listbox.go",
"listview.go",
"menu.go",
"ole32.go",
"oleaut32.go",
"oleaut32_amd64.go",
"opengl32.go",
"pdh.go",
"shdocvw.go",
"shell32.go",
"shobj.go",
"shobj_amd64.go",
"statusbar.go",
"syslink.go",
"tab.go",
"toolbar.go",
"tooltip.go",
"treeview.go",
"updown.go",
"user32.go",
"uxtheme.go",
"win.go",
"winspool.go",
],
"//conditions:default": [],
}),
visibility = ["//visibility:public"],
)
filegroup(
name = "package-srcs",
srcs = glob(["**"]),
tags = ["automanaged"],
visibility = ["//visibility:private"],
)
filegroup(
name = "all-srcs",
srcs = [":package-srcs"],
tags = ["automanaged"],
visibility = ["//visibility:public"],
)

23
vendor/github.com/lxn/win/LICENSE generated vendored Normal file
View File

@ -0,0 +1,23 @@
Copyright (c) 2010 The win Authors. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. The names of the authors may not be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

15
vendor/github.com/lxn/win/README.mdown generated vendored Normal file
View File

@ -0,0 +1,15 @@
About win
=========
win is a Windows API wrapper package for Go.
Originally part of [walk](https://github.com/lxn/walk), it is now a separate
project.
Setup
=====
Make sure you have a working Go installation.
See [Getting Started](http://golang.org/doc/install.html)
Now run `go get github.com/lxn/win`

136
vendor/github.com/lxn/win/advapi32.go generated vendored Normal file
View File

@ -0,0 +1,136 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
const KEY_READ REGSAM = 0x20019
const KEY_WRITE REGSAM = 0x20006
const (
HKEY_CLASSES_ROOT HKEY = 0x80000000
HKEY_CURRENT_USER HKEY = 0x80000001
HKEY_LOCAL_MACHINE HKEY = 0x80000002
HKEY_USERS HKEY = 0x80000003
HKEY_PERFORMANCE_DATA HKEY = 0x80000004
HKEY_CURRENT_CONFIG HKEY = 0x80000005
HKEY_DYN_DATA HKEY = 0x80000006
)
const (
ERROR_NO_MORE_ITEMS = 259
)
type (
ACCESS_MASK uint32
HKEY HANDLE
REGSAM ACCESS_MASK
)
const (
REG_NONE uint64 = 0 // No value type
REG_SZ = 1 // Unicode nul terminated string
REG_EXPAND_SZ = 2 // Unicode nul terminated string
// (with environment variable references)
REG_BINARY = 3 // Free form binary
REG_DWORD = 4 // 32-bit number
REG_DWORD_LITTLE_ENDIAN = 4 // 32-bit number (same as REG_DWORD)
REG_DWORD_BIG_ENDIAN = 5 // 32-bit number
REG_LINK = 6 // Symbolic Link (unicode)
REG_MULTI_SZ = 7 // Multiple Unicode strings
REG_RESOURCE_LIST = 8 // Resource list in the resource map
REG_FULL_RESOURCE_DESCRIPTOR = 9 // Resource list in the hardware description
REG_RESOURCE_REQUIREMENTS_LIST = 10
REG_QWORD = 11 // 64-bit number
REG_QWORD_LITTLE_ENDIAN = 11 // 64-bit number (same as REG_QWORD)
)
var (
// Library
libadvapi32 uintptr
// Functions
regCloseKey uintptr
regOpenKeyEx uintptr
regQueryValueEx uintptr
regEnumValue uintptr
regSetValueEx uintptr
)
func init() {
// Library
libadvapi32 = MustLoadLibrary("advapi32.dll")
// Functions
regCloseKey = MustGetProcAddress(libadvapi32, "RegCloseKey")
regOpenKeyEx = MustGetProcAddress(libadvapi32, "RegOpenKeyExW")
regQueryValueEx = MustGetProcAddress(libadvapi32, "RegQueryValueExW")
regEnumValue = MustGetProcAddress(libadvapi32, "RegEnumValueW")
regSetValueEx = MustGetProcAddress(libadvapi32, "RegSetValueExW")
}
func RegCloseKey(hKey HKEY) int32 {
ret, _, _ := syscall.Syscall(regCloseKey, 1,
uintptr(hKey),
0,
0)
return int32(ret)
}
func RegOpenKeyEx(hKey HKEY, lpSubKey *uint16, ulOptions uint32, samDesired REGSAM, phkResult *HKEY) int32 {
ret, _, _ := syscall.Syscall6(regOpenKeyEx, 5,
uintptr(hKey),
uintptr(unsafe.Pointer(lpSubKey)),
uintptr(ulOptions),
uintptr(samDesired),
uintptr(unsafe.Pointer(phkResult)),
0)
return int32(ret)
}
func RegQueryValueEx(hKey HKEY, lpValueName *uint16, lpReserved, lpType *uint32, lpData *byte, lpcbData *uint32) int32 {
ret, _, _ := syscall.Syscall6(regQueryValueEx, 6,
uintptr(hKey),
uintptr(unsafe.Pointer(lpValueName)),
uintptr(unsafe.Pointer(lpReserved)),
uintptr(unsafe.Pointer(lpType)),
uintptr(unsafe.Pointer(lpData)),
uintptr(unsafe.Pointer(lpcbData)))
return int32(ret)
}
func RegEnumValue(hKey HKEY, index uint32, lpValueName *uint16, lpcchValueName *uint32, lpReserved, lpType *uint32, lpData *byte, lpcbData *uint32) int32 {
ret, _, _ := syscall.Syscall9(regEnumValue, 8,
uintptr(hKey),
uintptr(index),
uintptr(unsafe.Pointer(lpValueName)),
uintptr(unsafe.Pointer(lpcchValueName)),
uintptr(unsafe.Pointer(lpReserved)),
uintptr(unsafe.Pointer(lpType)),
uintptr(unsafe.Pointer(lpData)),
uintptr(unsafe.Pointer(lpcbData)),
0)
return int32(ret)
}
func RegSetValueEx(hKey HKEY, lpValueName *uint16, lpReserved, lpDataType uint64, lpData *byte, cbData uint32) int32 {
ret, _, _ := syscall.Syscall6(regSetValueEx, 6,
uintptr(hKey),
uintptr(unsafe.Pointer(lpValueName)),
uintptr(lpReserved),
uintptr(lpDataType),
uintptr(unsafe.Pointer(lpData)),
uintptr(cbData))
return int32(ret)
}

86
vendor/github.com/lxn/win/combobox.go generated vendored Normal file
View File

@ -0,0 +1,86 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// ComboBox return values
const (
CB_OKAY = 0
CB_ERR = ^uintptr(0) // -1
CB_ERRSPACE = ^uintptr(1) // -2
)
// ComboBox notifications
const (
CBN_ERRSPACE = -1
CBN_SELCHANGE = 1
CBN_DBLCLK = 2
CBN_SETFOCUS = 3
CBN_KILLFOCUS = 4
CBN_EDITCHANGE = 5
CBN_EDITUPDATE = 6
CBN_DROPDOWN = 7
CBN_CLOSEUP = 8
CBN_SELENDOK = 9
CBN_SELENDCANCEL = 10
)
// ComboBox styles
const (
CBS_SIMPLE = 0x0001
CBS_DROPDOWN = 0x0002
CBS_DROPDOWNLIST = 0x0003
CBS_OWNERDRAWFIXED = 0x0010
CBS_OWNERDRAWVARIABLE = 0x0020
CBS_AUTOHSCROLL = 0x0040
CBS_OEMCONVERT = 0x0080
CBS_SORT = 0x0100
CBS_HASSTRINGS = 0x0200
CBS_NOINTEGRALHEIGHT = 0x0400
CBS_DISABLENOSCROLL = 0x0800
CBS_UPPERCASE = 0x2000
CBS_LOWERCASE = 0x4000
)
// ComboBox messages
const (
CB_GETEDITSEL = 0x0140
CB_LIMITTEXT = 0x0141
CB_SETEDITSEL = 0x0142
CB_ADDSTRING = 0x0143
CB_DELETESTRING = 0x0144
CB_DIR = 0x0145
CB_GETCOUNT = 0x0146
CB_GETCURSEL = 0x0147
CB_GETLBTEXT = 0x0148
CB_GETLBTEXTLEN = 0x0149
CB_INSERTSTRING = 0x014A
CB_RESETCONTENT = 0x014B
CB_FINDSTRING = 0x014C
CB_SELECTSTRING = 0x014D
CB_SETCURSEL = 0x014E
CB_SHOWDROPDOWN = 0x014F
CB_GETITEMDATA = 0x0150
CB_SETITEMDATA = 0x0151
CB_GETDROPPEDCONTROLRECT = 0x0152
CB_SETITEMHEIGHT = 0x0153
CB_GETITEMHEIGHT = 0x0154
CB_SETEXTENDEDUI = 0x0155
CB_GETEXTENDEDUI = 0x0156
CB_GETDROPPEDSTATE = 0x0157
CB_FINDSTRINGEXACT = 0x0158
CB_SETLOCALE = 0x0159
CB_GETLOCALE = 0x015A
CB_GETTOPINDEX = 0x015b
CB_SETTOPINDEX = 0x015c
CB_GETHORIZONTALEXTENT = 0x015d
CB_SETHORIZONTALEXTENT = 0x015e
CB_GETDROPPEDWIDTH = 0x015f
CB_SETDROPPEDWIDTH = 0x0160
CB_INITSTORAGE = 0x0161
CB_MULTIPLEADDSTRING = 0x0163
CB_GETCOMBOBOXINFO = 0x0164
)

308
vendor/github.com/lxn/win/comctl32.go generated vendored Normal file
View File

@ -0,0 +1,308 @@
// Copyright 2016 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
// Button control messages
const (
BCM_FIRST = 0x1600
BCM_GETIDEALSIZE = BCM_FIRST + 0x0001
BCM_SETIMAGELIST = BCM_FIRST + 0x0002
BCM_GETIMAGELIST = BCM_FIRST + 0x0003
BCM_SETTEXTMARGIN = BCM_FIRST + 0x0004
BCM_GETTEXTMARGIN = BCM_FIRST + 0x0005
BCM_SETDROPDOWNSTATE = BCM_FIRST + 0x0006
BCM_SETSPLITINFO = BCM_FIRST + 0x0007
BCM_GETSPLITINFO = BCM_FIRST + 0x0008
BCM_SETNOTE = BCM_FIRST + 0x0009
BCM_GETNOTE = BCM_FIRST + 0x000A
BCM_GETNOTELENGTH = BCM_FIRST + 0x000B
)
const (
CCM_FIRST = 0x2000
CCM_LAST = CCM_FIRST + 0x200
CCM_SETBKCOLOR = 8193
CCM_SETCOLORSCHEME = 8194
CCM_GETCOLORSCHEME = 8195
CCM_GETDROPTARGET = 8196
CCM_SETUNICODEFORMAT = 8197
CCM_GETUNICODEFORMAT = 8198
CCM_SETVERSION = 0x2007
CCM_GETVERSION = 0x2008
CCM_SETNOTIFYWINDOW = 0x2009
CCM_SETWINDOWTHEME = 0x200b
CCM_DPISCALE = 0x200c
)
// Common controls styles
const (
CCS_TOP = 1
CCS_NOMOVEY = 2
CCS_BOTTOM = 3
CCS_NORESIZE = 4
CCS_NOPARENTALIGN = 8
CCS_ADJUSTABLE = 32
CCS_NODIVIDER = 64
CCS_VERT = 128
CCS_LEFT = 129
CCS_NOMOVEX = 130
CCS_RIGHT = 131
)
// InitCommonControlsEx flags
const (
ICC_LISTVIEW_CLASSES = 1
ICC_TREEVIEW_CLASSES = 2
ICC_BAR_CLASSES = 4
ICC_TAB_CLASSES = 8
ICC_UPDOWN_CLASS = 16
ICC_PROGRESS_CLASS = 32
ICC_HOTKEY_CLASS = 64
ICC_ANIMATE_CLASS = 128
ICC_WIN95_CLASSES = 255
ICC_DATE_CLASSES = 256
ICC_USEREX_CLASSES = 512
ICC_COOL_CLASSES = 1024
ICC_INTERNET_CLASSES = 2048
ICC_PAGESCROLLER_CLASS = 4096
ICC_NATIVEFNTCTL_CLASS = 8192
INFOTIPSIZE = 1024
ICC_STANDARD_CLASSES = 0x00004000
ICC_LINK_CLASS = 0x00008000
)
// WM_NOTITY messages
const (
NM_FIRST = 0
NM_OUTOFMEMORY = ^uint32(0) // NM_FIRST - 1
NM_CLICK = ^uint32(1) // NM_FIRST - 2
NM_DBLCLK = ^uint32(2) // NM_FIRST - 3
NM_RETURN = ^uint32(3) // NM_FIRST - 4
NM_RCLICK = ^uint32(4) // NM_FIRST - 5
NM_RDBLCLK = ^uint32(5) // NM_FIRST - 6
NM_SETFOCUS = ^uint32(6) // NM_FIRST - 7
NM_KILLFOCUS = ^uint32(7) // NM_FIRST - 8
NM_CUSTOMDRAW = ^uint32(11) // NM_FIRST - 12
NM_HOVER = ^uint32(12) // NM_FIRST - 13
NM_NCHITTEST = ^uint32(13) // NM_FIRST - 14
NM_KEYDOWN = ^uint32(14) // NM_FIRST - 15
NM_RELEASEDCAPTURE = ^uint32(15) // NM_FIRST - 16
NM_SETCURSOR = ^uint32(16) // NM_FIRST - 17
NM_CHAR = ^uint32(17) // NM_FIRST - 18
NM_TOOLTIPSCREATED = ^uint32(18) // NM_FIRST - 19
NM_LAST = ^uint32(98) // NM_FIRST - 99
TRBN_THUMBPOSCHANGING = 0xfffffa22 // TRBN_FIRST - 1
)
// ProgressBar messages
const (
PBM_SETPOS = WM_USER + 2
PBM_DELTAPOS = WM_USER + 3
PBM_SETSTEP = WM_USER + 4
PBM_STEPIT = WM_USER + 5
PBM_SETMARQUEE = WM_USER + 10
PBM_SETRANGE32 = 1030
PBM_GETRANGE = 1031
PBM_GETPOS = 1032
PBM_SETBARCOLOR = 1033
PBM_SETBKCOLOR = CCM_SETBKCOLOR
)
// ProgressBar styles
const (
PBS_SMOOTH = 0x01
PBS_VERTICAL = 0x04
PBS_MARQUEE = 0x08
)
// TrackBar (Slider) messages
const (
TBM_GETPOS = WM_USER
TBM_GETRANGEMIN = WM_USER + 1
TBM_GETRANGEMAX = WM_USER + 2
TBM_SETPOS = WM_USER + 5
TBM_SETRANGEMIN = WM_USER + 7
TBM_SETRANGEMAX = WM_USER + 8
)
// TrackBar (Slider) styles
const (
TBS_VERT = 0x002
TBS_TOOLTIPS = 0x100
)
// ImageList creation flags
const (
ILC_MASK = 0x00000001
ILC_COLOR = 0x00000000
ILC_COLORDDB = 0x000000FE
ILC_COLOR4 = 0x00000004
ILC_COLOR8 = 0x00000008
ILC_COLOR16 = 0x00000010
ILC_COLOR24 = 0x00000018
ILC_COLOR32 = 0x00000020
ILC_PALETTE = 0x00000800
ILC_MIRROR = 0x00002000
ILC_PERITEMMIRROR = 0x00008000
)
const (
CDDS_PREPAINT = 0x00000001
CDDS_POSTPAINT = 0x00000002
CDDS_PREERASE = 0x00000003
CDDS_POSTERASE = 0x00000004
CDDS_ITEM = 0x00010000
CDDS_ITEMPREPAINT = CDDS_ITEM | CDDS_PREPAINT
CDDS_ITEMPOSTPAINT = CDDS_ITEM | CDDS_POSTPAINT
CDDS_ITEMPREERASE = CDDS_ITEM | CDDS_PREERASE
CDDS_ITEMPOSTERASE = CDDS_ITEM | CDDS_POSTERASE
CDDS_SUBITEM = 0x00020000
)
const (
CDIS_SELECTED = 0x0001
CDIS_GRAYED = 0x0002
CDIS_DISABLED = 0x0004
CDIS_CHECKED = 0x0008
CDIS_FOCUS = 0x0010
CDIS_DEFAULT = 0x0020
CDIS_HOT = 0x0040
CDIS_MARKED = 0x0080
CDIS_INDETERMINATE = 0x0100
CDIS_SHOWKEYBOARDCUES = 0x0200
CDIS_NEARHOT = 0x0400
CDIS_OTHERSIDEHOT = 0x0800
CDIS_DROPHILITED = 0x1000
)
const (
CDRF_DODEFAULT = 0x00000000
CDRF_NEWFONT = 0x00000002
CDRF_SKIPDEFAULT = 0x00000004
CDRF_DOERASE = 0x00000008
CDRF_NOTIFYPOSTPAINT = 0x00000010
CDRF_NOTIFYITEMDRAW = 0x00000020
CDRF_NOTIFYSUBITEMDRAW = 0x00000020
CDRF_NOTIFYPOSTERASE = 0x00000040
CDRF_SKIPPOSTPAINT = 0x00000100
)
const (
LPSTR_TEXTCALLBACK = ^uintptr(0)
I_CHILDRENCALLBACK = -1
)
type HIMAGELIST HANDLE
type INITCOMMONCONTROLSEX struct {
DwSize, DwICC uint32
}
type NMCUSTOMDRAW struct {
Hdr NMHDR
DwDrawStage uint32
Hdc HDC
Rc RECT
DwItemSpec uintptr
UItemState uint32
LItemlParam uintptr
}
var (
// Library
libcomctl32 uintptr
// Functions
imageList_Add uintptr
imageList_AddMasked uintptr
imageList_Create uintptr
imageList_Destroy uintptr
imageList_ReplaceIcon uintptr
initCommonControlsEx uintptr
)
func init() {
// Library
libcomctl32 = MustLoadLibrary("comctl32.dll")
// Functions
imageList_Add = MustGetProcAddress(libcomctl32, "ImageList_Add")
imageList_AddMasked = MustGetProcAddress(libcomctl32, "ImageList_AddMasked")
imageList_Create = MustGetProcAddress(libcomctl32, "ImageList_Create")
imageList_Destroy = MustGetProcAddress(libcomctl32, "ImageList_Destroy")
imageList_ReplaceIcon = MustGetProcAddress(libcomctl32, "ImageList_ReplaceIcon")
initCommonControlsEx = MustGetProcAddress(libcomctl32, "InitCommonControlsEx")
// Initialize the common controls we support
var initCtrls INITCOMMONCONTROLSEX
initCtrls.DwSize = uint32(unsafe.Sizeof(initCtrls))
initCtrls.DwICC = ICC_LINK_CLASS | ICC_LISTVIEW_CLASSES | ICC_PROGRESS_CLASS | ICC_TAB_CLASSES | ICC_TREEVIEW_CLASSES
InitCommonControlsEx(&initCtrls)
}
func ImageList_Add(himl HIMAGELIST, hbmImage, hbmMask HBITMAP) int32 {
ret, _, _ := syscall.Syscall(imageList_Add, 3,
uintptr(himl),
uintptr(hbmImage),
uintptr(hbmMask))
return int32(ret)
}
func ImageList_AddMasked(himl HIMAGELIST, hbmImage HBITMAP, crMask COLORREF) int32 {
ret, _, _ := syscall.Syscall(imageList_AddMasked, 3,
uintptr(himl),
uintptr(hbmImage),
uintptr(crMask))
return int32(ret)
}
func ImageList_Create(cx, cy int32, flags uint32, cInitial, cGrow int32) HIMAGELIST {
ret, _, _ := syscall.Syscall6(imageList_Create, 5,
uintptr(cx),
uintptr(cy),
uintptr(flags),
uintptr(cInitial),
uintptr(cGrow),
0)
return HIMAGELIST(ret)
}
func ImageList_Destroy(hIml HIMAGELIST) bool {
ret, _, _ := syscall.Syscall(imageList_Destroy, 1,
uintptr(hIml),
0,
0)
return ret != 0
}
func ImageList_ReplaceIcon(himl HIMAGELIST, i int32, hicon HICON) int32 {
ret, _, _ := syscall.Syscall(imageList_ReplaceIcon, 3,
uintptr(himl),
uintptr(i),
uintptr(hicon))
return int32(ret)
}
func InitCommonControlsEx(lpInitCtrls *INITCOMMONCONTROLSEX) bool {
ret, _, _ := syscall.Syscall(initCommonControlsEx, 1,
uintptr(unsafe.Pointer(lpInitCtrls)),
0,
0)
return ret != 0
}

299
vendor/github.com/lxn/win/comdlg32.go generated vendored Normal file
View File

@ -0,0 +1,299 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
// Common error codes
const (
CDERR_DIALOGFAILURE = 0xFFFF
CDERR_FINDRESFAILURE = 0x0006
CDERR_INITIALIZATION = 0x0002
CDERR_LOADRESFAILURE = 0x0007
CDERR_LOADSTRFAILURE = 0x0005
CDERR_LOCKRESFAILURE = 0x0008
CDERR_MEMALLOCFAILURE = 0x0009
CDERR_MEMLOCKFAILURE = 0x000A
CDERR_NOHINSTANCE = 0x0004
CDERR_NOHOOK = 0x000B
CDERR_NOTEMPLATE = 0x0003
CDERR_REGISTERMSGFAIL = 0x000C
CDERR_STRUCTSIZE = 0x0001
)
// CHOOSECOLOR flags
const (
CC_ANYCOLOR = 0x00000100
CC_ENABLEHOOK = 0x00000010
CC_ENABLETEMPLATE = 0x00000020
CC_ENABLETEMPLATEHANDLE = 0x00000040
CC_FULLOPEN = 0x00000002
CC_PREVENTFULLOPEN = 0x00000004
CC_RGBINIT = 0x00000001
CC_SHOWHELP = 0x00000008
CC_SOLIDCOLOR = 0x00000080
)
type CHOOSECOLOR struct {
LStructSize uint32
HwndOwner HWND
HInstance HWND
RgbResult COLORREF
LpCustColors *COLORREF
Flags uint32
LCustData uintptr
LpfnHook uintptr
LpTemplateName *uint16
}
// PrintDlg specific error codes
const (
PDERR_CREATEICFAILURE = 0x100A
PDERR_DEFAULTDIFFERENT = 0x100C
PDERR_DNDMMISMATCH = 0x1009
PDERR_GETDEVMODEFAIL = 0x1005
PDERR_INITFAILURE = 0x1006
PDERR_LOADDRVFAILURE = 0x1004
PDERR_NODEFAULTPRN = 0x1008
PDERR_NODEVICES = 0x1007
PDERR_PARSEFAILURE = 0x1002
PDERR_PRINTERNOTFOUND = 0x100B
PDERR_RETDEFFAILURE = 0x1003
PDERR_SETUPFAILURE = 0x1001
)
// ChooseFont specific error codes
const (
CFERR_MAXLESSTHANMIN = 0x2002
CFERR_NOFONTS = 0x2001
)
// GetOpenFileName and GetSaveFileName specific error codes
const (
FNERR_BUFFERTOOSMALL = 0x3003
FNERR_INVALIDFILENAME = 0x3002
FNERR_SUBCLASSFAILURE = 0x3001
)
// FindText and ReplaceText specific error codes
const (
FRERR_BUFFERLENGTHZERO = 0x4001
)
// GetOpenFileName and GetSaveFileName flags
const (
OFN_ALLOWMULTISELECT = 0x00000200
OFN_CREATEPROMPT = 0x00002000
OFN_DONTADDTORECENT = 0x02000000
OFN_ENABLEHOOK = 0x00000020
OFN_ENABLEINCLUDENOTIFY = 0x00400000
OFN_ENABLESIZING = 0x00800000
OFN_ENABLETEMPLATE = 0x00000040
OFN_ENABLETEMPLATEHANDLE = 0x00000080
OFN_EXPLORER = 0x00080000
OFN_EXTENSIONDIFFERENT = 0x00000400
OFN_FILEMUSTEXIST = 0x00001000
OFN_FORCESHOWHIDDEN = 0x10000000
OFN_HIDEREADONLY = 0x00000004
OFN_LONGNAMES = 0x00200000
OFN_NOCHANGEDIR = 0x00000008
OFN_NODEREFERENCELINKS = 0x00100000
OFN_NOLONGNAMES = 0x00040000
OFN_NONETWORKBUTTON = 0x00020000
OFN_NOREADONLYRETURN = 0x00008000
OFN_NOTESTFILECREATE = 0x00010000
OFN_NOVALIDATE = 0x00000100
OFN_OVERWRITEPROMPT = 0x00000002
OFN_PATHMUSTEXIST = 0x00000800
OFN_READONLY = 0x00000001
OFN_SHAREAWARE = 0x00004000
OFN_SHOWHELP = 0x00000010
)
// GetOpenFileName and GetSaveFileName extended flags
const (
OFN_EX_NOPLACESBAR = 0x00000001
)
// PrintDlg[Ex] result actions
const (
PD_RESULT_APPLY = 2
PD_RESULT_CANCEL = 0
PD_RESULT_PRINT = 1
)
// PrintDlg[Ex] flags
const (
PD_ALLPAGES = 0x00000000
PD_COLLATE = 0x00000010
PD_CURRENTPAGE = 0x00400000
PD_DISABLEPRINTTOFILE = 0x00080000
PD_ENABLEPRINTTEMPLATE = 0x00004000
PD_ENABLEPRINTTEMPLATEHANDLE = 0x00010000
PD_EXCLUSIONFLAGS = 0x01000000
PD_HIDEPRINTTOFILE = 0x00100000
PD_NOCURRENTPAGE = 0x00800000
PD_NOPAGENUMS = 0x00000008
PD_NOSELECTION = 0x00000004
PD_NOWARNING = 0x00000080
PD_PAGENUMS = 0x00000002
PD_PRINTTOFILE = 0x00000020
PD_RETURNDC = 0x00000100
PD_RETURNDEFAULT = 0x00000400
PD_RETURNIC = 0x00000200
PD_SELECTION = 0x00000001
PD_USEDEVMODECOPIES = 0x00040000
PD_USEDEVMODECOPIESANDCOLLATE = 0x00040000
PD_USELARGETEMPLATE = 0x10000000
)
// PrintDlgEx exclusion flags
const (
PD_EXCL_COPIESANDCOLLATE = DM_COPIES | DM_COLLATE
)
const START_PAGE_GENERAL = 0xffffffff
type (
LPOFNHOOKPROC uintptr
HPROPSHEETPAGE HANDLE
LPUNKNOWN uintptr
)
type OPENFILENAME struct {
LStructSize uint32
HwndOwner HWND
HInstance HINSTANCE
LpstrFilter *uint16
LpstrCustomFilter *uint16
NMaxCustFilter uint32
NFilterIndex uint32
LpstrFile *uint16
NMaxFile uint32
LpstrFileTitle *uint16
NMaxFileTitle uint32
LpstrInitialDir *uint16
LpstrTitle *uint16
Flags uint32
NFileOffset uint16
NFileExtension uint16
LpstrDefExt *uint16
LCustData uintptr
LpfnHook LPOFNHOOKPROC
LpTemplateName *uint16
PvReserved unsafe.Pointer
DwReserved uint32
FlagsEx uint32
}
type PRINTPAGERANGE struct {
NFromPage uint32
NToPage uint32
}
type DEVNAMES struct {
WDriverOffset uint16
WDeviceOffset uint16
WOutputOffset uint16
WDefault uint16
}
type PRINTDLGEX struct {
LStructSize uint32
HwndOwner HWND
HDevMode HGLOBAL
HDevNames HGLOBAL
HDC HDC
Flags uint32
Flags2 uint32
ExclusionFlags uint32
NPageRanges uint32
NMaxPageRanges uint32
LpPageRanges *PRINTPAGERANGE
NMinPage uint32
NMaxPage uint32
NCopies uint32
HInstance HINSTANCE
LpPrintTemplateName *uint16
LpCallback LPUNKNOWN
NPropertyPages uint32
LphPropertyPages *HPROPSHEETPAGE
NStartPage uint32
DwResultAction uint32
}
var (
// Library
libcomdlg32 uintptr
// Functions
chooseColor uintptr
commDlgExtendedError uintptr
getOpenFileName uintptr
getSaveFileName uintptr
printDlgEx uintptr
)
func init() {
// Library
libcomdlg32 = MustLoadLibrary("comdlg32.dll")
// Functions
chooseColor = MustGetProcAddress(libcomdlg32, "ChooseColorW")
commDlgExtendedError = MustGetProcAddress(libcomdlg32, "CommDlgExtendedError")
getOpenFileName = MustGetProcAddress(libcomdlg32, "GetOpenFileNameW")
getSaveFileName = MustGetProcAddress(libcomdlg32, "GetSaveFileNameW")
printDlgEx = MustGetProcAddress(libcomdlg32, "PrintDlgExW")
}
func ChooseColor(lpcc *CHOOSECOLOR) bool {
ret, _, _ := syscall.Syscall(chooseColor, 1,
uintptr(unsafe.Pointer(lpcc)),
0,
0)
return ret != 0
}
func CommDlgExtendedError() uint32 {
ret, _, _ := syscall.Syscall(commDlgExtendedError, 0,
0,
0,
0)
return uint32(ret)
}
func GetOpenFileName(lpofn *OPENFILENAME) bool {
ret, _, _ := syscall.Syscall(getOpenFileName, 1,
uintptr(unsafe.Pointer(lpofn)),
0,
0)
return ret != 0
}
func GetSaveFileName(lpofn *OPENFILENAME) bool {
ret, _, _ := syscall.Syscall(getSaveFileName, 1,
uintptr(unsafe.Pointer(lpofn)),
0,
0)
return ret != 0
}
func PrintDlgEx(lppd *PRINTDLGEX) HRESULT {
ret, _, _ := syscall.Syscall(printDlgEx, 1,
uintptr(unsafe.Pointer(lppd)),
0,
0)
return HRESULT(ret)
}

96
vendor/github.com/lxn/win/datetimepicker.go generated vendored Normal file
View File

@ -0,0 +1,96 @@
// Copyright 2011 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
const DTM_FIRST = 0x1000
const DTN_FIRST = ^uint32(739) // -740
const DTN_FIRST2 = ^uint32(752) // -753
const (
GDTR_MIN = 0x0001
GDTR_MAX = 0x0002
)
const (
GDT_ERROR = -1
GDT_VALID = 0
GDT_NONE = 1
)
// Messages
const (
DTM_GETSYSTEMTIME = DTM_FIRST + 1
DTM_SETSYSTEMTIME = DTM_FIRST + 2
DTM_GETRANGE = DTM_FIRST + 3
DTM_SETRANGE = DTM_FIRST + 4
DTM_SETFORMAT = DTM_FIRST + 50
DTM_SETMCCOLOR = DTM_FIRST + 6
DTM_GETMCCOLOR = DTM_FIRST + 7
DTM_GETMONTHCAL = DTM_FIRST + 8
DTM_SETMCFONT = DTM_FIRST + 9
DTM_GETMCFONT = DTM_FIRST + 10
)
// Styles
const (
DTS_UPDOWN = 0x0001
DTS_SHOWNONE = 0x0002
DTS_SHORTDATEFORMAT = 0x0000
DTS_LONGDATEFORMAT = 0x0004
DTS_SHORTDATECENTURYFORMAT = 0x000C
DTS_TIMEFORMAT = 0x0009
DTS_APPCANPARSE = 0x0010
DTS_RIGHTALIGN = 0x0020
)
// Notifications
const (
DTN_DATETIMECHANGE = DTN_FIRST2 - 6
DTN_USERSTRING = DTN_FIRST - 5
DTN_WMKEYDOWN = DTN_FIRST - 4
DTN_FORMAT = DTN_FIRST - 3
DTN_FORMATQUERY = DTN_FIRST - 2
DTN_DROPDOWN = DTN_FIRST2 - 1
DTN_CLOSEUP = DTN_FIRST2
)
// Structs
type (
NMDATETIMECHANGE struct {
Nmhdr NMHDR
DwFlags uint32
St SYSTEMTIME
}
NMDATETIMESTRING struct {
Nmhdr NMHDR
PszUserString *uint16
St SYSTEMTIME
DwFlags uint32
}
NMDATETIMEWMKEYDOWN struct {
Nmhdr NMHDR
NVirtKey int
PszFormat *uint16
St SYSTEMTIME
}
NMDATETIMEFORMAT struct {
Nmhdr NMHDR
PszFormat *uint16
St SYSTEMTIME
PszDisplay *uint16
SzDisplay [64]uint16
}
NMDATETIMEFORMATQUERY struct {
Nmhdr NMHDR
PszFormat *uint16
SzMax SIZE
}
)

84
vendor/github.com/lxn/win/edit.go generated vendored Normal file
View File

@ -0,0 +1,84 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// Edit styles
const (
ES_LEFT = 0x0000
ES_CENTER = 0x0001
ES_RIGHT = 0x0002
ES_MULTILINE = 0x0004
ES_UPPERCASE = 0x0008
ES_LOWERCASE = 0x0010
ES_PASSWORD = 0x0020
ES_AUTOVSCROLL = 0x0040
ES_AUTOHSCROLL = 0x0080
ES_NOHIDESEL = 0x0100
ES_OEMCONVERT = 0x0400
ES_READONLY = 0x0800
ES_WANTRETURN = 0x1000
ES_NUMBER = 0x2000
)
// Edit notifications
const (
EN_SETFOCUS = 0x0100
EN_KILLFOCUS = 0x0200
EN_CHANGE = 0x0300
EN_UPDATE = 0x0400
EN_ERRSPACE = 0x0500
EN_MAXTEXT = 0x0501
EN_HSCROLL = 0x0601
EN_VSCROLL = 0x0602
EN_ALIGN_LTR_EC = 0x0700
EN_ALIGN_RTL_EC = 0x0701
)
// Edit messages
const (
EM_GETSEL = 0x00B0
EM_SETSEL = 0x00B1
EM_GETRECT = 0x00B2
EM_SETRECT = 0x00B3
EM_SETRECTNP = 0x00B4
EM_SCROLL = 0x00B5
EM_LINESCROLL = 0x00B6
EM_SCROLLCARET = 0x00B7
EM_GETMODIFY = 0x00B8
EM_SETMODIFY = 0x00B9
EM_GETLINECOUNT = 0x00BA
EM_LINEINDEX = 0x00BB
EM_SETHANDLE = 0x00BC
EM_GETHANDLE = 0x00BD
EM_GETTHUMB = 0x00BE
EM_LINELENGTH = 0x00C1
EM_REPLACESEL = 0x00C2
EM_GETLINE = 0x00C4
EM_LIMITTEXT = 0x00C5
EM_CANUNDO = 0x00C6
EM_UNDO = 0x00C7
EM_FMTLINES = 0x00C8
EM_LINEFROMCHAR = 0x00C9
EM_SETTABSTOPS = 0x00CB
EM_SETPASSWORDCHAR = 0x00CC
EM_EMPTYUNDOBUFFER = 0x00CD
EM_GETFIRSTVISIBLELINE = 0x00CE
EM_SETREADONLY = 0x00CF
EM_SETWORDBREAKPROC = 0x00D0
EM_GETWORDBREAKPROC = 0x00D1
EM_GETPASSWORDCHAR = 0x00D2
EM_SETMARGINS = 0x00D3
EM_GETMARGINS = 0x00D4
EM_SETLIMITTEXT = EM_LIMITTEXT
EM_GETLIMITTEXT = 0x00D5
EM_POSFROMCHAR = 0x00D6
EM_CHARFROMPOS = 0x00D7
EM_SETIMESTATUS = 0x00D8
EM_GETIMESTATUS = 0x00D9
EM_SETCUEBANNER = 0x1501
EM_GETCUEBANNER = 0x1502
)

1808
vendor/github.com/lxn/win/gdi32.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

223
vendor/github.com/lxn/win/gdiplus.go generated vendored Normal file
View File

@ -0,0 +1,223 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
type GpStatus int32
const (
Ok GpStatus = 0
GenericError GpStatus = 1
InvalidParameter GpStatus = 2
OutOfMemory GpStatus = 3
ObjectBusy GpStatus = 4
InsufficientBuffer GpStatus = 5
NotImplemented GpStatus = 6
Win32Error GpStatus = 7
WrongState GpStatus = 8
Aborted GpStatus = 9
FileNotFound GpStatus = 10
ValueOverflow GpStatus = 11
AccessDenied GpStatus = 12
UnknownImageFormat GpStatus = 13
FontFamilyNotFound GpStatus = 14
FontStyleNotFound GpStatus = 15
NotTrueTypeFont GpStatus = 16
UnsupportedGdiplusVersion GpStatus = 17
GdiplusNotInitialized GpStatus = 18
PropertyNotFound GpStatus = 19
PropertyNotSupported GpStatus = 20
ProfileNotFound GpStatus = 21
)
func (s GpStatus) String() string {
switch s {
case Ok:
return "Ok"
case GenericError:
return "GenericError"
case InvalidParameter:
return "InvalidParameter"
case OutOfMemory:
return "OutOfMemory"
case ObjectBusy:
return "ObjectBusy"
case InsufficientBuffer:
return "InsufficientBuffer"
case NotImplemented:
return "NotImplemented"
case Win32Error:
return "Win32Error"
case WrongState:
return "WrongState"
case Aborted:
return "Aborted"
case FileNotFound:
return "FileNotFound"
case ValueOverflow:
return "ValueOverflow"
case AccessDenied:
return "AccessDenied"
case UnknownImageFormat:
return "UnknownImageFormat"
case FontFamilyNotFound:
return "FontFamilyNotFound"
case FontStyleNotFound:
return "FontStyleNotFound"
case NotTrueTypeFont:
return "NotTrueTypeFont"
case UnsupportedGdiplusVersion:
return "UnsupportedGdiplusVersion"
case GdiplusNotInitialized:
return "GdiplusNotInitialized"
case PropertyNotFound:
return "PropertyNotFound"
case PropertyNotSupported:
return "PropertyNotSupported"
case ProfileNotFound:
return "ProfileNotFound"
}
return "Unknown Status Value"
}
type GdiplusStartupInput struct {
GdiplusVersion uint32
DebugEventCallback uintptr
SuppressBackgroundThread BOOL
SuppressExternalCodecs BOOL
}
type GdiplusStartupOutput struct {
NotificationHook uintptr
NotificationUnhook uintptr
}
type GpImage struct{}
type GpBitmap GpImage
type ARGB uint32
var (
// Library
libgdiplus uintptr
// Functions
gdipCreateBitmapFromFile uintptr
gdipCreateBitmapFromHBITMAP uintptr
gdipCreateHBITMAPFromBitmap uintptr
gdipDisposeImage uintptr
gdiplusShutdown uintptr
gdiplusStartup uintptr
)
var (
token uintptr
)
func init() {
// Library
libgdiplus = MustLoadLibrary("gdiplus.dll")
// Functions
gdipCreateBitmapFromFile = MustGetProcAddress(libgdiplus, "GdipCreateBitmapFromFile")
gdipCreateBitmapFromHBITMAP = MustGetProcAddress(libgdiplus, "GdipCreateBitmapFromHBITMAP")
gdipCreateHBITMAPFromBitmap = MustGetProcAddress(libgdiplus, "GdipCreateHBITMAPFromBitmap")
gdipDisposeImage = MustGetProcAddress(libgdiplus, "GdipDisposeImage")
gdiplusShutdown = MustGetProcAddress(libgdiplus, "GdiplusShutdown")
gdiplusStartup = MustGetProcAddress(libgdiplus, "GdiplusStartup")
}
func GdipCreateBitmapFromFile(filename *uint16, bitmap **GpBitmap) GpStatus {
ret, _, _ := syscall.Syscall(gdipCreateBitmapFromFile, 2,
uintptr(unsafe.Pointer(filename)),
uintptr(unsafe.Pointer(bitmap)),
0)
return GpStatus(ret)
}
func GdipCreateBitmapFromHBITMAP(hbm HBITMAP, hpal HPALETTE, bitmap **GpBitmap) GpStatus {
ret, _, _ := syscall.Syscall(gdipCreateBitmapFromHBITMAP, 3,
uintptr(hbm),
uintptr(hpal),
uintptr(unsafe.Pointer(bitmap)))
return GpStatus(ret)
}
func GdipCreateHBITMAPFromBitmap(bitmap *GpBitmap, hbmReturn *HBITMAP, background ARGB) GpStatus {
ret, _, _ := syscall.Syscall(gdipCreateHBITMAPFromBitmap, 3,
uintptr(unsafe.Pointer(bitmap)),
uintptr(unsafe.Pointer(hbmReturn)),
uintptr(background))
return GpStatus(ret)
}
func GdipDisposeImage(image *GpImage) GpStatus {
ret, _, _ := syscall.Syscall(gdipDisposeImage, 1,
uintptr(unsafe.Pointer(image)),
0,
0)
return GpStatus(ret)
}
func GdiplusShutdown() {
syscall.Syscall(gdiplusShutdown, 1,
token,
0,
0)
}
func GdiplusStartup(input *GdiplusStartupInput, output *GdiplusStartupOutput) GpStatus {
ret, _, _ := syscall.Syscall(gdiplusStartup, 3,
uintptr(unsafe.Pointer(&token)),
uintptr(unsafe.Pointer(input)),
uintptr(unsafe.Pointer(output)))
return GpStatus(ret)
}
/*GdipSaveImageToFile(image *GpImage, filename *uint16, clsidEncoder *CLSID, encoderParams *EncoderParameters) GpStatus {
ret, _, _ := syscall.Syscall6(gdipSaveImageToFile, 4,
uintptr(unsafe.Pointer(image)),
uintptr(unsafe.Pointer(filename)),
uintptr(unsafe.Pointer(clsidEncoder)),
uintptr(unsafe.Pointer(encoderParams)),
0,
0)
return GpStatus(ret)
}*/

40
vendor/github.com/lxn/win/header.go generated vendored Normal file
View File

@ -0,0 +1,40 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
const (
HDF_SORTDOWN = 0x200
HDF_SORTUP = 0x400
)
const (
HDI_FORMAT = 4
)
const (
HDM_FIRST = 0x1200
HDM_GETITEM = HDM_FIRST + 11
HDM_SETITEM = HDM_FIRST + 12
)
const (
HDS_NOSIZING = 0x0800
)
type HDITEM struct {
Mask uint32
Cxy int32
PszText *uint16
Hbm HBITMAP
CchTextMax int32
Fmt int32
LParam uintptr
IImage int32
IOrder int32
Type uint32
PvFilter uintptr
}

352
vendor/github.com/lxn/win/kernel32.go generated vendored Normal file
View File

@ -0,0 +1,352 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
const MAX_PATH = 260
// Error codes
const (
ERROR_SUCCESS = 0
ERROR_INVALID_FUNCTION = 1
ERROR_FILE_NOT_FOUND = 2
ERROR_INVALID_PARAMETER = 87
ERROR_INSUFFICIENT_BUFFER = 122
ERROR_MORE_DATA = 234
)
// GlobalAlloc flags
const (
GHND = 0x0042
GMEM_FIXED = 0x0000
GMEM_MOVEABLE = 0x0002
GMEM_ZEROINIT = 0x0040
GPTR = 0x004
)
// Predefined locale ids
const (
LOCALE_CUSTOM_DEFAULT LCID = 0x0c00
LOCALE_CUSTOM_UI_DEFAULT LCID = 0x1400
LOCALE_CUSTOM_UNSPECIFIED LCID = 0x1000
LOCALE_INVARIANT LCID = 0x007f
LOCALE_USER_DEFAULT LCID = 0x0400
LOCALE_SYSTEM_DEFAULT LCID = 0x0800
)
// LCTYPE constants
const (
LOCALE_SDECIMAL LCTYPE = 14
LOCALE_STHOUSAND LCTYPE = 15
LOCALE_SISO3166CTRYNAME LCTYPE = 0x5a
LOCALE_SISO3166CTRYNAME2 LCTYPE = 0x68
LOCALE_SISO639LANGNAME LCTYPE = 0x59
LOCALE_SISO639LANGNAME2 LCTYPE = 0x67
)
var (
// Library
libkernel32 uintptr
// Functions
closeHandle uintptr
fileTimeToSystemTime uintptr
getConsoleTitle uintptr
getConsoleWindow uintptr
getLastError uintptr
getLocaleInfo uintptr
getLogicalDriveStrings uintptr
getModuleHandle uintptr
getNumberFormat uintptr
getThreadLocale uintptr
getThreadUILanguage uintptr
getVersion uintptr
globalAlloc uintptr
globalFree uintptr
globalLock uintptr
globalUnlock uintptr
moveMemory uintptr
mulDiv uintptr
setLastError uintptr
systemTimeToFileTime uintptr
getProfileString uintptr
getPhysicallyInstalledSystemMemory uintptr
)
type (
ATOM uint16
HANDLE uintptr
HGLOBAL HANDLE
HINSTANCE HANDLE
LCID uint32
LCTYPE uint32
LANGID uint16
)
type FILETIME struct {
DwLowDateTime uint32
DwHighDateTime uint32
}
type NUMBERFMT struct {
NumDigits uint32
LeadingZero uint32
Grouping uint32
LpDecimalSep *uint16
LpThousandSep *uint16
NegativeOrder uint32
}
type SYSTEMTIME struct {
WYear uint16
WMonth uint16
WDayOfWeek uint16
WDay uint16
WHour uint16
WMinute uint16
WSecond uint16
WMilliseconds uint16
}
func init() {
// Library
libkernel32 = MustLoadLibrary("kernel32.dll")
// Functions
closeHandle = MustGetProcAddress(libkernel32, "CloseHandle")
fileTimeToSystemTime = MustGetProcAddress(libkernel32, "FileTimeToSystemTime")
getConsoleTitle = MustGetProcAddress(libkernel32, "GetConsoleTitleW")
getConsoleWindow = MustGetProcAddress(libkernel32, "GetConsoleWindow")
getLastError = MustGetProcAddress(libkernel32, "GetLastError")
getLocaleInfo = MustGetProcAddress(libkernel32, "GetLocaleInfoW")
getLogicalDriveStrings = MustGetProcAddress(libkernel32, "GetLogicalDriveStringsW")
getModuleHandle = MustGetProcAddress(libkernel32, "GetModuleHandleW")
getNumberFormat = MustGetProcAddress(libkernel32, "GetNumberFormatW")
getProfileString = MustGetProcAddress(libkernel32, "GetProfileStringW")
getThreadLocale = MustGetProcAddress(libkernel32, "GetThreadLocale")
getThreadUILanguage, _ = syscall.GetProcAddress(syscall.Handle(libkernel32), "GetThreadUILanguage")
getVersion = MustGetProcAddress(libkernel32, "GetVersion")
globalAlloc = MustGetProcAddress(libkernel32, "GlobalAlloc")
globalFree = MustGetProcAddress(libkernel32, "GlobalFree")
globalLock = MustGetProcAddress(libkernel32, "GlobalLock")
globalUnlock = MustGetProcAddress(libkernel32, "GlobalUnlock")
moveMemory = MustGetProcAddress(libkernel32, "RtlMoveMemory")
mulDiv = MustGetProcAddress(libkernel32, "MulDiv")
setLastError = MustGetProcAddress(libkernel32, "SetLastError")
systemTimeToFileTime = MustGetProcAddress(libkernel32, "SystemTimeToFileTime")
getPhysicallyInstalledSystemMemory = MustGetProcAddress(libkernel32, "GetPhysicallyInstalledSystemMemory")
}
func CloseHandle(hObject HANDLE) bool {
ret, _, _ := syscall.Syscall(closeHandle, 1,
uintptr(hObject),
0,
0)
return ret != 0
}
func FileTimeToSystemTime(lpFileTime *FILETIME, lpSystemTime *SYSTEMTIME) bool {
ret, _, _ := syscall.Syscall(fileTimeToSystemTime, 2,
uintptr(unsafe.Pointer(lpFileTime)),
uintptr(unsafe.Pointer(lpSystemTime)),
0)
return ret != 0
}
func GetConsoleTitle(lpConsoleTitle *uint16, nSize uint32) uint32 {
ret, _, _ := syscall.Syscall(getConsoleTitle, 2,
uintptr(unsafe.Pointer(lpConsoleTitle)),
uintptr(nSize),
0)
return uint32(ret)
}
func GetConsoleWindow() HWND {
ret, _, _ := syscall.Syscall(getConsoleWindow, 0,
0,
0,
0)
return HWND(ret)
}
func GetLastError() uint32 {
ret, _, _ := syscall.Syscall(getLastError, 0,
0,
0,
0)
return uint32(ret)
}
func GetLocaleInfo(Locale LCID, LCType LCTYPE, lpLCData *uint16, cchData int32) int32 {
ret, _, _ := syscall.Syscall6(getLocaleInfo, 4,
uintptr(Locale),
uintptr(LCType),
uintptr(unsafe.Pointer(lpLCData)),
uintptr(cchData),
0,
0)
return int32(ret)
}
func GetLogicalDriveStrings(nBufferLength uint32, lpBuffer *uint16) uint32 {
ret, _, _ := syscall.Syscall(getLogicalDriveStrings, 2,
uintptr(nBufferLength),
uintptr(unsafe.Pointer(lpBuffer)),
0)
return uint32(ret)
}
func GetModuleHandle(lpModuleName *uint16) HINSTANCE {
ret, _, _ := syscall.Syscall(getModuleHandle, 1,
uintptr(unsafe.Pointer(lpModuleName)),
0,
0)
return HINSTANCE(ret)
}
func GetNumberFormat(Locale LCID, dwFlags uint32, lpValue *uint16, lpFormat *NUMBERFMT, lpNumberStr *uint16, cchNumber int32) int32 {
ret, _, _ := syscall.Syscall6(getNumberFormat, 6,
uintptr(Locale),
uintptr(dwFlags),
uintptr(unsafe.Pointer(lpValue)),
uintptr(unsafe.Pointer(lpFormat)),
uintptr(unsafe.Pointer(lpNumberStr)),
uintptr(cchNumber))
return int32(ret)
}
func GetProfileString(lpAppName, lpKeyName, lpDefault *uint16, lpReturnedString uintptr, nSize uint32) bool {
ret, _, _ := syscall.Syscall6(getProfileString, 5,
uintptr(unsafe.Pointer(lpAppName)),
uintptr(unsafe.Pointer(lpKeyName)),
uintptr(unsafe.Pointer(lpDefault)),
lpReturnedString,
uintptr(nSize),
0)
return ret != 0
}
func GetThreadLocale() LCID {
ret, _, _ := syscall.Syscall(getThreadLocale, 0,
0,
0,
0)
return LCID(ret)
}
func GetThreadUILanguage() LANGID {
if getThreadUILanguage == 0 {
return 0
}
ret, _, _ := syscall.Syscall(getThreadUILanguage, 0,
0,
0,
0)
return LANGID(ret)
}
func GetVersion() int64 {
ret, _, _ := syscall.Syscall(getVersion, 0,
0,
0,
0)
return int64(ret)
}
func GlobalAlloc(uFlags uint32, dwBytes uintptr) HGLOBAL {
ret, _, _ := syscall.Syscall(globalAlloc, 2,
uintptr(uFlags),
dwBytes,
0)
return HGLOBAL(ret)
}
func GlobalFree(hMem HGLOBAL) HGLOBAL {
ret, _, _ := syscall.Syscall(globalFree, 1,
uintptr(hMem),
0,
0)
return HGLOBAL(ret)
}
func GlobalLock(hMem HGLOBAL) unsafe.Pointer {
ret, _, _ := syscall.Syscall(globalLock, 1,
uintptr(hMem),
0,
0)
return unsafe.Pointer(ret)
}
func GlobalUnlock(hMem HGLOBAL) bool {
ret, _, _ := syscall.Syscall(globalUnlock, 1,
uintptr(hMem),
0,
0)
return ret != 0
}
func MoveMemory(destination, source unsafe.Pointer, length uintptr) {
syscall.Syscall(moveMemory, 3,
uintptr(unsafe.Pointer(destination)),
uintptr(source),
uintptr(length))
}
func MulDiv(nNumber, nNumerator, nDenominator int32) int32 {
ret, _, _ := syscall.Syscall(mulDiv, 3,
uintptr(nNumber),
uintptr(nNumerator),
uintptr(nDenominator))
return int32(ret)
}
func SetLastError(dwErrorCode uint32) {
syscall.Syscall(setLastError, 1,
uintptr(dwErrorCode),
0,
0)
}
func SystemTimeToFileTime(lpSystemTime *SYSTEMTIME, lpFileTime *FILETIME) bool {
ret, _, _ := syscall.Syscall(systemTimeToFileTime, 2,
uintptr(unsafe.Pointer(lpSystemTime)),
uintptr(unsafe.Pointer(lpFileTime)),
0)
return ret != 0
}
func GetPhysicallyInstalledSystemMemory(totalMemoryInKilobytes *uint64) bool {
ret, _, _ := syscall.Syscall(getPhysicallyInstalledSystemMemory, 1,
uintptr(unsafe.Pointer(totalMemoryInKilobytes)),
0,
0)
return ret != 0
}

87
vendor/github.com/lxn/win/listbox.go generated vendored Normal file
View File

@ -0,0 +1,87 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// ListBox style
const (
LBS_NOTIFY = 0x0001
LBS_SORT = 0x0002
LBS_NOREDRAW = 0x0004
LBS_MULTIPLESEL = 0x0008
LBS_OWNERDRAWFIXED = 0x0010
LBS_OWNERDRAWVARIABLE = 0x0020
LBS_HASSTRINGS = 0x0040
LBS_USETABSTOPS = 0x0080
LBS_NOINTEGRALHEIGHT = 0x0100
LBS_MULTICOLUMN = 0x0200
LBS_WANTKEYBOARDINPUT = 0x0400
LBS_EXTENDEDSEL = 0x0800
LBS_DISABLENOSCROLL = 0x1000
LBS_NODATA = 0x2000
LBS_NOSEL = 0x4000
LBS_COMBOBOX = 0x8000
LBS_STANDARD = LBS_NOTIFY | LBS_SORT | WS_BORDER | WS_VSCROLL
)
// ListBox messages
const (
LB_ADDSTRING = 0x0180
LB_INSERTSTRING = 0x0181
LB_DELETESTRING = 0x0182
LB_SELITEMRANGEEX = 0x0183
LB_RESETCONTENT = 0x0184
LB_SETSEL = 0x0185
LB_SETCURSEL = 0x0186
LB_GETSEL = 0x0187
LB_GETCURSEL = 0x0188
LB_GETTEXT = 0x0189
LB_GETTEXTLEN = 0x018A
LB_GETCOUNT = 0x018B
LB_SELECTSTRING = 0x018C
LB_DIR = 0x018D
LB_GETTOPINDEX = 0x018E
LB_FINDSTRING = 0x018F
LB_GETSELCOUNT = 0x0190
LB_GETSELITEMS = 0x0191
LB_SETTABSTOPS = 0x0192
LB_GETHORIZONTALEXTENT = 0x0193
LB_SETHORIZONTALEXTENT = 0x0194
LB_SETCOLUMNWIDTH = 0x0195
LB_ADDFILE = 0x0196
LB_SETTOPINDEX = 0x0197
LB_GETITEMRECT = 0x0198
LB_GETITEMDATA = 0x0199
LB_SETITEMDATA = 0x019A
LB_SELITEMRANGE = 0x019B
LB_SETANCHORINDEX = 0x019C
LB_GETANCHORINDEX = 0x019D
LB_SETCARETINDEX = 0x019E
LB_GETCARETINDEX = 0x019F
LB_SETITEMHEIGHT = 0x01A0
LB_GETITEMHEIGHT = 0x01A1
LB_FINDSTRINGEXACT = 0x01A2
LB_SETLOCALE = 0x01A5
LB_GETLOCALE = 0x01A6
LB_SETCOUNT = 0x01A7
LB_INITSTORAGE = 0x01A8
LB_ITEMFROMPOINT = 0x01A9
LB_MULTIPLEADDSTRING = 0x01B1
)
//Listbox Notification Codes
const (
LBN_ERRSPACE = -2
LBN_SELCHANGE = 1
LBN_DBLCLK = 2
LBN_SELCANCEL = 3
LBN_SETFOCUS = 4
LBN_KILLFOCUS = 5
)
const (
LB_ERR = -1
LB_ERRSPACE = -2
)

370
vendor/github.com/lxn/win/listview.go generated vendored Normal file
View File

@ -0,0 +1,370 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
const (
LVSCW_AUTOSIZE = ^uintptr(0)
LVSCW_AUTOSIZE_USEHEADER = ^uintptr(1)
)
// LVM_SETITEMCOUNT flags
const (
LVSICF_NOINVALIDATEALL = 0x0001
LVSICF_NOSCROLL = 0x0002
)
// ListView messages
const (
LVM_FIRST = 0x1000
LVM_SETIMAGELIST = LVM_FIRST + 3
LVM_GETITEM = LVM_FIRST + 75
LVM_SETITEM = LVM_FIRST + 76
LVM_INSERTITEM = LVM_FIRST + 77
LVM_DELETEITEM = LVM_FIRST + 8
LVM_DELETEALLITEMS = LVM_FIRST + 9
LVM_GETCALLBACKMASK = LVM_FIRST + 10
LVM_SETCALLBACKMASK = LVM_FIRST + 11
LVM_GETNEXTITEM = LVM_FIRST + 12
LVM_FINDITEM = LVM_FIRST + 83
LVM_GETITEMRECT = LVM_FIRST + 14
LVM_GETSTRINGWIDTH = LVM_FIRST + 87
LVM_HITTEST = LVM_FIRST + 18
LVM_ENSUREVISIBLE = LVM_FIRST + 19
LVM_SCROLL = LVM_FIRST + 20
LVM_REDRAWITEMS = LVM_FIRST + 21
LVM_ARRANGE = LVM_FIRST + 22
LVM_EDITLABEL = LVM_FIRST + 118
LVM_GETEDITCONTROL = LVM_FIRST + 24
LVM_GETCOLUMN = LVM_FIRST + 95
LVM_SETCOLUMN = LVM_FIRST + 96
LVM_INSERTCOLUMN = LVM_FIRST + 97
LVM_DELETECOLUMN = LVM_FIRST + 28
LVM_GETCOLUMNWIDTH = LVM_FIRST + 29
LVM_SETCOLUMNWIDTH = LVM_FIRST + 30
LVM_GETHEADER = LVM_FIRST + 31
LVM_CREATEDRAGIMAGE = LVM_FIRST + 33
LVM_GETVIEWRECT = LVM_FIRST + 34
LVM_GETTEXTCOLOR = LVM_FIRST + 35
LVM_SETTEXTCOLOR = LVM_FIRST + 36
LVM_GETTEXTBKCOLOR = LVM_FIRST + 37
LVM_SETTEXTBKCOLOR = LVM_FIRST + 38
LVM_GETTOPINDEX = LVM_FIRST + 39
LVM_GETCOUNTPERPAGE = LVM_FIRST + 40
LVM_GETORIGIN = LVM_FIRST + 41
LVM_UPDATE = LVM_FIRST + 42
LVM_SETITEMSTATE = LVM_FIRST + 43
LVM_GETITEMSTATE = LVM_FIRST + 44
LVM_GETITEMTEXT = LVM_FIRST + 115
LVM_SETITEMTEXT = LVM_FIRST + 116
LVM_SETITEMCOUNT = LVM_FIRST + 47
LVM_SORTITEMS = LVM_FIRST + 48
LVM_SETITEMPOSITION32 = LVM_FIRST + 49
LVM_GETSELECTEDCOUNT = LVM_FIRST + 50
LVM_GETITEMSPACING = LVM_FIRST + 51
LVM_GETISEARCHSTRING = LVM_FIRST + 117
LVM_SETICONSPACING = LVM_FIRST + 53
LVM_SETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 54
LVM_GETEXTENDEDLISTVIEWSTYLE = LVM_FIRST + 55
LVM_GETSUBITEMRECT = LVM_FIRST + 56
LVM_SUBITEMHITTEST = LVM_FIRST + 57
LVM_SETCOLUMNORDERARRAY = LVM_FIRST + 58
LVM_GETCOLUMNORDERARRAY = LVM_FIRST + 59
LVM_SETHOTITEM = LVM_FIRST + 60
LVM_GETHOTITEM = LVM_FIRST + 61
LVM_SETHOTCURSOR = LVM_FIRST + 62
LVM_GETHOTCURSOR = LVM_FIRST + 63
LVM_APPROXIMATEVIEWRECT = LVM_FIRST + 64
LVM_SETWORKAREAS = LVM_FIRST + 65
LVM_GETWORKAREAS = LVM_FIRST + 70
LVM_GETNUMBEROFWORKAREAS = LVM_FIRST + 73
LVM_GETSELECTIONMARK = LVM_FIRST + 66
LVM_SETSELECTIONMARK = LVM_FIRST + 67
LVM_SETHOVERTIME = LVM_FIRST + 71
LVM_GETHOVERTIME = LVM_FIRST + 72
LVM_SETTOOLTIPS = LVM_FIRST + 74
LVM_GETTOOLTIPS = LVM_FIRST + 78
LVM_SORTITEMSEX = LVM_FIRST + 81
LVM_SETBKIMAGE = LVM_FIRST + 138
LVM_GETBKIMAGE = LVM_FIRST + 139
LVM_SETSELECTEDCOLUMN = LVM_FIRST + 140
LVM_SETVIEW = LVM_FIRST + 142
LVM_GETVIEW = LVM_FIRST + 143
LVM_INSERTGROUP = LVM_FIRST + 145
LVM_SETGROUPINFO = LVM_FIRST + 147
LVM_GETGROUPINFO = LVM_FIRST + 149
LVM_REMOVEGROUP = LVM_FIRST + 150
LVM_MOVEGROUP = LVM_FIRST + 151
LVM_GETGROUPCOUNT = LVM_FIRST + 152
LVM_GETGROUPINFOBYINDEX = LVM_FIRST + 153
LVM_MOVEITEMTOGROUP = LVM_FIRST + 154
LVM_GETGROUPRECT = LVM_FIRST + 98
LVM_SETGROUPMETRICS = LVM_FIRST + 155
LVM_GETGROUPMETRICS = LVM_FIRST + 156
LVM_ENABLEGROUPVIEW = LVM_FIRST + 157
LVM_SORTGROUPS = LVM_FIRST + 158
LVM_INSERTGROUPSORTED = LVM_FIRST + 159
LVM_REMOVEALLGROUPS = LVM_FIRST + 160
LVM_HASGROUP = LVM_FIRST + 161
LVM_GETGROUPSTATE = LVM_FIRST + 92
LVM_GETFOCUSEDGROUP = LVM_FIRST + 93
LVM_SETTILEVIEWINFO = LVM_FIRST + 162
LVM_GETTILEVIEWINFO = LVM_FIRST + 163
LVM_SETTILEINFO = LVM_FIRST + 164
LVM_GETTILEINFO = LVM_FIRST + 165
LVM_SETINSERTMARK = LVM_FIRST + 166
LVM_GETINSERTMARK = LVM_FIRST + 167
LVM_INSERTMARKHITTEST = LVM_FIRST + 168
LVM_GETINSERTMARKRECT = LVM_FIRST + 169
LVM_SETINSERTMARKCOLOR = LVM_FIRST + 170
LVM_GETINSERTMARKCOLOR = LVM_FIRST + 171
LVM_SETINFOTIP = LVM_FIRST + 173
LVM_GETSELECTEDCOLUMN = LVM_FIRST + 174
LVM_ISGROUPVIEWENABLED = LVM_FIRST + 175
LVM_GETOUTLINECOLOR = LVM_FIRST + 176
LVM_SETOUTLINECOLOR = LVM_FIRST + 177
LVM_CANCELEDITLABEL = LVM_FIRST + 179
LVM_MAPINDEXTOID = LVM_FIRST + 180
LVM_MAPIDTOINDEX = LVM_FIRST + 181
LVM_ISITEMVISIBLE = LVM_FIRST + 182
LVM_GETNEXTITEMINDEX = LVM_FIRST + 211
)
// ListView notifications
const (
LVN_FIRST = ^uint32(99) // -100
LVN_ITEMCHANGING = LVN_FIRST - 0
LVN_ITEMCHANGED = LVN_FIRST - 1
LVN_INSERTITEM = LVN_FIRST - 2
LVN_DELETEITEM = LVN_FIRST - 3
LVN_DELETEALLITEMS = LVN_FIRST - 4
LVN_BEGINLABELEDIT = LVN_FIRST - 75
LVN_ENDLABELEDIT = LVN_FIRST - 76
LVN_COLUMNCLICK = LVN_FIRST - 8
LVN_BEGINDRAG = LVN_FIRST - 9
LVN_BEGINRDRAG = LVN_FIRST - 11
LVN_ODCACHEHINT = LVN_FIRST - 13
LVN_ODFINDITEM = LVN_FIRST - 79
LVN_ITEMACTIVATE = LVN_FIRST - 14
LVN_ODSTATECHANGED = LVN_FIRST - 15
LVN_HOTTRACK = LVN_FIRST - 21
LVN_GETDISPINFO = LVN_FIRST - 77
LVN_SETDISPINFO = LVN_FIRST - 78
LVN_KEYDOWN = LVN_FIRST - 55
LVN_MARQUEEBEGIN = LVN_FIRST - 56
LVN_GETINFOTIP = LVN_FIRST - 58
LVN_INCREMENTALSEARCH = LVN_FIRST - 63
LVN_BEGINSCROLL = LVN_FIRST - 80
LVN_ENDSCROLL = LVN_FIRST - 81
)
// ListView LVNI constants
const (
LVNI_ALL = 0
LVNI_FOCUSED = 1
LVNI_SELECTED = 2
LVNI_CUT = 4
LVNI_DROPHILITED = 8
LVNI_ABOVE = 256
LVNI_BELOW = 512
LVNI_TOLEFT = 1024
LVNI_TORIGHT = 2048
)
// ListView styles
const (
LVS_ICON = 0x0000
LVS_REPORT = 0x0001
LVS_SMALLICON = 0x0002
LVS_LIST = 0x0003
LVS_TYPEMASK = 0x0003
LVS_SINGLESEL = 0x0004
LVS_SHOWSELALWAYS = 0x0008
LVS_SORTASCENDING = 0x0010
LVS_SORTDESCENDING = 0x0020
LVS_SHAREIMAGELISTS = 0x0040
LVS_NOLABELWRAP = 0x0080
LVS_AUTOARRANGE = 0x0100
LVS_EDITLABELS = 0x0200
LVS_OWNERDATA = 0x1000
LVS_NOSCROLL = 0x2000
LVS_TYPESTYLEMASK = 0xfc00
LVS_ALIGNTOP = 0x0000
LVS_ALIGNLEFT = 0x0800
LVS_ALIGNMASK = 0x0c00
LVS_OWNERDRAWFIXED = 0x0400
LVS_NOCOLUMNHEADER = 0x4000
LVS_NOSORTHEADER = 0x8000
)
// ListView extended styles
const (
LVS_EX_GRIDLINES = 0x00000001
LVS_EX_SUBITEMIMAGES = 0x00000002
LVS_EX_CHECKBOXES = 0x00000004
LVS_EX_TRACKSELECT = 0x00000008
LVS_EX_HEADERDRAGDROP = 0x00000010
LVS_EX_FULLROWSELECT = 0x00000020
LVS_EX_ONECLICKACTIVATE = 0x00000040
LVS_EX_TWOCLICKACTIVATE = 0x00000080
LVS_EX_FLATSB = 0x00000100
LVS_EX_REGIONAL = 0x00000200
LVS_EX_INFOTIP = 0x00000400
LVS_EX_UNDERLINEHOT = 0x00000800
LVS_EX_UNDERLINECOLD = 0x00001000
LVS_EX_MULTIWORKAREAS = 0x00002000
LVS_EX_LABELTIP = 0x00004000
LVS_EX_BORDERSELECT = 0x00008000
LVS_EX_DOUBLEBUFFER = 0x00010000
LVS_EX_HIDELABELS = 0x00020000
LVS_EX_SINGLEROW = 0x00040000
LVS_EX_SNAPTOGRID = 0x00080000
LVS_EX_SIMPLESELECT = 0x00100000
)
// ListView column flags
const (
LVCF_FMT = 0x0001
LVCF_WIDTH = 0x0002
LVCF_TEXT = 0x0004
LVCF_SUBITEM = 0x0008
LVCF_IMAGE = 0x0010
LVCF_ORDER = 0x0020
)
// ListView column format constants
const (
LVCFMT_LEFT = 0x0000
LVCFMT_RIGHT = 0x0001
LVCFMT_CENTER = 0x0002
LVCFMT_JUSTIFYMASK = 0x0003
LVCFMT_IMAGE = 0x0800
LVCFMT_BITMAP_ON_RIGHT = 0x1000
LVCFMT_COL_HAS_IMAGES = 0x8000
)
// ListView item flags
const (
LVIF_TEXT = 0x00000001
LVIF_IMAGE = 0x00000002
LVIF_PARAM = 0x00000004
LVIF_STATE = 0x00000008
LVIF_INDENT = 0x00000010
LVIF_NORECOMPUTE = 0x00000800
LVIF_GROUPID = 0x00000100
LVIF_COLUMNS = 0x00000200
)
// ListView item states
const (
LVIS_FOCUSED = 1
LVIS_SELECTED = 2
LVIS_CUT = 4
LVIS_DROPHILITED = 8
LVIS_OVERLAYMASK = 0xF00
LVIS_STATEIMAGEMASK = 0xF000
)
// ListView hit test constants
const (
LVHT_NOWHERE = 0x00000001
LVHT_ONITEMICON = 0x00000002
LVHT_ONITEMLABEL = 0x00000004
LVHT_ONITEMSTATEICON = 0x00000008
LVHT_ONITEM = LVHT_ONITEMICON | LVHT_ONITEMLABEL | LVHT_ONITEMSTATEICON
LVHT_ABOVE = 0x00000008
LVHT_BELOW = 0x00000010
LVHT_TORIGHT = 0x00000020
LVHT_TOLEFT = 0x00000040
)
// ListView image list types
const (
LVSIL_NORMAL = 0
LVSIL_SMALL = 1
LVSIL_STATE = 2
LVSIL_GROUPHEADER = 3
)
type LVCOLUMN struct {
Mask uint32
Fmt int32
Cx int32
PszText *uint16
CchTextMax int32
ISubItem int32
IImage int32
IOrder int32
}
type LVITEM struct {
Mask uint32
IItem int32
ISubItem int32
State uint32
StateMask uint32
PszText *uint16
CchTextMax int32
IImage int32
LParam uintptr
IIndent int32
IGroupId int32
CColumns uint32
PuColumns uint32
}
type LVHITTESTINFO struct {
Pt POINT
Flags uint32
IItem int32
ISubItem int32
IGroup int32
}
type NMITEMACTIVATE struct {
Hdr NMHDR
IItem int32
ISubItem int32
UNewState uint32
UOldState uint32
UChanged uint32
PtAction POINT
LParam uintptr
UKeyFlags uint32
}
type NMLISTVIEW struct {
Hdr NMHDR
IItem int32
ISubItem int32
UNewState uint32
UOldState uint32
UChanged uint32
PtAction POINT
LParam uintptr
}
type NMLVCUSTOMDRAW struct {
Nmcd NMCUSTOMDRAW
ClrText COLORREF
ClrTextBk COLORREF
ISubItem int32
DwItemType uint32
ClrFace COLORREF
IIconEffect int32
IIconPhase int32
IPartId int32
IStateId int32
RcText RECT
UAlign uint32
}
type NMLVDISPINFO struct {
Hdr NMHDR
Item LVITEM
}

110
vendor/github.com/lxn/win/menu.go generated vendored Normal file
View File

@ -0,0 +1,110 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// Constants for MENUITEMINFO.fMask
const (
MIIM_STATE = 1
MIIM_ID = 2
MIIM_SUBMENU = 4
MIIM_CHECKMARKS = 8
MIIM_TYPE = 16
MIIM_DATA = 32
MIIM_STRING = 64
MIIM_BITMAP = 128
MIIM_FTYPE = 256
)
// Constants for MENUITEMINFO.fType
const (
MFT_BITMAP = 4
MFT_MENUBARBREAK = 32
MFT_MENUBREAK = 64
MFT_OWNERDRAW = 256
MFT_RADIOCHECK = 512
MFT_RIGHTJUSTIFY = 0x4000
MFT_SEPARATOR = 0x800
MFT_RIGHTORDER = 0x2000
MFT_STRING = 0
)
// Constants for MENUITEMINFO.fState
const (
MFS_CHECKED = 8
MFS_DEFAULT = 4096
MFS_DISABLED = 3
MFS_ENABLED = 0
MFS_GRAYED = 3
MFS_HILITE = 128
MFS_UNCHECKED = 0
MFS_UNHILITE = 0
)
// Constants for MENUITEMINFO.hbmp*
const (
HBMMENU_CALLBACK = -1
HBMMENU_SYSTEM = 1
HBMMENU_MBAR_RESTORE = 2
HBMMENU_MBAR_MINIMIZE = 3
HBMMENU_MBAR_CLOSE = 5
HBMMENU_MBAR_CLOSE_D = 6
HBMMENU_MBAR_MINIMIZE_D = 7
HBMMENU_POPUP_CLOSE = 8
HBMMENU_POPUP_RESTORE = 9
HBMMENU_POPUP_MAXIMIZE = 10
HBMMENU_POPUP_MINIMIZE = 11
)
// MENUINFO mask constants
const (
MIM_APPLYTOSUBMENUS = 0x80000000
MIM_BACKGROUND = 0x00000002
MIM_HELPID = 0x00000004
MIM_MAXHEIGHT = 0x00000001
MIM_MENUDATA = 0x00000008
MIM_STYLE = 0x00000010
)
// MENUINFO style constants
const (
MNS_AUTODISMISS = 0x10000000
MNS_CHECKORBMP = 0x04000000
MNS_DRAGDROP = 0x20000000
MNS_MODELESS = 0x40000000
MNS_NOCHECK = 0x80000000
MNS_NOTIFYBYPOS = 0x08000000
)
const (
MF_BYCOMMAND = 0x00000000
MF_BYPOSITION = 0x00000400
)
type MENUITEMINFO struct {
CbSize uint32
FMask uint32
FType uint32
FState uint32
WID uint32
HSubMenu HMENU
HbmpChecked HBITMAP
HbmpUnchecked HBITMAP
DwItemData uintptr
DwTypeData *uint16
Cch uint32
HbmpItem HBITMAP
}
type MENUINFO struct {
CbSize uint32
FMask uint32
DwStyle uint32
CyMax uint32
HbrBack HBRUSH
DwContextHelpID uint32
DwMenuData uintptr
}

500
vendor/github.com/lxn/win/ole32.go generated vendored Normal file
View File

@ -0,0 +1,500 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
const (
CLSCTX_INPROC_SERVER = 0x1
CLSCTX_INPROC_HANDLER = 0x2
CLSCTX_LOCAL_SERVER = 0x4
CLSCTX_INPROC_SERVER16 = 0x8
CLSCTX_REMOTE_SERVER = 0x10
CLSCTX_INPROC_HANDLER16 = 0x20
CLSCTX_RESERVED1 = 0x40
CLSCTX_RESERVED2 = 0x80
CLSCTX_RESERVED3 = 0x100
CLSCTX_RESERVED4 = 0x200
CLSCTX_NO_CODE_DOWNLOAD = 0x400
CLSCTX_RESERVED5 = 0x800
CLSCTX_NO_CUSTOM_MARSHAL = 0x1000
CLSCTX_ENABLE_CODE_DOWNLOAD = 0x2000
CLSCTX_NO_FAILURE_LOG = 0x4000
CLSCTX_DISABLE_AAA = 0x8000
CLSCTX_ENABLE_AAA = 0x10000
CLSCTX_FROM_DEFAULT_CONTEXT = 0x20000
CLSCTX_ACTIVATE_32_BIT_SERVER = 0x40000
CLSCTX_ACTIVATE_64_BIT_SERVER = 0x80000
CLSCTX_ENABLE_CLOAKING = 0x100000
CLSCTX_PS_DLL = 0x80000000
CLSCTX_ALL = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
)
// Verbs for IOleObject.DoVerb
const (
OLEIVERB_PRIMARY = 0
OLEIVERB_SHOW = -1
OLEIVERB_OPEN = -2
OLEIVERB_HIDE = -3
OLEIVERB_UIACTIVATE = -4
OLEIVERB_INPLACEACTIVATE = -5
OLEIVERB_DISCARDUNDOSTATE = -6
)
// OLECLOSE constants
const (
OLECLOSE_SAVEIFDIRTY = 0
OLECLOSE_NOSAVE = 1
OLECLOSE_PROMPTSAVE = 2
)
type IID syscall.GUID
type CLSID syscall.GUID
type REFIID *IID
type REFCLSID *CLSID
var (
IID_IClassFactory = IID{0x00000001, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
IID_IConnectionPointContainer = IID{0xB196B284, 0xBAB4, 0x101A, [8]byte{0xB6, 0x9C, 0x00, 0xAA, 0x00, 0x34, 0x1D, 0x07}}
IID_IOleClientSite = IID{0x00000118, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
IID_IOleInPlaceObject = IID{0x00000113, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
IID_IOleInPlaceSite = IID{0x00000119, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
IID_IOleObject = IID{0x00000112, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
IID_IUnknown = IID{0x00000000, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
)
func EqualREFIID(a, b REFIID) bool {
if a == b {
return true
}
if a == nil || b == nil {
return false
}
if a.Data1 != b.Data1 || a.Data2 != b.Data2 || a.Data3 != b.Data3 {
return false
}
for i := 0; i < 8; i++ {
if a.Data4[i] != b.Data4[i] {
return false
}
}
return true
}
type IClassFactoryVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
CreateInstance uintptr
LockServer uintptr
}
type IClassFactory struct {
LpVtbl *IClassFactoryVtbl
}
func (cf *IClassFactory) Release() uint32 {
ret, _, _ := syscall.Syscall(cf.LpVtbl.Release, 1,
uintptr(unsafe.Pointer(cf)),
0,
0)
return uint32(ret)
}
func (cf *IClassFactory) CreateInstance(pUnkOuter *IUnknown, riid REFIID, ppvObject *unsafe.Pointer) HRESULT {
ret, _, _ := syscall.Syscall6(cf.LpVtbl.CreateInstance, 4,
uintptr(unsafe.Pointer(cf)),
uintptr(unsafe.Pointer(pUnkOuter)),
uintptr(unsafe.Pointer(riid)),
uintptr(unsafe.Pointer(ppvObject)),
0,
0)
return HRESULT(ret)
}
type IConnectionPointVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
GetConnectionInterface uintptr
GetConnectionPointContainer uintptr
Advise uintptr
Unadvise uintptr
EnumConnections uintptr
}
type IConnectionPoint struct {
LpVtbl *IConnectionPointVtbl
}
func (cp *IConnectionPoint) Release() uint32 {
ret, _, _ := syscall.Syscall(cp.LpVtbl.Release, 1,
uintptr(unsafe.Pointer(cp)),
0,
0)
return uint32(ret)
}
func (cp *IConnectionPoint) Advise(pUnkSink unsafe.Pointer, pdwCookie *uint32) HRESULT {
ret, _, _ := syscall.Syscall(cp.LpVtbl.Advise, 3,
uintptr(unsafe.Pointer(cp)),
uintptr(pUnkSink),
uintptr(unsafe.Pointer(pdwCookie)))
return HRESULT(ret)
}
type IConnectionPointContainerVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
EnumConnectionPoints uintptr
FindConnectionPoint uintptr
}
type IConnectionPointContainer struct {
LpVtbl *IConnectionPointContainerVtbl
}
func (cpc *IConnectionPointContainer) Release() uint32 {
ret, _, _ := syscall.Syscall(cpc.LpVtbl.Release, 1,
uintptr(unsafe.Pointer(cpc)),
0,
0)
return uint32(ret)
}
func (cpc *IConnectionPointContainer) FindConnectionPoint(riid REFIID, ppCP **IConnectionPoint) HRESULT {
ret, _, _ := syscall.Syscall(cpc.LpVtbl.FindConnectionPoint, 3,
uintptr(unsafe.Pointer(cpc)),
uintptr(unsafe.Pointer(riid)),
uintptr(unsafe.Pointer(ppCP)))
return HRESULT(ret)
}
type IOleClientSiteVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
SaveObject uintptr
GetMoniker uintptr
GetContainer uintptr
ShowObject uintptr
OnShowWindow uintptr
RequestNewObjectLayout uintptr
}
type IOleClientSite struct {
LpVtbl *IOleClientSiteVtbl
}
type IOleInPlaceFrameVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
GetWindow uintptr
ContextSensitiveHelp uintptr
GetBorder uintptr
RequestBorderSpace uintptr
SetBorderSpace uintptr
SetActiveObject uintptr
InsertMenus uintptr
SetMenu uintptr
RemoveMenus uintptr
SetStatusText uintptr
EnableModeless uintptr
TranslateAccelerator uintptr
}
type IOleInPlaceFrame struct {
LpVtbl *IOleInPlaceFrameVtbl
}
type IOleInPlaceObjectVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
GetWindow uintptr
ContextSensitiveHelp uintptr
InPlaceDeactivate uintptr
UIDeactivate uintptr
SetObjectRects uintptr
ReactivateAndUndo uintptr
}
type IOleInPlaceObject struct {
LpVtbl *IOleInPlaceObjectVtbl
}
func (obj *IOleInPlaceObject) Release() uint32 {
ret, _, _ := syscall.Syscall(obj.LpVtbl.Release, 1,
uintptr(unsafe.Pointer(obj)),
0,
0)
return uint32(ret)
}
func (obj *IOleInPlaceObject) SetObjectRects(lprcPosRect, lprcClipRect *RECT) HRESULT {
ret, _, _ := syscall.Syscall(obj.LpVtbl.SetObjectRects, 3,
uintptr(unsafe.Pointer(obj)),
uintptr(unsafe.Pointer(lprcPosRect)),
uintptr(unsafe.Pointer(lprcClipRect)))
return HRESULT(ret)
}
type IOleInPlaceSiteVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
GetWindow uintptr
ContextSensitiveHelp uintptr
CanInPlaceActivate uintptr
OnInPlaceActivate uintptr
OnUIActivate uintptr
GetWindowContext uintptr
Scroll uintptr
OnUIDeactivate uintptr
OnInPlaceDeactivate uintptr
DiscardUndoState uintptr
DeactivateAndUndo uintptr
OnPosRectChange uintptr
}
type IOleInPlaceSite struct {
LpVtbl *IOleInPlaceSiteVtbl
}
type IOleObjectVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
SetClientSite uintptr
GetClientSite uintptr
SetHostNames uintptr
Close uintptr
SetMoniker uintptr
GetMoniker uintptr
InitFromData uintptr
GetClipboardData uintptr
DoVerb uintptr
EnumVerbs uintptr
Update uintptr
IsUpToDate uintptr
GetUserClassID uintptr
GetUserType uintptr
SetExtent uintptr
GetExtent uintptr
Advise uintptr
Unadvise uintptr
EnumAdvise uintptr
GetMiscStatus uintptr
SetColorScheme uintptr
}
type IOleObject struct {
LpVtbl *IOleObjectVtbl
}
func (obj *IOleObject) QueryInterface(riid REFIID, ppvObject *unsafe.Pointer) HRESULT {
ret, _, _ := syscall.Syscall(obj.LpVtbl.QueryInterface, 3,
uintptr(unsafe.Pointer(obj)),
uintptr(unsafe.Pointer(riid)),
uintptr(unsafe.Pointer(ppvObject)))
return HRESULT(ret)
}
func (obj *IOleObject) Release() uint32 {
ret, _, _ := syscall.Syscall(obj.LpVtbl.Release, 1,
uintptr(unsafe.Pointer(obj)),
0,
0)
return uint32(ret)
}
func (obj *IOleObject) SetClientSite(pClientSite *IOleClientSite) HRESULT {
ret, _, _ := syscall.Syscall(obj.LpVtbl.SetClientSite, 2,
uintptr(unsafe.Pointer(obj)),
uintptr(unsafe.Pointer(pClientSite)),
0)
return HRESULT(ret)
}
func (obj *IOleObject) SetHostNames(szContainerApp, szContainerObj *uint16) HRESULT {
ret, _, _ := syscall.Syscall(obj.LpVtbl.SetHostNames, 3,
uintptr(unsafe.Pointer(obj)),
uintptr(unsafe.Pointer(szContainerApp)),
uintptr(unsafe.Pointer(szContainerObj)))
return HRESULT(ret)
}
func (obj *IOleObject) Close(dwSaveOption uint32) HRESULT {
ret, _, _ := syscall.Syscall(obj.LpVtbl.Close, 2,
uintptr(unsafe.Pointer(obj)),
uintptr(dwSaveOption),
0)
return HRESULT(ret)
}
func (obj *IOleObject) DoVerb(iVerb int32, lpmsg *MSG, pActiveSite *IOleClientSite, lindex int32, hwndParent HWND, lprcPosRect *RECT) HRESULT {
ret, _, _ := syscall.Syscall9(obj.LpVtbl.DoVerb, 7,
uintptr(unsafe.Pointer(obj)),
uintptr(iVerb),
uintptr(unsafe.Pointer(lpmsg)),
uintptr(unsafe.Pointer(pActiveSite)),
uintptr(lindex),
uintptr(hwndParent),
uintptr(unsafe.Pointer(lprcPosRect)),
0,
0)
return HRESULT(ret)
}
type IUnknownVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
}
type IUnknown struct {
LpVtbl *IUnknownVtbl
}
type OLEINPLACEFRAMEINFO struct {
Cb uint32
FMDIApp BOOL
HwndFrame HWND
Haccel HACCEL
CAccelEntries uint32
}
type COAUTHIDENTITY struct {
User *uint16
UserLength uint32
Domain *uint16
DomainLength uint32
Password *uint16
PasswordLength uint32
Flags uint32
}
type COAUTHINFO struct {
dwAuthnSvc uint32
dwAuthzSvc uint32
pwszServerPrincName *uint16
dwAuthnLevel uint32
dwImpersonationLevel uint32
pAuthIdentityData *COAUTHIDENTITY
dwCapabilities uint32
}
type COSERVERINFO struct {
dwReserved1 uint32
pwszName *uint16
pAuthInfo *COAUTHINFO
dwReserved2 uint32
}
var (
// Library
libole32 uintptr
// Functions
coCreateInstance uintptr
coGetClassObject uintptr
coTaskMemFree uintptr
oleInitialize uintptr
oleSetContainedObject uintptr
oleUninitialize uintptr
)
func init() {
// Library
libole32 = MustLoadLibrary("ole32.dll")
// Functions
coCreateInstance = MustGetProcAddress(libole32, "CoCreateInstance")
coGetClassObject = MustGetProcAddress(libole32, "CoGetClassObject")
coTaskMemFree = MustGetProcAddress(libole32, "CoTaskMemFree")
oleInitialize = MustGetProcAddress(libole32, "OleInitialize")
oleSetContainedObject = MustGetProcAddress(libole32, "OleSetContainedObject")
oleUninitialize = MustGetProcAddress(libole32, "OleUninitialize")
}
func CoCreateInstance(rclsid REFCLSID, pUnkOuter *IUnknown, dwClsContext uint32, riid REFIID, ppv *unsafe.Pointer) HRESULT {
ret, _, _ := syscall.Syscall6(coCreateInstance, 5,
uintptr(unsafe.Pointer(rclsid)),
uintptr(unsafe.Pointer(pUnkOuter)),
uintptr(dwClsContext),
uintptr(unsafe.Pointer(riid)),
uintptr(unsafe.Pointer(ppv)),
0)
return HRESULT(ret)
}
func CoGetClassObject(rclsid REFCLSID, dwClsContext uint32, pServerInfo *COSERVERINFO, riid REFIID, ppv *unsafe.Pointer) HRESULT {
ret, _, _ := syscall.Syscall6(coGetClassObject, 5,
uintptr(unsafe.Pointer(rclsid)),
uintptr(dwClsContext),
uintptr(unsafe.Pointer(pServerInfo)),
uintptr(unsafe.Pointer(riid)),
uintptr(unsafe.Pointer(ppv)),
0)
return HRESULT(ret)
}
func CoTaskMemFree(pv uintptr) {
syscall.Syscall(coTaskMemFree, 1,
pv,
0,
0)
}
func OleInitialize() HRESULT {
ret, _, _ := syscall.Syscall(oleInitialize, 1, // WTF, why does 0 not work here?
0,
0,
0)
return HRESULT(ret)
}
func OleSetContainedObject(pUnknown *IUnknown, fContained bool) HRESULT {
ret, _, _ := syscall.Syscall(oleSetContainedObject, 2,
uintptr(unsafe.Pointer(pUnknown)),
uintptr(BoolToBOOL(fContained)),
0)
return HRESULT(ret)
}
func OleUninitialize() {
syscall.Syscall(oleUninitialize, 0,
0,
0,
0)
}

240
vendor/github.com/lxn/win/oleaut32.go generated vendored Normal file
View File

@ -0,0 +1,240 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
type DISPID int32
const (
DISPID_BEFORENAVIGATE DISPID = 100
DISPID_NAVIGATECOMPLETE DISPID = 101
DISPID_STATUSTEXTCHANGE DISPID = 102
DISPID_QUIT DISPID = 103
DISPID_DOWNLOADCOMPLETE DISPID = 104
DISPID_COMMANDSTATECHANGE DISPID = 105
DISPID_DOWNLOADBEGIN DISPID = 106
DISPID_NEWWINDOW DISPID = 107
DISPID_PROGRESSCHANGE DISPID = 108
DISPID_WINDOWMOVE DISPID = 109
DISPID_WINDOWRESIZE DISPID = 110
DISPID_WINDOWACTIVATE DISPID = 111
DISPID_PROPERTYCHANGE DISPID = 112
DISPID_TITLECHANGE DISPID = 113
DISPID_TITLEICONCHANGE DISPID = 114
DISPID_FRAMEBEFORENAVIGATE DISPID = 200
DISPID_FRAMENAVIGATECOMPLETE DISPID = 201
DISPID_FRAMENEWWINDOW DISPID = 204
DISPID_BEFORENAVIGATE2 DISPID = 250
DISPID_NEWWINDOW2 DISPID = 251
DISPID_NAVIGATECOMPLETE2 DISPID = 252
DISPID_ONQUIT DISPID = 253
DISPID_ONVISIBLE DISPID = 254
DISPID_ONTOOLBAR DISPID = 255
DISPID_ONMENUBAR DISPID = 256
DISPID_ONSTATUSBAR DISPID = 257
DISPID_ONFULLSCREEN DISPID = 258
DISPID_DOCUMENTCOMPLETE DISPID = 259
DISPID_ONTHEATERMODE DISPID = 260
DISPID_ONADDRESSBAR DISPID = 261
DISPID_WINDOWSETRESIZABLE DISPID = 262
DISPID_WINDOWCLOSING DISPID = 263
DISPID_WINDOWSETLEFT DISPID = 264
DISPID_WINDOWSETTOP DISPID = 265
DISPID_WINDOWSETWIDTH DISPID = 266
DISPID_WINDOWSETHEIGHT DISPID = 267
DISPID_CLIENTTOHOSTWINDOW DISPID = 268
DISPID_SETSECURELOCKICON DISPID = 269
DISPID_FILEDOWNLOAD DISPID = 270
DISPID_NAVIGATEERROR DISPID = 271
DISPID_PRIVACYIMPACTEDSTATECHANGE DISPID = 272
)
var (
IID_IDispatch = IID{0x00020400, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
)
const (
DISP_E_MEMBERNOTFOUND = 0x80020003
)
type VARTYPE uint16
const (
VT_EMPTY VARTYPE = 0
VT_NULL VARTYPE = 1
VT_I2 VARTYPE = 2
VT_I4 VARTYPE = 3
VT_R4 VARTYPE = 4
VT_R8 VARTYPE = 5
VT_CY VARTYPE = 6
VT_DATE VARTYPE = 7
VT_BSTR VARTYPE = 8
VT_DISPATCH VARTYPE = 9
VT_ERROR VARTYPE = 10
VT_BOOL VARTYPE = 11
VT_VARIANT VARTYPE = 12
VT_UNKNOWN VARTYPE = 13
VT_DECIMAL VARTYPE = 14
VT_I1 VARTYPE = 16
VT_UI1 VARTYPE = 17
VT_UI2 VARTYPE = 18
VT_UI4 VARTYPE = 19
VT_I8 VARTYPE = 20
VT_UI8 VARTYPE = 21
VT_INT VARTYPE = 22
VT_UINT VARTYPE = 23
VT_VOID VARTYPE = 24
VT_HRESULT VARTYPE = 25
VT_PTR VARTYPE = 26
VT_SAFEARRAY VARTYPE = 27
VT_CARRAY VARTYPE = 28
VT_USERDEFINED VARTYPE = 29
VT_LPSTR VARTYPE = 30
VT_LPWSTR VARTYPE = 31
VT_RECORD VARTYPE = 36
VT_INT_PTR VARTYPE = 37
VT_UINT_PTR VARTYPE = 38
VT_FILETIME VARTYPE = 64
VT_BLOB VARTYPE = 65
VT_STREAM VARTYPE = 66
VT_STORAGE VARTYPE = 67
VT_STREAMED_OBJECT VARTYPE = 68
VT_STORED_OBJECT VARTYPE = 69
VT_BLOB_OBJECT VARTYPE = 70
VT_CF VARTYPE = 71
VT_CLSID VARTYPE = 72
VT_VERSIONED_STREAM VARTYPE = 73
VT_BSTR_BLOB VARTYPE = 0xfff
VT_VECTOR VARTYPE = 0x1000
VT_ARRAY VARTYPE = 0x2000
VT_BYREF VARTYPE = 0x4000
VT_RESERVED VARTYPE = 0x8000
VT_ILLEGAL VARTYPE = 0xffff
VT_ILLEGALMASKED VARTYPE = 0xfff
VT_TYPEMASK VARTYPE = 0xfff
)
type VARIANT struct {
Vt VARTYPE
reserved [14]byte
}
type VARIANTARG VARIANT
type VARIANT_BOOL int16
//type BSTR *uint16
func StringToBSTR(value string) *uint16 /*BSTR*/ {
// IMPORTANT: Don't forget to free the BSTR value when no longer needed!
return SysAllocString(value)
}
func BSTRToString(value *uint16 /*BSTR*/) string {
// ISSUE: Is this really ok?
bstrArrPtr := (*[200000000]uint16)(unsafe.Pointer(value))
bstrSlice := make([]uint16, SysStringLen(value))
copy(bstrSlice, bstrArrPtr[:])
return syscall.UTF16ToString(bstrSlice)
}
type VAR_I4 struct {
vt VARTYPE
reserved1 [6]byte
lVal int32
reserved2 [4]byte
}
func IntToVariantI4(value int32) *VAR_I4 {
return &VAR_I4{vt: VT_I4, lVal: value}
}
func VariantI4ToInt(value *VAR_I4) int32 {
return value.lVal
}
type VAR_BOOL struct {
vt VARTYPE
reserved1 [6]byte
boolVal VARIANT_BOOL
reserved2 [6]byte
}
func BoolToVariantBool(value bool) *VAR_BOOL {
return &VAR_BOOL{vt: VT_BOOL, boolVal: VARIANT_BOOL(BoolToBOOL(value))}
}
func VariantBoolToBool(value *VAR_BOOL) bool {
return value.boolVal != 0
}
func StringToVariantBSTR(value string) *VAR_BSTR {
// IMPORTANT: Don't forget to free the BSTR value when no longer needed!
return &VAR_BSTR{vt: VT_BSTR, bstrVal: StringToBSTR(value)}
}
func VariantBSTRToString(value *VAR_BSTR) string {
return BSTRToString(value.bstrVal)
}
type DISPPARAMS struct {
Rgvarg *VARIANTARG
RgdispidNamedArgs *DISPID
CArgs int32
CNamedArgs int32
}
var (
// Library
liboleaut32 uintptr
// Functions
sysAllocString uintptr
sysFreeString uintptr
sysStringLen uintptr
)
func init() {
// Library
liboleaut32 = MustLoadLibrary("oleaut32.dll")
// Functions
sysAllocString = MustGetProcAddress(liboleaut32, "SysAllocString")
sysFreeString = MustGetProcAddress(liboleaut32, "SysFreeString")
sysStringLen = MustGetProcAddress(liboleaut32, "SysStringLen")
}
func SysAllocString(s string) *uint16 /*BSTR*/ {
ret, _, _ := syscall.Syscall(sysAllocString, 1,
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(s))),
0,
0)
return (*uint16) /*BSTR*/ (unsafe.Pointer(ret))
}
func SysFreeString(bstr *uint16 /*BSTR*/) {
syscall.Syscall(sysFreeString, 1,
uintptr(unsafe.Pointer(bstr)),
0,
0)
}
func SysStringLen(bstr *uint16 /*BSTR*/) uint32 {
ret, _, _ := syscall.Syscall(sysStringLen, 1,
uintptr(unsafe.Pointer(bstr)),
0,
0)
return uint32(ret)
}

14
vendor/github.com/lxn/win/oleaut32_386.go generated vendored Normal file
View File

@ -0,0 +1,14 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
type VAR_BSTR struct {
vt VARTYPE
reserved1 [6]byte
bstrVal *uint16 /*BSTR*/
reserved2 [4]byte
}

13
vendor/github.com/lxn/win/oleaut32_amd64.go generated vendored Normal file
View File

@ -0,0 +1,13 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
type VAR_BSTR struct {
vt VARTYPE
reserved1 [6]byte
bstrVal *uint16 /*BSTR*/
}

301
vendor/github.com/lxn/win/opengl32.go generated vendored Normal file
View File

@ -0,0 +1,301 @@
// Copyright 2011 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
// for second parameter of WglSwapLayerBuffers
const (
WGL_SWAP_MAIN_PLANE = (1 << 0)
WGL_SWAP_OVERLAY1 = (1 << 1)
WGL_SWAP_OVERLAY2 = (1 << 2)
WGL_SWAP_OVERLAY3 = (1 << 3)
WGL_SWAP_OVERLAY4 = (1 << 4)
WGL_SWAP_OVERLAY5 = (1 << 5)
WGL_SWAP_OVERLAY6 = (1 << 6)
WGL_SWAP_OVERLAY7 = (1 << 7)
WGL_SWAP_OVERLAY8 = (1 << 8)
WGL_SWAP_OVERLAY9 = (1 << 9)
WGL_SWAP_OVERLAY10 = (1 << 10)
WGL_SWAP_OVERLAY11 = (1 << 11)
WGL_SWAP_OVERLAY12 = (1 << 12)
WGL_SWAP_OVERLAY13 = (1 << 13)
WGL_SWAP_OVERLAY14 = (1 << 14)
WGL_SWAP_OVERLAY15 = (1 << 15)
WGL_SWAP_UNDERLAY1 = (1 << 16)
WGL_SWAP_UNDERLAY2 = (1 << 17)
WGL_SWAP_UNDERLAY3 = (1 << 18)
WGL_SWAP_UNDERLAY4 = (1 << 19)
WGL_SWAP_UNDERLAY5 = (1 << 20)
WGL_SWAP_UNDERLAY6 = (1 << 21)
WGL_SWAP_UNDERLAY7 = (1 << 22)
WGL_SWAP_UNDERLAY8 = (1 << 23)
WGL_SWAP_UNDERLAY9 = (1 << 24)
WGL_SWAP_UNDERLAY10 = (1 << 25)
WGL_SWAP_UNDERLAY11 = (1 << 26)
WGL_SWAP_UNDERLAY12 = (1 << 27)
WGL_SWAP_UNDERLAY13 = (1 << 28)
WGL_SWAP_UNDERLAY14 = (1 << 29)
WGL_SWAP_UNDERLAY15 = (1 << 30)
)
type (
HGLRC HANDLE
)
type LAYERPLANEDESCRIPTOR struct {
NSize uint16
NVersion uint16
DwFlags uint32
IPixelType uint8
CColorBits uint8
CRedBits uint8
CRedShift uint8
CGreenBits uint8
CGreenShift uint8
CBlueBits uint8
CBlueShift uint8
CAlphaBits uint8
CAlphaShift uint8
CAccumBits uint8
CAccumRedBits uint8
CAccumGreenBits uint8
CAccumBlueBits uint8
CAccumAlphaBits uint8
CDepthBits uint8
CStencilBits uint8
CAuxBuffers uint8
ILayerType uint8
BReserved uint8
CrTransparent COLORREF
}
type POINTFLOAT struct {
X, Y float32
}
type GLYPHMETRICSFLOAT struct {
GmfBlackBoxX float32
GmfBlackBoxY float32
GmfptGlyphOrigin POINTFLOAT
GmfCellIncX float32
GmfCellIncY float32
}
var (
// Library
lib uintptr
// Functions
wglCopyContext uintptr
wglCreateContext uintptr
wglCreateLayerContext uintptr
wglDeleteContext uintptr
wglDescribeLayerPlane uintptr
wglGetCurrentContext uintptr
wglGetCurrentDC uintptr
wglGetLayerPaletteEntries uintptr
wglGetProcAddress uintptr
wglMakeCurrent uintptr
wglRealizeLayerPalette uintptr
wglSetLayerPaletteEntries uintptr
wglShareLists uintptr
wglSwapLayerBuffers uintptr
wglUseFontBitmaps uintptr
wglUseFontOutlines uintptr
)
func init() {
// Library
lib = MustLoadLibrary("opengl32.dll")
// Functions
wglCopyContext = MustGetProcAddress(lib, "wglCopyContext")
wglCreateContext = MustGetProcAddress(lib, "wglCreateContext")
wglCreateLayerContext = MustGetProcAddress(lib, "wglCreateLayerContext")
wglDeleteContext = MustGetProcAddress(lib, "wglDeleteContext")
wglDescribeLayerPlane = MustGetProcAddress(lib, "wglDescribeLayerPlane")
wglGetCurrentContext = MustGetProcAddress(lib, "wglGetCurrentContext")
wglGetCurrentDC = MustGetProcAddress(lib, "wglGetCurrentDC")
wglGetLayerPaletteEntries = MustGetProcAddress(lib, "wglGetLayerPaletteEntries")
wglGetProcAddress = MustGetProcAddress(lib, "wglGetProcAddress")
wglMakeCurrent = MustGetProcAddress(lib, "wglMakeCurrent")
wglRealizeLayerPalette = MustGetProcAddress(lib, "wglRealizeLayerPalette")
wglSetLayerPaletteEntries = MustGetProcAddress(lib, "wglSetLayerPaletteEntries")
wglShareLists = MustGetProcAddress(lib, "wglShareLists")
wglSwapLayerBuffers = MustGetProcAddress(lib, "wglSwapLayerBuffers")
wglUseFontBitmaps = MustGetProcAddress(lib, "wglUseFontBitmapsW")
wglUseFontOutlines = MustGetProcAddress(lib, "wglUseFontOutlinesW")
}
func WglCopyContext(hglrcSrc, hglrcDst HGLRC, mask uint) bool {
ret, _, _ := syscall.Syscall(wglCopyContext, 3,
uintptr(hglrcSrc),
uintptr(hglrcDst),
uintptr(mask))
return ret != 0
}
func WglCreateContext(hdc HDC) HGLRC {
ret, _, _ := syscall.Syscall(wglCreateContext, 1,
uintptr(hdc),
0,
0)
return HGLRC(ret)
}
func WglCreateLayerContext(hdc HDC, iLayerPlane int) HGLRC {
ret, _, _ := syscall.Syscall(wglCreateLayerContext, 2,
uintptr(hdc),
uintptr(iLayerPlane),
0)
return HGLRC(ret)
}
func WglDeleteContext(hglrc HGLRC) bool {
ret, _, _ := syscall.Syscall(wglDeleteContext, 1,
uintptr(hglrc),
0,
0)
return ret != 0
}
func WglDescribeLayerPlane(hdc HDC, iPixelFormat, iLayerPlane int, nBytes uint8, plpd *LAYERPLANEDESCRIPTOR) bool {
ret, _, _ := syscall.Syscall6(wglDescribeLayerPlane, 5,
uintptr(hdc),
uintptr(iPixelFormat),
uintptr(iLayerPlane),
uintptr(nBytes),
uintptr(unsafe.Pointer(plpd)),
0)
return ret != 0
}
func WglGetCurrentContext() HGLRC {
ret, _, _ := syscall.Syscall(wglGetCurrentContext, 0,
0,
0,
0)
return HGLRC(ret)
}
func WglGetCurrentDC() HDC {
ret, _, _ := syscall.Syscall(wglGetCurrentDC, 0,
0,
0,
0)
return HDC(ret)
}
func WglGetLayerPaletteEntries(hdc HDC, iLayerPlane, iStart, cEntries int, pcr *COLORREF) int {
ret, _, _ := syscall.Syscall6(wglGetLayerPaletteEntries, 5,
uintptr(hdc),
uintptr(iLayerPlane),
uintptr(iStart),
uintptr(cEntries),
uintptr(unsafe.Pointer(pcr)),
0)
return int(ret)
}
func WglGetProcAddress(lpszProc *byte) uintptr {
ret, _, _ := syscall.Syscall(wglGetProcAddress, 1,
uintptr(unsafe.Pointer(lpszProc)),
0,
0)
return uintptr(ret)
}
func WglMakeCurrent(hdc HDC, hglrc HGLRC) bool {
ret, _, _ := syscall.Syscall(wglMakeCurrent, 2,
uintptr(hdc),
uintptr(hglrc),
0)
return ret != 0
}
func WglRealizeLayerPalette(hdc HDC, iLayerPlane int, bRealize bool) bool {
ret, _, _ := syscall.Syscall(wglRealizeLayerPalette, 3,
uintptr(hdc),
uintptr(iLayerPlane),
uintptr(BoolToBOOL(bRealize)))
return ret != 0
}
func WglSetLayerPaletteEntries(hdc HDC, iLayerPlane, iStart, cEntries int, pcr *COLORREF) int {
ret, _, _ := syscall.Syscall6(wglSetLayerPaletteEntries, 5,
uintptr(hdc),
uintptr(iLayerPlane),
uintptr(iStart),
uintptr(cEntries),
uintptr(unsafe.Pointer(pcr)),
0)
return int(ret)
}
func WglShareLists(hglrc1, hglrc2 HGLRC) bool {
ret, _, _ := syscall.Syscall(wglShareLists, 2,
uintptr(hglrc1),
uintptr(hglrc2),
0)
return ret != 0
}
func WglSwapLayerBuffers(hdc HDC, fuPlanes uint) bool {
ret, _, _ := syscall.Syscall(wglSwapLayerBuffers, 2,
uintptr(hdc),
uintptr(fuPlanes),
0)
return ret != 0
}
func WglUseFontBitmaps(hdc HDC, first, count, listbase uint32) bool {
ret, _, _ := syscall.Syscall6(wglUseFontBitmaps, 4,
uintptr(hdc),
uintptr(first),
uintptr(count),
uintptr(listbase),
0,
0)
return ret != 0
}
func WglUseFontOutlines(hdc HDC, first, count, listbase uint32, deviation, extrusion float32, format int, pgmf *GLYPHMETRICSFLOAT) bool {
ret, _, _ := syscall.Syscall12(wglUseFontBitmaps, 8,
uintptr(hdc),
uintptr(first),
uintptr(count),
uintptr(listbase),
uintptr(deviation),
uintptr(extrusion),
uintptr(format),
uintptr(unsafe.Pointer(pgmf)),
0,
0,
0,
0)
return ret != 0
}

436
vendor/github.com/lxn/win/pdh.go generated vendored Normal file
View File

@ -0,0 +1,436 @@
// Copyright 2013 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
// PDH error codes, which can be returned by all Pdh* functions. Taken from mingw-w64 pdhmsg.h
const (
PDH_CSTATUS_VALID_DATA = 0x00000000 // The returned data is valid.
PDH_CSTATUS_NEW_DATA = 0x00000001 // The return data value is valid and different from the last sample.
PDH_CSTATUS_NO_MACHINE = 0x800007D0 // Unable to connect to the specified computer, or the computer is offline.
PDH_CSTATUS_NO_INSTANCE = 0x800007D1
PDH_MORE_DATA = 0x800007D2 // The PdhGetFormattedCounterArray* function can return this if there's 'more data to be displayed'.
PDH_CSTATUS_ITEM_NOT_VALIDATED = 0x800007D3
PDH_RETRY = 0x800007D4
PDH_NO_DATA = 0x800007D5 // The query does not currently contain any counters (for example, limited access)
PDH_CALC_NEGATIVE_DENOMINATOR = 0x800007D6
PDH_CALC_NEGATIVE_TIMEBASE = 0x800007D7
PDH_CALC_NEGATIVE_VALUE = 0x800007D8
PDH_DIALOG_CANCELLED = 0x800007D9
PDH_END_OF_LOG_FILE = 0x800007DA
PDH_ASYNC_QUERY_TIMEOUT = 0x800007DB
PDH_CANNOT_SET_DEFAULT_REALTIME_DATASOURCE = 0x800007DC
PDH_CSTATUS_NO_OBJECT = 0xC0000BB8
PDH_CSTATUS_NO_COUNTER = 0xC0000BB9 // The specified counter could not be found.
PDH_CSTATUS_INVALID_DATA = 0xC0000BBA // The counter was successfully found, but the data returned is not valid.
PDH_MEMORY_ALLOCATION_FAILURE = 0xC0000BBB
PDH_INVALID_HANDLE = 0xC0000BBC
PDH_INVALID_ARGUMENT = 0xC0000BBD // Required argument is missing or incorrect.
PDH_FUNCTION_NOT_FOUND = 0xC0000BBE
PDH_CSTATUS_NO_COUNTERNAME = 0xC0000BBF
PDH_CSTATUS_BAD_COUNTERNAME = 0xC0000BC0 // Unable to parse the counter path. Check the format and syntax of the specified path.
PDH_INVALID_BUFFER = 0xC0000BC1
PDH_INSUFFICIENT_BUFFER = 0xC0000BC2
PDH_CANNOT_CONNECT_MACHINE = 0xC0000BC3
PDH_INVALID_PATH = 0xC0000BC4
PDH_INVALID_INSTANCE = 0xC0000BC5
PDH_INVALID_DATA = 0xC0000BC6 // specified counter does not contain valid data or a successful status code.
PDH_NO_DIALOG_DATA = 0xC0000BC7
PDH_CANNOT_READ_NAME_STRINGS = 0xC0000BC8
PDH_LOG_FILE_CREATE_ERROR = 0xC0000BC9
PDH_LOG_FILE_OPEN_ERROR = 0xC0000BCA
PDH_LOG_TYPE_NOT_FOUND = 0xC0000BCB
PDH_NO_MORE_DATA = 0xC0000BCC
PDH_ENTRY_NOT_IN_LOG_FILE = 0xC0000BCD
PDH_DATA_SOURCE_IS_LOG_FILE = 0xC0000BCE
PDH_DATA_SOURCE_IS_REAL_TIME = 0xC0000BCF
PDH_UNABLE_READ_LOG_HEADER = 0xC0000BD0
PDH_FILE_NOT_FOUND = 0xC0000BD1
PDH_FILE_ALREADY_EXISTS = 0xC0000BD2
PDH_NOT_IMPLEMENTED = 0xC0000BD3
PDH_STRING_NOT_FOUND = 0xC0000BD4
PDH_UNABLE_MAP_NAME_FILES = 0x80000BD5
PDH_UNKNOWN_LOG_FORMAT = 0xC0000BD6
PDH_UNKNOWN_LOGSVC_COMMAND = 0xC0000BD7
PDH_LOGSVC_QUERY_NOT_FOUND = 0xC0000BD8
PDH_LOGSVC_NOT_OPENED = 0xC0000BD9
PDH_WBEM_ERROR = 0xC0000BDA
PDH_ACCESS_DENIED = 0xC0000BDB
PDH_LOG_FILE_TOO_SMALL = 0xC0000BDC
PDH_INVALID_DATASOURCE = 0xC0000BDD
PDH_INVALID_SQLDB = 0xC0000BDE
PDH_NO_COUNTERS = 0xC0000BDF
PDH_SQL_ALLOC_FAILED = 0xC0000BE0
PDH_SQL_ALLOCCON_FAILED = 0xC0000BE1
PDH_SQL_EXEC_DIRECT_FAILED = 0xC0000BE2
PDH_SQL_FETCH_FAILED = 0xC0000BE3
PDH_SQL_ROWCOUNT_FAILED = 0xC0000BE4
PDH_SQL_MORE_RESULTS_FAILED = 0xC0000BE5
PDH_SQL_CONNECT_FAILED = 0xC0000BE6
PDH_SQL_BIND_FAILED = 0xC0000BE7
PDH_CANNOT_CONNECT_WMI_SERVER = 0xC0000BE8
PDH_PLA_COLLECTION_ALREADY_RUNNING = 0xC0000BE9
PDH_PLA_ERROR_SCHEDULE_OVERLAP = 0xC0000BEA
PDH_PLA_COLLECTION_NOT_FOUND = 0xC0000BEB
PDH_PLA_ERROR_SCHEDULE_ELAPSED = 0xC0000BEC
PDH_PLA_ERROR_NOSTART = 0xC0000BED
PDH_PLA_ERROR_ALREADY_EXISTS = 0xC0000BEE
PDH_PLA_ERROR_TYPE_MISMATCH = 0xC0000BEF
PDH_PLA_ERROR_FILEPATH = 0xC0000BF0
PDH_PLA_SERVICE_ERROR = 0xC0000BF1
PDH_PLA_VALIDATION_ERROR = 0xC0000BF2
PDH_PLA_VALIDATION_WARNING = 0x80000BF3
PDH_PLA_ERROR_NAME_TOO_LONG = 0xC0000BF4
PDH_INVALID_SQL_LOG_FORMAT = 0xC0000BF5
PDH_COUNTER_ALREADY_IN_QUERY = 0xC0000BF6
PDH_BINARY_LOG_CORRUPT = 0xC0000BF7
PDH_LOG_SAMPLE_TOO_SMALL = 0xC0000BF8
PDH_OS_LATER_VERSION = 0xC0000BF9
PDH_OS_EARLIER_VERSION = 0xC0000BFA
PDH_INCORRECT_APPEND_TIME = 0xC0000BFB
PDH_UNMATCHED_APPEND_COUNTER = 0xC0000BFC
PDH_SQL_ALTER_DETAIL_FAILED = 0xC0000BFD
PDH_QUERY_PERF_DATA_TIMEOUT = 0xC0000BFE
)
// Formatting options for GetFormattedCounterValue().
const (
PDH_FMT_RAW = 0x00000010
PDH_FMT_ANSI = 0x00000020
PDH_FMT_UNICODE = 0x00000040
PDH_FMT_LONG = 0x00000100 // Return data as a long int.
PDH_FMT_DOUBLE = 0x00000200 // Return data as a double precision floating point real.
PDH_FMT_LARGE = 0x00000400 // Return data as a 64 bit integer.
PDH_FMT_NOSCALE = 0x00001000 // can be OR-ed: Do not apply the counter's default scaling factor.
PDH_FMT_1000 = 0x00002000 // can be OR-ed: multiply the actual value by 1,000.
PDH_FMT_NODATA = 0x00004000 // can be OR-ed: unknown what this is for, MSDN says nothing.
PDH_FMT_NOCAP100 = 0x00008000 // can be OR-ed: do not cap values > 100.
PERF_DETAIL_COSTLY = 0x00010000
PERF_DETAIL_STANDARD = 0x0000FFFF
)
type (
PDH_HQUERY HANDLE // query handle
PDH_HCOUNTER HANDLE // counter handle
)
// Union specialization for double values
type PDH_FMT_COUNTERVALUE_DOUBLE struct {
CStatus uint32
DoubleValue float64
}
// Union specialization for 64 bit integer values
type PDH_FMT_COUNTERVALUE_LARGE struct {
CStatus uint32
LargeValue int64
}
// Union specialization for long values
type PDH_FMT_COUNTERVALUE_LONG struct {
CStatus uint32
LongValue int32
padding [4]byte
}
// Union specialization for double values, used by PdhGetFormattedCounterArrayDouble()
type PDH_FMT_COUNTERVALUE_ITEM_DOUBLE struct {
SzName *uint16 // pointer to a string
FmtValue PDH_FMT_COUNTERVALUE_DOUBLE
}
// Union specialization for 'large' values, used by PdhGetFormattedCounterArrayLarge()
type PDH_FMT_COUNTERVALUE_ITEM_LARGE struct {
SzName *uint16 // pointer to a string
FmtValue PDH_FMT_COUNTERVALUE_LARGE
}
// Union specialization for long values, used by PdhGetFormattedCounterArrayLong()
type PDH_FMT_COUNTERVALUE_ITEM_LONG struct {
SzName *uint16 // pointer to a string
FmtValue PDH_FMT_COUNTERVALUE_LONG
}
var (
// Library
libpdhDll *syscall.DLL
// Functions
pdh_AddCounterW *syscall.Proc
pdh_AddEnglishCounterW *syscall.Proc
pdh_CloseQuery *syscall.Proc
pdh_CollectQueryData *syscall.Proc
pdh_GetFormattedCounterValue *syscall.Proc
pdh_GetFormattedCounterArrayW *syscall.Proc
pdh_OpenQuery *syscall.Proc
pdh_ValidatePathW *syscall.Proc
)
func init() {
// Library
libpdhDll = syscall.MustLoadDLL("pdh.dll")
// Functions
pdh_AddCounterW = libpdhDll.MustFindProc("PdhAddCounterW")
pdh_AddEnglishCounterW, _ = libpdhDll.FindProc("PdhAddEnglishCounterW") // XXX: only supported on versions > Vista.
pdh_CloseQuery = libpdhDll.MustFindProc("PdhCloseQuery")
pdh_CollectQueryData = libpdhDll.MustFindProc("PdhCollectQueryData")
pdh_GetFormattedCounterValue = libpdhDll.MustFindProc("PdhGetFormattedCounterValue")
pdh_GetFormattedCounterArrayW = libpdhDll.MustFindProc("PdhGetFormattedCounterArrayW")
pdh_OpenQuery = libpdhDll.MustFindProc("PdhOpenQuery")
pdh_ValidatePathW = libpdhDll.MustFindProc("PdhValidatePathW")
}
// Adds the specified counter to the query. This is the internationalized version. Preferably, use the
// function PdhAddEnglishCounter instead. hQuery is the query handle, which has been fetched by PdhOpenQuery.
// szFullCounterPath is a full, internationalized counter path (this will differ per Windows language version).
// dwUserData is a 'user-defined value', which becomes part of the counter information. To retrieve this value
// later, call PdhGetCounterInfo() and access dwQueryUserData of the PDH_COUNTER_INFO structure.
//
// Examples of szFullCounterPath (in an English version of Windows):
//
// \\Processor(_Total)\\% Idle Time
// \\Processor(_Total)\\% Processor Time
// \\LogicalDisk(C:)\% Free Space
//
// To view all (internationalized...) counters on a system, there are three non-programmatic ways: perfmon utility,
// the typeperf command, and the the registry editor. perfmon.exe is perhaps the easiest way, because it's basically a
// full implemention of the pdh.dll API, except with a GUI and all that. The registry setting also provides an
// interface to the available counters, and can be found at the following key:
//
// HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib\CurrentLanguage
//
// This registry key contains several values as follows:
//
// 1
// 1847
// 2
// System
// 4
// Memory
// 6
// % Processor Time
// ... many, many more
//
// Somehow, these numeric values can be used as szFullCounterPath too:
//
// \2\6 will correspond to \\System\% Processor Time
//
// The typeperf command may also be pretty easy. To find all performance counters, simply execute:
//
// typeperf -qx
func PdhAddCounter(hQuery PDH_HQUERY, szFullCounterPath string, dwUserData uintptr, phCounter *PDH_HCOUNTER) uint32 {
ptxt, _ := syscall.UTF16PtrFromString(szFullCounterPath)
ret, _, _ := pdh_AddCounterW.Call(
uintptr(hQuery),
uintptr(unsafe.Pointer(ptxt)),
dwUserData,
uintptr(unsafe.Pointer(phCounter)))
return uint32(ret)
}
// Adds the specified language-neutral counter to the query. See the PdhAddCounter function. This function only exists on
// Windows versions higher than Vista.
func PdhAddEnglishCounter(hQuery PDH_HQUERY, szFullCounterPath string, dwUserData uintptr, phCounter *PDH_HCOUNTER) uint32 {
if pdh_AddEnglishCounterW == nil {
return ERROR_INVALID_FUNCTION
}
ptxt, _ := syscall.UTF16PtrFromString(szFullCounterPath)
ret, _, _ := pdh_AddEnglishCounterW.Call(
uintptr(hQuery),
uintptr(unsafe.Pointer(ptxt)),
dwUserData,
uintptr(unsafe.Pointer(phCounter)))
return uint32(ret)
}
// Closes all counters contained in the specified query, closes all handles related to the query,
// and frees all memory associated with the query.
func PdhCloseQuery(hQuery PDH_HQUERY) uint32 {
ret, _, _ := pdh_CloseQuery.Call(uintptr(hQuery))
return uint32(ret)
}
// Collects the current raw data value for all counters in the specified query and updates the status
// code of each counter. With some counters, this function needs to be repeatedly called before the value
// of the counter can be extracted with PdhGetFormattedCounterValue(). For example, the following code
// requires at least two calls:
//
// var handle win.PDH_HQUERY
// var counterHandle win.PDH_HCOUNTER
// ret := win.PdhOpenQuery(0, 0, &handle)
// ret = win.PdhAddEnglishCounter(handle, "\\Processor(_Total)\\% Idle Time", 0, &counterHandle)
// var derp win.PDH_FMT_COUNTERVALUE_DOUBLE
//
// ret = win.PdhCollectQueryData(handle)
// fmt.Printf("Collect return code is %x\n", ret) // return code will be PDH_CSTATUS_INVALID_DATA
// ret = win.PdhGetFormattedCounterValueDouble(counterHandle, 0, &derp)
//
// ret = win.PdhCollectQueryData(handle)
// fmt.Printf("Collect return code is %x\n", ret) // return code will be ERROR_SUCCESS
// ret = win.PdhGetFormattedCounterValueDouble(counterHandle, 0, &derp)
//
// The PdhCollectQueryData will return an error in the first call because it needs two values for
// displaying the correct data for the processor idle time. The second call will have a 0 return code.
func PdhCollectQueryData(hQuery PDH_HQUERY) uint32 {
ret, _, _ := pdh_CollectQueryData.Call(uintptr(hQuery))
return uint32(ret)
}
// Formats the given hCounter using a 'double'. The result is set into the specialized union struct pValue.
// This function does not directly translate to a Windows counterpart due to union specialization tricks.
func PdhGetFormattedCounterValueDouble(hCounter PDH_HCOUNTER, lpdwType *uint32, pValue *PDH_FMT_COUNTERVALUE_DOUBLE) uint32 {
ret, _, _ := pdh_GetFormattedCounterValue.Call(
uintptr(hCounter),
uintptr(PDH_FMT_DOUBLE),
uintptr(unsafe.Pointer(lpdwType)),
uintptr(unsafe.Pointer(pValue)))
return uint32(ret)
}
// Formats the given hCounter using a large int (int64). The result is set into the specialized union struct pValue.
// This function does not directly translate to a Windows counterpart due to union specialization tricks.
func PdhGetFormattedCounterValueLarge(hCounter PDH_HCOUNTER, lpdwType *uint32, pValue *PDH_FMT_COUNTERVALUE_LARGE) uint32 {
ret, _, _ := pdh_GetFormattedCounterValue.Call(
uintptr(hCounter),
uintptr(PDH_FMT_LARGE),
uintptr(unsafe.Pointer(lpdwType)),
uintptr(unsafe.Pointer(pValue)))
return uint32(ret)
}
// Formats the given hCounter using a 'long'. The result is set into the specialized union struct pValue.
// This function does not directly translate to a Windows counterpart due to union specialization tricks.
//
// BUG(krpors): Testing this function on multiple systems yielded inconsistent results. For instance,
// the pValue.LongValue kept the value '192' on test system A, but on B this was '0', while the padding
// bytes of the struct got the correct value. Until someone can figure out this behaviour, prefer to use
// the Double or Large counterparts instead. These functions provide actually the same data, except in
// a different, working format.
func PdhGetFormattedCounterValueLong(hCounter PDH_HCOUNTER, lpdwType *uint32, pValue *PDH_FMT_COUNTERVALUE_LONG) uint32 {
ret, _, _ := pdh_GetFormattedCounterValue.Call(
uintptr(hCounter),
uintptr(PDH_FMT_LONG),
uintptr(unsafe.Pointer(lpdwType)),
uintptr(unsafe.Pointer(pValue)))
return uint32(ret)
}
// Returns an array of formatted counter values. Use this function when you want to format the counter values of a
// counter that contains a wildcard character for the instance name. The itemBuffer must a slice of type PDH_FMT_COUNTERVALUE_ITEM_DOUBLE.
// An example of how this function can be used:
//
// okPath := "\\Process(*)\\% Processor Time" // notice the wildcard * character
//
// // ommitted all necessary stuff ...
//
// var bufSize uint32
// var bufCount uint32
// var size uint32 = uint32(unsafe.Sizeof(win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE{}))
// var emptyBuf [1]win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE // need at least 1 addressable null ptr.
//
// for {
// // collect
// ret := win.PdhCollectQueryData(queryHandle)
// if ret == win.ERROR_SUCCESS {
// ret = win.PdhGetFormattedCounterArrayDouble(counterHandle, &bufSize, &bufCount, &emptyBuf[0]) // uses null ptr here according to MSDN.
// if ret == win.PDH_MORE_DATA {
// filledBuf := make([]win.PDH_FMT_COUNTERVALUE_ITEM_DOUBLE, bufCount*size)
// ret = win.PdhGetFormattedCounterArrayDouble(counterHandle, &bufSize, &bufCount, &filledBuf[0])
// for i := 0; i < int(bufCount); i++ {
// c := filledBuf[i]
// var s string = win.UTF16PtrToString(c.SzName)
// fmt.Printf("Index %d -> %s, value %v\n", i, s, c.FmtValue.DoubleValue)
// }
//
// filledBuf = nil
// // Need to at least set bufSize to zero, because if not, the function will not
// // return PDH_MORE_DATA and will not set the bufSize.
// bufCount = 0
// bufSize = 0
// }
//
// time.Sleep(2000 * time.Millisecond)
// }
// }
func PdhGetFormattedCounterArrayDouble(hCounter PDH_HCOUNTER, lpdwBufferSize *uint32, lpdwBufferCount *uint32, itemBuffer *PDH_FMT_COUNTERVALUE_ITEM_DOUBLE) uint32 {
ret, _, _ := pdh_GetFormattedCounterArrayW.Call(
uintptr(hCounter),
uintptr(PDH_FMT_DOUBLE),
uintptr(unsafe.Pointer(lpdwBufferSize)),
uintptr(unsafe.Pointer(lpdwBufferCount)),
uintptr(unsafe.Pointer(itemBuffer)))
return uint32(ret)
}
// Returns an array of formatted counter values. Use this function when you want to format the counter values of a
// counter that contains a wildcard character for the instance name. The itemBuffer must a slice of type PDH_FMT_COUNTERVALUE_ITEM_LARGE.
// For an example usage, see PdhGetFormattedCounterArrayDouble.
func PdhGetFormattedCounterArrayLarge(hCounter PDH_HCOUNTER, lpdwBufferSize *uint32, lpdwBufferCount *uint32, itemBuffer *PDH_FMT_COUNTERVALUE_ITEM_LARGE) uint32 {
ret, _, _ := pdh_GetFormattedCounterArrayW.Call(
uintptr(hCounter),
uintptr(PDH_FMT_LARGE),
uintptr(unsafe.Pointer(lpdwBufferSize)),
uintptr(unsafe.Pointer(lpdwBufferCount)),
uintptr(unsafe.Pointer(itemBuffer)))
return uint32(ret)
}
// Returns an array of formatted counter values. Use this function when you want to format the counter values of a
// counter that contains a wildcard character for the instance name. The itemBuffer must a slice of type PDH_FMT_COUNTERVALUE_ITEM_LONG.
// For an example usage, see PdhGetFormattedCounterArrayDouble.
//
// BUG(krpors): See description of PdhGetFormattedCounterValueLong().
func PdhGetFormattedCounterArrayLong(hCounter PDH_HCOUNTER, lpdwBufferSize *uint32, lpdwBufferCount *uint32, itemBuffer *PDH_FMT_COUNTERVALUE_ITEM_LONG) uint32 {
ret, _, _ := pdh_GetFormattedCounterArrayW.Call(
uintptr(hCounter),
uintptr(PDH_FMT_LONG),
uintptr(unsafe.Pointer(lpdwBufferSize)),
uintptr(unsafe.Pointer(lpdwBufferCount)),
uintptr(unsafe.Pointer(itemBuffer)))
return uint32(ret)
}
// Creates a new query that is used to manage the collection of performance data.
// szDataSource is a null terminated string that specifies the name of the log file from which to
// retrieve the performance data. If 0, performance data is collected from a real-time data source.
// dwUserData is a user-defined value to associate with this query. To retrieve the user data later,
// call PdhGetCounterInfo and access dwQueryUserData of the PDH_COUNTER_INFO structure. phQuery is
// the handle to the query, and must be used in subsequent calls. This function returns a PDH_
// constant error code, or ERROR_SUCCESS if the call succeeded.
func PdhOpenQuery(szDataSource uintptr, dwUserData uintptr, phQuery *PDH_HQUERY) uint32 {
ret, _, _ := pdh_OpenQuery.Call(
szDataSource,
dwUserData,
uintptr(unsafe.Pointer(phQuery)))
return uint32(ret)
}
// Validates a path. Will return ERROR_SUCCESS when ok, or PDH_CSTATUS_BAD_COUNTERNAME when the path is
// erroneous.
func PdhValidatePath(path string) uint32 {
ptxt, _ := syscall.UTF16PtrFromString(path)
ret, _, _ := pdh_ValidatePathW.Call(uintptr(unsafe.Pointer(ptxt)))
return uint32(ret)
}

273
vendor/github.com/lxn/win/shdocvw.go generated vendored Normal file
View File

@ -0,0 +1,273 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
const (
DOCHOSTUIDBLCLK_DEFAULT = 0
DOCHOSTUIDBLCLK_SHOWPROPERTIES = 1
DOCHOSTUIDBLCLK_SHOWCODE = 2
)
const (
DOCHOSTUIFLAG_DIALOG = 0x1
DOCHOSTUIFLAG_DISABLE_HELP_MENU = 0x2
DOCHOSTUIFLAG_NO3DBORDER = 0x4
DOCHOSTUIFLAG_SCROLL_NO = 0x8
DOCHOSTUIFLAG_DISABLE_SCRIPT_INACTIVE = 0x10
DOCHOSTUIFLAG_OPENNEWWIN = 0x20
DOCHOSTUIFLAG_DISABLE_OFFSCREEN = 0x40
DOCHOSTUIFLAG_FLAT_SCROLLBAR = 0x80
DOCHOSTUIFLAG_DIV_BLOCKDEFAULT = 0x100
DOCHOSTUIFLAG_ACTIVATE_CLIENTHIT_ONLY = 0x200
DOCHOSTUIFLAG_OVERRIDEBEHAVIORFACTORY = 0x400
DOCHOSTUIFLAG_CODEPAGELINKEDFONTS = 0x800
DOCHOSTUIFLAG_URL_ENCODING_DISABLE_UTF8 = 0x1000
DOCHOSTUIFLAG_URL_ENCODING_ENABLE_UTF8 = 0x2000
DOCHOSTUIFLAG_ENABLE_FORMS_AUTOCOMPLETE = 0x4000
DOCHOSTUIFLAG_ENABLE_INPLACE_NAVIGATION = 0x10000
DOCHOSTUIFLAG_IME_ENABLE_RECONVERSION = 0x20000
DOCHOSTUIFLAG_THEME = 0x40000
DOCHOSTUIFLAG_NOTHEME = 0x80000
DOCHOSTUIFLAG_NOPICS = 0x100000
DOCHOSTUIFLAG_NO3DOUTERBORDER = 0x200000
DOCHOSTUIFLAG_DISABLE_EDIT_NS_FIXUP = 0x400000
DOCHOSTUIFLAG_LOCAL_MACHINE_ACCESS_CHECK = 0x800000
DOCHOSTUIFLAG_DISABLE_UNTRUSTEDPROTOCOL = 0x1000000
)
// BrowserNavConstants
const (
NavOpenInNewWindow = 0x1
NavNoHistory = 0x2
NavNoReadFromCache = 0x4
NavNoWriteToCache = 0x8
NavAllowAutosearch = 0x10
NavBrowserBar = 0x20
NavHyperlink = 0x40
NavEnforceRestricted = 0x80
NavNewWindowsManaged = 0x0100
NavUntrustedForDownload = 0x0200
NavTrustedForActiveX = 0x0400
NavOpenInNewTab = 0x0800
NavOpenInBackgroundTab = 0x1000
NavKeepWordWheelText = 0x2000
NavVirtualTab = 0x4000
NavBlockRedirectsXDomain = 0x8000
NavOpenNewForegroundTab = 0x10000
)
var (
CLSID_WebBrowser = CLSID{0x8856F961, 0x340A, 0x11D0, [8]byte{0xA9, 0x6B, 0x00, 0xC0, 0x4F, 0xD7, 0x05, 0xA2}}
DIID_DWebBrowserEvents2 = IID{0x34A715A0, 0x6587, 0x11D0, [8]byte{0x92, 0x4A, 0x00, 0x20, 0xAF, 0xC7, 0xAC, 0x4D}}
IID_IWebBrowser2 = IID{0xD30C1661, 0xCDAF, 0x11D0, [8]byte{0x8A, 0x3E, 0x00, 0xC0, 0x4F, 0xC9, 0xE2, 0x6E}}
IID_IDocHostUIHandler = IID{0xBD3F23C0, 0xD43E, 0x11CF, [8]byte{0x89, 0x3B, 0x00, 0xAA, 0x00, 0xBD, 0xCE, 0x1A}}
)
type DWebBrowserEvents2Vtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
GetTypeInfoCount uintptr
GetTypeInfo uintptr
GetIDsOfNames uintptr
Invoke uintptr
}
type DWebBrowserEvents2 struct {
LpVtbl *DWebBrowserEvents2Vtbl
}
type IWebBrowser2Vtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
GetTypeInfoCount uintptr
GetTypeInfo uintptr
GetIDsOfNames uintptr
Invoke uintptr
GoBack uintptr
GoForward uintptr
GoHome uintptr
GoSearch uintptr
Navigate uintptr
Refresh uintptr
Refresh2 uintptr
Stop uintptr
Get_Application uintptr
Get_Parent uintptr
Get_Container uintptr
Get_Document uintptr
Get_TopLevelContainer uintptr
Get_Type uintptr
Get_Left uintptr
Put_Left uintptr
Get_Top uintptr
Put_Top uintptr
Get_Width uintptr
Put_Width uintptr
Get_Height uintptr
Put_Height uintptr
Get_LocationName uintptr
Get_LocationURL uintptr
Get_Busy uintptr
Quit uintptr
ClientToWindow uintptr
PutProperty uintptr
GetProperty uintptr
Get_Name uintptr
Get_HWND uintptr
Get_FullName uintptr
Get_Path uintptr
Get_Visible uintptr
Put_Visible uintptr
Get_StatusBar uintptr
Put_StatusBar uintptr
Get_StatusText uintptr
Put_StatusText uintptr
Get_ToolBar uintptr
Put_ToolBar uintptr
Get_MenuBar uintptr
Put_MenuBar uintptr
Get_FullScreen uintptr
Put_FullScreen uintptr
Navigate2 uintptr
QueryStatusWB uintptr
ExecWB uintptr
ShowBrowserBar uintptr
Get_ReadyState uintptr
Get_Offline uintptr
Put_Offline uintptr
Get_Silent uintptr
Put_Silent uintptr
Get_RegisterAsBrowser uintptr
Put_RegisterAsBrowser uintptr
Get_RegisterAsDropTarget uintptr
Put_RegisterAsDropTarget uintptr
Get_TheaterMode uintptr
Put_TheaterMode uintptr
Get_AddressBar uintptr
Put_AddressBar uintptr
Get_Resizable uintptr
Put_Resizable uintptr
}
type IWebBrowser2 struct {
LpVtbl *IWebBrowser2Vtbl
}
func (wb2 *IWebBrowser2) Release() HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Release, 1,
uintptr(unsafe.Pointer(wb2)),
0,
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Refresh() HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Refresh, 1,
uintptr(unsafe.Pointer(wb2)),
0,
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Put_Left(Left int32) HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Put_Left, 2,
uintptr(unsafe.Pointer(wb2)),
uintptr(Left),
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Put_Top(Top int32) HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Put_Top, 2,
uintptr(unsafe.Pointer(wb2)),
uintptr(Top),
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Put_Width(Width int32) HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Put_Width, 2,
uintptr(unsafe.Pointer(wb2)),
uintptr(Width),
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Put_Height(Height int32) HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Put_Height, 2,
uintptr(unsafe.Pointer(wb2)),
uintptr(Height),
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Get_LocationURL(pbstrLocationURL **uint16 /*BSTR*/) HRESULT {
ret, _, _ := syscall.Syscall(wb2.LpVtbl.Get_LocationURL, 2,
uintptr(unsafe.Pointer(wb2)),
uintptr(unsafe.Pointer(pbstrLocationURL)),
0)
return HRESULT(ret)
}
func (wb2 *IWebBrowser2) Navigate2(URL *VAR_BSTR, Flags *VAR_I4, TargetFrameName *VAR_BSTR, PostData unsafe.Pointer, Headers *VAR_BSTR) HRESULT {
ret, _, _ := syscall.Syscall6(wb2.LpVtbl.Navigate2, 6,
uintptr(unsafe.Pointer(wb2)),
uintptr(unsafe.Pointer(URL)),
uintptr(unsafe.Pointer(Flags)),
uintptr(unsafe.Pointer(TargetFrameName)),
uintptr(PostData),
uintptr(unsafe.Pointer(Headers)))
return HRESULT(ret)
}
type IDocHostUIHandlerVtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
ShowContextMenu uintptr
GetHostInfo uintptr
ShowUI uintptr
HideUI uintptr
UpdateUI uintptr
EnableModeless uintptr
OnDocWindowActivate uintptr
OnFrameWindowActivate uintptr
ResizeBorder uintptr
TranslateAccelerator uintptr
GetOptionKeyPath uintptr
GetDropTarget uintptr
GetExternal uintptr
TranslateUrl uintptr
FilterDataObject uintptr
}
type IDocHostUIHandler struct {
LpVtbl *IDocHostUIHandlerVtbl
}
type DOCHOSTUIINFO struct {
CbSize uint32
DwFlags uint32
DwDoubleClick uint32
PchHostCss *uint16
PchHostNS *uint16
}

297
vendor/github.com/lxn/win/shell32.go generated vendored Normal file
View File

@ -0,0 +1,297 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
type CSIDL uint32
type HDROP HANDLE
const (
CSIDL_DESKTOP = 0x00
CSIDL_INTERNET = 0x01
CSIDL_PROGRAMS = 0x02
CSIDL_CONTROLS = 0x03
CSIDL_PRINTERS = 0x04
CSIDL_PERSONAL = 0x05
CSIDL_FAVORITES = 0x06
CSIDL_STARTUP = 0x07
CSIDL_RECENT = 0x08
CSIDL_SENDTO = 0x09
CSIDL_BITBUCKET = 0x0A
CSIDL_STARTMENU = 0x0B
CSIDL_MYDOCUMENTS = 0x0C
CSIDL_MYMUSIC = 0x0D
CSIDL_MYVIDEO = 0x0E
CSIDL_DESKTOPDIRECTORY = 0x10
CSIDL_DRIVES = 0x11
CSIDL_NETWORK = 0x12
CSIDL_NETHOOD = 0x13
CSIDL_FONTS = 0x14
CSIDL_TEMPLATES = 0x15
CSIDL_COMMON_STARTMENU = 0x16
CSIDL_COMMON_PROGRAMS = 0x17
CSIDL_COMMON_STARTUP = 0x18
CSIDL_COMMON_DESKTOPDIRECTORY = 0x19
CSIDL_APPDATA = 0x1A
CSIDL_PRINTHOOD = 0x1B
CSIDL_LOCAL_APPDATA = 0x1C
CSIDL_ALTSTARTUP = 0x1D
CSIDL_COMMON_ALTSTARTUP = 0x1E
CSIDL_COMMON_FAVORITES = 0x1F
CSIDL_INTERNET_CACHE = 0x20
CSIDL_COOKIES = 0x21
CSIDL_HISTORY = 0x22
CSIDL_COMMON_APPDATA = 0x23
CSIDL_WINDOWS = 0x24
CSIDL_SYSTEM = 0x25
CSIDL_PROGRAM_FILES = 0x26
CSIDL_MYPICTURES = 0x27
CSIDL_PROFILE = 0x28
CSIDL_SYSTEMX86 = 0x29
CSIDL_PROGRAM_FILESX86 = 0x2A
CSIDL_PROGRAM_FILES_COMMON = 0x2B
CSIDL_PROGRAM_FILES_COMMONX86 = 0x2C
CSIDL_COMMON_TEMPLATES = 0x2D
CSIDL_COMMON_DOCUMENTS = 0x2E
CSIDL_COMMON_ADMINTOOLS = 0x2F
CSIDL_ADMINTOOLS = 0x30
CSIDL_CONNECTIONS = 0x31
CSIDL_COMMON_MUSIC = 0x35
CSIDL_COMMON_PICTURES = 0x36
CSIDL_COMMON_VIDEO = 0x37
CSIDL_RESOURCES = 0x38
CSIDL_RESOURCES_LOCALIZED = 0x39
CSIDL_COMMON_OEM_LINKS = 0x3A
CSIDL_CDBURN_AREA = 0x3B
CSIDL_COMPUTERSNEARME = 0x3D
CSIDL_FLAG_CREATE = 0x8000
CSIDL_FLAG_DONT_VERIFY = 0x4000
CSIDL_FLAG_NO_ALIAS = 0x1000
CSIDL_FLAG_PER_USER_INIT = 0x8000
CSIDL_FLAG_MASK = 0xFF00
)
// NotifyIcon flags
const (
NIF_MESSAGE = 0x00000001
NIF_ICON = 0x00000002
NIF_TIP = 0x00000004
NIF_STATE = 0x00000008
NIF_INFO = 0x00000010
)
// NotifyIcon messages
const (
NIM_ADD = 0x00000000
NIM_MODIFY = 0x00000001
NIM_DELETE = 0x00000002
NIM_SETFOCUS = 0x00000003
NIM_SETVERSION = 0x00000004
)
// NotifyIcon states
const (
NIS_HIDDEN = 0x00000001
NIS_SHAREDICON = 0x00000002
)
// NotifyIcon info flags
const (
NIIF_NONE = 0x00000000
NIIF_INFO = 0x00000001
NIIF_WARNING = 0x00000002
NIIF_ERROR = 0x00000003
NIIF_USER = 0x00000004
NIIF_NOSOUND = 0x00000010
)
const NOTIFYICON_VERSION = 3
// SHGetFileInfo flags
const (
SHGFI_LARGEICON = 0x000000000
SHGFI_SMALLICON = 0x000000001
SHGFI_OPENICON = 0x000000002
SHGFI_SHELLICONSIZE = 0x000000004
SHGFI_PIDL = 0x000000008
SHGFI_USEFILEATTRIBUTES = 0x000000010
SHGFI_ADDOVERLAYS = 0x000000020
SHGFI_OVERLAYINDEX = 0x000000040
SHGFI_ICON = 0x000000100
SHGFI_DISPLAYNAME = 0x000000200
SHGFI_TYPENAME = 0x000000400
SHGFI_ATTRIBUTES = 0x000000800
SHGFI_ICONLOCATION = 0x000001000
SHGFI_EXETYPE = 0x000002000
SHGFI_SYSICONINDEX = 0x000004000
SHGFI_LINKOVERLAY = 0x000008000
SHGFI_SELECTED = 0x000010000
SHGFI_ATTR_SPECIFIED = 0x000020000
)
type NOTIFYICONDATA struct {
CbSize uint32
HWnd HWND
UID uint32
UFlags uint32
UCallbackMessage uint32
HIcon HICON
SzTip [128]uint16
DwState uint32
DwStateMask uint32
SzInfo [256]uint16
UVersion uint32
SzInfoTitle [64]uint16
DwInfoFlags uint32
GuidItem syscall.GUID
}
type SHFILEINFO struct {
HIcon HICON
IIcon int32
DwAttributes uint32
SzDisplayName [MAX_PATH]uint16
SzTypeName [80]uint16
}
type BROWSEINFO struct {
HwndOwner HWND
PidlRoot uintptr
PszDisplayName *uint16
LpszTitle *uint16
UlFlags uint32
Lpfn uintptr
LParam uintptr
IImage int32
}
var (
// Library
libshell32 uintptr
// Functions
dragAcceptFiles uintptr
dragFinish uintptr
dragQueryFile uintptr
shBrowseForFolder uintptr
shGetFileInfo uintptr
shGetPathFromIDList uintptr
shGetSpecialFolderPath uintptr
shParseDisplayName uintptr
shell_NotifyIcon uintptr
)
func init() {
// Library
libshell32 = MustLoadLibrary("shell32.dll")
// Functions
dragAcceptFiles = MustGetProcAddress(libshell32, "DragAcceptFiles")
dragFinish = MustGetProcAddress(libshell32, "DragFinish")
dragQueryFile = MustGetProcAddress(libshell32, "DragQueryFileW")
shBrowseForFolder = MustGetProcAddress(libshell32, "SHBrowseForFolderW")
shGetFileInfo = MustGetProcAddress(libshell32, "SHGetFileInfoW")
shGetPathFromIDList = MustGetProcAddress(libshell32, "SHGetPathFromIDListW")
shGetSpecialFolderPath = MustGetProcAddress(libshell32, "SHGetSpecialFolderPathW")
shParseDisplayName = MustGetProcAddress(libshell32, "SHParseDisplayName")
shell_NotifyIcon = MustGetProcAddress(libshell32, "Shell_NotifyIconW")
}
func DragAcceptFiles(hWnd HWND, fAccept bool) bool {
ret, _, _ := syscall.Syscall(dragAcceptFiles, 2,
uintptr(hWnd),
uintptr(BoolToBOOL(fAccept)),
0)
return ret != 0
}
func DragQueryFile(hDrop HDROP, iFile uint, lpszFile *uint16, cch uint) uint {
ret, _, _ := syscall.Syscall6(dragQueryFile, 4,
uintptr(hDrop),
uintptr(iFile),
uintptr(unsafe.Pointer(lpszFile)),
uintptr(cch),
0,
0)
return uint(ret)
}
func DragFinish(hDrop HDROP) {
syscall.Syscall(dragAcceptFiles, 1,
uintptr(hDrop),
0,
0)
}
func SHBrowseForFolder(lpbi *BROWSEINFO) uintptr {
ret, _, _ := syscall.Syscall(shBrowseForFolder, 1,
uintptr(unsafe.Pointer(lpbi)),
0,
0)
return ret
}
func SHGetFileInfo(pszPath *uint16, dwFileAttributes uint32, psfi *SHFILEINFO, cbFileInfo, uFlags uint32) uintptr {
ret, _, _ := syscall.Syscall6(shGetFileInfo, 5,
uintptr(unsafe.Pointer(pszPath)),
uintptr(dwFileAttributes),
uintptr(unsafe.Pointer(psfi)),
uintptr(cbFileInfo),
uintptr(uFlags),
0)
return ret
}
func SHGetPathFromIDList(pidl uintptr, pszPath *uint16) bool {
ret, _, _ := syscall.Syscall(shGetPathFromIDList, 2,
pidl,
uintptr(unsafe.Pointer(pszPath)),
0)
return ret != 0
}
func SHGetSpecialFolderPath(hwndOwner HWND, lpszPath *uint16, csidl CSIDL, fCreate bool) bool {
ret, _, _ := syscall.Syscall6(shGetSpecialFolderPath, 4,
uintptr(hwndOwner),
uintptr(unsafe.Pointer(lpszPath)),
uintptr(csidl),
uintptr(BoolToBOOL(fCreate)),
0,
0)
return ret != 0
}
func SHParseDisplayName(pszName *uint16, pbc uintptr, ppidl *uintptr, sfgaoIn uint32, psfgaoOut *uint32) HRESULT {
ret, _, _ := syscall.Syscall6(shParseDisplayName, 5,
uintptr(unsafe.Pointer(pszName)),
pbc,
uintptr(unsafe.Pointer(ppidl)),
0,
uintptr(unsafe.Pointer(psfgaoOut)),
0)
return HRESULT(ret)
}
func Shell_NotifyIcon(dwMessage uint32, lpdata *NOTIFYICONDATA) bool {
ret, _, _ := syscall.Syscall(shell_NotifyIcon, 2,
uintptr(dwMessage),
uintptr(unsafe.Pointer(lpdata)),
0)
return ret != 0
}

62
vendor/github.com/lxn/win/shobj.go generated vendored Normal file
View File

@ -0,0 +1,62 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
var (
CLSID_TaskbarList = CLSID{0x56FDF344, 0xFD6D, 0x11d0, [8]byte{0x95, 0x8A, 0x00, 0x60, 0x97, 0xC9, 0xA0, 0x90}}
IID_ITaskbarList3 = IID{0xea1afb91, 0x9e28, 0x4b86, [8]byte{0x90, 0xe9, 0x9e, 0x9f, 0x8a, 0x5e, 0xef, 0xaf}}
)
//TBPFLAG
const (
TBPF_NOPROGRESS = 0
TBPF_INDETERMINATE = 0x1
TBPF_NORMAL = 0x2
TBPF_ERROR = 0x4
TBPF_PAUSED = 0x8
)
type ITaskbarList3Vtbl struct {
QueryInterface uintptr
AddRef uintptr
Release uintptr
HrInit uintptr
AddTab uintptr
DeleteTab uintptr
ActivateTab uintptr
SetActiveAlt uintptr
MarkFullscreenWindow uintptr
SetProgressValue uintptr
SetProgressState uintptr
RegisterTab uintptr
UnregisterTab uintptr
SetTabOrder uintptr
SetTabActive uintptr
ThumbBarAddButtons uintptr
ThumbBarUpdateButtons uintptr
ThumbBarSetImageList uintptr
SetOverlayIcon uintptr
SetThumbnailTooltip uintptr
SetThumbnailClip uintptr
}
type ITaskbarList3 struct {
LpVtbl *ITaskbarList3Vtbl
}
func (obj *ITaskbarList3) SetProgressState(hwnd HWND, state int) HRESULT {
ret, _, _ := syscall.Syscall(obj.LpVtbl.SetProgressState, 3,
uintptr(unsafe.Pointer(obj)),
uintptr(hwnd),
uintptr(state))
return HRESULT(ret)
}

24
vendor/github.com/lxn/win/shobj_386.go generated vendored Normal file
View File

@ -0,0 +1,24 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
func (obj *ITaskbarList3) SetProgressValue(hwnd HWND, current uint32, length uint32) HRESULT {
ret, _, _ := syscall.Syscall6(obj.LpVtbl.SetProgressValue, 6,
uintptr(unsafe.Pointer(obj)),
uintptr(hwnd),
uintptr(current),
0,
uintptr(length),
0)
return HRESULT(ret)
}

24
vendor/github.com/lxn/win/shobj_amd64.go generated vendored Normal file
View File

@ -0,0 +1,24 @@
// Copyright 2012 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
func (obj *ITaskbarList3) SetProgressValue(hwnd HWND, current uint32, length uint32) HRESULT {
ret, _, _ := syscall.Syscall6(obj.LpVtbl.SetProgressValue, 4,
uintptr(unsafe.Pointer(obj)),
uintptr(hwnd),
uintptr(current),
uintptr(length),
0,
0)
return HRESULT(ret)
}

50
vendor/github.com/lxn/win/statusbar.go generated vendored Normal file
View File

@ -0,0 +1,50 @@
// Copyright 2013 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// Styles
const (
SBARS_SIZEGRIP = 0x100
SBARS_TOOLTIPS = 0x800
)
// Messages
const (
SB_SETPARTS = WM_USER + 4
SB_GETPARTS = WM_USER + 6
SB_GETBORDERS = WM_USER + 7
SB_SETMINHEIGHT = WM_USER + 8
SB_SIMPLE = WM_USER + 9
SB_GETRECT = WM_USER + 10
SB_SETTEXT = WM_USER + 11
SB_GETTEXTLENGTH = WM_USER + 12
SB_GETTEXT = WM_USER + 13
SB_ISSIMPLE = WM_USER + 14
SB_SETICON = WM_USER + 15
SB_SETTIPTEXT = WM_USER + 17
SB_GETTIPTEXT = WM_USER + 19
SB_GETICON = WM_USER + 20
SB_SETUNICODEFORMAT = CCM_SETUNICODEFORMAT
SB_GETUNICODEFORMAT = CCM_GETUNICODEFORMAT
SB_SETBKCOLOR = CCM_SETBKCOLOR
)
// SB_SETTEXT options
const (
SBT_NOBORDERS = 0x100
SBT_POPOUT = 0x200
SBT_RTLREADING = 0x400
SBT_NOTABPARSING = 0x800
SBT_OWNERDRAW = 0x1000
)
const (
SBN_FIRST = -880
SBN_SIMPLEMODECHANGE = SBN_FIRST - 0
)
const SB_SIMPLEID = 0xff

65
vendor/github.com/lxn/win/syslink.go generated vendored Normal file
View File

@ -0,0 +1,65 @@
// Copyright 2017 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
const (
INVALID_LINK_INDEX = -1
MAX_LINKID_TEXT = 48
L_MAX_URL_LENGTH = 2048 + 32 + len("://")
WC_LINK = "SysLink"
)
const (
LWS_TRANSPARENT = 0x0001
LWS_IGNORERETURN = 0x0002
LWS_NOPREFIX = 0x0004
LWS_USEVISUALSTYLE = 0x0008
LWS_USECUSTOMTEXT = 0x0010
LWS_RIGHT = 0x0020
)
const (
LIF_ITEMINDEX = 0x00000001
LIF_STATE = 0x00000002
LIF_ITEMID = 0x00000004
LIF_URL = 0x00000008
)
const (
LIS_FOCUSED = 0x00000001
LIS_ENABLED = 0x00000002
LIS_VISITED = 0x00000004
LIS_HOTTRACK = 0x00000008
LIS_DEFAULTCOLORS = 0x00000010
)
const (
LM_HITTEST = WM_USER + 0x300
LM_GETIDEALHEIGHT = WM_USER + 0x301
LM_SETITEM = WM_USER + 0x302
LM_GETITEM = WM_USER + 0x303
LM_GETIDEALSIZE = LM_GETIDEALHEIGHT
)
type LITEM struct {
Mask uint32
ILink int32
State uint32
StateMask uint32
SzID [MAX_LINKID_TEXT]uint16
SzUrl [L_MAX_URL_LENGTH]uint16
}
type LHITTESTINFO struct {
Pt POINT
Item LITEM
}
type NMLINK struct {
Hdr NMHDR
Item LITEM
}

128
vendor/github.com/lxn/win/tab.go generated vendored Normal file
View File

@ -0,0 +1,128 @@
// Copyright 2011 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
const TCM_FIRST = 0x1300
const TCN_FIRST = -550
const (
TCS_SCROLLOPPOSITE = 0x0001
TCS_BOTTOM = 0x0002
TCS_RIGHT = 0x0002
TCS_MULTISELECT = 0x0004
TCS_FLATBUTTONS = 0x0008
TCS_FORCEICONLEFT = 0x0010
TCS_FORCELABELLEFT = 0x0020
TCS_HOTTRACK = 0x0040
TCS_VERTICAL = 0x0080
TCS_TABS = 0x0000
TCS_BUTTONS = 0x0100
TCS_SINGLELINE = 0x0000
TCS_MULTILINE = 0x0200
TCS_RIGHTJUSTIFY = 0x0000
TCS_FIXEDWIDTH = 0x0400
TCS_RAGGEDRIGHT = 0x0800
TCS_FOCUSONBUTTONDOWN = 0x1000
TCS_OWNERDRAWFIXED = 0x2000
TCS_TOOLTIPS = 0x4000
TCS_FOCUSNEVER = 0x8000
)
const (
TCS_EX_FLATSEPARATORS = 0x00000001
TCS_EX_REGISTERDROP = 0x00000002
)
const (
TCM_GETIMAGELIST = TCM_FIRST + 2
TCM_SETIMAGELIST = TCM_FIRST + 3
TCM_GETITEMCOUNT = TCM_FIRST + 4
TCM_GETITEM = TCM_FIRST + 60
TCM_SETITEM = TCM_FIRST + 61
TCM_INSERTITEM = TCM_FIRST + 62
TCM_DELETEITEM = TCM_FIRST + 8
TCM_DELETEALLITEMS = TCM_FIRST + 9
TCM_GETITEMRECT = TCM_FIRST + 10
TCM_GETCURSEL = TCM_FIRST + 11
TCM_SETCURSEL = TCM_FIRST + 12
TCM_HITTEST = TCM_FIRST + 13
TCM_SETITEMEXTRA = TCM_FIRST + 14
TCM_ADJUSTRECT = TCM_FIRST + 40
TCM_SETITEMSIZE = TCM_FIRST + 41
TCM_REMOVEIMAGE = TCM_FIRST + 42
TCM_SETPADDING = TCM_FIRST + 43
TCM_GETROWCOUNT = TCM_FIRST + 44
TCM_GETTOOLTIPS = TCM_FIRST + 45
TCM_SETTOOLTIPS = TCM_FIRST + 46
TCM_GETCURFOCUS = TCM_FIRST + 47
TCM_SETCURFOCUS = TCM_FIRST + 48
TCM_SETMINTABWIDTH = TCM_FIRST + 49
TCM_DESELECTALL = TCM_FIRST + 50
TCM_HIGHLIGHTITEM = TCM_FIRST + 51
TCM_SETEXTENDEDSTYLE = TCM_FIRST + 52
TCM_GETEXTENDEDSTYLE = TCM_FIRST + 53
TCM_SETUNICODEFORMAT = CCM_SETUNICODEFORMAT
TCM_GETUNICODEFORMAT = CCM_GETUNICODEFORMAT
)
const (
TCIF_TEXT = 0x0001
TCIF_IMAGE = 0x0002
TCIF_RTLREADING = 0x0004
TCIF_PARAM = 0x0008
TCIF_STATE = 0x0010
)
const (
TCIS_BUTTONPRESSED = 0x0001
TCIS_HIGHLIGHTED = 0x0002
)
const (
TCHT_NOWHERE = 0x0001
TCHT_ONITEMICON = 0x0002
TCHT_ONITEMLABEL = 0x0004
TCHT_ONITEM = TCHT_ONITEMICON | TCHT_ONITEMLABEL
)
const (
TCN_KEYDOWN = TCN_FIRST - 0
TCN_SELCHANGE = TCN_FIRST - 1
TCN_SELCHANGING = TCN_FIRST - 2
TCN_GETOBJECT = TCN_FIRST - 3
TCN_FOCUSCHANGE = TCN_FIRST - 4
)
type TCITEMHEADER struct {
Mask uint32
LpReserved1 uint32
LpReserved2 uint32
PszText *uint16
CchTextMax int32
IImage int32
}
type TCITEM struct {
Mask uint32
DwState uint32
DwStateMask uint32
PszText *uint16
CchTextMax int32
IImage int32
LParam uintptr
}
type TCHITTESTINFO struct {
Pt POINT
flags uint32
}
type NMTCKEYDOWN struct {
Hdr NMHDR
WVKey uint16
Flags uint32
}

219
vendor/github.com/lxn/win/toolbar.go generated vendored Normal file
View File

@ -0,0 +1,219 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// ToolBar messages
const (
TB_THUMBPOSITION = 4
TB_THUMBTRACK = 5
TB_ENDTRACK = 8
TB_ENABLEBUTTON = WM_USER + 1
TB_CHECKBUTTON = WM_USER + 2
TB_PRESSBUTTON = WM_USER + 3
TB_HIDEBUTTON = WM_USER + 4
TB_INDETERMINATE = WM_USER + 5
TB_MARKBUTTON = WM_USER + 6
TB_ISBUTTONENABLED = WM_USER + 9
TB_ISBUTTONCHECKED = WM_USER + 10
TB_ISBUTTONPRESSED = WM_USER + 11
TB_ISBUTTONHIDDEN = WM_USER + 12
TB_ISBUTTONINDETERMINATE = WM_USER + 13
TB_ISBUTTONHIGHLIGHTED = WM_USER + 14
TB_SETSTATE = WM_USER + 17
TB_GETSTATE = WM_USER + 18
TB_ADDBITMAP = WM_USER + 19
TB_DELETEBUTTON = WM_USER + 22
TB_GETBUTTON = WM_USER + 23
TB_BUTTONCOUNT = WM_USER + 24
TB_COMMANDTOINDEX = WM_USER + 25
TB_SAVERESTORE = WM_USER + 76
TB_CUSTOMIZE = WM_USER + 27
TB_ADDSTRING = WM_USER + 77
TB_GETITEMRECT = WM_USER + 29
TB_BUTTONSTRUCTSIZE = WM_USER + 30
TB_SETBUTTONSIZE = WM_USER + 31
TB_SETBITMAPSIZE = WM_USER + 32
TB_AUTOSIZE = WM_USER + 33
TB_GETTOOLTIPS = WM_USER + 35
TB_SETTOOLTIPS = WM_USER + 36
TB_SETPARENT = WM_USER + 37
TB_SETROWS = WM_USER + 39
TB_GETROWS = WM_USER + 40
TB_GETBITMAPFLAGS = WM_USER + 41
TB_SETCMDID = WM_USER + 42
TB_CHANGEBITMAP = WM_USER + 43
TB_GETBITMAP = WM_USER + 44
TB_GETBUTTONTEXT = WM_USER + 75
TB_REPLACEBITMAP = WM_USER + 46
TB_GETBUTTONSIZE = WM_USER + 58
TB_SETBUTTONWIDTH = WM_USER + 59
TB_SETINDENT = WM_USER + 47
TB_SETIMAGELIST = WM_USER + 48
TB_GETIMAGELIST = WM_USER + 49
TB_LOADIMAGES = WM_USER + 50
TB_GETRECT = WM_USER + 51
TB_SETHOTIMAGELIST = WM_USER + 52
TB_GETHOTIMAGELIST = WM_USER + 53
TB_SETDISABLEDIMAGELIST = WM_USER + 54
TB_GETDISABLEDIMAGELIST = WM_USER + 55
TB_SETSTYLE = WM_USER + 56
TB_GETSTYLE = WM_USER + 57
TB_SETMAXTEXTROWS = WM_USER + 60
TB_GETTEXTROWS = WM_USER + 61
TB_GETOBJECT = WM_USER + 62
TB_GETBUTTONINFO = WM_USER + 63
TB_SETBUTTONINFO = WM_USER + 64
TB_INSERTBUTTON = WM_USER + 67
TB_ADDBUTTONS = WM_USER + 68
TB_HITTEST = WM_USER + 69
TB_SETDRAWTEXTFLAGS = WM_USER + 70
TB_GETHOTITEM = WM_USER + 71
TB_SETHOTITEM = WM_USER + 72
TB_SETANCHORHIGHLIGHT = WM_USER + 73
TB_GETANCHORHIGHLIGHT = WM_USER + 74
TB_GETINSERTMARK = WM_USER + 79
TB_SETINSERTMARK = WM_USER + 80
TB_INSERTMARKHITTEST = WM_USER + 81
TB_MOVEBUTTON = WM_USER + 82
TB_GETMAXSIZE = WM_USER + 83
TB_SETEXTENDEDSTYLE = WM_USER + 84
TB_GETEXTENDEDSTYLE = WM_USER + 85
TB_GETPADDING = WM_USER + 86
TB_SETPADDING = WM_USER + 87
TB_SETINSERTMARKCOLOR = WM_USER + 88
TB_GETINSERTMARKCOLOR = WM_USER + 89
TB_MAPACCELERATOR = WM_USER + 90
TB_GETSTRING = WM_USER + 91
TB_GETIDEALSIZE = WM_USER + 99
TB_SETCOLORSCHEME = CCM_SETCOLORSCHEME
TB_GETCOLORSCHEME = CCM_GETCOLORSCHEME
TB_SETUNICODEFORMAT = CCM_SETUNICODEFORMAT
TB_GETUNICODEFORMAT = CCM_GETUNICODEFORMAT
)
// ToolBar notifications
const (
TBN_FIRST = -700
TBN_DROPDOWN = TBN_FIRST - 10
)
// TBN_DROPDOWN return codes
const (
TBDDRET_DEFAULT = 0
TBDDRET_NODEFAULT = 1
TBDDRET_TREATPRESSED = 2
)
// ToolBar state constants
const (
TBSTATE_CHECKED = 1
TBSTATE_PRESSED = 2
TBSTATE_ENABLED = 4
TBSTATE_HIDDEN = 8
TBSTATE_INDETERMINATE = 16
TBSTATE_WRAP = 32
TBSTATE_ELLIPSES = 0x40
TBSTATE_MARKED = 0x0080
)
// ToolBar style constants
const (
TBSTYLE_BUTTON = 0
TBSTYLE_SEP = 1
TBSTYLE_CHECK = 2
TBSTYLE_GROUP = 4
TBSTYLE_CHECKGROUP = TBSTYLE_GROUP | TBSTYLE_CHECK
TBSTYLE_DROPDOWN = 8
TBSTYLE_AUTOSIZE = 16
TBSTYLE_NOPREFIX = 32
TBSTYLE_TOOLTIPS = 256
TBSTYLE_WRAPABLE = 512
TBSTYLE_ALTDRAG = 1024
TBSTYLE_FLAT = 2048
TBSTYLE_LIST = 4096
TBSTYLE_CUSTOMERASE = 8192
TBSTYLE_REGISTERDROP = 0x4000
TBSTYLE_TRANSPARENT = 0x8000
)
// ToolBar extended style constants
const (
TBSTYLE_EX_DRAWDDARROWS = 0x00000001
TBSTYLE_EX_MIXEDBUTTONS = 8
TBSTYLE_EX_HIDECLIPPEDBUTTONS = 16
TBSTYLE_EX_DOUBLEBUFFER = 0x80
)
// ToolBar button style constants
const (
BTNS_BUTTON = TBSTYLE_BUTTON
BTNS_SEP = TBSTYLE_SEP
BTNS_CHECK = TBSTYLE_CHECK
BTNS_GROUP = TBSTYLE_GROUP
BTNS_CHECKGROUP = TBSTYLE_CHECKGROUP
BTNS_DROPDOWN = TBSTYLE_DROPDOWN
BTNS_AUTOSIZE = TBSTYLE_AUTOSIZE
BTNS_NOPREFIX = TBSTYLE_NOPREFIX
BTNS_WHOLEDROPDOWN = 0x0080
BTNS_SHOWTEXT = 0x0040
)
// TBBUTTONINFO mask flags
const (
TBIF_IMAGE = 0x00000001
TBIF_TEXT = 0x00000002
TBIF_STATE = 0x00000004
TBIF_STYLE = 0x00000008
TBIF_LPARAM = 0x00000010
TBIF_COMMAND = 0x00000020
TBIF_SIZE = 0x00000040
TBIF_BYINDEX = 0x80000000
)
type NMMOUSE struct {
Hdr NMHDR
DwItemSpec uintptr
DwItemData uintptr
Pt POINT
DwHitInfo uintptr
}
type NMTOOLBAR struct {
Hdr NMHDR
IItem int32
TbButton TBBUTTON
CchText int32
PszText *uint16
RcButton RECT
}
type TBBUTTON struct {
IBitmap int32
IdCommand int32
FsState byte
FsStyle byte
//#ifdef _WIN64
// BYTE bReserved[6] // padding for alignment
//#elif defined(_WIN32)
BReserved [2]byte // padding for alignment
//#endif
DwData uintptr
IString uintptr
}
type TBBUTTONINFO struct {
CbSize uint32
DwMask uint32
IdCommand int32
IImage int32
FsState byte
FsStyle byte
Cx uint16
LParam uintptr
PszText uintptr
CchText int32
}

97
vendor/github.com/lxn/win/tooltip.go generated vendored Normal file
View File

@ -0,0 +1,97 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"unsafe"
)
// ToolTip styles
const (
TTS_ALWAYSTIP = 0x01
TTS_NOPREFIX = 0x02
TTS_NOANIMATE = 0x10
TTS_NOFADE = 0x20
TTS_BALLOON = 0x40
TTS_CLOSE = 0x80
)
// ToolTip messages
const (
TTM_ACTIVATE = WM_USER + 1
TTM_SETDELAYTIME = WM_USER + 3
TTM_ADDTOOL = WM_USER + 50
TTM_DELTOOL = WM_USER + 51
TTM_NEWTOOLRECT = WM_USER + 52
TTM_RELAYEVENT = WM_USER + 7
TTM_GETTOOLINFO = WM_USER + 53
TTM_SETTOOLINFO = WM_USER + 54
TTM_HITTEST = WM_USER + 55
TTM_GETTEXT = WM_USER + 56
TTM_UPDATETIPTEXT = WM_USER + 57
TTM_GETTOOLCOUNT = WM_USER + 13
TTM_ENUMTOOLS = WM_USER + 58
TTM_GETCURRENTTOOL = WM_USER + 59
TTM_WINDOWFROMPOINT = WM_USER + 16
TTM_TRACKACTIVATE = WM_USER + 17
TTM_TRACKPOSITION = WM_USER + 18
TTM_SETTIPBKCOLOR = WM_USER + 19
TTM_SETTIPTEXTCOLOR = WM_USER + 20
TTM_GETDELAYTIME = WM_USER + 21
TTM_GETTIPBKCOLOR = WM_USER + 22
TTM_GETTIPTEXTCOLOR = WM_USER + 23
TTM_SETMAXTIPWIDTH = WM_USER + 24
TTM_GETMAXTIPWIDTH = WM_USER + 25
TTM_SETMARGIN = WM_USER + 26
TTM_GETMARGIN = WM_USER + 27
TTM_POP = WM_USER + 28
TTM_UPDATE = WM_USER + 29
TTM_GETBUBBLESIZE = WM_USER + 30
TTM_ADJUSTRECT = WM_USER + 31
TTM_SETTITLE = WM_USER + 33
TTM_POPUP = WM_USER + 34
TTM_GETTITLE = WM_USER + 35
)
// ToolTip flags
const (
TTF_IDISHWND = 0x0001
TTF_CENTERTIP = 0x0002
TTF_RTLREADING = 0x0004
TTF_SUBCLASS = 0x0010
TTF_TRACK = 0x0020
TTF_ABSOLUTE = 0x0080
TTF_TRANSPARENT = 0x0100
TTF_DI_SETITEM = 0x8000
)
// ToolTip icons
const (
TTI_NONE = 0
TTI_INFO = 1
TTI_WARNING = 2
TTI_ERROR = 3
)
type TOOLINFO struct {
CbSize uint32
UFlags uint32
Hwnd HWND
UId uintptr
Rect RECT
Hinst HINSTANCE
LpszText *uint16
LParam uintptr
LpReserved unsafe.Pointer
}
type TTGETTITLE struct {
DwSize uint32
UTitleBitmap uint32
Cch uint32
PszTitle *uint16
}

247
vendor/github.com/lxn/win/treeview.go generated vendored Normal file
View File

@ -0,0 +1,247 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
// TreeView styles
const (
TVS_HASBUTTONS = 0x0001
TVS_HASLINES = 0x0002
TVS_LINESATROOT = 0x0004
TVS_EDITLABELS = 0x0008
TVS_DISABLEDRAGDROP = 0x0010
TVS_SHOWSELALWAYS = 0x0020
TVS_RTLREADING = 0x0040
TVS_NOTOOLTIPS = 0x0080
TVS_CHECKBOXES = 0x0100
TVS_TRACKSELECT = 0x0200
TVS_SINGLEEXPAND = 0x0400
TVS_INFOTIP = 0x0800
TVS_FULLROWSELECT = 0x1000
TVS_NOSCROLL = 0x2000
TVS_NONEVENHEIGHT = 0x4000
TVS_NOHSCROLL = 0x8000
)
const (
TVS_EX_NOSINGLECOLLAPSE = 0x0001
TVS_EX_MULTISELECT = 0x0002
TVS_EX_DOUBLEBUFFER = 0x0004
TVS_EX_NOINDENTSTATE = 0x0008
TVS_EX_RICHTOOLTIP = 0x0010
TVS_EX_AUTOHSCROLL = 0x0020
TVS_EX_FADEINOUTEXPANDOS = 0x0040
TVS_EX_PARTIALCHECKBOXES = 0x0080
TVS_EX_EXCLUSIONCHECKBOXES = 0x0100
TVS_EX_DIMMEDCHECKBOXES = 0x0200
TVS_EX_DRAWIMAGEASYNC = 0x0400
)
const (
TVIF_TEXT = 0x0001
TVIF_IMAGE = 0x0002
TVIF_PARAM = 0x0004
TVIF_STATE = 0x0008
TVIF_HANDLE = 0x0010
TVIF_SELECTEDIMAGE = 0x0020
TVIF_CHILDREN = 0x0040
TVIF_INTEGRAL = 0x0080
TVIF_STATEEX = 0x0100
TVIF_EXPANDEDIMAGE = 0x0200
)
const (
TVIS_SELECTED = 0x0002
TVIS_CUT = 0x0004
TVIS_DROPHILITED = 0x0008
TVIS_BOLD = 0x0010
TVIS_EXPANDED = 0x0020
TVIS_EXPANDEDONCE = 0x0040
TVIS_EXPANDPARTIAL = 0x0080
TVIS_OVERLAYMASK = 0x0F00
TVIS_STATEIMAGEMASK = 0xF000
TVIS_USERMASK = 0xF000
)
const (
TVIS_EX_FLAT = 0x0001
TVIS_EX_DISABLED = 0x0002
TVIS_EX_ALL = 0x0002
)
const (
TVI_ROOT = ^HTREEITEM(0xffff)
TVI_FIRST = ^HTREEITEM(0xfffe)
TVI_LAST = ^HTREEITEM(0xfffd)
TVI_SORT = ^HTREEITEM(0xfffc)
)
// TVM_EXPAND action flags
const (
TVE_COLLAPSE = 0x0001
TVE_EXPAND = 0x0002
TVE_TOGGLE = 0x0003
TVE_EXPANDPARTIAL = 0x4000
TVE_COLLAPSERESET = 0x8000
)
const (
TVGN_CARET = 9
)
// TreeView messages
const (
TV_FIRST = 0x1100
TVM_INSERTITEM = TV_FIRST + 50
TVM_DELETEITEM = TV_FIRST + 1
TVM_EXPAND = TV_FIRST + 2
TVM_GETITEMRECT = TV_FIRST + 4
TVM_GETCOUNT = TV_FIRST + 5
TVM_GETINDENT = TV_FIRST + 6
TVM_SETINDENT = TV_FIRST + 7
TVM_GETIMAGELIST = TV_FIRST + 8
TVM_SETIMAGELIST = TV_FIRST + 9
TVM_GETNEXTITEM = TV_FIRST + 10
TVM_SELECTITEM = TV_FIRST + 11
TVM_GETITEM = TV_FIRST + 62
TVM_SETITEM = TV_FIRST + 63
TVM_EDITLABEL = TV_FIRST + 65
TVM_GETEDITCONTROL = TV_FIRST + 15
TVM_GETVISIBLECOUNT = TV_FIRST + 16
TVM_HITTEST = TV_FIRST + 17
TVM_CREATEDRAGIMAGE = TV_FIRST + 18
TVM_SORTCHILDREN = TV_FIRST + 19
TVM_ENSUREVISIBLE = TV_FIRST + 20
TVM_SORTCHILDRENCB = TV_FIRST + 21
TVM_ENDEDITLABELNOW = TV_FIRST + 22
TVM_GETISEARCHSTRING = TV_FIRST + 64
TVM_SETTOOLTIPS = TV_FIRST + 24
TVM_GETTOOLTIPS = TV_FIRST + 25
TVM_SETINSERTMARK = TV_FIRST + 26
TVM_SETUNICODEFORMAT = CCM_SETUNICODEFORMAT
TVM_GETUNICODEFORMAT = CCM_GETUNICODEFORMAT
TVM_SETITEMHEIGHT = TV_FIRST + 27
TVM_GETITEMHEIGHT = TV_FIRST + 28
TVM_SETBKCOLOR = TV_FIRST + 29
TVM_SETTEXTCOLOR = TV_FIRST + 30
TVM_GETBKCOLOR = TV_FIRST + 31
TVM_GETTEXTCOLOR = TV_FIRST + 32
TVM_SETSCROLLTIME = TV_FIRST + 33
TVM_GETSCROLLTIME = TV_FIRST + 34
TVM_SETINSERTMARKCOLOR = TV_FIRST + 37
TVM_GETINSERTMARKCOLOR = TV_FIRST + 38
TVM_GETITEMSTATE = TV_FIRST + 39
TVM_SETLINECOLOR = TV_FIRST + 40
TVM_GETLINECOLOR = TV_FIRST + 41
TVM_MAPACCIDTOHTREEITEM = TV_FIRST + 42
TVM_MAPHTREEITEMTOACCID = TV_FIRST + 43
TVM_SETEXTENDEDSTYLE = TV_FIRST + 44
TVM_GETEXTENDEDSTYLE = TV_FIRST + 45
TVM_SETAUTOSCROLLINFO = TV_FIRST + 59
)
// TreeView notifications
const (
TVN_FIRST = ^uint32(399)
TVN_SELCHANGING = TVN_FIRST - 50
TVN_SELCHANGED = TVN_FIRST - 51
TVN_GETDISPINFO = TVN_FIRST - 52
TVN_ITEMEXPANDING = TVN_FIRST - 54
TVN_ITEMEXPANDED = TVN_FIRST - 55
TVN_BEGINDRAG = TVN_FIRST - 56
TVN_BEGINRDRAG = TVN_FIRST - 57
TVN_DELETEITEM = TVN_FIRST - 58
TVN_BEGINLABELEDIT = TVN_FIRST - 59
TVN_ENDLABELEDIT = TVN_FIRST - 60
TVN_KEYDOWN = TVN_FIRST - 12
TVN_GETINFOTIP = TVN_FIRST - 14
TVN_SINGLEEXPAND = TVN_FIRST - 15
TVN_ITEMCHANGING = TVN_FIRST - 17
TVN_ITEMCHANGED = TVN_FIRST - 19
TVN_ASYNCDRAW = TVN_FIRST - 20
)
// TreeView hit test constants
const (
TVHT_NOWHERE = 1
TVHT_ONITEMICON = 2
TVHT_ONITEMLABEL = 4
TVHT_ONITEM = TVHT_ONITEMICON | TVHT_ONITEMLABEL | TVHT_ONITEMSTATEICON
TVHT_ONITEMINDENT = 8
TVHT_ONITEMBUTTON = 16
TVHT_ONITEMRIGHT = 32
TVHT_ONITEMSTATEICON = 64
TVHT_ABOVE = 256
TVHT_BELOW = 512
TVHT_TORIGHT = 1024
TVHT_TOLEFT = 2048
)
type HTREEITEM HANDLE
type TVITEM struct {
Mask uint32
HItem HTREEITEM
State uint32
StateMask uint32
PszText uintptr
CchTextMax int32
IImage int32
ISelectedImage int32
CChildren int32
LParam uintptr
}
/*type TVITEMEX struct {
mask UINT
hItem HTREEITEM
state UINT
stateMask UINT
pszText LPWSTR
cchTextMax int
iImage int
iSelectedImage int
cChildren int
lParam LPARAM
iIntegral int
uStateEx UINT
hwnd HWND
iExpandedImage int
}*/
type TVINSERTSTRUCT struct {
HParent HTREEITEM
HInsertAfter HTREEITEM
Item TVITEM
// itemex TVITEMEX
}
type NMTREEVIEW struct {
Hdr NMHDR
Action uint32
ItemOld TVITEM
ItemNew TVITEM
PtDrag POINT
}
type NMTVDISPINFO struct {
Hdr NMHDR
Item TVITEM
}
type NMTVKEYDOWN struct {
Hdr NMHDR
WVKey uint16
Flags uint32
}
type TVHITTESTINFO struct {
Pt POINT
Flags uint32
HItem HTREEITEM
}

58
vendor/github.com/lxn/win/updown.go generated vendored Normal file
View File

@ -0,0 +1,58 @@
// Copyright 2011 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
const UDN_FIRST = ^uint32(720)
const (
UD_MAXVAL = 0x7fff
UD_MINVAL = ^uintptr(UD_MAXVAL - 1)
)
const (
UDS_WRAP = 0x0001
UDS_SETBUDDYINT = 0x0002
UDS_ALIGNRIGHT = 0x0004
UDS_ALIGNLEFT = 0x0008
UDS_AUTOBUDDY = 0x0010
UDS_ARROWKEYS = 0x0020
UDS_HORZ = 0x0040
UDS_NOTHOUSANDS = 0x0080
UDS_HOTTRACK = 0x0100
)
const (
UDM_SETRANGE = WM_USER + 101
UDM_GETRANGE = WM_USER + 102
UDM_SETPOS = WM_USER + 103
UDM_GETPOS = WM_USER + 104
UDM_SETBUDDY = WM_USER + 105
UDM_GETBUDDY = WM_USER + 106
UDM_SETACCEL = WM_USER + 107
UDM_GETACCEL = WM_USER + 108
UDM_SETBASE = WM_USER + 109
UDM_GETBASE = WM_USER + 110
UDM_SETRANGE32 = WM_USER + 111
UDM_GETRANGE32 = WM_USER + 112
UDM_SETUNICODEFORMAT = CCM_SETUNICODEFORMAT
UDM_GETUNICODEFORMAT = CCM_GETUNICODEFORMAT
UDM_SETPOS32 = WM_USER + 113
UDM_GETPOS32 = WM_USER + 114
)
const UDN_DELTAPOS = UDN_FIRST - 1
type UDACCEL struct {
NSec uint32
NInc uint32
}
type NMUPDOWN struct {
Hdr NMHDR
IPos int32
IDelta int32
}

2865
vendor/github.com/lxn/win/user32.go generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

260
vendor/github.com/lxn/win/uxtheme.go generated vendored Normal file
View File

@ -0,0 +1,260 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
// CheckBox parts
const (
BP_CHECKBOX = 3
)
// CheckBox states
const (
CBS_UNCHECKEDNORMAL = 1
)
// LISTVIEW parts
const (
LVP_LISTITEM = 1
LVP_LISTGROUP = 2
LVP_LISTDETAIL = 3
LVP_LISTSORTEDDETAIL = 4
LVP_EMPTYTEXT = 5
LVP_GROUPHEADER = 6
LVP_GROUPHEADERLINE = 7
LVP_EXPANDBUTTON = 8
LVP_COLLAPSEBUTTON = 9
LVP_COLUMNDETAIL = 10
)
// LVP_LISTITEM states
const (
LISS_NORMAL = 1
LISS_HOT = 2
LISS_SELECTED = 3
LISS_DISABLED = 4
LISS_SELECTEDNOTFOCUS = 5
LISS_HOTSELECTED = 6
)
// TAB parts
const (
TABP_TABITEM = 1
)
// TABP_TABITEM states
const (
TIS_NORMAL = 1
TIS_HOT = 2
TIS_SELECTED = 3
TIS_DISABLED = 4
TIS_FOCUSED = 5
)
// TREEVIEW parts
const (
TVP_TREEITEM = 1
TVP_GLYPH = 2
TVP_BRANCH = 3
TVP_HOTGLYPH = 4
)
// TVP_TREEITEM states
const (
TREIS_NORMAL = 1
TREIS_HOT = 2
TREIS_SELECTED = 3
TREIS_DISABLED = 4
TREIS_SELECTEDNOTFOCUS = 5
TREIS_HOTSELECTED = 6
)
// DTTOPTS flags
const (
DTT_TEXTCOLOR = 1 << 0
DTT_BORDERCOLOR = 1 << 1
DTT_SHADOWCOLOR = 1 << 2
DTT_SHADOWTYPE = 1 << 3
DTT_SHADOWOFFSET = 1 << 4
DTT_BORDERSIZE = 1 << 5
DTT_FONTPROP = 1 << 6
DTT_COLORPROP = 1 << 7
DTT_STATEID = 1 << 8
DTT_CALCRECT = 1 << 9
DTT_APPLYOVERLAY = 1 << 10
DTT_GLOWSIZE = 1 << 11
DTT_CALLBACK = 1 << 12
DTT_COMPOSITED = 1 << 13
DTT_VALIDBITS = DTT_TEXTCOLOR |
DTT_BORDERCOLOR |
DTT_SHADOWCOLOR |
DTT_SHADOWTYPE |
DTT_SHADOWOFFSET |
DTT_BORDERSIZE |
DTT_FONTPROP |
DTT_COLORPROP |
DTT_STATEID |
DTT_CALCRECT |
DTT_APPLYOVERLAY |
DTT_GLOWSIZE |
DTT_COMPOSITED
)
type HTHEME HANDLE
type THEMESIZE int
const (
TS_MIN THEMESIZE = iota
TS_TRUE
TS_DRAW
)
type DTTOPTS struct {
DwSize uint32
DwFlags uint32
CrText COLORREF
CrBorder COLORREF
CrShadow COLORREF
ITextShadowType int
PtShadowOffset POINT
IBorderSize int
IFontPropId int
IColorPropId int
IStateId int
FApplyOverlay BOOL
IGlowSize int
PfnDrawTextCallback uintptr
LParam uintptr
}
var (
// Library
libuxtheme uintptr
// Functions
closeThemeData uintptr
drawThemeBackground uintptr
drawThemeTextEx uintptr
getThemePartSize uintptr
getThemeTextExtent uintptr
isAppThemed uintptr
openThemeData uintptr
setWindowTheme uintptr
)
func init() {
// Library
libuxtheme = MustLoadLibrary("uxtheme.dll")
// Functions
closeThemeData = MustGetProcAddress(libuxtheme, "CloseThemeData")
drawThemeBackground = MustGetProcAddress(libuxtheme, "DrawThemeBackground")
drawThemeTextEx = MustGetProcAddress(libuxtheme, "DrawThemeTextEx")
getThemePartSize = MustGetProcAddress(libuxtheme, "GetThemePartSize")
getThemeTextExtent = MustGetProcAddress(libuxtheme, "GetThemeTextExtent")
isAppThemed = MustGetProcAddress(libuxtheme, "IsAppThemed")
openThemeData = MustGetProcAddress(libuxtheme, "OpenThemeData")
setWindowTheme = MustGetProcAddress(libuxtheme, "SetWindowTheme")
}
func CloseThemeData(hTheme HTHEME) HRESULT {
ret, _, _ := syscall.Syscall(closeThemeData, 1,
uintptr(hTheme),
0,
0)
return HRESULT(ret)
}
func DrawThemeBackground(hTheme HTHEME, hdc HDC, iPartId, iStateId int32, pRect, pClipRect *RECT) HRESULT {
ret, _, _ := syscall.Syscall6(drawThemeBackground, 6,
uintptr(hTheme),
uintptr(hdc),
uintptr(iPartId),
uintptr(iStateId),
uintptr(unsafe.Pointer(pRect)),
uintptr(unsafe.Pointer(pClipRect)))
return HRESULT(ret)
}
func DrawThemeTextEx(hTheme HTHEME, hdc HDC, iPartId, iStateId int32, pszText *uint16, iCharCount int32, dwFlags uint32, pRect *RECT, pOptions *DTTOPTS) HRESULT {
ret, _, _ := syscall.Syscall9(drawThemeTextEx, 9,
uintptr(hTheme),
uintptr(hdc),
uintptr(iPartId),
uintptr(iStateId),
uintptr(unsafe.Pointer(pszText)),
uintptr(iCharCount),
uintptr(dwFlags),
uintptr(unsafe.Pointer(pRect)),
uintptr(unsafe.Pointer(pOptions)))
return HRESULT(ret)
}
func GetThemePartSize(hTheme HTHEME, hdc HDC, iPartId, iStateId int32, prc *RECT, eSize THEMESIZE, psz *SIZE) HRESULT {
ret, _, _ := syscall.Syscall9(getThemePartSize, 7,
uintptr(hTheme),
uintptr(hdc),
uintptr(iPartId),
uintptr(iStateId),
uintptr(unsafe.Pointer(prc)),
uintptr(eSize),
uintptr(unsafe.Pointer(psz)),
0,
0)
return HRESULT(ret)
}
func GetThemeTextExtent(hTheme HTHEME, hdc HDC, iPartId, iStateId int32, pszText *uint16, iCharCount int32, dwTextFlags uint32, pBoundingRect, pExtentRect *RECT) HRESULT {
ret, _, _ := syscall.Syscall9(getThemeTextExtent, 9,
uintptr(hTheme),
uintptr(hdc),
uintptr(iPartId),
uintptr(iStateId),
uintptr(unsafe.Pointer(pszText)),
uintptr(iCharCount),
uintptr(dwTextFlags),
uintptr(unsafe.Pointer(pBoundingRect)),
uintptr(unsafe.Pointer(pExtentRect)))
return HRESULT(ret)
}
func IsAppThemed() bool {
ret, _, _ := syscall.Syscall(isAppThemed, 0,
0,
0,
0)
return ret != 0
}
func OpenThemeData(hwnd HWND, pszClassList *uint16) HTHEME {
ret, _, _ := syscall.Syscall(openThemeData, 2,
uintptr(hwnd),
uintptr(unsafe.Pointer(pszClassList)),
0)
return HTHEME(ret)
}
func SetWindowTheme(hwnd HWND, pszSubAppName, pszSubIdList *uint16) HRESULT {
ret, _, _ := syscall.Syscall(setWindowTheme, 3,
uintptr(hwnd),
uintptr(unsafe.Pointer(pszSubAppName)),
uintptr(unsafe.Pointer(pszSubIdList)))
return HRESULT(ret)
}

112
vendor/github.com/lxn/win/win.go generated vendored Normal file
View File

@ -0,0 +1,112 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"runtime"
"syscall"
"unsafe"
)
func init() {
runtime.LockOSThread()
}
const (
S_OK = 0x00000000
S_FALSE = 0x00000001
E_UNEXPECTED = 0x8000FFFF
E_NOTIMPL = 0x80004001
E_OUTOFMEMORY = 0x8007000E
E_INVALIDARG = 0x80070057
E_NOINTERFACE = 0x80004002
E_POINTER = 0x80004003
E_HANDLE = 0x80070006
E_ABORT = 0x80004004
E_FAIL = 0x80004005
E_ACCESSDENIED = 0x80070005
E_PENDING = 0x8000000A
)
const (
FALSE = 0
TRUE = 1
)
type (
BOOL int32
HRESULT int32
)
func MustLoadLibrary(name string) uintptr {
lib, err := syscall.LoadLibrary(name)
if err != nil {
panic(err)
}
return uintptr(lib)
}
func MustGetProcAddress(lib uintptr, name string) uintptr {
addr, err := syscall.GetProcAddress(syscall.Handle(lib), name)
if err != nil {
panic(err)
}
return uintptr(addr)
}
func SUCCEEDED(hr HRESULT) bool {
return hr >= 0
}
func FAILED(hr HRESULT) bool {
return hr < 0
}
func MAKEWORD(lo, hi byte) uint16 {
return uint16(uint16(lo) | ((uint16(hi)) << 8))
}
func LOBYTE(w uint16) byte {
return byte(w)
}
func HIBYTE(w uint16) byte {
return byte(w >> 8 & 0xff)
}
func MAKELONG(lo, hi uint16) uint32 {
return uint32(uint32(lo) | ((uint32(hi)) << 16))
}
func LOWORD(dw uint32) uint16 {
return uint16(dw)
}
func HIWORD(dw uint32) uint16 {
return uint16(dw >> 16 & 0xffff)
}
func UTF16PtrToString(s *uint16) string {
if s == nil {
return ""
}
return syscall.UTF16ToString((*[1 << 29]uint16)(unsafe.Pointer(s))[0:])
}
func MAKEINTRESOURCE(id uintptr) *uint16 {
return (*uint16)(unsafe.Pointer(id))
}
func BoolToBOOL(value bool) BOOL {
if value {
return 1
}
return 0
}

100
vendor/github.com/lxn/win/winspool.go generated vendored Normal file
View File

@ -0,0 +1,100 @@
// Copyright 2010 The win Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// +build windows
package win
import (
"syscall"
"unsafe"
)
// EnumPrinters flags
const (
PRINTER_ENUM_DEFAULT = 0x00000001
PRINTER_ENUM_LOCAL = 0x00000002
PRINTER_ENUM_CONNECTIONS = 0x00000004
PRINTER_ENUM_FAVORITE = 0x00000004
PRINTER_ENUM_NAME = 0x00000008
PRINTER_ENUM_REMOTE = 0x00000010
PRINTER_ENUM_SHARED = 0x00000020
PRINTER_ENUM_NETWORK = 0x00000040
)
type PRINTER_INFO_4 struct {
PPrinterName *uint16
PServerName *uint16
Attributes uint32
}
var (
// Library
libwinspool uintptr
// Functions
deviceCapabilities uintptr
documentProperties uintptr
enumPrinters uintptr
getDefaultPrinter uintptr
)
func init() {
// Library
libwinspool = MustLoadLibrary("winspool.drv")
// Functions
deviceCapabilities = MustGetProcAddress(libwinspool, "DeviceCapabilitiesW")
documentProperties = MustGetProcAddress(libwinspool, "DocumentPropertiesW")
enumPrinters = MustGetProcAddress(libwinspool, "EnumPrintersW")
getDefaultPrinter = MustGetProcAddress(libwinspool, "GetDefaultPrinterW")
}
func DeviceCapabilities(pDevice, pPort *uint16, fwCapability uint16, pOutput *uint16, pDevMode *DEVMODE) uint32 {
ret, _, _ := syscall.Syscall6(deviceCapabilities, 5,
uintptr(unsafe.Pointer(pDevice)),
uintptr(unsafe.Pointer(pPort)),
uintptr(fwCapability),
uintptr(unsafe.Pointer(pOutput)),
uintptr(unsafe.Pointer(pDevMode)),
0)
return uint32(ret)
}
func DocumentProperties(hWnd HWND, hPrinter HANDLE, pDeviceName *uint16, pDevModeOutput, pDevModeInput *DEVMODE, fMode uint32) int32 {
ret, _, _ := syscall.Syscall6(documentProperties, 6,
uintptr(hWnd),
uintptr(hPrinter),
uintptr(unsafe.Pointer(pDeviceName)),
uintptr(unsafe.Pointer(pDevModeOutput)),
uintptr(unsafe.Pointer(pDevModeInput)),
uintptr(fMode))
return int32(ret)
}
func EnumPrinters(Flags uint32, Name *uint16, Level uint32, pPrinterEnum *byte, cbBuf uint32, pcbNeeded, pcReturned *uint32) bool {
ret, _, _ := syscall.Syscall9(enumPrinters, 7,
uintptr(Flags),
uintptr(unsafe.Pointer(Name)),
uintptr(Level),
uintptr(unsafe.Pointer(pPrinterEnum)),
uintptr(cbBuf),
uintptr(unsafe.Pointer(pcbNeeded)),
uintptr(unsafe.Pointer(pcReturned)),
0,
0)
return ret != 0
}
func GetDefaultPrinter(pszBuffer *uint16, pcchBuffer *uint32) bool {
ret, _, _ := syscall.Syscall(getDefaultPrinter, 2,
uintptr(unsafe.Pointer(pszBuffer)),
uintptr(unsafe.Pointer(pcchBuffer)),
0)
return ret != 0
}