From a854ddb3580d95b11a0c5cc4139f786476e25e3d Mon Sep 17 00:00:00 2001 From: David Porter Date: Tue, 8 Aug 2017 19:18:42 +0000 Subject: [PATCH] Implement metrics for Windows Nodes 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. --- Godeps/Godeps.json | 4 + Godeps/LICENSES | 31 + pkg/kubelet/BUILD | 1 + pkg/kubelet/cadvisor/BUILD | 3 + pkg/kubelet/cadvisor/cadvisor_windows.go | 11 +- pkg/kubelet/winstats/BUILD | 53 + pkg/kubelet/winstats/perfcounter_nodestats.go | 166 + pkg/kubelet/winstats/perfcounters.go | 102 + pkg/kubelet/winstats/winstats.go | 145 + pkg/kubelet/winstats/winstats_test.go | 132 + vendor/BUILD | 1 + vendor/github.com/lxn/win/AUTHORS | 24 + vendor/github.com/lxn/win/BUILD | 58 + vendor/github.com/lxn/win/LICENSE | 23 + vendor/github.com/lxn/win/README.mdown | 15 + vendor/github.com/lxn/win/advapi32.go | 136 + vendor/github.com/lxn/win/combobox.go | 86 + vendor/github.com/lxn/win/comctl32.go | 308 ++ vendor/github.com/lxn/win/comdlg32.go | 299 ++ vendor/github.com/lxn/win/datetimepicker.go | 96 + vendor/github.com/lxn/win/edit.go | 84 + vendor/github.com/lxn/win/gdi32.go | 1808 +++++++++++ vendor/github.com/lxn/win/gdiplus.go | 223 ++ vendor/github.com/lxn/win/header.go | 40 + vendor/github.com/lxn/win/kernel32.go | 352 ++ vendor/github.com/lxn/win/listbox.go | 87 + vendor/github.com/lxn/win/listview.go | 370 +++ vendor/github.com/lxn/win/menu.go | 110 + vendor/github.com/lxn/win/ole32.go | 500 +++ vendor/github.com/lxn/win/oleaut32.go | 240 ++ vendor/github.com/lxn/win/oleaut32_386.go | 14 + vendor/github.com/lxn/win/oleaut32_amd64.go | 13 + vendor/github.com/lxn/win/opengl32.go | 301 ++ vendor/github.com/lxn/win/pdh.go | 436 +++ vendor/github.com/lxn/win/shdocvw.go | 273 ++ vendor/github.com/lxn/win/shell32.go | 297 ++ vendor/github.com/lxn/win/shobj.go | 62 + vendor/github.com/lxn/win/shobj_386.go | 24 + vendor/github.com/lxn/win/shobj_amd64.go | 24 + vendor/github.com/lxn/win/statusbar.go | 50 + vendor/github.com/lxn/win/syslink.go | 65 + vendor/github.com/lxn/win/tab.go | 128 + vendor/github.com/lxn/win/toolbar.go | 219 ++ vendor/github.com/lxn/win/tooltip.go | 97 + vendor/github.com/lxn/win/treeview.go | 247 ++ vendor/github.com/lxn/win/updown.go | 58 + vendor/github.com/lxn/win/user32.go | 2865 +++++++++++++++++ vendor/github.com/lxn/win/uxtheme.go | 260 ++ vendor/github.com/lxn/win/win.go | 112 + vendor/github.com/lxn/win/winspool.go | 100 + 50 files changed, 11149 insertions(+), 4 deletions(-) create mode 100644 pkg/kubelet/winstats/BUILD create mode 100644 pkg/kubelet/winstats/perfcounter_nodestats.go create mode 100644 pkg/kubelet/winstats/perfcounters.go create mode 100644 pkg/kubelet/winstats/winstats.go create mode 100644 pkg/kubelet/winstats/winstats_test.go create mode 100644 vendor/github.com/lxn/win/AUTHORS create mode 100644 vendor/github.com/lxn/win/BUILD create mode 100644 vendor/github.com/lxn/win/LICENSE create mode 100644 vendor/github.com/lxn/win/README.mdown create mode 100644 vendor/github.com/lxn/win/advapi32.go create mode 100644 vendor/github.com/lxn/win/combobox.go create mode 100644 vendor/github.com/lxn/win/comctl32.go create mode 100644 vendor/github.com/lxn/win/comdlg32.go create mode 100644 vendor/github.com/lxn/win/datetimepicker.go create mode 100644 vendor/github.com/lxn/win/edit.go create mode 100644 vendor/github.com/lxn/win/gdi32.go create mode 100644 vendor/github.com/lxn/win/gdiplus.go create mode 100644 vendor/github.com/lxn/win/header.go create mode 100644 vendor/github.com/lxn/win/kernel32.go create mode 100644 vendor/github.com/lxn/win/listbox.go create mode 100644 vendor/github.com/lxn/win/listview.go create mode 100644 vendor/github.com/lxn/win/menu.go create mode 100644 vendor/github.com/lxn/win/ole32.go create mode 100644 vendor/github.com/lxn/win/oleaut32.go create mode 100644 vendor/github.com/lxn/win/oleaut32_386.go create mode 100644 vendor/github.com/lxn/win/oleaut32_amd64.go create mode 100644 vendor/github.com/lxn/win/opengl32.go create mode 100644 vendor/github.com/lxn/win/pdh.go create mode 100644 vendor/github.com/lxn/win/shdocvw.go create mode 100644 vendor/github.com/lxn/win/shell32.go create mode 100644 vendor/github.com/lxn/win/shobj.go create mode 100644 vendor/github.com/lxn/win/shobj_386.go create mode 100644 vendor/github.com/lxn/win/shobj_amd64.go create mode 100644 vendor/github.com/lxn/win/statusbar.go create mode 100644 vendor/github.com/lxn/win/syslink.go create mode 100644 vendor/github.com/lxn/win/tab.go create mode 100644 vendor/github.com/lxn/win/toolbar.go create mode 100644 vendor/github.com/lxn/win/tooltip.go create mode 100644 vendor/github.com/lxn/win/treeview.go create mode 100644 vendor/github.com/lxn/win/updown.go create mode 100644 vendor/github.com/lxn/win/user32.go create mode 100644 vendor/github.com/lxn/win/uxtheme.go create mode 100644 vendor/github.com/lxn/win/win.go create mode 100644 vendor/github.com/lxn/win/winspool.go diff --git a/Godeps/Godeps.json b/Godeps/Godeps.json index e31e8fa747b..818e3de544d 100644 --- a/Godeps/Godeps.json +++ b/Godeps/Godeps.json @@ -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", diff --git a/Godeps/LICENSES b/Godeps/LICENSES index b9282f35f61..2da1baa67fd 100644 --- a/Godeps/LICENSES +++ b/Godeps/LICENSES @@ -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: = diff --git a/pkg/kubelet/BUILD b/pkg/kubelet/BUILD index cd8c207bd45..683b7ad12a5 100644 --- a/pkg/kubelet/BUILD +++ b/pkg/kubelet/BUILD @@ -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"], ) diff --git a/pkg/kubelet/cadvisor/BUILD b/pkg/kubelet/cadvisor/BUILD index 29c45eb2b87..39b0f68da03 100644 --- a/pkg/kubelet/cadvisor/BUILD +++ b/pkg/kubelet/cadvisor/BUILD @@ -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": [], }), ) diff --git a/pkg/kubelet/cadvisor/cadvisor_windows.go b/pkg/kubelet/cadvisor/cadvisor_windows.go index b663c372fd2..52d3cd56050 100644 --- a/pkg/kubelet/cadvisor/cadvisor_windows.go +++ b/pkg/kubelet/cadvisor/cadvisor_windows.go @@ -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) { diff --git a/pkg/kubelet/winstats/BUILD b/pkg/kubelet/winstats/BUILD new file mode 100644 index 00000000000..0f5839a14ba --- /dev/null +++ b/pkg/kubelet/winstats/BUILD @@ -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", + ], +) diff --git a/pkg/kubelet/winstats/perfcounter_nodestats.go b/pkg/kubelet/winstats/perfcounter_nodestats.go new file mode 100644 index 00000000000..9d0a3e92a22 --- /dev/null +++ b/pkg/kubelet/winstats/perfcounter_nodestats.go @@ -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 +} diff --git a/pkg/kubelet/winstats/perfcounters.go b/pkg/kubelet/winstats/perfcounters.go new file mode 100644 index 00000000000..dd77103bd0a --- /dev/null +++ b/pkg/kubelet/winstats/perfcounters.go @@ -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 +} diff --git a/pkg/kubelet/winstats/winstats.go b/pkg/kubelet/winstats/winstats.go new file mode 100644 index 00000000000..123870b8968 --- /dev/null +++ b/pkg/kubelet/winstats/winstats.go @@ -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 +} diff --git a/pkg/kubelet/winstats/winstats_test.go b/pkg/kubelet/winstats/winstats_test.go new file mode 100644 index 00000000000..c1710750708 --- /dev/null +++ b/pkg/kubelet/winstats/winstats_test.go @@ -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 +} diff --git a/vendor/BUILD b/vendor/BUILD index 80286c1ff93..66c96ac265b 100644 --- a/vendor/BUILD +++ b/vendor/BUILD @@ -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", diff --git a/vendor/github.com/lxn/win/AUTHORS b/vendor/github.com/lxn/win/AUTHORS new file mode 100644 index 00000000000..fd1738bb823 --- /dev/null +++ b/vendor/github.com/lxn/win/AUTHORS @@ -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 +# The email address is not required for organizations. + +# Please keep the list sorted. + +# Contributors +# ============ + +Alexander Neumann +Anton Lahti +Benny Siegert +Bruno Bigras +Carlos Cobo +Cary Cherng +David Porter +Hill +Joseph Watson +Kevin Pors +ktye +mycaosf +wsf01 diff --git a/vendor/github.com/lxn/win/BUILD b/vendor/github.com/lxn/win/BUILD new file mode 100644 index 00000000000..cb881159f17 --- /dev/null +++ b/vendor/github.com/lxn/win/BUILD @@ -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"], +) diff --git a/vendor/github.com/lxn/win/LICENSE b/vendor/github.com/lxn/win/LICENSE new file mode 100644 index 00000000000..2bd706be7f0 --- /dev/null +++ b/vendor/github.com/lxn/win/LICENSE @@ -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. diff --git a/vendor/github.com/lxn/win/README.mdown b/vendor/github.com/lxn/win/README.mdown new file mode 100644 index 00000000000..33d81fffc4a --- /dev/null +++ b/vendor/github.com/lxn/win/README.mdown @@ -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` diff --git a/vendor/github.com/lxn/win/advapi32.go b/vendor/github.com/lxn/win/advapi32.go new file mode 100644 index 00000000000..31e4ffe8977 --- /dev/null +++ b/vendor/github.com/lxn/win/advapi32.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/combobox.go b/vendor/github.com/lxn/win/combobox.go new file mode 100644 index 00000000000..3fdc782c3ec --- /dev/null +++ b/vendor/github.com/lxn/win/combobox.go @@ -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 +) diff --git a/vendor/github.com/lxn/win/comctl32.go b/vendor/github.com/lxn/win/comctl32.go new file mode 100644 index 00000000000..31564e0b52f --- /dev/null +++ b/vendor/github.com/lxn/win/comctl32.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/comdlg32.go b/vendor/github.com/lxn/win/comdlg32.go new file mode 100644 index 00000000000..56c556478e5 --- /dev/null +++ b/vendor/github.com/lxn/win/comdlg32.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/datetimepicker.go b/vendor/github.com/lxn/win/datetimepicker.go new file mode 100644 index 00000000000..07a65324514 --- /dev/null +++ b/vendor/github.com/lxn/win/datetimepicker.go @@ -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 + } +) diff --git a/vendor/github.com/lxn/win/edit.go b/vendor/github.com/lxn/win/edit.go new file mode 100644 index 00000000000..38509cf7d3d --- /dev/null +++ b/vendor/github.com/lxn/win/edit.go @@ -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 +) diff --git a/vendor/github.com/lxn/win/gdi32.go b/vendor/github.com/lxn/win/gdi32.go new file mode 100644 index 00000000000..184ba8711b3 --- /dev/null +++ b/vendor/github.com/lxn/win/gdi32.go @@ -0,0 +1,1808 @@ +// 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" +) + +// GetDeviceCaps index constants +const ( + DRIVERVERSION = 0 + TECHNOLOGY = 2 + HORZSIZE = 4 + VERTSIZE = 6 + HORZRES = 8 + VERTRES = 10 + LOGPIXELSX = 88 + LOGPIXELSY = 90 + BITSPIXEL = 12 + PLANES = 14 + NUMBRUSHES = 16 + NUMPENS = 18 + NUMFONTS = 22 + NUMCOLORS = 24 + NUMMARKERS = 20 + ASPECTX = 40 + ASPECTY = 42 + ASPECTXY = 44 + PDEVICESIZE = 26 + CLIPCAPS = 36 + SIZEPALETTE = 104 + NUMRESERVED = 106 + COLORRES = 108 + PHYSICALWIDTH = 110 + PHYSICALHEIGHT = 111 + PHYSICALOFFSETX = 112 + PHYSICALOFFSETY = 113 + SCALINGFACTORX = 114 + SCALINGFACTORY = 115 + VREFRESH = 116 + DESKTOPHORZRES = 118 + DESKTOPVERTRES = 117 + BLTALIGNMENT = 119 + SHADEBLENDCAPS = 120 + COLORMGMTCAPS = 121 + RASTERCAPS = 38 + CURVECAPS = 28 + LINECAPS = 30 + POLYGONALCAPS = 32 + TEXTCAPS = 34 +) + +// GetDeviceCaps TECHNOLOGY constants +const ( + DT_PLOTTER = 0 + DT_RASDISPLAY = 1 + DT_RASPRINTER = 2 + DT_RASCAMERA = 3 + DT_CHARSTREAM = 4 + DT_METAFILE = 5 + DT_DISPFILE = 6 +) + +// GetDeviceCaps SHADEBLENDCAPS constants +const ( + SB_NONE = 0x00 + SB_CONST_ALPHA = 0x01 + SB_PIXEL_ALPHA = 0x02 + SB_PREMULT_ALPHA = 0x04 + SB_GRAD_RECT = 0x10 + SB_GRAD_TRI = 0x20 +) + +// GetDeviceCaps COLORMGMTCAPS constants +const ( + CM_NONE = 0x00 + CM_DEVICE_ICM = 0x01 + CM_GAMMA_RAMP = 0x02 + CM_CMYK_COLOR = 0x04 +) + +// GetDeviceCaps RASTERCAPS constants +const ( + RC_BANDING = 2 + RC_BITBLT = 1 + RC_BITMAP64 = 8 + RC_DI_BITMAP = 128 + RC_DIBTODEV = 512 + RC_FLOODFILL = 4096 + RC_GDI20_OUTPUT = 16 + RC_PALETTE = 256 + RC_SCALING = 4 + RC_STRETCHBLT = 2048 + RC_STRETCHDIB = 8192 + RC_DEVBITS = 0x8000 + RC_OP_DX_OUTPUT = 0x4000 +) + +// GetDeviceCaps CURVECAPS constants +const ( + CC_NONE = 0 + CC_CIRCLES = 1 + CC_PIE = 2 + CC_CHORD = 4 + CC_ELLIPSES = 8 + CC_WIDE = 16 + CC_STYLED = 32 + CC_WIDESTYLED = 64 + CC_INTERIORS = 128 + CC_ROUNDRECT = 256 +) + +// GetDeviceCaps LINECAPS constants +const ( + LC_NONE = 0 + LC_POLYLINE = 2 + LC_MARKER = 4 + LC_POLYMARKER = 8 + LC_WIDE = 16 + LC_STYLED = 32 + LC_WIDESTYLED = 64 + LC_INTERIORS = 128 +) + +// GetDeviceCaps POLYGONALCAPS constants +const ( + PC_NONE = 0 + PC_POLYGON = 1 + PC_POLYPOLYGON = 256 + PC_PATHS = 512 + PC_RECTANGLE = 2 + PC_WINDPOLYGON = 4 + PC_SCANLINE = 8 + PC_TRAPEZOID = 4 + PC_WIDE = 16 + PC_STYLED = 32 + PC_WIDESTYLED = 64 + PC_INTERIORS = 128 +) + +// GetDeviceCaps TEXTCAPS constants +const ( + TC_OP_CHARACTER = 1 + TC_OP_STROKE = 2 + TC_CP_STROKE = 4 + TC_CR_90 = 8 + TC_CR_ANY = 16 + TC_SF_X_YINDEP = 32 + TC_SA_DOUBLE = 64 + TC_SA_INTEGER = 128 + TC_SA_CONTIN = 256 + TC_EA_DOUBLE = 512 + TC_IA_ABLE = 1024 + TC_UA_ABLE = 2048 + TC_SO_ABLE = 4096 + TC_RA_ABLE = 8192 + TC_VA_ABLE = 16384 + TC_RESERVED = 32768 + TC_SCROLLBLT = 65536 +) + +// Brush styles +const ( + BS_SOLID = 0 + BS_NULL = 1 + BS_HOLLOW = BS_NULL + BS_HATCHED = 2 + BS_PATTERN = 3 + BS_INDEXED = 4 + BS_DIBPATTERN = 5 + BS_DIBPATTERNPT = 6 + BS_PATTERN8X8 = 7 + BS_DIBPATTERN8X8 = 8 + BS_MONOPATTERN = 9 +) + +// Hatch styles +const ( + HS_HORIZONTAL = 0 + HS_VERTICAL = 1 + HS_FDIAGONAL = 2 + HS_BDIAGONAL = 3 + HS_CROSS = 4 + HS_DIAGCROSS = 5 +) + +// Pen types +const ( + PS_COSMETIC = 0x00000000 + PS_GEOMETRIC = 0x00010000 + PS_TYPE_MASK = 0x000F0000 +) + +// Pen styles +const ( + PS_SOLID = 0 + PS_DASH = 1 + PS_DOT = 2 + PS_DASHDOT = 3 + PS_DASHDOTDOT = 4 + PS_NULL = 5 + PS_INSIDEFRAME = 6 + PS_USERSTYLE = 7 + PS_ALTERNATE = 8 + PS_STYLE_MASK = 0x0000000F +) + +// Pen cap types +const ( + PS_ENDCAP_ROUND = 0x00000000 + PS_ENDCAP_SQUARE = 0x00000100 + PS_ENDCAP_FLAT = 0x00000200 + PS_ENDCAP_MASK = 0x00000F00 +) + +// Pen join types +const ( + PS_JOIN_ROUND = 0x00000000 + PS_JOIN_BEVEL = 0x00001000 + PS_JOIN_MITER = 0x00002000 + PS_JOIN_MASK = 0x0000F000 +) + +// Print constants +const ( + PRF_NONCLIENT = 0x00000002 + PRF_CLIENT = 0x00000004 + PRF_ERASEBKGND = 0x00000008 + PRF_CHILDREN = 0x00000010 + PRF_OWNED = 0x00000020 +) + +// Stock logical objects +const ( + WHITE_BRUSH = 0 + LTGRAY_BRUSH = 1 + GRAY_BRUSH = 2 + DKGRAY_BRUSH = 3 + BLACK_BRUSH = 4 + NULL_BRUSH = 5 + HOLLOW_BRUSH = NULL_BRUSH + WHITE_PEN = 6 + BLACK_PEN = 7 + NULL_PEN = 8 + OEM_FIXED_FONT = 10 + ANSI_FIXED_FONT = 11 + ANSI_VAR_FONT = 12 + SYSTEM_FONT = 13 + DEVICE_DEFAULT_FONT = 14 + DEFAULT_PALETTE = 15 + SYSTEM_FIXED_FONT = 16 + DEFAULT_GUI_FONT = 17 + DC_BRUSH = 18 + DC_PEN = 19 +) + +const LF_FACESIZE = 32 + +// Font weight constants +const ( + FW_DONTCARE = 0 + FW_THIN = 100 + FW_EXTRALIGHT = 200 + FW_ULTRALIGHT = FW_EXTRALIGHT + FW_LIGHT = 300 + FW_NORMAL = 400 + FW_REGULAR = 400 + FW_MEDIUM = 500 + FW_SEMIBOLD = 600 + FW_DEMIBOLD = FW_SEMIBOLD + FW_BOLD = 700 + FW_EXTRABOLD = 800 + FW_ULTRABOLD = FW_EXTRABOLD + FW_HEAVY = 900 + FW_BLACK = FW_HEAVY +) + +// Charset constants +const ( + ANSI_CHARSET = 0 + DEFAULT_CHARSET = 1 + SYMBOL_CHARSET = 2 + SHIFTJIS_CHARSET = 128 + HANGEUL_CHARSET = 129 + HANGUL_CHARSET = 129 + GB2312_CHARSET = 134 + CHINESEBIG5_CHARSET = 136 + GREEK_CHARSET = 161 + TURKISH_CHARSET = 162 + HEBREW_CHARSET = 177 + ARABIC_CHARSET = 178 + BALTIC_CHARSET = 186 + RUSSIAN_CHARSET = 204 + THAI_CHARSET = 222 + EASTEUROPE_CHARSET = 238 + OEM_CHARSET = 255 + JOHAB_CHARSET = 130 + VIETNAMESE_CHARSET = 163 + MAC_CHARSET = 77 +) + +// Font output precision constants +const ( + OUT_DEFAULT_PRECIS = 0 + OUT_STRING_PRECIS = 1 + OUT_CHARACTER_PRECIS = 2 + OUT_STROKE_PRECIS = 3 + OUT_TT_PRECIS = 4 + OUT_DEVICE_PRECIS = 5 + OUT_RASTER_PRECIS = 6 + OUT_TT_ONLY_PRECIS = 7 + OUT_OUTLINE_PRECIS = 8 + OUT_PS_ONLY_PRECIS = 10 +) + +// Font clipping precision constants +const ( + CLIP_DEFAULT_PRECIS = 0 + CLIP_CHARACTER_PRECIS = 1 + CLIP_STROKE_PRECIS = 2 + CLIP_MASK = 15 + CLIP_LH_ANGLES = 16 + CLIP_TT_ALWAYS = 32 + CLIP_EMBEDDED = 128 +) + +// Font output quality constants +const ( + DEFAULT_QUALITY = 0 + DRAFT_QUALITY = 1 + PROOF_QUALITY = 2 + NONANTIALIASED_QUALITY = 3 + ANTIALIASED_QUALITY = 4 + CLEARTYPE_QUALITY = 5 +) + +// Font pitch constants +const ( + DEFAULT_PITCH = 0 + FIXED_PITCH = 1 + VARIABLE_PITCH = 2 +) + +// Font family constants +const ( + FF_DECORATIVE = 80 + FF_DONTCARE = 0 + FF_MODERN = 48 + FF_ROMAN = 16 + FF_SCRIPT = 64 + FF_SWISS = 32 +) + +// DeviceCapabilities capabilities +const ( + DC_FIELDS = 1 + DC_PAPERS = 2 + DC_PAPERSIZE = 3 + DC_MINEXTENT = 4 + DC_MAXEXTENT = 5 + DC_BINS = 6 + DC_DUPLEX = 7 + DC_SIZE = 8 + DC_EXTRA = 9 + DC_VERSION = 10 + DC_DRIVER = 11 + DC_BINNAMES = 12 + DC_ENUMRESOLUTIONS = 13 + DC_FILEDEPENDENCIES = 14 + DC_TRUETYPE = 15 + DC_PAPERNAMES = 16 + DC_ORIENTATION = 17 + DC_COPIES = 18 + DC_BINADJUST = 19 + DC_EMF_COMPLIANT = 20 + DC_DATATYPE_PRODUCED = 21 + DC_COLLATE = 22 + DC_MANUFACTURER = 23 + DC_MODEL = 24 + DC_PERSONALITY = 25 + DC_PRINTRATE = 26 + DC_PRINTRATEUNIT = 27 + DC_PRINTERMEM = 28 + DC_MEDIAREADY = 29 + DC_STAPLE = 30 + DC_PRINTRATEPPM = 31 + DC_COLORDEVICE = 32 + DC_NUP = 33 + DC_MEDIATYPENAMES = 34 + DC_MEDIATYPES = 35 +) + +const ( + CCHDEVICENAME = 32 + CCHFORMNAME = 32 +) + +const ( + DM_UPDATE = 1 + DM_COPY = 2 + DM_PROMPT = 4 + DM_MODIFY = 8 + DM_IN_BUFFER = DM_MODIFY + DM_IN_PROMPT = DM_PROMPT + DM_OUT_BUFFER = DM_COPY + DM_OUT_DEFAULT = DM_UPDATE +) + +// DEVMODE field selection bits +const ( + DM_ORIENTATION = 0x00000001 + DM_PAPERSIZE = 0x00000002 + DM_PAPERLENGTH = 0x00000004 + DM_PAPERWIDTH = 0x00000008 + DM_SCALE = 0x00000010 + DM_POSITION = 0x00000020 + DM_NUP = 0x00000040 + DM_DISPLAYORIENTATION = 0x00000080 + DM_COPIES = 0x00000100 + DM_DEFAULTSOURCE = 0x00000200 + DM_PRINTQUALITY = 0x00000400 + DM_COLOR = 0x00000800 + DM_DUPLEX = 0x00001000 + DM_YRESOLUTION = 0x00002000 + DM_TTOPTION = 0x00004000 + DM_COLLATE = 0x00008000 + DM_FORMNAME = 0x00010000 + DM_LOGPIXELS = 0x00020000 + DM_BITSPERPEL = 0x00040000 + DM_PELSWIDTH = 0x00080000 + DM_PELSHEIGHT = 0x00100000 + DM_DISPLAYFLAGS = 0x00200000 + DM_DISPLAYFREQUENCY = 0x00400000 + DM_ICMMETHOD = 0x00800000 + DM_ICMINTENT = 0x01000000 + DM_MEDIATYPE = 0x02000000 + DM_DITHERTYPE = 0x04000000 + DM_PANNINGWIDTH = 0x08000000 + DM_PANNINGHEIGHT = 0x10000000 + DM_DISPLAYFIXEDOUTPUT = 0x20000000 +) + +// Orientation constants +const ( + DMORIENT_PORTRAIT = 1 + DMORIENT_LANDSCAPE = 2 +) + +// Paper sizes +const ( + DMPAPER_FIRST = DMPAPER_LETTER + DMPAPER_LETTER = 1 /* Letter 8 1/2 x 11 in */ + DMPAPER_LETTERSMALL = 2 /* Letter Small 8 1/2 x 11 in */ + DMPAPER_TABLOID = 3 /* Tabloid 11 x 17 in */ + DMPAPER_LEDGER = 4 /* Ledger 17 x 11 in */ + DMPAPER_LEGAL = 5 /* Legal 8 1/2 x 14 in */ + DMPAPER_STATEMENT = 6 /* Statement 5 1/2 x 8 1/2 in */ + DMPAPER_EXECUTIVE = 7 /* Executive 7 1/4 x 10 1/2 in */ + DMPAPER_A3 = 8 /* A3 297 x 420 mm */ + DMPAPER_A4 = 9 /* A4 210 x 297 mm */ + DMPAPER_A4SMALL = 10 /* A4 Small 210 x 297 mm */ + DMPAPER_A5 = 11 /* A5 148 x 210 mm */ + DMPAPER_B4 = 12 /* B4 (JIS) 250 x 354 */ + DMPAPER_B5 = 13 /* B5 (JIS) 182 x 257 mm */ + DMPAPER_FOLIO = 14 /* Folio 8 1/2 x 13 in */ + DMPAPER_QUARTO = 15 /* Quarto 215 x 275 mm */ + DMPAPER_10X14 = 16 /* 10x14 in */ + DMPAPER_11X17 = 17 /* 11x17 in */ + DMPAPER_NOTE = 18 /* Note 8 1/2 x 11 in */ + DMPAPER_ENV_9 = 19 /* Envelope #9 3 7/8 x 8 7/8 */ + DMPAPER_ENV_10 = 20 /* Envelope #10 4 1/8 x 9 1/2 */ + DMPAPER_ENV_11 = 21 /* Envelope #11 4 1/2 x 10 3/8 */ + DMPAPER_ENV_12 = 22 /* Envelope #12 4 \276 x 11 */ + DMPAPER_ENV_14 = 23 /* Envelope #14 5 x 11 1/2 */ + DMPAPER_CSHEET = 24 /* C size sheet */ + DMPAPER_DSHEET = 25 /* D size sheet */ + DMPAPER_ESHEET = 26 /* E size sheet */ + DMPAPER_ENV_DL = 27 /* Envelope DL 110 x 220mm */ + DMPAPER_ENV_C5 = 28 /* Envelope C5 162 x 229 mm */ + DMPAPER_ENV_C3 = 29 /* Envelope C3 324 x 458 mm */ + DMPAPER_ENV_C4 = 30 /* Envelope C4 229 x 324 mm */ + DMPAPER_ENV_C6 = 31 /* Envelope C6 114 x 162 mm */ + DMPAPER_ENV_C65 = 32 /* Envelope C65 114 x 229 mm */ + DMPAPER_ENV_B4 = 33 /* Envelope B4 250 x 353 mm */ + DMPAPER_ENV_B5 = 34 /* Envelope B5 176 x 250 mm */ + DMPAPER_ENV_B6 = 35 /* Envelope B6 176 x 125 mm */ + DMPAPER_ENV_ITALY = 36 /* Envelope 110 x 230 mm */ + DMPAPER_ENV_MONARCH = 37 /* Envelope Monarch 3.875 x 7.5 in */ + DMPAPER_ENV_PERSONAL = 38 /* 6 3/4 Envelope 3 5/8 x 6 1/2 in */ + DMPAPER_FANFOLD_US = 39 /* US Std Fanfold 14 7/8 x 11 in */ + DMPAPER_FANFOLD_STD_GERMAN = 40 /* German Std Fanfold 8 1/2 x 12 in */ + DMPAPER_FANFOLD_LGL_GERMAN = 41 /* German Legal Fanfold 8 1/2 x 13 in */ + DMPAPER_ISO_B4 = 42 /* B4 (ISO) 250 x 353 mm */ + DMPAPER_JAPANESE_POSTCARD = 43 /* Japanese Postcard 100 x 148 mm */ + DMPAPER_9X11 = 44 /* 9 x 11 in */ + DMPAPER_10X11 = 45 /* 10 x 11 in */ + DMPAPER_15X11 = 46 /* 15 x 11 in */ + DMPAPER_ENV_INVITE = 47 /* Envelope Invite 220 x 220 mm */ + DMPAPER_RESERVED_48 = 48 /* RESERVED--DO NOT USE */ + DMPAPER_RESERVED_49 = 49 /* RESERVED--DO NOT USE */ + DMPAPER_LETTER_EXTRA = 50 /* Letter Extra 9 \275 x 12 in */ + DMPAPER_LEGAL_EXTRA = 51 /* Legal Extra 9 \275 x 15 in */ + DMPAPER_TABLOID_EXTRA = 52 /* Tabloid Extra 11.69 x 18 in */ + DMPAPER_A4_EXTRA = 53 /* A4 Extra 9.27 x 12.69 in */ + DMPAPER_LETTER_TRANSVERSE = 54 /* Letter Transverse 8 \275 x 11 in */ + DMPAPER_A4_TRANSVERSE = 55 /* A4 Transverse 210 x 297 mm */ + DMPAPER_LETTER_EXTRA_TRANSVERSE = 56 /* Letter Extra Transverse 9\275 x 12 in */ + DMPAPER_A_PLUS = 57 /* SuperA/SuperA/A4 227 x 356 mm */ + DMPAPER_B_PLUS = 58 /* SuperB/SuperB/A3 305 x 487 mm */ + DMPAPER_LETTER_PLUS = 59 /* Letter Plus 8.5 x 12.69 in */ + DMPAPER_A4_PLUS = 60 /* A4 Plus 210 x 330 mm */ + DMPAPER_A5_TRANSVERSE = 61 /* A5 Transverse 148 x 210 mm */ + DMPAPER_B5_TRANSVERSE = 62 /* B5 (JIS) Transverse 182 x 257 mm */ + DMPAPER_A3_EXTRA = 63 /* A3 Extra 322 x 445 mm */ + DMPAPER_A5_EXTRA = 64 /* A5 Extra 174 x 235 mm */ + DMPAPER_B5_EXTRA = 65 /* B5 (ISO) Extra 201 x 276 mm */ + DMPAPER_A2 = 66 /* A2 420 x 594 mm */ + DMPAPER_A3_TRANSVERSE = 67 /* A3 Transverse 297 x 420 mm */ + DMPAPER_A3_EXTRA_TRANSVERSE = 68 /* A3 Extra Transverse 322 x 445 mm */ + DMPAPER_DBL_JAPANESE_POSTCARD = 69 /* Japanese Double Postcard 200 x 148 mm */ + DMPAPER_A6 = 70 /* A6 105 x 148 mm */ + DMPAPER_JENV_KAKU2 = 71 /* Japanese Envelope Kaku #2 */ + DMPAPER_JENV_KAKU3 = 72 /* Japanese Envelope Kaku #3 */ + DMPAPER_JENV_CHOU3 = 73 /* Japanese Envelope Chou #3 */ + DMPAPER_JENV_CHOU4 = 74 /* Japanese Envelope Chou #4 */ + DMPAPER_LETTER_ROTATED = 75 /* Letter Rotated 11 x 8 1/2 11 in */ + DMPAPER_A3_ROTATED = 76 /* A3 Rotated 420 x 297 mm */ + DMPAPER_A4_ROTATED = 77 /* A4 Rotated 297 x 210 mm */ + DMPAPER_A5_ROTATED = 78 /* A5 Rotated 210 x 148 mm */ + DMPAPER_B4_JIS_ROTATED = 79 /* B4 (JIS) Rotated 364 x 257 mm */ + DMPAPER_B5_JIS_ROTATED = 80 /* B5 (JIS) Rotated 257 x 182 mm */ + DMPAPER_JAPANESE_POSTCARD_ROTATED = 81 /* Japanese Postcard Rotated 148 x 100 mm */ + DMPAPER_DBL_JAPANESE_POSTCARD_ROTATED = 82 /* Double Japanese Postcard Rotated 148 x 200 mm */ + DMPAPER_A6_ROTATED = 83 /* A6 Rotated 148 x 105 mm */ + DMPAPER_JENV_KAKU2_ROTATED = 84 /* Japanese Envelope Kaku #2 Rotated */ + DMPAPER_JENV_KAKU3_ROTATED = 85 /* Japanese Envelope Kaku #3 Rotated */ + DMPAPER_JENV_CHOU3_ROTATED = 86 /* Japanese Envelope Chou #3 Rotated */ + DMPAPER_JENV_CHOU4_ROTATED = 87 /* Japanese Envelope Chou #4 Rotated */ + DMPAPER_B6_JIS = 88 /* B6 (JIS) 128 x 182 mm */ + DMPAPER_B6_JIS_ROTATED = 89 /* B6 (JIS) Rotated 182 x 128 mm */ + DMPAPER_12X11 = 90 /* 12 x 11 in */ + DMPAPER_JENV_YOU4 = 91 /* Japanese Envelope You #4 */ + DMPAPER_JENV_YOU4_ROTATED = 92 /* Japanese Envelope You #4 Rotated*/ + DMPAPER_P16K = 93 /* PRC 16K 146 x 215 mm */ + DMPAPER_P32K = 94 /* PRC 32K 97 x 151 mm */ + DMPAPER_P32KBIG = 95 /* PRC 32K(Big) 97 x 151 mm */ + DMPAPER_PENV_1 = 96 /* PRC Envelope #1 102 x 165 mm */ + DMPAPER_PENV_2 = 97 /* PRC Envelope #2 102 x 176 mm */ + DMPAPER_PENV_3 = 98 /* PRC Envelope #3 125 x 176 mm */ + DMPAPER_PENV_4 = 99 /* PRC Envelope #4 110 x 208 mm */ + DMPAPER_PENV_5 = 100 /* PRC Envelope #5 110 x 220 mm */ + DMPAPER_PENV_6 = 101 /* PRC Envelope #6 120 x 230 mm */ + DMPAPER_PENV_7 = 102 /* PRC Envelope #7 160 x 230 mm */ + DMPAPER_PENV_8 = 103 /* PRC Envelope #8 120 x 309 mm */ + DMPAPER_PENV_9 = 104 /* PRC Envelope #9 229 x 324 mm */ + DMPAPER_PENV_10 = 105 /* PRC Envelope #10 324 x 458 mm */ + DMPAPER_P16K_ROTATED = 106 /* PRC 16K Rotated */ + DMPAPER_P32K_ROTATED = 107 /* PRC 32K Rotated */ + DMPAPER_P32KBIG_ROTATED = 108 /* PRC 32K(Big) Rotated */ + DMPAPER_PENV_1_ROTATED = 109 /* PRC Envelope #1 Rotated 165 x 102 mm */ + DMPAPER_PENV_2_ROTATED = 110 /* PRC Envelope #2 Rotated 176 x 102 mm */ + DMPAPER_PENV_3_ROTATED = 111 /* PRC Envelope #3 Rotated 176 x 125 mm */ + DMPAPER_PENV_4_ROTATED = 112 /* PRC Envelope #4 Rotated 208 x 110 mm */ + DMPAPER_PENV_5_ROTATED = 113 /* PRC Envelope #5 Rotated 220 x 110 mm */ + DMPAPER_PENV_6_ROTATED = 114 /* PRC Envelope #6 Rotated 230 x 120 mm */ + DMPAPER_PENV_7_ROTATED = 115 /* PRC Envelope #7 Rotated 230 x 160 mm */ + DMPAPER_PENV_8_ROTATED = 116 /* PRC Envelope #8 Rotated 309 x 120 mm */ + DMPAPER_PENV_9_ROTATED = 117 /* PRC Envelope #9 Rotated 324 x 229 mm */ + DMPAPER_PENV_10_ROTATED = 118 /* PRC Envelope #10 Rotated 458 x 324 mm */ + DMPAPER_LAST = DMPAPER_PENV_10_ROTATED + DMPAPER_USER = 256 +) + +// Bin constants +const ( + DMBIN_FIRST = DMBIN_UPPER + DMBIN_UPPER = 1 + DMBIN_ONLYONE = 1 + DMBIN_LOWER = 2 + DMBIN_MIDDLE = 3 + DMBIN_MANUAL = 4 + DMBIN_ENVELOPE = 5 + DMBIN_ENVMANUAL = 6 + DMBIN_AUTO = 7 + DMBIN_TRACTOR = 8 + DMBIN_SMALLFMT = 9 + DMBIN_LARGEFMT = 10 + DMBIN_LARGECAPACITY = 11 + DMBIN_CASSETTE = 14 + DMBIN_FORMSOURCE = 15 + DMBIN_LAST = DMBIN_FORMSOURCE + DMBIN_USER = 256 +) + +// Quality constants +const ( + DMRES_DRAFT = -1 + DMRES_LOW = -2 + DMRES_MEDIUM = -3 + DMRES_HIGH = -4 +) + +// Color/monochrome constants +const ( + DMCOLOR_MONOCHROME = 1 + DMCOLOR_COLOR = 2 +) + +// Duplex constants +const ( + DMDUP_SIMPLEX = 1 + DMDUP_VERTICAL = 2 + DMDUP_HORIZONTAL = 3 +) + +// TrueType constants +const ( + DMTT_BITMAP = 1 + DMTT_DOWNLOAD = 2 + DMTT_SUBDEV = 3 + DMTT_DOWNLOAD_OUTLINE = 4 +) + +// Collation constants +const ( + DMCOLLATE_FALSE = 0 + DMCOLLATE_TRUE = 1 +) + +// Background modes +const ( + TRANSPARENT = 1 + OPAQUE = 2 +) + +// Ternary raster operations +const ( + SRCCOPY = 0x00CC0020 + SRCPAINT = 0x00EE0086 + SRCAND = 0x008800C6 + SRCINVERT = 0x00660046 + SRCERASE = 0x00440328 + NOTSRCCOPY = 0x00330008 + NOTSRCERASE = 0x001100A6 + MERGECOPY = 0x00C000CA + MERGEPAINT = 0x00BB0226 + PATCOPY = 0x00F00021 + PATPAINT = 0x00FB0A09 + PATINVERT = 0x005A0049 + DSTINVERT = 0x00550009 + BLACKNESS = 0x00000042 + WHITENESS = 0x00FF0062 + NOMIRRORBITMAP = 0x80000000 + CAPTUREBLT = 0x40000000 +) + +// StretchBlt modes +const ( + BLACKONWHITE = 1 + WHITEONBLACK = 2 + COLORONCOLOR = 3 + HALFTONE = 4 + MAXSTRETCHBLTMODE = 4 + STRETCH_ANDSCANS = BLACKONWHITE + STRETCH_ORSCANS = WHITEONBLACK + STRETCH_DELETESCANS = COLORONCOLOR + STRETCH_HALFTONE = HALFTONE +) + +// Bitmap compression constants +const ( + BI_RGB = 0 + BI_RLE8 = 1 + BI_RLE4 = 2 + BI_BITFIELDS = 3 + BI_JPEG = 4 + BI_PNG = 5 +) + +// Bitmap color table usage +const ( + DIB_RGB_COLORS = 0 + DIB_PAL_COLORS = 1 +) + +const CBM_INIT = 4 + +const CLR_INVALID = 0xFFFFFFFF + +const ( + /* pixel types */ + PFD_TYPE_RGBA = 0 + PFD_TYPE_COLORINDEX = 1 + + /* layer types */ + PFD_MAIN_PLANE = 0 + PFD_OVERLAY_PLANE = 1 + PFD_UNDERLAY_PLANE = (-1) + + /* PIXELFORMATDESCRIPTOR flags */ + PFD_DOUBLEBUFFER = 0x00000001 + PFD_STEREO = 0x00000002 + PFD_DRAW_TO_WINDOW = 0x00000004 + PFD_DRAW_TO_BITMAP = 0x00000008 + PFD_SUPPORT_GDI = 0x00000010 + PFD_SUPPORT_OPENGL = 0x00000020 + PFD_GENERIC_FORMAT = 0x00000040 + PFD_NEED_PALETTE = 0x00000080 + PFD_NEED_SYSTEM_PALETTE = 0x00000100 + PFD_SWAP_EXCHANGE = 0x00000200 + PFD_SWAP_COPY = 0x00000400 + PFD_SWAP_LAYER_BUFFERS = 0x00000800 + PFD_GENERIC_ACCELERATED = 0x00001000 + PFD_SUPPORT_DIRECTDRAW = 0x00002000 + + /* PIXELFORMATDESCRIPTOR flags for use in ChoosePixelFormat only */ + PFD_DEPTH_DONTCARE = 0x20000000 + PFD_DOUBLEBUFFER_DONTCARE = 0x40000000 + PFD_STEREO_DONTCARE = 0x80000000 +) + +// GradientFill constants +const ( + GRADIENT_FILL_RECT_H = 0x00 + GRADIENT_FILL_RECT_V = 0x01 + GRADIENT_FILL_TRIANGLE = 0x02 +) + +// Region Combine Modes +const ( + RGN_AND = 1 + RGN_OR = 2 + RGN_XOR = 3 + RGN_DIFF = 4 + RGN_COPY = 5 +) + +// Region Types +const ( + REGIONERROR = 0 + NULLREGION = 1 + SIMPLEREGION = 2 + COMPLEXREGION = 3 +) + +type ( + COLORREF uint32 + HBITMAP HGDIOBJ + HBRUSH HGDIOBJ + HDC HANDLE + HFONT HGDIOBJ + HGDIOBJ HANDLE + HENHMETAFILE HANDLE + HPALETTE HGDIOBJ + HPEN HGDIOBJ + HRGN HGDIOBJ +) + +type PIXELFORMATDESCRIPTOR struct { + NSize uint16 + NVersion uint16 + DwFlags uint32 + IPixelType byte + CColorBits byte + CRedBits byte + CRedShift byte + CGreenBits byte + CGreenShift byte + CBlueBits byte + CBlueShift byte + CAlphaBits byte + CAlphaShift byte + CAccumBits byte + CAccumRedBits byte + CAccumGreenBits byte + CAccumBlueBits byte + CAccumAlphaBits byte + CDepthBits byte + CStencilBits byte + CAuxBuffers byte + ILayerType byte + BReserved byte + DwLayerMask uint32 + DwVisibleMask uint32 + DwDamageMask uint32 +} + +type LOGFONT struct { + LfHeight int32 + LfWidth int32 + LfEscapement int32 + LfOrientation int32 + LfWeight int32 + LfItalic byte + LfUnderline byte + LfStrikeOut byte + LfCharSet byte + LfOutPrecision byte + LfClipPrecision byte + LfQuality byte + LfPitchAndFamily byte + LfFaceName [LF_FACESIZE]uint16 +} + +type TEXTMETRIC struct { + TmHeight int32 + TmAscent int32 + TmDescent int32 + TmInternalLeading int32 + TmExternalLeading int32 + TmAveCharWidth int32 + TmMaxCharWidth int32 + TmWeight int32 + TmOverhang int32 + TmDigitizedAspectX int32 + TmDigitizedAspectY int32 + TmFirstChar uint16 + TmLastChar uint16 + TmDefaultChar uint16 + TmBreakChar uint16 + TmItalic byte + TmUnderlined byte + TmStruckOut byte + TmPitchAndFamily byte + TmCharSet byte +} + +type DEVMODE struct { + DmDeviceName [CCHDEVICENAME]uint16 + DmSpecVersion uint16 + DmDriverVersion uint16 + DmSize uint16 + DmDriverExtra uint16 + DmFields uint32 + DmOrientation int16 + DmPaperSize int16 + DmPaperLength int16 + DmPaperWidth int16 + DmScale int16 + DmCopies int16 + DmDefaultSource int16 + DmPrintQuality int16 + DmColor int16 + DmDuplex int16 + DmYResolution int16 + DmTTOption int16 + DmCollate int16 + DmFormName [CCHFORMNAME]uint16 + DmLogPixels uint16 + DmBitsPerPel uint32 + DmPelsWidth uint32 + DmPelsHeight uint32 + DmDisplayFlags uint32 + DmDisplayFrequency uint32 + DmICMMethod uint32 + DmICMIntent uint32 + DmMediaType uint32 + DmDitherType uint32 + DmReserved1 uint32 + DmReserved2 uint32 + DmPanningWidth uint32 + DmPanningHeight uint32 +} + +type POINT struct { + X, Y int32 +} + +type RECT struct { + Left, Top, Right, Bottom int32 +} + +type SIZE struct { + CX, CY int32 +} + +type DOCINFO struct { + CbSize int32 + LpszDocName *uint16 + LpszOutput *uint16 + LpszDatatype *uint16 + FwType uint32 +} + +type LOGBRUSH struct { + LbStyle uint32 + LbColor COLORREF + LbHatch uintptr +} + +type CIEXYZ struct { + CiexyzX, CiexyzY, CiexyzZ int32 // FXPT2DOT30 +} + +type CIEXYZTRIPLE struct { + CiexyzRed, CiexyzGreen, CiexyzBlue CIEXYZ +} + +type BITMAPINFOHEADER struct { + BiSize uint32 + BiWidth int32 + BiHeight int32 + BiPlanes uint16 + BiBitCount uint16 + BiCompression uint32 + BiSizeImage uint32 + BiXPelsPerMeter int32 + BiYPelsPerMeter int32 + BiClrUsed uint32 + BiClrImportant uint32 +} + +type BITMAPV4HEADER struct { + BITMAPINFOHEADER + BV4RedMask uint32 + BV4GreenMask uint32 + BV4BlueMask uint32 + BV4AlphaMask uint32 + BV4CSType uint32 + BV4Endpoints CIEXYZTRIPLE + BV4GammaRed uint32 + BV4GammaGreen uint32 + BV4GammaBlue uint32 +} + +type BITMAPV5HEADER struct { + BITMAPV4HEADER + BV5Intent uint32 + BV5ProfileData uint32 + BV5ProfileSize uint32 + BV5Reserved uint32 +} + +type RGBQUAD struct { + RgbBlue byte + RgbGreen byte + RgbRed byte + RgbReserved byte +} + +type BITMAPINFO struct { + BmiHeader BITMAPINFOHEADER + BmiColors *RGBQUAD +} + +type BITMAP struct { + BmType int32 + BmWidth int32 + BmHeight int32 + BmWidthBytes int32 + BmPlanes uint16 + BmBitsPixel uint16 + BmBits unsafe.Pointer +} + +type DIBSECTION struct { + DsBm BITMAP + DsBmih BITMAPINFOHEADER + DsBitfields [3]uint32 + DshSection HANDLE + DsOffset uint32 +} + +type ENHMETAHEADER struct { + IType uint32 + NSize uint32 + RclBounds RECT + RclFrame RECT + DSignature uint32 + NVersion uint32 + NBytes uint32 + NRecords uint32 + NHandles uint16 + SReserved uint16 + NDescription uint32 + OffDescription uint32 + NPalEntries uint32 + SzlDevice SIZE + SzlMillimeters SIZE + CbPixelFormat uint32 + OffPixelFormat uint32 + BOpenGL uint32 + SzlMicrometers SIZE +} + +type TRIVERTEX struct { + X int32 + Y int32 + Red uint16 + Green uint16 + Blue uint16 + Alpha uint16 +} + +type GRADIENT_RECT struct { + UpperLeft uint32 + LowerRight uint32 +} + +type GRADIENT_TRIANGLE struct { + Vertex1 uint32 + Vertex2 uint32 + Vertex3 uint32 +} + +var ( + // Library + libgdi32 uintptr + libmsimg32 uintptr + + // Functions + abortDoc uintptr + bitBlt uintptr + choosePixelFormat uintptr + closeEnhMetaFile uintptr + combineRgn uintptr + copyEnhMetaFile uintptr + createBitmap uintptr + createCompatibleBitmap uintptr + createBrushIndirect uintptr + createCompatibleDC uintptr + createDC uintptr + createDIBSection uintptr + createFontIndirect uintptr + createEnhMetaFile uintptr + createIC uintptr + createPatternBrush uintptr + createRectRgn uintptr + deleteDC uintptr + deleteEnhMetaFile uintptr + deleteObject uintptr + ellipse uintptr + endDoc uintptr + endPage uintptr + excludeClipRect uintptr + extCreatePen uintptr + fillRgn uintptr + getDeviceCaps uintptr + getDIBits uintptr + getEnhMetaFile uintptr + getEnhMetaFileHeader uintptr + getObject uintptr + getPixel uintptr + getRgnBox uintptr + getStockObject uintptr + getTextExtentExPoint uintptr + getTextExtentPoint32 uintptr + getTextMetrics uintptr + getViewportOrgEx uintptr + gradientFill uintptr + intersectClipRect uintptr + lineTo uintptr + moveToEx uintptr + playEnhMetaFile uintptr + polyline uintptr + rectangle uintptr + resetDC uintptr + restoreDC uintptr + selectObject uintptr + setBkColor uintptr + setBkMode uintptr + setBrushOrgEx uintptr + setPixel uintptr + setPixelFormat uintptr + setStretchBltMode uintptr + setTextColor uintptr + setViewportOrgEx uintptr + saveDC uintptr + startDoc uintptr + startPage uintptr + stretchBlt uintptr + swapBuffers uintptr + textOut uintptr + transparentBlt uintptr +) + +func init() { + // Library + libgdi32 = MustLoadLibrary("gdi32.dll") + libmsimg32 = MustLoadLibrary("msimg32.dll") + + // Functions + abortDoc = MustGetProcAddress(libgdi32, "AbortDoc") + bitBlt = MustGetProcAddress(libgdi32, "BitBlt") + choosePixelFormat = MustGetProcAddress(libgdi32, "ChoosePixelFormat") + closeEnhMetaFile = MustGetProcAddress(libgdi32, "CloseEnhMetaFile") + combineRgn = MustGetProcAddress(libgdi32, "CombineRgn") + copyEnhMetaFile = MustGetProcAddress(libgdi32, "CopyEnhMetaFileW") + createBitmap = MustGetProcAddress(libgdi32, "CreateBitmap") + createCompatibleBitmap = MustGetProcAddress(libgdi32, "CreateCompatibleBitmap") + createBrushIndirect = MustGetProcAddress(libgdi32, "CreateBrushIndirect") + createCompatibleDC = MustGetProcAddress(libgdi32, "CreateCompatibleDC") + createDC = MustGetProcAddress(libgdi32, "CreateDCW") + createDIBSection = MustGetProcAddress(libgdi32, "CreateDIBSection") + createEnhMetaFile = MustGetProcAddress(libgdi32, "CreateEnhMetaFileW") + createFontIndirect = MustGetProcAddress(libgdi32, "CreateFontIndirectW") + createIC = MustGetProcAddress(libgdi32, "CreateICW") + createPatternBrush = MustGetProcAddress(libgdi32, "CreatePatternBrush") + createRectRgn = MustGetProcAddress(libgdi32, "CreateRectRgn") + deleteDC = MustGetProcAddress(libgdi32, "DeleteDC") + deleteEnhMetaFile = MustGetProcAddress(libgdi32, "DeleteEnhMetaFile") + deleteObject = MustGetProcAddress(libgdi32, "DeleteObject") + ellipse = MustGetProcAddress(libgdi32, "Ellipse") + endDoc = MustGetProcAddress(libgdi32, "EndDoc") + endPage = MustGetProcAddress(libgdi32, "EndPage") + excludeClipRect = MustGetProcAddress(libgdi32, "ExcludeClipRect") + extCreatePen = MustGetProcAddress(libgdi32, "ExtCreatePen") + fillRgn = MustGetProcAddress(libgdi32, "FillRgn") + getDeviceCaps = MustGetProcAddress(libgdi32, "GetDeviceCaps") + getDIBits = MustGetProcAddress(libgdi32, "GetDIBits") + getEnhMetaFile = MustGetProcAddress(libgdi32, "GetEnhMetaFileW") + getEnhMetaFileHeader = MustGetProcAddress(libgdi32, "GetEnhMetaFileHeader") + getObject = MustGetProcAddress(libgdi32, "GetObjectW") + getPixel = MustGetProcAddress(libgdi32, "GetPixel") + getRgnBox = MustGetProcAddress(libgdi32, "GetRgnBox") + getStockObject = MustGetProcAddress(libgdi32, "GetStockObject") + getTextExtentExPoint = MustGetProcAddress(libgdi32, "GetTextExtentExPointW") + getTextExtentPoint32 = MustGetProcAddress(libgdi32, "GetTextExtentPoint32W") + getTextMetrics = MustGetProcAddress(libgdi32, "GetTextMetricsW") + getViewportOrgEx = MustGetProcAddress(libgdi32, "GetViewportOrgEx") + intersectClipRect = MustGetProcAddress(libgdi32, "IntersectClipRect") + lineTo = MustGetProcAddress(libgdi32, "LineTo") + moveToEx = MustGetProcAddress(libgdi32, "MoveToEx") + playEnhMetaFile = MustGetProcAddress(libgdi32, "PlayEnhMetaFile") + polyline = MustGetProcAddress(libgdi32, "Polyline") + rectangle = MustGetProcAddress(libgdi32, "Rectangle") + resetDC = MustGetProcAddress(libgdi32, "ResetDCW") + restoreDC = MustGetProcAddress(libgdi32, "RestoreDC") + saveDC = MustGetProcAddress(libgdi32, "SaveDC") + selectObject = MustGetProcAddress(libgdi32, "SelectObject") + setBkColor = MustGetProcAddress(libgdi32, "SetBkColor") + setBkMode = MustGetProcAddress(libgdi32, "SetBkMode") + setBrushOrgEx = MustGetProcAddress(libgdi32, "SetBrushOrgEx") + setPixel = MustGetProcAddress(libgdi32, "SetPixel") + setPixelFormat = MustGetProcAddress(libgdi32, "SetPixelFormat") + setStretchBltMode = MustGetProcAddress(libgdi32, "SetStretchBltMode") + setTextColor = MustGetProcAddress(libgdi32, "SetTextColor") + setViewportOrgEx = MustGetProcAddress(libgdi32, "SetViewportOrgEx") + startDoc = MustGetProcAddress(libgdi32, "StartDocW") + startPage = MustGetProcAddress(libgdi32, "StartPage") + stretchBlt = MustGetProcAddress(libgdi32, "StretchBlt") + swapBuffers = MustGetProcAddress(libgdi32, "SwapBuffers") + textOut = MustGetProcAddress(libgdi32, "TextOutW") + + gradientFill = MustGetProcAddress(libmsimg32, "GradientFill") + transparentBlt = MustGetProcAddress(libmsimg32, "TransparentBlt") +} + +func AbortDoc(hdc HDC) int32 { + ret, _, _ := syscall.Syscall(abortDoc, 1, + uintptr(hdc), + 0, + 0) + + return int32(ret) +} + +func BitBlt(hdcDest HDC, nXDest, nYDest, nWidth, nHeight int32, hdcSrc HDC, nXSrc, nYSrc int32, dwRop uint32) bool { + ret, _, _ := syscall.Syscall9(bitBlt, 9, + uintptr(hdcDest), + uintptr(nXDest), + uintptr(nYDest), + uintptr(nWidth), + uintptr(nHeight), + uintptr(hdcSrc), + uintptr(nXSrc), + uintptr(nYSrc), + uintptr(dwRop)) + + return ret != 0 +} + +func ChoosePixelFormat(hdc HDC, ppfd *PIXELFORMATDESCRIPTOR) int32 { + ret, _, _ := syscall.Syscall(choosePixelFormat, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(ppfd)), + 0) + + return int32(ret) +} + +func CloseEnhMetaFile(hdc HDC) HENHMETAFILE { + ret, _, _ := syscall.Syscall(closeEnhMetaFile, 1, + uintptr(hdc), + 0, + 0) + + return HENHMETAFILE(ret) +} + +func CombineRgn(hrgnDest, hrgnSrc1, hrgnSrc2 HRGN, fnCombineMode int32) int32 { + ret, _, _ := syscall.Syscall6(combineRgn, 4, + uintptr(hrgnDest), + uintptr(hrgnSrc1), + uintptr(hrgnSrc2), + uintptr(fnCombineMode), + 0, + 0) + + return int32(ret) +} + +func CopyEnhMetaFile(hemfSrc HENHMETAFILE, lpszFile *uint16) HENHMETAFILE { + ret, _, _ := syscall.Syscall(copyEnhMetaFile, 2, + uintptr(hemfSrc), + uintptr(unsafe.Pointer(lpszFile)), + 0) + + return HENHMETAFILE(ret) +} + +func CreateBitmap(nWidth, nHeight int32, cPlanes, cBitsPerPel uint32, lpvBits unsafe.Pointer) HBITMAP { + ret, _, _ := syscall.Syscall6(createBitmap, 5, + uintptr(nWidth), + uintptr(nHeight), + uintptr(cPlanes), + uintptr(cBitsPerPel), + uintptr(lpvBits), + 0) + + return HBITMAP(ret) +} + +func CreateCompatibleBitmap(hdc HDC, nWidth, nHeight int32) HBITMAP { + ret, _, _ := syscall.Syscall(createCompatibleBitmap, 3, + uintptr(hdc), + uintptr(nWidth), + uintptr(nHeight)) + + return HBITMAP(ret) +} + +func CreateBrushIndirect(lplb *LOGBRUSH) HBRUSH { + ret, _, _ := syscall.Syscall(createBrushIndirect, 1, + uintptr(unsafe.Pointer(lplb)), + 0, + 0) + + return HBRUSH(ret) +} + +func CreateCompatibleDC(hdc HDC) HDC { + ret, _, _ := syscall.Syscall(createCompatibleDC, 1, + uintptr(hdc), + 0, + 0) + + return HDC(ret) +} + +func CreateDC(lpszDriver, lpszDevice, lpszOutput *uint16, lpInitData *DEVMODE) HDC { + ret, _, _ := syscall.Syscall6(createDC, 4, + uintptr(unsafe.Pointer(lpszDriver)), + uintptr(unsafe.Pointer(lpszDevice)), + uintptr(unsafe.Pointer(lpszOutput)), + uintptr(unsafe.Pointer(lpInitData)), + 0, + 0) + + return HDC(ret) +} + +func CreateDIBSection(hdc HDC, pbmih *BITMAPINFOHEADER, iUsage uint32, ppvBits *unsafe.Pointer, hSection HANDLE, dwOffset uint32) HBITMAP { + ret, _, _ := syscall.Syscall6(createDIBSection, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(pbmih)), + uintptr(iUsage), + uintptr(unsafe.Pointer(ppvBits)), + uintptr(hSection), + uintptr(dwOffset)) + + return HBITMAP(ret) +} + +func CreateEnhMetaFile(hdcRef HDC, lpFilename *uint16, lpRect *RECT, lpDescription *uint16) HDC { + ret, _, _ := syscall.Syscall6(createEnhMetaFile, 4, + uintptr(hdcRef), + uintptr(unsafe.Pointer(lpFilename)), + uintptr(unsafe.Pointer(lpRect)), + uintptr(unsafe.Pointer(lpDescription)), + 0, + 0) + + return HDC(ret) +} + +func CreateFontIndirect(lplf *LOGFONT) HFONT { + ret, _, _ := syscall.Syscall(createFontIndirect, 1, + uintptr(unsafe.Pointer(lplf)), + 0, + 0) + + return HFONT(ret) +} + +func CreateIC(lpszDriver, lpszDevice, lpszOutput *uint16, lpdvmInit *DEVMODE) HDC { + ret, _, _ := syscall.Syscall6(createIC, 4, + uintptr(unsafe.Pointer(lpszDriver)), + uintptr(unsafe.Pointer(lpszDevice)), + uintptr(unsafe.Pointer(lpszOutput)), + uintptr(unsafe.Pointer(lpdvmInit)), + 0, + 0) + + return HDC(ret) +} + +func CreatePatternBrush(hbmp HBITMAP) HBRUSH { + ret, _, _ := syscall.Syscall(createPatternBrush, 1, + uintptr(hbmp), + 0, + 0) + + return HBRUSH(ret) +} + +func CreateRectRgn(nLeftRect, nTopRect, nRightRect, nBottomRect int32) HRGN { + ret, _, _ := syscall.Syscall6(createRectRgn, 4, + uintptr(nLeftRect), + uintptr(nTopRect), + uintptr(nRightRect), + uintptr(nBottomRect), + 0, + 0) + + return HRGN(ret) +} + +func DeleteDC(hdc HDC) bool { + ret, _, _ := syscall.Syscall(deleteDC, 1, + uintptr(hdc), + 0, + 0) + + return ret != 0 +} + +func DeleteEnhMetaFile(hemf HENHMETAFILE) bool { + ret, _, _ := syscall.Syscall(deleteEnhMetaFile, 1, + uintptr(hemf), + 0, + 0) + + return ret != 0 +} + +func DeleteObject(hObject HGDIOBJ) bool { + ret, _, _ := syscall.Syscall(deleteObject, 1, + uintptr(hObject), + 0, + 0) + + return ret != 0 +} + +func Ellipse(hdc HDC, nLeftRect, nTopRect, nRightRect, nBottomRect int32) bool { + ret, _, _ := syscall.Syscall6(ellipse, 5, + uintptr(hdc), + uintptr(nLeftRect), + uintptr(nTopRect), + uintptr(nRightRect), + uintptr(nBottomRect), + 0) + + return ret != 0 +} + +func EndDoc(hdc HDC) int32 { + ret, _, _ := syscall.Syscall(endDoc, 1, + uintptr(hdc), + 0, + 0) + + return int32(ret) +} + +func EndPage(hdc HDC) int32 { + ret, _, _ := syscall.Syscall(endPage, 1, + uintptr(hdc), + 0, + 0) + + return int32(ret) +} + +func ExcludeClipRect(hdc HDC, nLeftRect, nTopRect, nRightRect, nBottomRect int32) int32 { + ret, _, _ := syscall.Syscall6(excludeClipRect, 5, + uintptr(hdc), + uintptr(nLeftRect), + uintptr(nTopRect), + uintptr(nRightRect), + uintptr(nBottomRect), + 0) + + return int32(ret) +} + +func ExtCreatePen(dwPenStyle, dwWidth uint32, lplb *LOGBRUSH, dwStyleCount uint32, lpStyle *uint32) HPEN { + ret, _, _ := syscall.Syscall6(extCreatePen, 5, + uintptr(dwPenStyle), + uintptr(dwWidth), + uintptr(unsafe.Pointer(lplb)), + uintptr(dwStyleCount), + uintptr(unsafe.Pointer(lpStyle)), + 0) + + return HPEN(ret) +} + +func FillRgn(hdc HDC, hrgn HRGN, hbr HBRUSH) bool { + ret, _, _ := syscall.Syscall(fillRgn, 3, + uintptr(hdc), + uintptr(hrgn), + uintptr(hbr)) + + return ret != 0 +} + +func GetDeviceCaps(hdc HDC, nIndex int32) int32 { + ret, _, _ := syscall.Syscall(getDeviceCaps, 2, + uintptr(hdc), + uintptr(nIndex), + 0) + + return int32(ret) +} + +func GetDIBits(hdc HDC, hbmp HBITMAP, uStartScan uint32, cScanLines uint32, lpvBits *byte, lpbi *BITMAPINFO, uUsage uint32) int32 { + ret, _, _ := syscall.Syscall9(getDIBits, 7, + uintptr(hdc), + uintptr(hbmp), + uintptr(uStartScan), + uintptr(cScanLines), + uintptr(unsafe.Pointer(lpvBits)), + uintptr(unsafe.Pointer(lpbi)), + uintptr(uUsage), + 0, + 0) + return int32(ret) +} + +func GetEnhMetaFile(lpszMetaFile *uint16) HENHMETAFILE { + ret, _, _ := syscall.Syscall(getEnhMetaFile, 1, + uintptr(unsafe.Pointer(lpszMetaFile)), + 0, + 0) + + return HENHMETAFILE(ret) +} + +func GetEnhMetaFileHeader(hemf HENHMETAFILE, cbBuffer uint32, lpemh *ENHMETAHEADER) uint32 { + ret, _, _ := syscall.Syscall(getEnhMetaFileHeader, 3, + uintptr(hemf), + uintptr(cbBuffer), + uintptr(unsafe.Pointer(lpemh))) + + return uint32(ret) +} + +func GetObject(hgdiobj HGDIOBJ, cbBuffer uintptr, lpvObject unsafe.Pointer) int32 { + ret, _, _ := syscall.Syscall(getObject, 3, + uintptr(hgdiobj), + uintptr(cbBuffer), + uintptr(lpvObject)) + + return int32(ret) +} + +func GetPixel(hdc HDC, nXPos, nYPos int32) COLORREF { + ret, _, _ := syscall.Syscall(getPixel, 3, + uintptr(hdc), + uintptr(nXPos), + uintptr(nYPos)) + + return COLORREF(ret) +} + +func GetRgnBox(hrgn HRGN, lprc *RECT) int32 { + ret, _, _ := syscall.Syscall(getRgnBox, 2, + uintptr(hrgn), + uintptr(unsafe.Pointer(lprc)), + 0) + + return int32(ret) +} + +func GetStockObject(fnObject int32) HGDIOBJ { + ret, _, _ := syscall.Syscall(getStockObject, 1, + uintptr(fnObject), + 0, + 0) + + return HGDIOBJ(ret) +} + +func GetTextExtentExPoint(hdc HDC, lpszStr *uint16, cchString, nMaxExtent int32, lpnFit, alpDx *int32, lpSize *SIZE) bool { + ret, _, _ := syscall.Syscall9(getTextExtentExPoint, 7, + uintptr(hdc), + uintptr(unsafe.Pointer(lpszStr)), + uintptr(cchString), + uintptr(nMaxExtent), + uintptr(unsafe.Pointer(lpnFit)), + uintptr(unsafe.Pointer(alpDx)), + uintptr(unsafe.Pointer(lpSize)), + 0, + 0) + + return ret != 0 +} + +func GetTextExtentPoint32(hdc HDC, lpString *uint16, c int32, lpSize *SIZE) bool { + ret, _, _ := syscall.Syscall6(getTextExtentPoint32, 4, + uintptr(hdc), + uintptr(unsafe.Pointer(lpString)), + uintptr(c), + uintptr(unsafe.Pointer(lpSize)), + 0, + 0) + + return ret != 0 +} + +func GetTextMetrics(hdc HDC, lptm *TEXTMETRIC) bool { + ret, _, _ := syscall.Syscall(getTextMetrics, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lptm)), + 0) + + return ret != 0 +} + +func GetViewportOrgEx(hdc HDC, lpPoint *POINT) bool { + ret, _, _ := syscall.Syscall(getViewportOrgEx, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpPoint)), + 0) + + return ret != 0 +} + +func GradientFill(hdc HDC, pVertex *TRIVERTEX, nVertex uint32, pMesh unsafe.Pointer, nMesh, ulMode uint32) bool { + ret, _, _ := syscall.Syscall6(gradientFill, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(pVertex)), + uintptr(nVertex), + uintptr(pMesh), + uintptr(nMesh), + uintptr(ulMode)) + + return ret != 0 +} + +func IntersectClipRect(hdc HDC, nLeftRect, nTopRect, nRightRect, nBottomRect int32) int32 { + ret, _, _ := syscall.Syscall6(intersectClipRect, 5, + uintptr(hdc), + uintptr(nLeftRect), + uintptr(nTopRect), + uintptr(nRightRect), + uintptr(nBottomRect), + 0) + + return int32(ret) +} + +func LineTo(hdc HDC, nXEnd, nYEnd int32) bool { + ret, _, _ := syscall.Syscall(lineTo, 3, + uintptr(hdc), + uintptr(nXEnd), + uintptr(nYEnd)) + + return ret != 0 +} + +func MoveToEx(hdc HDC, x, y int, lpPoint *POINT) bool { + ret, _, _ := syscall.Syscall6(moveToEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lpPoint)), + 0, + 0) + + return ret != 0 +} + +func PlayEnhMetaFile(hdc HDC, hemf HENHMETAFILE, lpRect *RECT) bool { + ret, _, _ := syscall.Syscall(playEnhMetaFile, 3, + uintptr(hdc), + uintptr(hemf), + uintptr(unsafe.Pointer(lpRect))) + + return ret != 0 +} + +func Polyline(hdc HDC, lppt unsafe.Pointer, cPoints int32) bool { + ret, _, _ := syscall.Syscall(polyline, 3, + uintptr(hdc), + uintptr(lppt), + uintptr(cPoints)) + + return ret != 0 +} + +func Rectangle_(hdc HDC, nLeftRect, nTopRect, nRightRect, nBottomRect int32) bool { + ret, _, _ := syscall.Syscall6(rectangle, 5, + uintptr(hdc), + uintptr(nLeftRect), + uintptr(nTopRect), + uintptr(nRightRect), + uintptr(nBottomRect), + 0) + + return ret != 0 +} + +func ResetDC(hdc HDC, lpInitData *DEVMODE) HDC { + ret, _, _ := syscall.Syscall(resetDC, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpInitData)), + 0) + + return HDC(ret) +} + +func RestoreDC(hdc HDC, nSaveDC int32) bool { + ret, _, _ := syscall.Syscall(restoreDC, 2, + uintptr(hdc), + uintptr(nSaveDC), + 0) + return ret != 0 +} + +func SaveDC(hdc HDC) int32 { + ret, _, _ := syscall.Syscall(saveDC, 1, + uintptr(hdc), + 0, + 0) + return int32(ret) +} + +func SelectObject(hdc HDC, hgdiobj HGDIOBJ) HGDIOBJ { + ret, _, _ := syscall.Syscall(selectObject, 2, + uintptr(hdc), + uintptr(hgdiobj), + 0) + + return HGDIOBJ(ret) +} + +func SetBkColor(hdc HDC, crColor COLORREF) COLORREF { + ret, _, _ := syscall.Syscall(setBkColor, 2, + uintptr(hdc), + uintptr(crColor), + 0) + + return COLORREF(ret) +} + +func SetBkMode(hdc HDC, iBkMode int32) int32 { + ret, _, _ := syscall.Syscall(setBkMode, 2, + uintptr(hdc), + uintptr(iBkMode), + 0) + + return int32(ret) +} + +func SetBrushOrgEx(hdc HDC, nXOrg, nYOrg int32, lppt *POINT) bool { + ret, _, _ := syscall.Syscall6(setBrushOrgEx, 4, + uintptr(hdc), + uintptr(nXOrg), + uintptr(nYOrg), + uintptr(unsafe.Pointer(lppt)), + 0, + 0) + + return ret != 0 +} + +func SetPixel(hdc HDC, X, Y int32, crColor COLORREF) COLORREF { + ret, _, _ := syscall.Syscall6(setPixel, 4, + uintptr(hdc), + uintptr(X), + uintptr(Y), + uintptr(crColor), + 0, + 0) + + return COLORREF(ret) +} + +func SetPixelFormat(hdc HDC, iPixelFormat int32, ppfd *PIXELFORMATDESCRIPTOR) bool { + ret, _, _ := syscall.Syscall(setPixelFormat, 3, + uintptr(hdc), + uintptr(iPixelFormat), + uintptr(unsafe.Pointer(ppfd))) + + return ret != 0 +} + +func SetStretchBltMode(hdc HDC, iStretchMode int32) int32 { + ret, _, _ := syscall.Syscall(setStretchBltMode, 2, + uintptr(hdc), + uintptr(iStretchMode), + 0) + + return int32(ret) +} + +func SetTextColor(hdc HDC, crColor COLORREF) COLORREF { + ret, _, _ := syscall.Syscall(setTextColor, 2, + uintptr(hdc), + uintptr(crColor), + 0) + + return COLORREF(ret) +} + +func SetViewportOrgEx(hdc HDC, x, y int32, lpPoint *POINT) COLORREF { + ret, _, _ := syscall.Syscall6(setViewportOrgEx, 4, + uintptr(hdc), + uintptr(x), + uintptr(y), + uintptr(unsafe.Pointer(lpPoint)), + 0, + 0) + + return COLORREF(ret) +} + +func StartDoc(hdc HDC, lpdi *DOCINFO) int32 { + ret, _, _ := syscall.Syscall(startDoc, 2, + uintptr(hdc), + uintptr(unsafe.Pointer(lpdi)), + 0) + + return int32(ret) +} + +func StartPage(hdc HDC) int32 { + ret, _, _ := syscall.Syscall(startPage, 1, + uintptr(hdc), + 0, + 0) + + return int32(ret) +} + +func StretchBlt(hdcDest HDC, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest int32, hdcSrc HDC, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc int32, dwRop uint32) bool { + ret, _, _ := syscall.Syscall12(stretchBlt, 11, + uintptr(hdcDest), + uintptr(nXOriginDest), + uintptr(nYOriginDest), + uintptr(nWidthDest), + uintptr(nHeightDest), + uintptr(hdcSrc), + uintptr(nXOriginSrc), + uintptr(nYOriginSrc), + uintptr(nWidthSrc), + uintptr(nHeightSrc), + uintptr(dwRop), + 0) + + return ret != 0 +} + +func SwapBuffers(hdc HDC) bool { + ret, _, _ := syscall.Syscall(swapBuffers, 1, + uintptr(hdc), + 0, + 0) + + return ret != 0 +} + +func TextOut(hdc HDC, nXStart, nYStart int32, lpString *uint16, cchString int32) bool { + ret, _, _ := syscall.Syscall6(textOut, 5, + uintptr(hdc), + uintptr(nXStart), + uintptr(nYStart), + uintptr(unsafe.Pointer(lpString)), + uintptr(cchString), + 0) + return ret != 0 +} + +func TransparentBlt(hdcDest HDC, xoriginDest, yoriginDest, wDest, hDest int32, hdcSrc HDC, xoriginSrc, yoriginSrc, wSrc, hSrc int32, crTransparent uint32) bool { + ret, _, _ := syscall.Syscall12(transparentBlt, 11, + uintptr(hdcDest), + uintptr(xoriginDest), + uintptr(yoriginDest), + uintptr(wDest), + uintptr(hDest), + uintptr(hdcSrc), + uintptr(xoriginSrc), + uintptr(yoriginSrc), + uintptr(wSrc), + uintptr(hSrc), + uintptr(crTransparent), + 0) + + return ret != 0 +} diff --git a/vendor/github.com/lxn/win/gdiplus.go b/vendor/github.com/lxn/win/gdiplus.go new file mode 100644 index 00000000000..17522622149 --- /dev/null +++ b/vendor/github.com/lxn/win/gdiplus.go @@ -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) +}*/ diff --git a/vendor/github.com/lxn/win/header.go b/vendor/github.com/lxn/win/header.go new file mode 100644 index 00000000000..6e15fb09728 --- /dev/null +++ b/vendor/github.com/lxn/win/header.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/kernel32.go b/vendor/github.com/lxn/win/kernel32.go new file mode 100644 index 00000000000..b16d6ff86f0 --- /dev/null +++ b/vendor/github.com/lxn/win/kernel32.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/listbox.go b/vendor/github.com/lxn/win/listbox.go new file mode 100644 index 00000000000..abb872bbcc1 --- /dev/null +++ b/vendor/github.com/lxn/win/listbox.go @@ -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 +) diff --git a/vendor/github.com/lxn/win/listview.go b/vendor/github.com/lxn/win/listview.go new file mode 100644 index 00000000000..ef1db0ec7b9 --- /dev/null +++ b/vendor/github.com/lxn/win/listview.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/menu.go b/vendor/github.com/lxn/win/menu.go new file mode 100644 index 00000000000..0773f29a44b --- /dev/null +++ b/vendor/github.com/lxn/win/menu.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/ole32.go b/vendor/github.com/lxn/win/ole32.go new file mode 100644 index 00000000000..d75dee746a7 --- /dev/null +++ b/vendor/github.com/lxn/win/ole32.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/oleaut32.go b/vendor/github.com/lxn/win/oleaut32.go new file mode 100644 index 00000000000..b02e02eb393 --- /dev/null +++ b/vendor/github.com/lxn/win/oleaut32.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/oleaut32_386.go b/vendor/github.com/lxn/win/oleaut32_386.go new file mode 100644 index 00000000000..6d453317e2b --- /dev/null +++ b/vendor/github.com/lxn/win/oleaut32_386.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/oleaut32_amd64.go b/vendor/github.com/lxn/win/oleaut32_amd64.go new file mode 100644 index 00000000000..1af64f06784 --- /dev/null +++ b/vendor/github.com/lxn/win/oleaut32_amd64.go @@ -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*/ +} diff --git a/vendor/github.com/lxn/win/opengl32.go b/vendor/github.com/lxn/win/opengl32.go new file mode 100644 index 00000000000..dbacc220cca --- /dev/null +++ b/vendor/github.com/lxn/win/opengl32.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/pdh.go b/vendor/github.com/lxn/win/pdh.go new file mode 100644 index 00000000000..ca594fe4740 --- /dev/null +++ b/vendor/github.com/lxn/win/pdh.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/shdocvw.go b/vendor/github.com/lxn/win/shdocvw.go new file mode 100644 index 00000000000..3f180943bda --- /dev/null +++ b/vendor/github.com/lxn/win/shdocvw.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/shell32.go b/vendor/github.com/lxn/win/shell32.go new file mode 100644 index 00000000000..373097ff0e7 --- /dev/null +++ b/vendor/github.com/lxn/win/shell32.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/shobj.go b/vendor/github.com/lxn/win/shobj.go new file mode 100644 index 00000000000..b3aeefae901 --- /dev/null +++ b/vendor/github.com/lxn/win/shobj.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/shobj_386.go b/vendor/github.com/lxn/win/shobj_386.go new file mode 100644 index 00000000000..5e028a36d3d --- /dev/null +++ b/vendor/github.com/lxn/win/shobj_386.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/shobj_amd64.go b/vendor/github.com/lxn/win/shobj_amd64.go new file mode 100644 index 00000000000..312fa21ee8a --- /dev/null +++ b/vendor/github.com/lxn/win/shobj_amd64.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/statusbar.go b/vendor/github.com/lxn/win/statusbar.go new file mode 100644 index 00000000000..41b7067cb15 --- /dev/null +++ b/vendor/github.com/lxn/win/statusbar.go @@ -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 diff --git a/vendor/github.com/lxn/win/syslink.go b/vendor/github.com/lxn/win/syslink.go new file mode 100644 index 00000000000..289e7bc85ff --- /dev/null +++ b/vendor/github.com/lxn/win/syslink.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/tab.go b/vendor/github.com/lxn/win/tab.go new file mode 100644 index 00000000000..10dbd3de5fc --- /dev/null +++ b/vendor/github.com/lxn/win/tab.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/toolbar.go b/vendor/github.com/lxn/win/toolbar.go new file mode 100644 index 00000000000..80f0b0a41fa --- /dev/null +++ b/vendor/github.com/lxn/win/toolbar.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/tooltip.go b/vendor/github.com/lxn/win/tooltip.go new file mode 100644 index 00000000000..8e2aec71cae --- /dev/null +++ b/vendor/github.com/lxn/win/tooltip.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/treeview.go b/vendor/github.com/lxn/win/treeview.go new file mode 100644 index 00000000000..b21e42fd397 --- /dev/null +++ b/vendor/github.com/lxn/win/treeview.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/updown.go b/vendor/github.com/lxn/win/updown.go new file mode 100644 index 00000000000..f315c3f0ee0 --- /dev/null +++ b/vendor/github.com/lxn/win/updown.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/user32.go b/vendor/github.com/lxn/win/user32.go new file mode 100644 index 00000000000..5a857f3f7c1 --- /dev/null +++ b/vendor/github.com/lxn/win/user32.go @@ -0,0 +1,2865 @@ +// 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 CW_USEDEFAULT = ^0x7fffffff + +// MessageBox constants +const ( + MB_OK = 0x00000000 + MB_OKCANCEL = 0x00000001 + MB_ABORTRETRYIGNORE = 0x00000002 + MB_YESNOCANCEL = 0x00000003 + MB_YESNO = 0x00000004 + MB_RETRYCANCEL = 0x00000005 + MB_CANCELTRYCONTINUE = 0x00000006 + MB_ICONHAND = 0x00000010 + MB_ICONQUESTION = 0x00000020 + MB_ICONEXCLAMATION = 0x00000030 + MB_ICONASTERISK = 0x00000040 + MB_USERICON = 0x00000080 + MB_ICONWARNING = MB_ICONEXCLAMATION + MB_ICONERROR = MB_ICONHAND + MB_ICONINFORMATION = MB_ICONASTERISK + MB_ICONSTOP = MB_ICONHAND + MB_DEFBUTTON1 = 0x00000000 + MB_DEFBUTTON2 = 0x00000100 + MB_DEFBUTTON3 = 0x00000200 + MB_DEFBUTTON4 = 0x00000300 +) + +// Dialog box command ids +const ( + IDOK = 1 + IDCANCEL = 2 + IDABORT = 3 + IDRETRY = 4 + IDIGNORE = 5 + IDYES = 6 + IDNO = 7 + IDCLOSE = 8 + IDHELP = 9 + IDTRYAGAIN = 10 + IDCONTINUE = 11 + IDTIMEOUT = 32000 +) + +// System commands +const ( + SC_SIZE = 0xF000 + SC_MOVE = 0xF010 + SC_MINIMIZE = 0xF020 + SC_MAXIMIZE = 0xF030 + SC_NEXTWINDOW = 0xF040 + SC_PREVWINDOW = 0xF050 + SC_CLOSE = 0xF060 + SC_VSCROLL = 0xF070 + SC_HSCROLL = 0xF080 + SC_MOUSEMENU = 0xF090 + SC_KEYMENU = 0xF100 + SC_ARRANGE = 0xF110 + SC_RESTORE = 0xF120 + SC_TASKLIST = 0xF130 + SC_SCREENSAVE = 0xF140 + SC_HOTKEY = 0xF150 + SC_DEFAULT = 0xF160 + SC_MONITORPOWER = 0xF170 + SC_CONTEXTHELP = 0xF180 + SC_SEPARATOR = 0xF00F +) + +// Static control styles +const ( + SS_BITMAP = 14 + SS_BLACKFRAME = 7 + SS_BLACKRECT = 4 + SS_CENTER = 1 + SS_CENTERIMAGE = 512 + SS_EDITCONTROL = 0x2000 + SS_ENHMETAFILE = 15 + SS_ETCHEDFRAME = 18 + SS_ETCHEDHORZ = 16 + SS_ETCHEDVERT = 17 + SS_GRAYFRAME = 8 + SS_GRAYRECT = 5 + SS_ICON = 3 + SS_LEFT = 0 + SS_LEFTNOWORDWRAP = 0xc + SS_NOPREFIX = 128 + SS_NOTIFY = 256 + SS_OWNERDRAW = 0xd + SS_REALSIZECONTROL = 0x040 + SS_REALSIZEIMAGE = 0x800 + SS_RIGHT = 2 + SS_RIGHTJUST = 0x400 + SS_SIMPLE = 11 + SS_SUNKEN = 4096 + SS_WHITEFRAME = 9 + SS_WHITERECT = 6 + SS_USERITEM = 10 + SS_TYPEMASK = 0x0000001F + SS_ENDELLIPSIS = 0x00004000 + SS_PATHELLIPSIS = 0x00008000 + SS_WORDELLIPSIS = 0x0000C000 + SS_ELLIPSISMASK = 0x0000C000 +) + +// Button message constants +const ( + BM_CLICK = 245 + BM_GETCHECK = 240 + BM_GETIMAGE = 246 + BM_GETSTATE = 242 + BM_SETCHECK = 241 + BM_SETIMAGE = 247 + BM_SETSTATE = 243 + BM_SETSTYLE = 244 +) + +// Button notifications +const ( + BCN_DROPDOWN = 0xfffffb20 + BN_CLICKED = 0 + BN_PAINT = 1 + BN_HILITE = 2 + BN_PUSHED = BN_HILITE + BN_UNHILITE = 3 + BN_UNPUSHED = BN_UNHILITE + BN_DISABLE = 4 + BN_DOUBLECLICKED = 5 + BN_DBLCLK = BN_DOUBLECLICKED + BN_SETFOCUS = 6 + BN_KILLFOCUS = 7 +) + +const ( + IMAGE_BITMAP = 0 + IMAGE_ICON = 1 + IMAGE_CURSOR = 2 + IMAGE_ENHMETAFILE = 3 +) + +const ( + LR_DEFAULTCOLOR = 0 + LR_MONOCHROME = 1 + LR_COLOR = 2 + LR_COPYRETURNORG = 4 + LR_COPYDELETEORG = 8 + LR_LOADFROMFILE = 16 + LR_LOADTRANSPARENT = 32 + LR_LOADREALSIZE = 128 + LR_DEFAULTSIZE = 0x0040 + LR_VGACOLOR = 0x0080 + LR_LOADMAP3DCOLORS = 4096 + LR_CREATEDIBSECTION = 8192 + LR_COPYFROMRESOURCE = 0x4000 + LR_SHARED = 32768 +) + +// Button style constants +const ( + BS_3STATE = 5 + BS_AUTO3STATE = 6 + BS_AUTOCHECKBOX = 3 + BS_AUTORADIOBUTTON = 9 + BS_BITMAP = 128 + BS_BOTTOM = 0X800 + BS_CENTER = 0X300 + BS_CHECKBOX = 2 + BS_DEFPUSHBUTTON = 1 + BS_GROUPBOX = 7 + BS_ICON = 64 + BS_LEFT = 256 + BS_LEFTTEXT = 32 + BS_MULTILINE = 0X2000 + BS_NOTIFY = 0X4000 + BS_OWNERDRAW = 0XB + BS_PUSHBUTTON = 0 + BS_PUSHLIKE = 4096 + BS_RADIOBUTTON = 4 + BS_RIGHT = 512 + BS_RIGHTBUTTON = 32 + BS_SPLITBUTTON = 0x0000000c + BS_TEXT = 0 + BS_TOP = 0X400 + BS_USERBUTTON = 8 + BS_VCENTER = 0XC00 + BS_FLAT = 0X8000 +) + +const ( + PM_NOREMOVE = 0x0000 + PM_REMOVE = 0x0001 + PM_NOYIELD = 0x0002 +) + +// Button state constants +const ( + BST_CHECKED = 1 + BST_INDETERMINATE = 2 + BST_UNCHECKED = 0 + BST_FOCUS = 8 + BST_PUSHED = 4 +) + +// Predefined brushes constants +const ( + COLOR_3DDKSHADOW = 21 + COLOR_3DFACE = 15 + COLOR_3DHILIGHT = 20 + COLOR_3DHIGHLIGHT = 20 + COLOR_3DLIGHT = 22 + COLOR_BTNHILIGHT = 20 + COLOR_3DSHADOW = 16 + COLOR_ACTIVEBORDER = 10 + COLOR_ACTIVECAPTION = 2 + COLOR_APPWORKSPACE = 12 + COLOR_BACKGROUND = 1 + COLOR_DESKTOP = 1 + COLOR_BTNFACE = 15 + COLOR_BTNHIGHLIGHT = 20 + COLOR_BTNSHADOW = 16 + COLOR_BTNTEXT = 18 + COLOR_CAPTIONTEXT = 9 + COLOR_GRAYTEXT = 17 + COLOR_HIGHLIGHT = 13 + COLOR_HIGHLIGHTTEXT = 14 + COLOR_INACTIVEBORDER = 11 + COLOR_INACTIVECAPTION = 3 + COLOR_INACTIVECAPTIONTEXT = 19 + COLOR_INFOBK = 24 + COLOR_INFOTEXT = 23 + COLOR_MENU = 4 + COLOR_MENUTEXT = 7 + COLOR_SCROLLBAR = 0 + COLOR_WINDOW = 5 + COLOR_WINDOWFRAME = 6 + COLOR_WINDOWTEXT = 8 + COLOR_HOTLIGHT = 26 + COLOR_GRADIENTACTIVECAPTION = 27 + COLOR_GRADIENTINACTIVECAPTION = 28 +) + +// GetAncestor flags +const ( + GA_PARENT = 1 + GA_ROOT = 2 + GA_ROOTOWNER = 3 +) + +// GetWindowLong and GetWindowLongPtr constants +const ( + GWL_EXSTYLE = -20 + GWL_STYLE = -16 + GWL_WNDPROC = -4 + GWLP_WNDPROC = -4 + GWL_HINSTANCE = -6 + GWLP_HINSTANCE = -6 + GWL_HWNDPARENT = -8 + GWLP_HWNDPARENT = -8 + GWL_ID = -12 + GWLP_ID = -12 + GWL_USERDATA = -21 + GWLP_USERDATA = -21 +) + +// Predefined window handles +const ( + HWND_BROADCAST = HWND(0xFFFF) + HWND_BOTTOM = HWND(1) + HWND_NOTOPMOST = ^HWND(1) // -2 + HWND_TOP = HWND(0) + HWND_TOPMOST = ^HWND(0) // -1 + HWND_DESKTOP = HWND(0) + HWND_MESSAGE = ^HWND(2) // -3 +) + +// Predefined icon constants +const ( + IDI_APPLICATION = 32512 + IDI_HAND = 32513 + IDI_QUESTION = 32514 + IDI_EXCLAMATION = 32515 + IDI_ASTERISK = 32516 + IDI_WINLOGO = 32517 + IDI_SHIELD = 32518 + IDI_WARNING = IDI_EXCLAMATION + IDI_ERROR = IDI_HAND + IDI_INFORMATION = IDI_ASTERISK +) + +// Predefined cursor constants +const ( + IDC_ARROW = 32512 + IDC_IBEAM = 32513 + IDC_WAIT = 32514 + IDC_CROSS = 32515 + IDC_UPARROW = 32516 + IDC_SIZENWSE = 32642 + IDC_SIZENESW = 32643 + IDC_SIZEWE = 32644 + IDC_SIZENS = 32645 + IDC_SIZEALL = 32646 + IDC_NO = 32648 + IDC_HAND = 32649 + IDC_APPSTARTING = 32650 + IDC_HELP = 32651 + IDC_ICON = 32641 + IDC_SIZE = 32640 +) + +// GetSystemMetrics constants +const ( + SM_CXSCREEN = 0 + SM_CYSCREEN = 1 + SM_CXVSCROLL = 2 + SM_CYHSCROLL = 3 + SM_CYCAPTION = 4 + SM_CXBORDER = 5 + SM_CYBORDER = 6 + SM_CXDLGFRAME = 7 + SM_CYDLGFRAME = 8 + SM_CYVTHUMB = 9 + SM_CXHTHUMB = 10 + SM_CXICON = 11 + SM_CYICON = 12 + SM_CXCURSOR = 13 + SM_CYCURSOR = 14 + SM_CYMENU = 15 + SM_CXFULLSCREEN = 16 + SM_CYFULLSCREEN = 17 + SM_CYKANJIWINDOW = 18 + SM_MOUSEPRESENT = 19 + SM_CYVSCROLL = 20 + SM_CXHSCROLL = 21 + SM_DEBUG = 22 + SM_SWAPBUTTON = 23 + SM_RESERVED1 = 24 + SM_RESERVED2 = 25 + SM_RESERVED3 = 26 + SM_RESERVED4 = 27 + SM_CXMIN = 28 + SM_CYMIN = 29 + SM_CXSIZE = 30 + SM_CYSIZE = 31 + SM_CXFRAME = 32 + SM_CYFRAME = 33 + SM_CXMINTRACK = 34 + SM_CYMINTRACK = 35 + SM_CXDOUBLECLK = 36 + SM_CYDOUBLECLK = 37 + SM_CXICONSPACING = 38 + SM_CYICONSPACING = 39 + SM_MENUDROPALIGNMENT = 40 + SM_PENWINDOWS = 41 + SM_DBCSENABLED = 42 + SM_CMOUSEBUTTONS = 43 + SM_CXFIXEDFRAME = SM_CXDLGFRAME + SM_CYFIXEDFRAME = SM_CYDLGFRAME + SM_CXSIZEFRAME = SM_CXFRAME + SM_CYSIZEFRAME = SM_CYFRAME + SM_SECURE = 44 + SM_CXEDGE = 45 + SM_CYEDGE = 46 + SM_CXMINSPACING = 47 + SM_CYMINSPACING = 48 + SM_CXSMICON = 49 + SM_CYSMICON = 50 + SM_CYSMCAPTION = 51 + SM_CXSMSIZE = 52 + SM_CYSMSIZE = 53 + SM_CXMENUSIZE = 54 + SM_CYMENUSIZE = 55 + SM_ARRANGE = 56 + SM_CXMINIMIZED = 57 + SM_CYMINIMIZED = 58 + SM_CXMAXTRACK = 59 + SM_CYMAXTRACK = 60 + SM_CXMAXIMIZED = 61 + SM_CYMAXIMIZED = 62 + SM_NETWORK = 63 + SM_CLEANBOOT = 67 + SM_CXDRAG = 68 + SM_CYDRAG = 69 + SM_SHOWSOUNDS = 70 + SM_CXMENUCHECK = 71 + SM_CYMENUCHECK = 72 + SM_SLOWMACHINE = 73 + SM_MIDEASTENABLED = 74 + SM_MOUSEWHEELPRESENT = 75 + SM_XVIRTUALSCREEN = 76 + SM_YVIRTUALSCREEN = 77 + SM_CXVIRTUALSCREEN = 78 + SM_CYVIRTUALSCREEN = 79 + SM_CMONITORS = 80 + SM_SAMEDISPLAYFORMAT = 81 + SM_IMMENABLED = 82 + SM_CXFOCUSBORDER = 83 + SM_CYFOCUSBORDER = 84 + SM_TABLETPC = 86 + SM_MEDIACENTER = 87 + SM_STARTER = 88 + SM_SERVERR2 = 89 + SM_CMETRICS = 91 + SM_REMOTESESSION = 0x1000 + SM_SHUTTINGDOWN = 0x2000 + SM_REMOTECONTROL = 0x2001 + SM_CARETBLINKINGENABLED = 0x2002 +) + +// ShowWindow constants +const ( + SW_HIDE = 0 + SW_NORMAL = 1 + SW_SHOWNORMAL = 1 + SW_SHOWMINIMIZED = 2 + SW_MAXIMIZE = 3 + SW_SHOWMAXIMIZED = 3 + SW_SHOWNOACTIVATE = 4 + SW_SHOW = 5 + SW_MINIMIZE = 6 + SW_SHOWMINNOACTIVE = 7 + SW_SHOWNA = 8 + SW_RESTORE = 9 + SW_SHOWDEFAULT = 10 + SW_FORCEMINIMIZE = 11 +) + +// SetWindowPos flags +const ( + SWP_DRAWFRAME = 0x0020 + SWP_FRAMECHANGED = 0x0020 + SWP_HIDEWINDOW = 0x0080 + SWP_NOACTIVATE = 0x0010 + SWP_NOCOPYBITS = 0x0100 + SWP_NOMOVE = 0x0002 + SWP_NOSIZE = 0x0001 + SWP_NOREDRAW = 0x0008 + SWP_NOZORDER = 0x0004 + SWP_SHOWWINDOW = 0x0040 + SWP_NOOWNERZORDER = 0x0200 + SWP_NOREPOSITION = SWP_NOOWNERZORDER + SWP_NOSENDCHANGING = 0x0400 + SWP_DEFERERASE = 0x2000 + SWP_ASYNCWINDOWPOS = 0x4000 +) + +// UI state constants +const ( + UIS_SET = 1 + UIS_CLEAR = 2 + UIS_INITIALIZE = 3 +) + +// UI state constants +const ( + UISF_HIDEFOCUS = 0x1 + UISF_HIDEACCEL = 0x2 + UISF_ACTIVE = 0x4 +) + +// Virtual key codes +const ( + VK_LBUTTON = 1 + VK_RBUTTON = 2 + VK_CANCEL = 3 + VK_MBUTTON = 4 + VK_XBUTTON1 = 5 + VK_XBUTTON2 = 6 + VK_BACK = 8 + VK_TAB = 9 + VK_CLEAR = 12 + VK_RETURN = 13 + VK_SHIFT = 16 + VK_CONTROL = 17 + VK_MENU = 18 + VK_PAUSE = 19 + VK_CAPITAL = 20 + VK_KANA = 0x15 + VK_HANGEUL = 0x15 + VK_HANGUL = 0x15 + VK_JUNJA = 0x17 + VK_FINAL = 0x18 + VK_HANJA = 0x19 + VK_KANJI = 0x19 + VK_ESCAPE = 0x1B + VK_CONVERT = 0x1C + VK_NONCONVERT = 0x1D + VK_ACCEPT = 0x1E + VK_MODECHANGE = 0x1F + VK_SPACE = 32 + VK_PRIOR = 33 + VK_NEXT = 34 + VK_END = 35 + VK_HOME = 36 + VK_LEFT = 37 + VK_UP = 38 + VK_RIGHT = 39 + VK_DOWN = 40 + VK_SELECT = 41 + VK_PRINT = 42 + VK_EXECUTE = 43 + VK_SNAPSHOT = 44 + VK_INSERT = 45 + VK_DELETE = 46 + VK_HELP = 47 + VK_LWIN = 0x5B + VK_RWIN = 0x5C + VK_APPS = 0x5D + VK_SLEEP = 0x5F + VK_NUMPAD0 = 0x60 + VK_NUMPAD1 = 0x61 + VK_NUMPAD2 = 0x62 + VK_NUMPAD3 = 0x63 + VK_NUMPAD4 = 0x64 + VK_NUMPAD5 = 0x65 + VK_NUMPAD6 = 0x66 + VK_NUMPAD7 = 0x67 + VK_NUMPAD8 = 0x68 + VK_NUMPAD9 = 0x69 + VK_MULTIPLY = 0x6A + VK_ADD = 0x6B + VK_SEPARATOR = 0x6C + VK_SUBTRACT = 0x6D + VK_DECIMAL = 0x6E + VK_DIVIDE = 0x6F + VK_F1 = 0x70 + VK_F2 = 0x71 + VK_F3 = 0x72 + VK_F4 = 0x73 + VK_F5 = 0x74 + VK_F6 = 0x75 + VK_F7 = 0x76 + VK_F8 = 0x77 + VK_F9 = 0x78 + VK_F10 = 0x79 + VK_F11 = 0x7A + VK_F12 = 0x7B + VK_F13 = 0x7C + VK_F14 = 0x7D + VK_F15 = 0x7E + VK_F16 = 0x7F + VK_F17 = 0x80 + VK_F18 = 0x81 + VK_F19 = 0x82 + VK_F20 = 0x83 + VK_F21 = 0x84 + VK_F22 = 0x85 + VK_F23 = 0x86 + VK_F24 = 0x87 + VK_NUMLOCK = 0x90 + VK_SCROLL = 0x91 + VK_LSHIFT = 0xA0 + VK_RSHIFT = 0xA1 + VK_LCONTROL = 0xA2 + VK_RCONTROL = 0xA3 + VK_LMENU = 0xA4 + VK_RMENU = 0xA5 + VK_BROWSER_BACK = 0xA6 + VK_BROWSER_FORWARD = 0xA7 + VK_BROWSER_REFRESH = 0xA8 + VK_BROWSER_STOP = 0xA9 + VK_BROWSER_SEARCH = 0xAA + VK_BROWSER_FAVORITES = 0xAB + VK_BROWSER_HOME = 0xAC + VK_VOLUME_MUTE = 0xAD + VK_VOLUME_DOWN = 0xAE + VK_VOLUME_UP = 0xAF + VK_MEDIA_NEXT_TRACK = 0xB0 + VK_MEDIA_PREV_TRACK = 0xB1 + VK_MEDIA_STOP = 0xB2 + VK_MEDIA_PLAY_PAUSE = 0xB3 + VK_LAUNCH_MAIL = 0xB4 + VK_LAUNCH_MEDIA_SELECT = 0xB5 + VK_LAUNCH_APP1 = 0xB6 + VK_LAUNCH_APP2 = 0xB7 + VK_OEM_1 = 0xBA + VK_OEM_PLUS = 0xBB + VK_OEM_COMMA = 0xBC + VK_OEM_MINUS = 0xBD + VK_OEM_PERIOD = 0xBE + VK_OEM_2 = 0xBF + VK_OEM_3 = 0xC0 + VK_OEM_4 = 0xDB + VK_OEM_5 = 0xDC + VK_OEM_6 = 0xDD + VK_OEM_7 = 0xDE + VK_OEM_8 = 0xDF + VK_OEM_102 = 0xE2 + VK_PROCESSKEY = 0xE5 + VK_PACKET = 0xE7 + VK_ATTN = 0xF6 + VK_CRSEL = 0xF7 + VK_EXSEL = 0xF8 + VK_EREOF = 0xF9 + VK_PLAY = 0xFA + VK_ZOOM = 0xFB + VK_NONAME = 0xFC + VK_PA1 = 0xFD + VK_OEM_CLEAR = 0xFE +) + +// Window style constants +const ( + WS_OVERLAPPED = 0X00000000 + WS_POPUP = 0X80000000 + WS_CHILD = 0X40000000 + WS_MINIMIZE = 0X20000000 + WS_VISIBLE = 0X10000000 + WS_DISABLED = 0X08000000 + WS_CLIPSIBLINGS = 0X04000000 + WS_CLIPCHILDREN = 0X02000000 + WS_MAXIMIZE = 0X01000000 + WS_CAPTION = 0X00C00000 + WS_BORDER = 0X00800000 + WS_DLGFRAME = 0X00400000 + WS_VSCROLL = 0X00200000 + WS_HSCROLL = 0X00100000 + WS_SYSMENU = 0X00080000 + WS_THICKFRAME = 0X00040000 + WS_GROUP = 0X00020000 + WS_TABSTOP = 0X00010000 + WS_MINIMIZEBOX = 0X00020000 + WS_MAXIMIZEBOX = 0X00010000 + WS_TILED = 0X00000000 + WS_ICONIC = 0X20000000 + WS_SIZEBOX = 0X00040000 + WS_OVERLAPPEDWINDOW = 0X00000000 | 0X00C00000 | 0X00080000 | 0X00040000 | 0X00020000 | 0X00010000 + WS_POPUPWINDOW = 0X80000000 | 0X00800000 | 0X00080000 + WS_CHILDWINDOW = 0X40000000 +) + +// Extended window style constants +const ( + WS_EX_DLGMODALFRAME = 0X00000001 + WS_EX_NOPARENTNOTIFY = 0X00000004 + WS_EX_TOPMOST = 0X00000008 + WS_EX_ACCEPTFILES = 0X00000010 + WS_EX_TRANSPARENT = 0X00000020 + WS_EX_MDICHILD = 0X00000040 + WS_EX_TOOLWINDOW = 0X00000080 + WS_EX_WINDOWEDGE = 0X00000100 + WS_EX_CLIENTEDGE = 0X00000200 + WS_EX_CONTEXTHELP = 0X00000400 + WS_EX_RIGHT = 0X00001000 + WS_EX_LEFT = 0X00000000 + WS_EX_RTLREADING = 0X00002000 + WS_EX_LTRREADING = 0X00000000 + WS_EX_LEFTSCROLLBAR = 0X00004000 + WS_EX_RIGHTSCROLLBAR = 0X00000000 + WS_EX_CONTROLPARENT = 0X00010000 + WS_EX_STATICEDGE = 0X00020000 + WS_EX_APPWINDOW = 0X00040000 + WS_EX_OVERLAPPEDWINDOW = 0X00000100 | 0X00000200 + WS_EX_PALETTEWINDOW = 0X00000100 | 0X00000080 | 0X00000008 + WS_EX_LAYERED = 0X00080000 + WS_EX_NOINHERITLAYOUT = 0X00100000 + WS_EX_LAYOUTRTL = 0X00400000 + WS_EX_NOACTIVATE = 0X08000000 +) + +// Window message constants +const ( + WM_APP = 32768 + WM_ACTIVATE = 6 + WM_ACTIVATEAPP = 28 + WM_AFXFIRST = 864 + WM_AFXLAST = 895 + WM_ASKCBFORMATNAME = 780 + WM_CANCELJOURNAL = 75 + WM_CANCELMODE = 31 + WM_CAPTURECHANGED = 533 + WM_CHANGECBCHAIN = 781 + WM_CHAR = 258 + WM_CHARTOITEM = 47 + WM_CHILDACTIVATE = 34 + WM_CLEAR = 771 + WM_CLOSE = 16 + WM_COMMAND = 273 + WM_COMMNOTIFY = 68 /* OBSOLETE */ + WM_COMPACTING = 65 + WM_COMPAREITEM = 57 + WM_CONTEXTMENU = 123 + WM_COPY = 769 + WM_COPYDATA = 74 + WM_CREATE = 1 + WM_CTLCOLORBTN = 309 + WM_CTLCOLORDLG = 310 + WM_CTLCOLOREDIT = 307 + WM_CTLCOLORLISTBOX = 308 + WM_CTLCOLORMSGBOX = 306 + WM_CTLCOLORSCROLLBAR = 311 + WM_CTLCOLORSTATIC = 312 + WM_CUT = 768 + WM_DEADCHAR = 259 + WM_DELETEITEM = 45 + WM_DESTROY = 2 + WM_DESTROYCLIPBOARD = 775 + WM_DEVICECHANGE = 537 + WM_DEVMODECHANGE = 27 + WM_DISPLAYCHANGE = 126 + WM_DRAWCLIPBOARD = 776 + WM_DRAWITEM = 43 + WM_DROPFILES = 563 + WM_ENABLE = 10 + WM_ENDSESSION = 22 + WM_ENTERIDLE = 289 + WM_ENTERMENULOOP = 529 + WM_ENTERSIZEMOVE = 561 + WM_ERASEBKGND = 20 + WM_EXITMENULOOP = 530 + WM_EXITSIZEMOVE = 562 + WM_FONTCHANGE = 29 + WM_GETDLGCODE = 135 + WM_GETFONT = 49 + WM_GETHOTKEY = 51 + WM_GETICON = 127 + WM_GETMINMAXINFO = 36 + WM_GETTEXT = 13 + WM_GETTEXTLENGTH = 14 + WM_HANDHELDFIRST = 856 + WM_HANDHELDLAST = 863 + WM_HELP = 83 + WM_HOTKEY = 786 + WM_HSCROLL = 276 + WM_HSCROLLCLIPBOARD = 782 + WM_ICONERASEBKGND = 39 + WM_INITDIALOG = 272 + WM_INITMENU = 278 + WM_INITMENUPOPUP = 279 + WM_INPUT = 0X00FF + WM_INPUTLANGCHANGE = 81 + WM_INPUTLANGCHANGEREQUEST = 80 + WM_KEYDOWN = 256 + WM_KEYUP = 257 + WM_KILLFOCUS = 8 + WM_MDIACTIVATE = 546 + WM_MDICASCADE = 551 + WM_MDICREATE = 544 + WM_MDIDESTROY = 545 + WM_MDIGETACTIVE = 553 + WM_MDIICONARRANGE = 552 + WM_MDIMAXIMIZE = 549 + WM_MDINEXT = 548 + WM_MDIREFRESHMENU = 564 + WM_MDIRESTORE = 547 + WM_MDISETMENU = 560 + WM_MDITILE = 550 + WM_MEASUREITEM = 44 + WM_GETOBJECT = 0X003D + WM_CHANGEUISTATE = 0X0127 + WM_UPDATEUISTATE = 0X0128 + WM_QUERYUISTATE = 0X0129 + WM_UNINITMENUPOPUP = 0X0125 + WM_MENURBUTTONUP = 290 + WM_MENUCOMMAND = 0X0126 + WM_MENUGETOBJECT = 0X0124 + WM_MENUDRAG = 0X0123 + WM_APPCOMMAND = 0X0319 + WM_MENUCHAR = 288 + WM_MENUSELECT = 287 + WM_MOVE = 3 + WM_MOVING = 534 + WM_NCACTIVATE = 134 + WM_NCCALCSIZE = 131 + WM_NCCREATE = 129 + WM_NCDESTROY = 130 + WM_NCHITTEST = 132 + WM_NCLBUTTONDBLCLK = 163 + WM_NCLBUTTONDOWN = 161 + WM_NCLBUTTONUP = 162 + WM_NCMBUTTONDBLCLK = 169 + WM_NCMBUTTONDOWN = 167 + WM_NCMBUTTONUP = 168 + WM_NCXBUTTONDOWN = 171 + WM_NCXBUTTONUP = 172 + WM_NCXBUTTONDBLCLK = 173 + WM_NCMOUSEHOVER = 0X02A0 + WM_NCMOUSELEAVE = 0X02A2 + WM_NCMOUSEMOVE = 160 + WM_NCPAINT = 133 + WM_NCRBUTTONDBLCLK = 166 + WM_NCRBUTTONDOWN = 164 + WM_NCRBUTTONUP = 165 + WM_NEXTDLGCTL = 40 + WM_NEXTMENU = 531 + WM_NOTIFY = 78 + WM_NOTIFYFORMAT = 85 + WM_NULL = 0 + WM_PAINT = 15 + WM_PAINTCLIPBOARD = 777 + WM_PAINTICON = 38 + WM_PALETTECHANGED = 785 + WM_PALETTEISCHANGING = 784 + WM_PARENTNOTIFY = 528 + WM_PASTE = 770 + WM_PENWINFIRST = 896 + WM_PENWINLAST = 911 + WM_POWER = 72 + WM_POWERBROADCAST = 536 + WM_PRINT = 791 + WM_PRINTCLIENT = 792 + WM_QUERYDRAGICON = 55 + WM_QUERYENDSESSION = 17 + WM_QUERYNEWPALETTE = 783 + WM_QUERYOPEN = 19 + WM_QUEUESYNC = 35 + WM_QUIT = 18 + WM_RENDERALLFORMATS = 774 + WM_RENDERFORMAT = 773 + WM_SETCURSOR = 32 + WM_SETFOCUS = 7 + WM_SETFONT = 48 + WM_SETHOTKEY = 50 + WM_SETICON = 128 + WM_SETREDRAW = 11 + WM_SETTEXT = 12 + WM_SETTINGCHANGE = 26 + WM_SHOWWINDOW = 24 + WM_SIZE = 5 + WM_SIZECLIPBOARD = 779 + WM_SIZING = 532 + WM_SPOOLERSTATUS = 42 + WM_STYLECHANGED = 125 + WM_STYLECHANGING = 124 + WM_SYSCHAR = 262 + WM_SYSCOLORCHANGE = 21 + WM_SYSCOMMAND = 274 + WM_SYSDEADCHAR = 263 + WM_SYSKEYDOWN = 260 + WM_SYSKEYUP = 261 + WM_TCARD = 82 + WM_THEMECHANGED = 794 + WM_TIMECHANGE = 30 + WM_TIMER = 275 + WM_UNDO = 772 + WM_USER = 1024 + WM_USERCHANGED = 84 + WM_VKEYTOITEM = 46 + WM_VSCROLL = 277 + WM_VSCROLLCLIPBOARD = 778 + WM_WINDOWPOSCHANGED = 71 + WM_WINDOWPOSCHANGING = 70 + WM_WININICHANGE = 26 + WM_KEYFIRST = 256 + WM_KEYLAST = 264 + WM_SYNCPAINT = 136 + WM_MOUSEACTIVATE = 33 + WM_MOUSEMOVE = 512 + WM_LBUTTONDOWN = 513 + WM_LBUTTONUP = 514 + WM_LBUTTONDBLCLK = 515 + WM_RBUTTONDOWN = 516 + WM_RBUTTONUP = 517 + WM_RBUTTONDBLCLK = 518 + WM_MBUTTONDOWN = 519 + WM_MBUTTONUP = 520 + WM_MBUTTONDBLCLK = 521 + WM_MOUSEWHEEL = 522 + WM_MOUSEFIRST = 512 + WM_XBUTTONDOWN = 523 + WM_XBUTTONUP = 524 + WM_XBUTTONDBLCLK = 525 + WM_MOUSELAST = 525 + WM_MOUSEHOVER = 0X2A1 + WM_MOUSELEAVE = 0X2A3 + WM_CLIPBOARDUPDATE = 0x031D +) + +// mouse button constants +const ( + MK_CONTROL = 0x0008 + MK_LBUTTON = 0x0001 + MK_MBUTTON = 0x0010 + MK_RBUTTON = 0x0002 + MK_SHIFT = 0x0004 + MK_XBUTTON1 = 0x0020 + MK_XBUTTON2 = 0x0040 +) + +// TrackPopupMenu[Ex] flags +const ( + TPM_CENTERALIGN = 0x0004 + TPM_LEFTALIGN = 0x0000 + TPM_RIGHTALIGN = 0x0008 + TPM_BOTTOMALIGN = 0x0020 + TPM_TOPALIGN = 0x0000 + TPM_VCENTERALIGN = 0x0010 + TPM_NONOTIFY = 0x0080 + TPM_RETURNCMD = 0x0100 + TPM_LEFTBUTTON = 0x0000 + TPM_RIGHTBUTTON = 0x0002 + TPM_HORNEGANIMATION = 0x0800 + TPM_HORPOSANIMATION = 0x0400 + TPM_NOANIMATION = 0x4000 + TPM_VERNEGANIMATION = 0x2000 + TPM_VERPOSANIMATION = 0x1000 + TPM_HORIZONTAL = 0x0000 + TPM_VERTICAL = 0x0040 +) + +// WINDOWPLACEMENT flags +const ( + WPF_ASYNCWINDOWPLACEMENT = 0x0004 + WPF_RESTORETOMAXIMIZED = 0x0002 + WPF_SETMINPOSITION = 0x0001 +) + +// DrawText[Ex] format flags +const ( + DT_TOP = 0x00000000 + DT_LEFT = 0x00000000 + DT_CENTER = 0x00000001 + DT_RIGHT = 0x00000002 + DT_VCENTER = 0x00000004 + DT_BOTTOM = 0x00000008 + DT_WORDBREAK = 0x00000010 + DT_SINGLELINE = 0x00000020 + DT_EXPANDTABS = 0x00000040 + DT_TABSTOP = 0x00000080 + DT_NOCLIP = 0x00000100 + DT_EXTERNALLEADING = 0x00000200 + DT_CALCRECT = 0x00000400 + DT_NOPREFIX = 0x00000800 + DT_INTERNAL = 0x00001000 + DT_EDITCONTROL = 0x00002000 + DT_PATH_ELLIPSIS = 0x00004000 + DT_END_ELLIPSIS = 0x00008000 + DT_MODIFYSTRING = 0x00010000 + DT_RTLREADING = 0x00020000 + DT_WORD_ELLIPSIS = 0x00040000 + DT_NOFULLWIDTHCHARBREAK = 0x00080000 + DT_HIDEPREFIX = 0x00100000 + DT_PREFIXONLY = 0x00200000 +) + +// Window class styles +const ( + CS_VREDRAW = 0x00000001 + CS_HREDRAW = 0x00000002 + CS_KEYCVTWINDOW = 0x00000004 + CS_DBLCLKS = 0x00000008 + CS_OWNDC = 0x00000020 + CS_CLASSDC = 0x00000040 + CS_PARENTDC = 0x00000080 + CS_NOKEYCVT = 0x00000100 + CS_NOCLOSE = 0x00000200 + CS_SAVEBITS = 0x00000800 + CS_BYTEALIGNCLIENT = 0x00001000 + CS_BYTEALIGNWINDOW = 0x00002000 + CS_GLOBALCLASS = 0x00004000 + CS_IME = 0x00010000 + CS_DROPSHADOW = 0x00020000 +) + +// SystemParametersInfo actions +const ( + SPI_GETNONCLIENTMETRICS = 0x0029 +) + +// Dialog styles +const ( + DS_ABSALIGN = 0x0001 + DS_SYSMODAL = 0x0002 + DS_3DLOOK = 0x0004 + DS_FIXEDSYS = 0x0008 + DS_NOFAILCREATE = 0x0010 + DS_LOCALEDIT = 0x0020 + DS_SETFONT = 0x0040 + DS_MODALFRAME = 0x0080 + DS_NOIDLEMSG = 0x0100 + DS_SETFOREGROUND = 0x0200 + DS_CONTROL = 0x0400 + DS_CENTER = 0x0800 + DS_CENTERMOUSE = 0x1000 + DS_CONTEXTHELP = 0x2000 + DS_USEPIXELS = 0x8000 + DS_SHELLFONT = (DS_SETFONT | DS_FIXEDSYS) +) + +// WM_GETDLGCODE return values +const ( + DLGC_BUTTON = 0x2000 + DLGC_DEFPUSHBUTTON = 0x0010 + DLGC_HASSETSEL = 0x0008 + DLGC_RADIOBUTTON = 0x0040 + DLGC_STATIC = 0x0100 + DLGC_UNDEFPUSHBUTTON = 0x0020 + DLGC_WANTALLKEYS = 0x0004 + DLGC_WANTARROWS = 0x0001 + DLGC_WANTCHARS = 0x0080 + DLGC_WANTMESSAGE = 0x0004 + DLGC_WANTTAB = 0x0002 +) + +// WM_ACTIVATE codes +const ( + WA_ACTIVE = 1 + WA_CLICKACTIVE = 2 + WA_INACTIVE = 0 +) + +// Owner drawing states +const ( + ODS_CHECKED = 0x0001 + ODS_COMBOBOXEDIT = 0x0002 + ODS_DEFAULT = 0x0004 + ODS_DISABLED = 0x0008 + ODS_FOCUS = 0x0010 + ODS_GRAYED = 0x0020 + ODS_SELECTED = 0x0040 +) + +// Raw input device flags +const ( + RIDEV_APPKEYS = 0x00000400 + RIDEV_CAPTUREMOUSE = 0x00000200 + RIDEV_DEVNOTIFY = 0x00002000 + RIDEV_EXCLUDE = 0x00000010 + RIDEV_EXINPUTSINK = 0x00001000 + RIDEV_INPUTSINK = 0x00000100 + RIDEV_NOHOTKEYS = 0x00000200 + RIDEV_NOLEGACY = 0x00000030 + RIDEV_PAGEONLY = 0x00000020 + RIDEV_REMOVE = 0x00000001 +) + +// Raw input device command flags +const ( + RID_HEADER = 0x10000005 + RID_INPUT = 0x10000003 +) + +// Raw input type +const ( + RIM_TYPEHID = 2 + RIM_TYPEKEYBOARD = 1 + RIM_TYPEMOUSE = 0 +) + +// Raw input scan code information +const ( + RI_KEY_MAKE = 0 + RI_KEY_BREAK = 1 + RI_KEY_E0 = 2 + RI_KEY_E1 = 4 +) + +// Raw input mouse state +const ( + MOUSE_MOVE_RELATIVE = 0x00 + MOUSE_MOVE_ABSOLUTE = 0x01 + MOUSE_VIRTUAL_DESKTOP = 0x02 + MOUSE_ATTRIBUTES_CHANGED = 0x04 +) + +// Raw input transistion state of mouse buttons +const ( + RI_MOUSE_LEFT_BUTTON_DOWN = 0x0001 + RI_MOUSE_LEFT_BUTTON_UP = 0x0002 + RI_MOUSE_MIDDLE_BUTTON_DOWN = 0x0010 + RI_MOUSE_MIDDLE_BUTTON_UP = 0x0020 + RI_MOUSE_RIGHT_BUTTON_DOWN = 0x0004 + RI_MOUSE_RIGHT_BUTTON_UP = 0x0008 + RI_MOUSE_BUTTON_1_DOWN = 0x0001 + RI_MOUSE_BUTTON_1_UP = 0x0002 + RI_MOUSE_BUTTON_2_DOWN = 0x0004 + RI_MOUSE_BUTTON_2_UP = 0x0008 + RI_MOUSE_BUTTON_3_DOWN = 0x0010 + RI_MOUSE_BUTTON_3_UP = 0x0020 + RI_MOUSE_BUTTON_4_DOWN = 0x0040 + RI_MOUSE_BUTTON_4_UP = 0x0080 + RI_MOUSE_BUTTON_5_DOWN = 0x0100 + RI_MOUSE_BUTTON_5_UP = 0x0200 + RI_MOUSE_WHEEL = 0x0400 +) + +// Multi monitor constants +const ( + MONITOR_DEFAULTTONULL = 0x0 + MONITOR_DEFAULTTOPRIMARY = 0x1 + MONITOR_DEFAULTTONEAREST = 0x2 +) + +// MONITORINFO flags +const ( + MONITORINFOF_PRIMARY = 0x1 +) + +// INPUT Type +const ( + INPUT_MOUSE = 0 + INPUT_KEYBOARD = 1 + INPUT_HARDWARE = 2 +) + +// MOUSEINPUT MouseData +const ( + XBUTTON1 = 0x0001 + XBUTTON2 = 0x0002 +) + +// MOUSEINPUT DwFlags +const ( + MOUSEEVENTF_ABSOLUTE = 0x8000 + MOUSEEVENTF_HWHEEL = 0x1000 + MOUSEEVENTF_MOVE = 0x0001 + MOUSEEVENTF_MOVE_NOCOALESCE = 0x2000 + MOUSEEVENTF_LEFTDOWN = 0x0002 + MOUSEEVENTF_LEFTUP = 0x0004 + MOUSEEVENTF_RIGHTDOWN = 0x0008 + MOUSEEVENTF_RIGHTUP = 0x0010 + MOUSEEVENTF_MIDDLEDOWN = 0x0020 + MOUSEEVENTF_MIDDLEUP = 0x0040 + MOUSEEVENTF_VIRTUALDESK = 0x4000 + MOUSEEVENTF_WHEEL = 0x0800 + MOUSEEVENTF_XDOWN = 0x0080 + MOUSEEVENTF_XUP = 0x0100 +) + +// KEYBDINPUT DwFlags +const ( + KEYEVENTF_EXTENDEDKEY = 0x0001 + KEYEVENTF_KEYUP = 0x0002 + KEYEVENTF_SCANCODE = 0x0008 + KEYEVENTF_UNICODE = 0x0004 +) + +// GetWindow uCmd constants +const ( + GW_CHILD = 5 + GW_ENABLEDPOPUP = 6 + GW_HWNDFIRST = 0 + GW_HWNDLAST = 1 + GW_HWNDNEXT = 2 + GW_HWNDPREV = 3 + GW_OWNER = 4 +) + +// Standard clipboard formats +const ( + CF_BITMAP = 2 + CF_DIB = 8 + CF_DIBV5 = 17 + CF_DIF = 5 + CF_DSPBITMAP = 0x0082 + CF_DSPENHMETAFILE = 0x008E + CF_DSPMETAFILEPICT = 0x0083 + CF_DSPTEXT = 0x0081 + CF_ENHMETAFILE = 14 + CF_GDIOBJFIRST = 0x0300 + CF_GDIOBJLAST = 0x03FF + CF_HDROP = 15 + CF_LOCALE = 16 + CF_METAFILEPICT = 3 + CF_OEMTEXT = 7 + CF_OWNERDISPLAY = 0x0080 + CF_PALETTE = 9 + CF_PENDATA = 10 + CF_PRIVATEFIRST = 0x0200 + CF_PRIVATELAST = 0x02FF + CF_RIFF = 11 + CF_SYLK = 4 + CF_TEXT = 1 + CF_TIFF = 6 + CF_UNICODETEXT = 13 + CF_WAVE = 12 +) + +// ScrollBar constants +const ( + SB_HORZ = 0 + SB_VERT = 1 + SB_CTL = 2 + SB_BOTH = 3 +) + +// ScrollBar commands +const ( + SB_LINEUP = 0 + SB_LINELEFT = 0 + SB_LINEDOWN = 1 + SB_LINERIGHT = 1 + SB_PAGEUP = 2 + SB_PAGELEFT = 2 + SB_PAGEDOWN = 3 + SB_PAGERIGHT = 3 + SB_THUMBPOSITION = 4 + SB_THUMBTRACK = 5 + SB_TOP = 6 + SB_LEFT = 6 + SB_BOTTOM = 7 + SB_RIGHT = 7 + SB_ENDSCROLL = 8 +) + +// [Get|Set]ScrollInfo mask constants +const ( + SIF_RANGE = 1 + SIF_PAGE = 2 + SIF_POS = 4 + SIF_DISABLENOSCROLL = 8 + SIF_TRACKPOS = 16 + SIF_ALL = SIF_RANGE + SIF_PAGE + SIF_POS + SIF_TRACKPOS +) + +// DrawIconEx flags +const ( + DI_COMPAT = 0x0004 + DI_DEFAULTSIZE = 0x0008 + DI_IMAGE = 0x0002 + DI_MASK = 0x0001 + DI_NOMIRROR = 0x0010 + DI_NORMAL = DI_IMAGE | DI_MASK +) + +// WM_NCHITTEST constants +const ( + HTBORDER = 18 + HTBOTTOM = 15 + HTBOTTOMLEFT = 16 + HTBOTTOMRIGHT = 17 + HTCAPTION = 2 + HTCLIENT = 1 + HTCLOSE = 20 + HTERROR = -2 + HTGROWBOX = 4 + HTHELP = 21 + HTHSCROLL = 6 + HTLEFT = 10 + HTMENU = 5 + HTMAXBUTTON = 9 + HTMINBUTTON = 8 + HTNOWHERE = 0 + HTREDUCE = 8 + HTRIGHT = 11 + HTSIZE = 4 + HTSYSMENU = 3 + HTTOP = 12 + HTTOPLEFT = 13 + HTTOPRIGHT = 14 + HTTRANSPARENT = -1 + HTVSCROLL = 7 + HTZOOM = 9 +) + +type NMBCDROPDOWN struct { + Hdr NMHDR + RcButton RECT +} + +type MONITORINFO struct { + CbSize uint32 + RcMonitor RECT + RcWork RECT + DwFlags uint32 +} + +type ( + HACCEL HANDLE + HCURSOR HANDLE + HDWP HANDLE + HICON HANDLE + HMENU HANDLE + HMONITOR HANDLE + HRAWINPUT HANDLE + HWND HANDLE +) + +type MSG struct { + HWnd HWND + Message uint32 + WParam uintptr + LParam uintptr + Time uint32 + Pt POINT +} + +type RAWINPUTDEVICE struct { + UsUsagePage uint16 + UsUsage uint16 + DwFlags uint32 + HwndTarget HWND +} + +type RAWINPUTHEADER struct { + DwType uint32 + DwSize uint32 + HDevice HANDLE + WParam uintptr +} + +type RAWINPUTMOUSE struct { + Header RAWINPUTHEADER + Data RAWMOUSE +} + +type RAWINPUTKEYBOARD struct { + Header RAWINPUTHEADER + Data RAWKEYBOARD +} + +type RAWINPUTHID struct { + Header RAWINPUTHEADER + Data RAWHID +} + +type RAWMOUSE struct { + UsFlags uint16 + UsButtonFlags uint16 + UsButtonData uint16 + Pad_cgo_0 [2]byte + UlRawButtons uint32 + LLastX int32 + LLastY int32 + UlExtraInformation uint32 +} + +type RAWKEYBOARD struct { + MakeCode uint16 + Flags uint16 + Reserved int16 + VKey uint16 + Message uint32 + ExtraInformation uint32 +} + +type RAWHID struct { + DwSizeHid uint32 + DwCount uint32 + BRawData [1]byte +} + +type NMHDR struct { + HwndFrom HWND + IdFrom uintptr + Code uint32 +} + +type CREATESTRUCT struct { + CreateParams uintptr + Instance HINSTANCE + Menu HMENU + Parent HWND + Cy int32 + Cx int32 + Y int32 + X int32 + Style int32 + Name, ClassName uintptr + ExStyle uint32 +} + +type WNDCLASSEX struct { + CbSize uint32 + Style uint32 + LpfnWndProc uintptr + CbClsExtra int32 + CbWndExtra int32 + HInstance HINSTANCE + HIcon HICON + HCursor HCURSOR + HbrBackground HBRUSH + LpszMenuName *uint16 + LpszClassName *uint16 + HIconSm HICON +} + +type TPMPARAMS struct { + CbSize uint32 + RcExclude RECT +} + +type WINDOWPLACEMENT struct { + Length uint32 + Flags uint32 + ShowCmd uint32 + PtMinPosition POINT + PtMaxPosition POINT + RcNormalPosition RECT +} + +type DRAWTEXTPARAMS struct { + CbSize uint32 + ITabLength int32 + ILeftMargin int32 + IRightMargin int32 + UiLengthDrawn uint32 +} + +type PAINTSTRUCT struct { + Hdc HDC + FErase BOOL + RcPaint RECT + FRestore BOOL + FIncUpdate BOOL + RgbReserved [32]byte +} + +type MINMAXINFO struct { + PtReserved POINT + PtMaxSize POINT + PtMaxPosition POINT + PtMinTrackSize POINT + PtMaxTrackSize POINT +} + +type NONCLIENTMETRICS struct { + CbSize uint32 + IBorderWidth int32 + IScrollWidth int32 + IScrollHeight int32 + ICaptionWidth int32 + ICaptionHeight int32 + LfCaptionFont LOGFONT + ISmCaptionWidth int32 + ISmCaptionHeight int32 + LfSmCaptionFont LOGFONT + IMenuWidth int32 + IMenuHeight int32 + LfMenuFont LOGFONT + LfStatusFont LOGFONT + LfMessageFont LOGFONT +} + +type MEASUREITEMSTRUCT struct { + CtlType uint32 + CtlID uint32 + ItemID int32 + ItemWidth uint32 + ItemHeight uint32 + ItemData uintptr +} + +type DRAWITEMSTRUCT struct { + CtlType uint32 + CtlID uint32 + ItemID int32 + ItemAction uint32 + ItemState uint32 + HwndItem HWND + HDC HDC + RcItem RECT + ItemData uintptr +} + +type ICONINFO struct { + FIcon BOOL + XHotspot uint32 + YHotspot uint32 + HbmMask HBITMAP + HbmColor HBITMAP +} + +type MOUSE_INPUT struct { + Type uint32 + Mi MOUSEINPUT +} + +type MOUSEINPUT struct { + Dx int32 + Dy int32 + MouseData uint32 + DwFlags uint32 + Time uint32 + DwExtraInfo uintptr +} + +type KEYBD_INPUT struct { + Type uint32 + Ki KEYBDINPUT +} + +type KEYBDINPUT struct { + WVk uint16 + WScan uint16 + DwFlags uint32 + Time uint32 + DwExtraInfo uintptr + Unused [8]byte +} + +type HARDWARE_INPUT struct { + Type uint32 + Hi HARDWAREINPUT +} + +type HARDWAREINPUT struct { + UMsg uint32 + WParamL uint16 + WParamH uint16 + Unused [16]byte +} + +type SCROLLINFO struct { + CbSize uint32 + FMask uint32 + NMin int32 + NMax int32 + NPage uint32 + NPos int32 + NTrackPos int32 +} + +func GET_X_LPARAM(lp uintptr) int32 { + return int32(int16(LOWORD(uint32(lp)))) +} + +func GET_Y_LPARAM(lp uintptr) int32 { + return int32(int16(HIWORD(uint32(lp)))) +} + +var ( + // Library + libuser32 uintptr + + // Functions + addClipboardFormatListener uintptr + adjustWindowRect uintptr + beginDeferWindowPos uintptr + beginPaint uintptr + callWindowProc uintptr + clientToScreen uintptr + closeClipboard uintptr + createDialogParam uintptr + createIconIndirect uintptr + createMenu uintptr + createPopupMenu uintptr + createWindowEx uintptr + deferWindowPos uintptr + defWindowProc uintptr + destroyIcon uintptr + destroyMenu uintptr + destroyWindow uintptr + dialogBoxParam uintptr + dispatchMessage uintptr + drawIconEx uintptr + drawMenuBar uintptr + drawFocusRect uintptr + drawTextEx uintptr + emptyClipboard uintptr + enableWindow uintptr + endDeferWindowPos uintptr + endDialog uintptr + endPaint uintptr + enumChildWindows uintptr + findWindow uintptr + getActiveWindow uintptr + getAncestor uintptr + getCaretPos uintptr + getClientRect uintptr + getClipboardData uintptr + getCursorPos uintptr + getDC uintptr + getFocus uintptr + getForegroundWindow uintptr + getKeyState uintptr + getMenuInfo uintptr + getMessage uintptr + getMonitorInfo uintptr + getParent uintptr + getRawInputData uintptr + getScrollInfo uintptr + getSysColor uintptr + getSysColorBrush uintptr + getSystemMetrics uintptr + getWindow uintptr + getWindowLong uintptr + getWindowLongPtr uintptr + getWindowPlacement uintptr + getWindowRect uintptr + insertMenuItem uintptr + invalidateRect uintptr + isChild uintptr + isClipboardFormatAvailable uintptr + isDialogMessage uintptr + isWindowEnabled uintptr + isWindowVisible uintptr + killTimer uintptr + loadCursor uintptr + loadIcon uintptr + loadImage uintptr + loadMenu uintptr + loadString uintptr + messageBeep uintptr + messageBox uintptr + monitorFromWindow uintptr + moveWindow uintptr + unregisterClass uintptr + openClipboard uintptr + peekMessage uintptr + postMessage uintptr + postQuitMessage uintptr + registerClassEx uintptr + registerRawInputDevices uintptr + registerWindowMessage uintptr + releaseCapture uintptr + releaseDC uintptr + removeMenu uintptr + screenToClient uintptr + sendDlgItemMessage uintptr + sendInput uintptr + sendMessage uintptr + setActiveWindow uintptr + setCapture uintptr + setClipboardData uintptr + setCursor uintptr + setCursorPos uintptr + setFocus uintptr + setForegroundWindow uintptr + setMenu uintptr + setMenuInfo uintptr + setMenuItemInfo uintptr + setParent uintptr + setRect uintptr + setScrollInfo uintptr + setTimer uintptr + setWindowLong uintptr + setWindowLongPtr uintptr + setWindowPlacement uintptr + setWindowPos uintptr + showWindow uintptr + systemParametersInfo uintptr + trackPopupMenuEx uintptr + translateMessage uintptr + updateWindow uintptr + windowFromPoint uintptr +) + +func init() { + is64bit := unsafe.Sizeof(uintptr(0)) == 8 + + // Library + libuser32 = MustLoadLibrary("user32.dll") + + // Functions + addClipboardFormatListener, _ = syscall.GetProcAddress(syscall.Handle(libuser32), "AddClipboardFormatListener") + adjustWindowRect = MustGetProcAddress(libuser32, "AdjustWindowRect") + beginDeferWindowPos = MustGetProcAddress(libuser32, "BeginDeferWindowPos") + beginPaint = MustGetProcAddress(libuser32, "BeginPaint") + callWindowProc = MustGetProcAddress(libuser32, "CallWindowProcW") + clientToScreen = MustGetProcAddress(libuser32, "ClientToScreen") + closeClipboard = MustGetProcAddress(libuser32, "CloseClipboard") + createDialogParam = MustGetProcAddress(libuser32, "CreateDialogParamW") + createIconIndirect = MustGetProcAddress(libuser32, "CreateIconIndirect") + createMenu = MustGetProcAddress(libuser32, "CreateMenu") + createPopupMenu = MustGetProcAddress(libuser32, "CreatePopupMenu") + createWindowEx = MustGetProcAddress(libuser32, "CreateWindowExW") + deferWindowPos = MustGetProcAddress(libuser32, "DeferWindowPos") + defWindowProc = MustGetProcAddress(libuser32, "DefWindowProcW") + destroyIcon = MustGetProcAddress(libuser32, "DestroyIcon") + destroyMenu = MustGetProcAddress(libuser32, "DestroyMenu") + destroyWindow = MustGetProcAddress(libuser32, "DestroyWindow") + dialogBoxParam = MustGetProcAddress(libuser32, "DialogBoxParamW") + dispatchMessage = MustGetProcAddress(libuser32, "DispatchMessageW") + drawIconEx = MustGetProcAddress(libuser32, "DrawIconEx") + drawFocusRect = MustGetProcAddress(libuser32, "DrawFocusRect") + drawMenuBar = MustGetProcAddress(libuser32, "DrawMenuBar") + drawTextEx = MustGetProcAddress(libuser32, "DrawTextExW") + emptyClipboard = MustGetProcAddress(libuser32, "EmptyClipboard") + enableWindow = MustGetProcAddress(libuser32, "EnableWindow") + endDeferWindowPos = MustGetProcAddress(libuser32, "EndDeferWindowPos") + endDialog = MustGetProcAddress(libuser32, "EndDialog") + endPaint = MustGetProcAddress(libuser32, "EndPaint") + enumChildWindows = MustGetProcAddress(libuser32, "EnumChildWindows") + findWindow = MustGetProcAddress(libuser32, "FindWindowW") + getActiveWindow = MustGetProcAddress(libuser32, "GetActiveWindow") + getAncestor = MustGetProcAddress(libuser32, "GetAncestor") + getCaretPos = MustGetProcAddress(libuser32, "GetCaretPos") + getClientRect = MustGetProcAddress(libuser32, "GetClientRect") + getClipboardData = MustGetProcAddress(libuser32, "GetClipboardData") + getCursorPos = MustGetProcAddress(libuser32, "GetCursorPos") + getDC = MustGetProcAddress(libuser32, "GetDC") + getFocus = MustGetProcAddress(libuser32, "GetFocus") + getForegroundWindow = MustGetProcAddress(libuser32, "GetForegroundWindow") + getKeyState = MustGetProcAddress(libuser32, "GetKeyState") + getMenuInfo = MustGetProcAddress(libuser32, "GetMenuInfo") + getMessage = MustGetProcAddress(libuser32, "GetMessageW") + getMonitorInfo = MustGetProcAddress(libuser32, "GetMonitorInfoW") + getParent = MustGetProcAddress(libuser32, "GetParent") + getRawInputData = MustGetProcAddress(libuser32, "GetRawInputData") + getScrollInfo = MustGetProcAddress(libuser32, "GetScrollInfo") + getSysColor = MustGetProcAddress(libuser32, "GetSysColor") + getSysColorBrush = MustGetProcAddress(libuser32, "GetSysColorBrush") + getSystemMetrics = MustGetProcAddress(libuser32, "GetSystemMetrics") + getWindow = MustGetProcAddress(libuser32, "GetWindow") + getWindowLong = MustGetProcAddress(libuser32, "GetWindowLongW") + // On 32 bit GetWindowLongPtrW is not available + if is64bit { + getWindowLongPtr = MustGetProcAddress(libuser32, "GetWindowLongPtrW") + } else { + getWindowLongPtr = MustGetProcAddress(libuser32, "GetWindowLongW") + } + getWindowPlacement = MustGetProcAddress(libuser32, "GetWindowPlacement") + getWindowRect = MustGetProcAddress(libuser32, "GetWindowRect") + insertMenuItem = MustGetProcAddress(libuser32, "InsertMenuItemW") + invalidateRect = MustGetProcAddress(libuser32, "InvalidateRect") + isChild = MustGetProcAddress(libuser32, "IsChild") + isClipboardFormatAvailable = MustGetProcAddress(libuser32, "IsClipboardFormatAvailable") + isDialogMessage = MustGetProcAddress(libuser32, "IsDialogMessageW") + isWindowEnabled = MustGetProcAddress(libuser32, "IsWindowEnabled") + isWindowVisible = MustGetProcAddress(libuser32, "IsWindowVisible") + killTimer = MustGetProcAddress(libuser32, "KillTimer") + loadCursor = MustGetProcAddress(libuser32, "LoadCursorW") + loadIcon = MustGetProcAddress(libuser32, "LoadIconW") + loadImage = MustGetProcAddress(libuser32, "LoadImageW") + loadMenu = MustGetProcAddress(libuser32, "LoadMenuW") + loadString = MustGetProcAddress(libuser32, "LoadStringW") + messageBeep = MustGetProcAddress(libuser32, "MessageBeep") + messageBox = MustGetProcAddress(libuser32, "MessageBoxW") + monitorFromWindow = MustGetProcAddress(libuser32, "MonitorFromWindow") + moveWindow = MustGetProcAddress(libuser32, "MoveWindow") + unregisterClass = MustGetProcAddress(libuser32, "UnregisterClassW") + openClipboard = MustGetProcAddress(libuser32, "OpenClipboard") + peekMessage = MustGetProcAddress(libuser32, "PeekMessageW") + postMessage = MustGetProcAddress(libuser32, "PostMessageW") + postQuitMessage = MustGetProcAddress(libuser32, "PostQuitMessage") + registerClassEx = MustGetProcAddress(libuser32, "RegisterClassExW") + registerRawInputDevices = MustGetProcAddress(libuser32, "RegisterRawInputDevices") + registerWindowMessage = MustGetProcAddress(libuser32, "RegisterWindowMessageW") + releaseCapture = MustGetProcAddress(libuser32, "ReleaseCapture") + releaseDC = MustGetProcAddress(libuser32, "ReleaseDC") + removeMenu = MustGetProcAddress(libuser32, "RemoveMenu") + screenToClient = MustGetProcAddress(libuser32, "ScreenToClient") + sendDlgItemMessage = MustGetProcAddress(libuser32, "SendDlgItemMessageW") + sendInput = MustGetProcAddress(libuser32, "SendInput") + sendMessage = MustGetProcAddress(libuser32, "SendMessageW") + setActiveWindow = MustGetProcAddress(libuser32, "SetActiveWindow") + setCapture = MustGetProcAddress(libuser32, "SetCapture") + setClipboardData = MustGetProcAddress(libuser32, "SetClipboardData") + setCursor = MustGetProcAddress(libuser32, "SetCursor") + setCursorPos = MustGetProcAddress(libuser32, "SetCursorPos") + setFocus = MustGetProcAddress(libuser32, "SetFocus") + setForegroundWindow = MustGetProcAddress(libuser32, "SetForegroundWindow") + setMenu = MustGetProcAddress(libuser32, "SetMenu") + setMenuInfo = MustGetProcAddress(libuser32, "SetMenuInfo") + setMenuItemInfo = MustGetProcAddress(libuser32, "SetMenuItemInfoW") + setRect = MustGetProcAddress(libuser32, "SetRect") + setParent = MustGetProcAddress(libuser32, "SetParent") + setScrollInfo = MustGetProcAddress(libuser32, "SetScrollInfo") + setTimer = MustGetProcAddress(libuser32, "SetTimer") + setWindowLong = MustGetProcAddress(libuser32, "SetWindowLongW") + // On 32 bit SetWindowLongPtrW is not available + if is64bit { + setWindowLongPtr = MustGetProcAddress(libuser32, "SetWindowLongPtrW") + } else { + setWindowLongPtr = MustGetProcAddress(libuser32, "SetWindowLongW") + } + setWindowPlacement = MustGetProcAddress(libuser32, "SetWindowPlacement") + setWindowPos = MustGetProcAddress(libuser32, "SetWindowPos") + showWindow = MustGetProcAddress(libuser32, "ShowWindow") + systemParametersInfo = MustGetProcAddress(libuser32, "SystemParametersInfoW") + trackPopupMenuEx = MustGetProcAddress(libuser32, "TrackPopupMenuEx") + translateMessage = MustGetProcAddress(libuser32, "TranslateMessage") + updateWindow = MustGetProcAddress(libuser32, "UpdateWindow") + windowFromPoint = MustGetProcAddress(libuser32, "WindowFromPoint") +} + +func AddClipboardFormatListener(hwnd HWND) bool { + if addClipboardFormatListener == 0 { + return false + } + + ret, _, _ := syscall.Syscall(addClipboardFormatListener, 1, + uintptr(hwnd), + 0, + 0) + + return ret != 0 +} + +func AdjustWindowRect(lpRect *RECT, dwStyle uint32, bMenu bool) bool { + ret, _, _ := syscall.Syscall(adjustWindowRect, 3, + uintptr(unsafe.Pointer(lpRect)), + uintptr(dwStyle), + uintptr(BoolToBOOL(bMenu))) + + return ret != 0 +} + +func BeginDeferWindowPos(nNumWindows int32) HDWP { + ret, _, _ := syscall.Syscall(beginDeferWindowPos, 1, + uintptr(nNumWindows), + 0, + 0) + + return HDWP(ret) +} + +func BeginPaint(hwnd HWND, lpPaint *PAINTSTRUCT) HDC { + ret, _, _ := syscall.Syscall(beginPaint, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(lpPaint)), + 0) + + return HDC(ret) +} + +func CallWindowProc(lpPrevWndFunc uintptr, hWnd HWND, Msg uint32, wParam, lParam uintptr) uintptr { + ret, _, _ := syscall.Syscall6(callWindowProc, 5, + lpPrevWndFunc, + uintptr(hWnd), + uintptr(Msg), + wParam, + lParam, + 0) + + return ret +} + +func ClientToScreen(hwnd HWND, lpPoint *POINT) bool { + ret, _, _ := syscall.Syscall(clientToScreen, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(lpPoint)), + 0) + + return ret != 0 +} + +func CloseClipboard() bool { + ret, _, _ := syscall.Syscall(closeClipboard, 0, + 0, + 0, + 0) + + return ret != 0 +} + +func CreateDialogParam(instRes HINSTANCE, name *uint16, parent HWND, + proc, param uintptr) HWND { + ret, _, _ := syscall.Syscall6(createDialogParam, 5, + uintptr(instRes), + uintptr(unsafe.Pointer(name)), + uintptr(parent), + proc, + param, + 0) + + return HWND(ret) +} + +func CreateIconIndirect(lpiconinfo *ICONINFO) HICON { + ret, _, _ := syscall.Syscall(createIconIndirect, 1, + uintptr(unsafe.Pointer(lpiconinfo)), + 0, + 0) + + return HICON(ret) +} + +func CreateMenu() HMENU { + ret, _, _ := syscall.Syscall(createMenu, 0, + 0, + 0, + 0) + + return HMENU(ret) +} + +func CreatePopupMenu() HMENU { + ret, _, _ := syscall.Syscall(createPopupMenu, 0, + 0, + 0, + 0) + + return HMENU(ret) +} + +func CreateWindowEx(dwExStyle uint32, lpClassName, lpWindowName *uint16, dwStyle uint32, x, y, nWidth, nHeight int32, hWndParent HWND, hMenu HMENU, hInstance HINSTANCE, lpParam unsafe.Pointer) HWND { + ret, _, _ := syscall.Syscall12(createWindowEx, 12, + uintptr(dwExStyle), + uintptr(unsafe.Pointer(lpClassName)), + uintptr(unsafe.Pointer(lpWindowName)), + uintptr(dwStyle), + uintptr(x), + uintptr(y), + uintptr(nWidth), + uintptr(nHeight), + uintptr(hWndParent), + uintptr(hMenu), + uintptr(hInstance), + uintptr(lpParam)) + + return HWND(ret) +} + +func DeferWindowPos(hWinPosInfo HDWP, hWnd, hWndInsertAfter HWND, x, y, cx, cy int32, uFlags uint32) HDWP { + ret, _, _ := syscall.Syscall9(deferWindowPos, 8, + uintptr(hWinPosInfo), + uintptr(hWnd), + uintptr(hWndInsertAfter), + uintptr(x), + uintptr(y), + uintptr(cx), + uintptr(cy), + uintptr(uFlags), + 0) + + return HDWP(ret) +} + +func DefWindowProc(hWnd HWND, Msg uint32, wParam, lParam uintptr) uintptr { + ret, _, _ := syscall.Syscall6(defWindowProc, 4, + uintptr(hWnd), + uintptr(Msg), + wParam, + lParam, + 0, + 0) + + return ret +} + +func DestroyIcon(hIcon HICON) bool { + ret, _, _ := syscall.Syscall(destroyIcon, 1, + uintptr(hIcon), + 0, + 0) + + return ret != 0 +} + +func DestroyMenu(hMenu HMENU) bool { + ret, _, _ := syscall.Syscall(destroyMenu, 1, + uintptr(hMenu), + 0, + 0) + + return ret != 0 +} + +func DestroyWindow(hWnd HWND) bool { + ret, _, _ := syscall.Syscall(destroyWindow, 1, + uintptr(hWnd), + 0, + 0) + + return ret != 0 +} + +func DialogBoxParam(instRes HINSTANCE, name *uint16, parent HWND, proc, param uintptr) int { + ret, _, _ := syscall.Syscall6(dialogBoxParam, 5, + uintptr(instRes), + uintptr(unsafe.Pointer(name)), + uintptr(parent), + proc, + param, + 0) + + return int(ret) +} + +func DispatchMessage(msg *MSG) uintptr { + ret, _, _ := syscall.Syscall(dispatchMessage, 1, + uintptr(unsafe.Pointer(msg)), + 0, + 0) + + return ret +} + +func DrawFocusRect(hDC HDC, lprc *RECT) bool { + ret, _, _ := syscall.Syscall(drawFocusRect, 2, + uintptr(hDC), + uintptr(unsafe.Pointer(lprc)), + 0) + + return ret != 0 +} + +func DrawIconEx(hdc HDC, xLeft, yTop int32, hIcon HICON, cxWidth, cyWidth int32, istepIfAniCur uint32, hbrFlickerFreeDraw HBRUSH, diFlags uint32) bool { + ret, _, _ := syscall.Syscall9(drawIconEx, 9, + uintptr(hdc), + uintptr(xLeft), + uintptr(yTop), + uintptr(hIcon), + uintptr(cxWidth), + uintptr(cyWidth), + uintptr(istepIfAniCur), + uintptr(hbrFlickerFreeDraw), + uintptr(diFlags)) + + return ret != 0 +} + +func DrawMenuBar(hWnd HWND) bool { + ret, _, _ := syscall.Syscall(drawMenuBar, 1, + uintptr(hWnd), + 0, + 0) + + return ret != 0 +} + +func DrawTextEx(hdc HDC, lpchText *uint16, cchText int32, lprc *RECT, dwDTFormat uint32, lpDTParams *DRAWTEXTPARAMS) int32 { + ret, _, _ := syscall.Syscall6(drawTextEx, 6, + uintptr(hdc), + uintptr(unsafe.Pointer(lpchText)), + uintptr(cchText), + uintptr(unsafe.Pointer(lprc)), + uintptr(dwDTFormat), + uintptr(unsafe.Pointer(lpDTParams))) + + return int32(ret) +} + +func EmptyClipboard() bool { + ret, _, _ := syscall.Syscall(emptyClipboard, 0, + 0, + 0, + 0) + + return ret != 0 +} + +func EnableWindow(hWnd HWND, bEnable bool) bool { + ret, _, _ := syscall.Syscall(enableWindow, 2, + uintptr(hWnd), + uintptr(BoolToBOOL(bEnable)), + 0) + + return ret != 0 +} + +func EndDeferWindowPos(hWinPosInfo HDWP) bool { + ret, _, _ := syscall.Syscall(endDeferWindowPos, 1, + uintptr(hWinPosInfo), + 0, + 0) + + return ret != 0 +} + +func EndDialog(hwnd HWND, result int) bool { + ret, _, _ := syscall.Syscall(endDialog, 2, + uintptr(hwnd), + uintptr(result), + 0) + + return ret != 0 +} + +func EndPaint(hwnd HWND, lpPaint *PAINTSTRUCT) bool { + ret, _, _ := syscall.Syscall(endPaint, 2, + uintptr(hwnd), + uintptr(unsafe.Pointer(lpPaint)), + 0) + + return ret != 0 +} + +func EnumChildWindows(hWndParent HWND, lpEnumFunc, lParam uintptr) bool { + ret, _, _ := syscall.Syscall(enumChildWindows, 3, + uintptr(hWndParent), + lpEnumFunc, + lParam) + + return ret != 0 +} + +func FindWindow(lpClassName, lpWindowName *uint16) HWND { + ret, _, _ := syscall.Syscall(findWindow, 2, + uintptr(unsafe.Pointer(lpClassName)), + uintptr(unsafe.Pointer(lpWindowName)), + 0) + + return HWND(ret) +} + +func GetActiveWindow() HWND { + ret, _, _ := syscall.Syscall(getActiveWindow, 0, + 0, + 0, + 0) + + return HWND(ret) +} + +func GetAncestor(hWnd HWND, gaFlags uint32) HWND { + ret, _, _ := syscall.Syscall(getAncestor, 2, + uintptr(hWnd), + uintptr(gaFlags), + 0) + + return HWND(ret) +} + +func GetCaretPos(lpPoint *POINT) bool { + ret, _, _ := syscall.Syscall(getCaretPos, 1, + uintptr(unsafe.Pointer(lpPoint)), + 0, + 0) + + return ret != 0 +} + +func GetClientRect(hWnd HWND, rect *RECT) bool { + ret, _, _ := syscall.Syscall(getClientRect, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(rect)), + 0) + + return ret != 0 +} + +func GetClipboardData(uFormat uint32) HANDLE { + ret, _, _ := syscall.Syscall(getClipboardData, 1, + uintptr(uFormat), + 0, + 0) + + return HANDLE(ret) +} + +func GetCursorPos(lpPoint *POINT) bool { + ret, _, _ := syscall.Syscall(getCursorPos, 1, + uintptr(unsafe.Pointer(lpPoint)), + 0, + 0) + + return ret != 0 +} + +func GetDC(hWnd HWND) HDC { + ret, _, _ := syscall.Syscall(getDC, 1, + uintptr(hWnd), + 0, + 0) + + return HDC(ret) +} + +func GetFocus() HWND { + ret, _, _ := syscall.Syscall(getFocus, 0, + 0, + 0, + 0) + + return HWND(ret) +} + +func GetForegroundWindow() HWND { + ret, _, _ := syscall.Syscall(getForegroundWindow, 0, + 0, + 0, + 0) + + return HWND(ret) +} + +func GetKeyState(nVirtKey int32) int16 { + ret, _, _ := syscall.Syscall(getKeyState, 1, + uintptr(nVirtKey), + 0, + 0) + + return int16(ret) +} + +func GetMenuInfo(hmenu HMENU, lpcmi *MENUINFO) bool { + ret, _, _ := syscall.Syscall(getMenuInfo, 2, + uintptr(hmenu), + uintptr(unsafe.Pointer(lpcmi)), + 0) + + return ret != 0 +} + +func GetMessage(msg *MSG, hWnd HWND, msgFilterMin, msgFilterMax uint32) BOOL { + ret, _, _ := syscall.Syscall6(getMessage, 4, + uintptr(unsafe.Pointer(msg)), + uintptr(hWnd), + uintptr(msgFilterMin), + uintptr(msgFilterMax), + 0, + 0) + + return BOOL(ret) +} + +func GetMonitorInfo(hMonitor HMONITOR, lpmi *MONITORINFO) bool { + ret, _, _ := syscall.Syscall(getMonitorInfo, 2, + uintptr(hMonitor), + uintptr(unsafe.Pointer(lpmi)), + 0) + + return ret != 0 +} + +func GetParent(hWnd HWND) HWND { + ret, _, _ := syscall.Syscall(getParent, 1, + uintptr(hWnd), + 0, + 0) + + return HWND(ret) +} + +func GetRawInputData(hRawInput HRAWINPUT, uiCommand uint32, pData unsafe.Pointer, pcbSize *uint32, cBSizeHeader uint32) uint32 { + ret, _, _ := syscall.Syscall6(getRawInputData, 5, + uintptr(hRawInput), + uintptr(uiCommand), + uintptr(pData), + uintptr(unsafe.Pointer(pcbSize)), + uintptr(cBSizeHeader), + 0) + + return uint32(ret) +} + +func GetScrollInfo(hwnd HWND, fnBar int32, lpsi *SCROLLINFO) bool { + ret, _, _ := syscall.Syscall(getScrollInfo, 3, + uintptr(hwnd), + uintptr(fnBar), + uintptr(unsafe.Pointer(lpsi))) + + return ret != 0 +} + +func GetSysColor(nIndex int) uint32 { + ret, _, _ := syscall.Syscall(getSysColor, 1, + uintptr(nIndex), + 0, + 0) + + return uint32(ret) +} + +func GetSysColorBrush(nIndex int) HBRUSH { + ret, _, _ := syscall.Syscall(getSysColorBrush, 1, + uintptr(nIndex), + 0, + 0) + + return HBRUSH(ret) +} + +func GetSystemMetrics(nIndex int32) int32 { + ret, _, _ := syscall.Syscall(getSystemMetrics, 1, + uintptr(nIndex), + 0, + 0) + + return int32(ret) +} + +func GetWindow(hWnd HWND, uCmd uint32) HWND { + ret, _, _ := syscall.Syscall(getWindow, 2, + uintptr(hWnd), + uintptr(uCmd), + 0) + + return HWND(ret) +} + +func GetWindowLong(hWnd HWND, index int32) int32 { + ret, _, _ := syscall.Syscall(getWindowLong, 2, + uintptr(hWnd), + uintptr(index), + 0) + + return int32(ret) +} + +func GetWindowLongPtr(hWnd HWND, index int32) uintptr { + ret, _, _ := syscall.Syscall(getWindowLongPtr, 2, + uintptr(hWnd), + uintptr(index), + 0) + + return ret +} + +func GetWindowPlacement(hWnd HWND, lpwndpl *WINDOWPLACEMENT) bool { + ret, _, _ := syscall.Syscall(getWindowPlacement, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpwndpl)), + 0) + + return ret != 0 +} + +func GetWindowRect(hWnd HWND, rect *RECT) bool { + ret, _, _ := syscall.Syscall(getWindowRect, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(rect)), + 0) + + return ret != 0 +} + +func InsertMenuItem(hMenu HMENU, uItem uint32, fByPosition bool, lpmii *MENUITEMINFO) bool { + ret, _, _ := syscall.Syscall6(insertMenuItem, 4, + uintptr(hMenu), + uintptr(uItem), + uintptr(BoolToBOOL(fByPosition)), + uintptr(unsafe.Pointer(lpmii)), + 0, + 0) + + return ret != 0 +} + +func InvalidateRect(hWnd HWND, lpRect *RECT, bErase bool) bool { + ret, _, _ := syscall.Syscall(invalidateRect, 3, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpRect)), + uintptr(BoolToBOOL(bErase))) + + return ret != 0 +} + +func IsChild(hWndParent, hWnd HWND) bool { + ret, _, _ := syscall.Syscall(isChild, 2, + uintptr(hWndParent), + uintptr(hWnd), + 0) + + return ret != 0 +} + +func IsClipboardFormatAvailable(format uint32) bool { + ret, _, _ := syscall.Syscall(isClipboardFormatAvailable, 1, + uintptr(format), + 0, + 0) + + return ret != 0 +} + +func IsDialogMessage(hWnd HWND, msg *MSG) bool { + ret, _, _ := syscall.Syscall(isDialogMessage, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(msg)), + 0) + + return ret != 0 +} + +func IsWindowEnabled(hWnd HWND) bool { + ret, _, _ := syscall.Syscall(isWindowEnabled, 1, + uintptr(hWnd), + 0, + 0) + + return ret != 0 +} + +func IsWindowVisible(hWnd HWND) bool { + ret, _, _ := syscall.Syscall(isWindowVisible, 1, + uintptr(hWnd), + 0, + 0) + + return ret != 0 +} + +func KillTimer(hWnd HWND, uIDEvent uintptr) bool { + ret, _, _ := syscall.Syscall(killTimer, 2, + uintptr(hWnd), + uIDEvent, + 0) + + return ret != 0 +} + +func LoadCursor(hInstance HINSTANCE, lpCursorName *uint16) HCURSOR { + ret, _, _ := syscall.Syscall(loadCursor, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(lpCursorName)), + 0) + + return HCURSOR(ret) +} + +func LoadIcon(hInstance HINSTANCE, lpIconName *uint16) HICON { + ret, _, _ := syscall.Syscall(loadIcon, 2, + uintptr(hInstance), + uintptr(unsafe.Pointer(lpIconName)), + 0) + + return HICON(ret) +} + +func LoadImage(hinst HINSTANCE, lpszName *uint16, uType uint32, cxDesired, cyDesired int32, fuLoad uint32) HANDLE { + ret, _, _ := syscall.Syscall6(loadImage, 6, + uintptr(hinst), + uintptr(unsafe.Pointer(lpszName)), + uintptr(uType), + uintptr(cxDesired), + uintptr(cyDesired), + uintptr(fuLoad)) + + return HANDLE(ret) +} + +func LoadMenu(hinst HINSTANCE, name *uint16) HMENU { + ret, _, _ := syscall.Syscall(loadMenu, 2, + uintptr(hinst), + uintptr(unsafe.Pointer(name)), + 0) + + return HMENU(ret) +} + +func LoadString(instRes HINSTANCE, id uint32, buf *uint16, length int32) int32 { + ret, _, _ := syscall.Syscall6(loadString, 4, + uintptr(instRes), + uintptr(id), + uintptr(unsafe.Pointer(buf)), + uintptr(length), + 0, + 0) + + return int32(ret) +} + +// Plays a waveform sound. uType is the sound to be played. The sounds are set by the user through the Sound control panel application. +// The following values can be used as a sound: +// +// MB_ICONASTERISK (see MB_ICONINFORMATION) +// MB_ICONEXCLAMATION (see MB_ICONWARNING) +// MB_ICONERROR (The sound specified as the Windows Critical Stop sound) +// MB_ICONHAND (See MB_ICONERROR) +// MB_ICONINFORMATION (The sounds specified as the Windows Asterisk sound) +// MB_ICONQUESTION (The sound specified as the Windows Question sound) +// MB_ICONSTOP (See MB_ICONERROR) +// MB_ICONWARNING (The sounds specified as the Windows Exclamation sound) +// MB_OK (The sound specified as the Windows Default Beep sound) +// +// The function will return true if the function succeeds, false if otherwise. +func MessageBeep(uType uint32) bool { + ret, _, _ := syscall.Syscall(messageBeep, 2, + uintptr(uType), + 0, + 0) + + return ret != 0 +} + +func MessageBox(hWnd HWND, lpText, lpCaption *uint16, uType uint32) int32 { + ret, _, _ := syscall.Syscall6(messageBox, 4, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpText)), + uintptr(unsafe.Pointer(lpCaption)), + uintptr(uType), + 0, + 0) + + return int32(ret) +} + +func MonitorFromWindow(hwnd HWND, dwFlags uint32) HMONITOR { + ret, _, _ := syscall.Syscall(monitorFromWindow, 2, + uintptr(hwnd), + uintptr(dwFlags), + 0) + + return HMONITOR(ret) +} + +func MoveWindow(hWnd HWND, x, y, width, height int32, repaint bool) bool { + ret, _, _ := syscall.Syscall6(moveWindow, 6, + uintptr(hWnd), + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + uintptr(BoolToBOOL(repaint))) + + return ret != 0 +} + +func UnregisterClass(name *uint16) bool { + ret, _, _ := syscall.Syscall(unregisterClass, 1, + uintptr(unsafe.Pointer(name)), + 0, + 0) + + return ret != 0 +} + +func OpenClipboard(hWndNewOwner HWND) bool { + ret, _, _ := syscall.Syscall(openClipboard, 1, + uintptr(hWndNewOwner), + 0, + 0) + + return ret != 0 +} + +func PeekMessage(lpMsg *MSG, hWnd HWND, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) bool { + ret, _, _ := syscall.Syscall6(peekMessage, 5, + uintptr(unsafe.Pointer(lpMsg)), + uintptr(hWnd), + uintptr(wMsgFilterMin), + uintptr(wMsgFilterMax), + uintptr(wRemoveMsg), + 0) + + return ret != 0 +} + +func PostMessage(hWnd HWND, msg uint32, wParam, lParam uintptr) uintptr { + ret, _, _ := syscall.Syscall6(postMessage, 4, + uintptr(hWnd), + uintptr(msg), + wParam, + lParam, + 0, + 0) + + return ret +} + +func PostQuitMessage(exitCode int32) { + syscall.Syscall(postQuitMessage, 1, + uintptr(exitCode), + 0, + 0) +} + +func RegisterClassEx(windowClass *WNDCLASSEX) ATOM { + ret, _, _ := syscall.Syscall(registerClassEx, 1, + uintptr(unsafe.Pointer(windowClass)), + 0, + 0) + + return ATOM(ret) +} + +func RegisterRawInputDevices(pRawInputDevices *RAWINPUTDEVICE, uiNumDevices uint32, cbSize uint32) bool { + ret, _, _ := syscall.Syscall(registerRawInputDevices, 3, + uintptr(unsafe.Pointer(pRawInputDevices)), + uintptr(uiNumDevices), + uintptr(cbSize)) + + return ret != 0 +} + +func RegisterWindowMessage(lpString *uint16) uint32 { + ret, _, _ := syscall.Syscall(registerWindowMessage, 1, + uintptr(unsafe.Pointer(lpString)), + 0, + 0) + + return uint32(ret) +} + +func ReleaseCapture() bool { + ret, _, _ := syscall.Syscall(releaseCapture, 0, + 0, + 0, + 0) + + return ret != 0 +} + +func ReleaseDC(hWnd HWND, hDC HDC) bool { + ret, _, _ := syscall.Syscall(releaseDC, 2, + uintptr(hWnd), + uintptr(hDC), + 0) + + return ret != 0 +} + +func RemoveMenu(hMenu HMENU, uPosition, uFlags uint32) bool { + ret, _, _ := syscall.Syscall(removeMenu, 3, + uintptr(hMenu), + uintptr(uPosition), + uintptr(uFlags)) + + return ret != 0 +} + +func ScreenToClient(hWnd HWND, point *POINT) bool { + ret, _, _ := syscall.Syscall(screenToClient, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(point)), + 0) + + return ret != 0 +} + +func SendDlgItemMessage(hWnd HWND, id int32, msg uint32, wParam, lParam uintptr) uintptr { + ret, _, _ := syscall.Syscall6(sendDlgItemMessage, 5, + uintptr(hWnd), + uintptr(id), + uintptr(msg), + wParam, + lParam, + 0) + + return ret +} + +// pInputs expects a unsafe.Pointer to a slice of MOUSE_INPUT or KEYBD_INPUT or HARDWARE_INPUT structs. +func SendInput(nInputs uint32, pInputs unsafe.Pointer, cbSize int32) uint32 { + ret, _, _ := syscall.Syscall(sendInput, 3, + uintptr(nInputs), + uintptr(pInputs), + uintptr(cbSize)) + + return uint32(ret) +} + +func SendMessage(hWnd HWND, msg uint32, wParam, lParam uintptr) uintptr { + ret, _, _ := syscall.Syscall6(sendMessage, 4, + uintptr(hWnd), + uintptr(msg), + wParam, + lParam, + 0, + 0) + + return ret +} + +func SetActiveWindow(hWnd HWND) HWND { + ret, _, _ := syscall.Syscall(setActiveWindow, 1, + uintptr(hWnd), + 0, + 0) + + return HWND(ret) +} + +func SetCapture(hWnd HWND) HWND { + ret, _, _ := syscall.Syscall(setCapture, 1, + uintptr(hWnd), + 0, + 0) + + return HWND(ret) +} + +func SetClipboardData(uFormat uint32, hMem HANDLE) HANDLE { + ret, _, _ := syscall.Syscall(setClipboardData, 2, + uintptr(uFormat), + uintptr(hMem), + 0) + + return HANDLE(ret) +} + +func SetCursor(hCursor HCURSOR) HCURSOR { + ret, _, _ := syscall.Syscall(setCursor, 1, + uintptr(hCursor), + 0, + 0) + + return HCURSOR(ret) +} + +func SetCursorPos(X, Y int32) bool { + ret, _, _ := syscall.Syscall(setCursorPos, 2, + uintptr(X), + uintptr(Y), + 0) + + return ret != 0 +} + +func SetFocus(hWnd HWND) HWND { + ret, _, _ := syscall.Syscall(setFocus, 1, + uintptr(hWnd), + 0, + 0) + + return HWND(ret) +} + +func SetForegroundWindow(hWnd HWND) bool { + ret, _, _ := syscall.Syscall(setForegroundWindow, 1, + uintptr(hWnd), + 0, + 0) + + return ret != 0 +} + +func SetMenu(hWnd HWND, hMenu HMENU) bool { + ret, _, _ := syscall.Syscall(setMenu, 2, + uintptr(hWnd), + uintptr(hMenu), + 0) + + return ret != 0 +} + +func SetMenuInfo(hmenu HMENU, lpcmi *MENUINFO) bool { + ret, _, _ := syscall.Syscall(setMenuInfo, 2, + uintptr(hmenu), + uintptr(unsafe.Pointer(lpcmi)), + 0) + + return ret != 0 +} + +func SetMenuItemInfo(hMenu HMENU, uItem uint32, fByPosition bool, lpmii *MENUITEMINFO) bool { + ret, _, _ := syscall.Syscall6(setMenuItemInfo, 4, + uintptr(hMenu), + uintptr(uItem), + uintptr(BoolToBOOL(fByPosition)), + uintptr(unsafe.Pointer(lpmii)), + 0, + 0) + + return ret != 0 +} + +func SetParent(hWnd HWND, parentHWnd HWND) HWND { + ret, _, _ := syscall.Syscall(setParent, 2, + uintptr(hWnd), + uintptr(parentHWnd), + 0) + + return HWND(ret) +} + +func SetRect(lprc *RECT, xLeft, yTop, xRight, yBottom uint32) BOOL { + ret, _, _ := syscall.Syscall6(setRect, 5, + uintptr(unsafe.Pointer(lprc)), + uintptr(xLeft), + uintptr(yTop), + uintptr(xRight), + uintptr(yBottom), + 0) + + return BOOL(ret) +} + +func SetScrollInfo(hwnd HWND, fnBar int32, lpsi *SCROLLINFO, fRedraw bool) int32 { + ret, _, _ := syscall.Syscall6(setScrollInfo, 4, + uintptr(hwnd), + uintptr(fnBar), + uintptr(unsafe.Pointer(lpsi)), + uintptr(BoolToBOOL(fRedraw)), + 0, + 0) + + return int32(ret) +} + +func SetTimer(hWnd HWND, nIDEvent uintptr, uElapse uint32, lpTimerFunc uintptr) uintptr { + ret, _, _ := syscall.Syscall6(setTimer, 4, + uintptr(hWnd), + nIDEvent, + uintptr(uElapse), + lpTimerFunc, + 0, + 0) + + return ret +} + +func SetWindowLong(hWnd HWND, index, value int32) int32 { + ret, _, _ := syscall.Syscall(setWindowLong, 3, + uintptr(hWnd), + uintptr(index), + uintptr(value)) + + return int32(ret) +} + +func SetWindowLongPtr(hWnd HWND, index int, value uintptr) uintptr { + ret, _, _ := syscall.Syscall(setWindowLongPtr, 3, + uintptr(hWnd), + uintptr(index), + value) + + return ret +} + +func SetWindowPlacement(hWnd HWND, lpwndpl *WINDOWPLACEMENT) bool { + ret, _, _ := syscall.Syscall(setWindowPlacement, 2, + uintptr(hWnd), + uintptr(unsafe.Pointer(lpwndpl)), + 0) + + return ret != 0 +} + +func SetWindowPos(hWnd, hWndInsertAfter HWND, x, y, width, height int32, flags uint32) bool { + ret, _, _ := syscall.Syscall9(setWindowPos, 7, + uintptr(hWnd), + uintptr(hWndInsertAfter), + uintptr(x), + uintptr(y), + uintptr(width), + uintptr(height), + uintptr(flags), + 0, + 0) + + return ret != 0 +} + +func ShowWindow(hWnd HWND, nCmdShow int32) bool { + ret, _, _ := syscall.Syscall(showWindow, 2, + uintptr(hWnd), + uintptr(nCmdShow), + 0) + + return ret != 0 +} + +func SystemParametersInfo(uiAction, uiParam uint32, pvParam unsafe.Pointer, fWinIni uint32) bool { + ret, _, _ := syscall.Syscall6(systemParametersInfo, 4, + uintptr(uiAction), + uintptr(uiParam), + uintptr(pvParam), + uintptr(fWinIni), + 0, + 0) + + return ret != 0 +} + +func TrackPopupMenuEx(hMenu HMENU, fuFlags uint32, x, y int32, hWnd HWND, lptpm *TPMPARAMS) BOOL { + ret, _, _ := syscall.Syscall6(trackPopupMenuEx, 6, + uintptr(hMenu), + uintptr(fuFlags), + uintptr(x), + uintptr(y), + uintptr(hWnd), + uintptr(unsafe.Pointer(lptpm))) + + return BOOL(ret) +} + +func TranslateMessage(msg *MSG) bool { + ret, _, _ := syscall.Syscall(translateMessage, 1, + uintptr(unsafe.Pointer(msg)), + 0, + 0) + + return ret != 0 +} + +func UpdateWindow(hwnd HWND) bool { + ret, _, _ := syscall.Syscall(updateWindow, 1, + uintptr(hwnd), + 0, + 0) + + return ret != 0 +} +func WindowFromPoint(Point POINT) HWND { + ret, _, _ := syscall.Syscall(windowFromPoint, 2, + uintptr(Point.X), + uintptr(Point.Y), + 0) + + return HWND(ret) +} diff --git a/vendor/github.com/lxn/win/uxtheme.go b/vendor/github.com/lxn/win/uxtheme.go new file mode 100644 index 00000000000..fff30224954 --- /dev/null +++ b/vendor/github.com/lxn/win/uxtheme.go @@ -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) +} diff --git a/vendor/github.com/lxn/win/win.go b/vendor/github.com/lxn/win/win.go new file mode 100644 index 00000000000..312cf962a00 --- /dev/null +++ b/vendor/github.com/lxn/win/win.go @@ -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 +} diff --git a/vendor/github.com/lxn/win/winspool.go b/vendor/github.com/lxn/win/winspool.go new file mode 100644 index 00000000000..c69214d48c1 --- /dev/null +++ b/vendor/github.com/lxn/win/winspool.go @@ -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 +}