Merge pull request #50396 from bobbypage/stats

Godeps/Godeps.json

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

Godeps/LICENSES

@@ -68457,6 +68457,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: =
 
 goproperties - properties file decoder for Go

pkg/kubelet/BUILD

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

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": [],
     }),
 )

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) {

pkg/kubelet/winstats/BUILD

+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",
+    ],
+)

pkg/kubelet/winstats/perfcounter_nodestats.go

+// +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
+}

pkg/kubelet/winstats/perfcounters.go

+// +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
+}

pkg/kubelet/winstats/winstats.go

+/*
+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
+}

pkg/kubelet/winstats/winstats_test.go

+/*
+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
+}

vendor/BUILD

@@ -264,6 +264,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",

vendor/github.com/lxn/win/AUTHORS

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

vendor/github.com/lxn/win/BUILD

+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"],
+)

vendor/github.com/lxn/win/LICENSE

+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/README.mdown

+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`

vendor/github.com/lxn/win/advapi32.go

+// 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)
+}

vendor/github.com/lxn/win/combobox.go

+// 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
+)

vendor/github.com/lxn/win/comctl32.go

+// 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
+}

vendor/github.com/lxn/win/comdlg32.go

+// 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)
+}

vendor/github.com/lxn/win/datetimepicker.go

+// 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
+	}
+)

vendor/github.com/lxn/win/edit.go

+// 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
+)

vendor/github.com/lxn/win/gdi32.go

+// 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
+}

vendor/github.com/lxn/win/gdiplus.go

+// 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)
+}*/

vendor/github.com/lxn/win/header.go

+// 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
+}

vendor/github.com/lxn/win/kernel32.go

+// 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
+}

vendor/github.com/lxn/win/listbox.go

+// 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
+)

vendor/github.com/lxn/win/listview.go

+// 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
+}

vendor/github.com/lxn/win/menu.go

+// 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
+}

vendor/github.com/lxn/win/ole32.go

+// 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)
+}

vendor/github.com/lxn/win/oleaut32.go

+// 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)
+}

vendor/github.com/lxn/win/oleaut32_386.go

+// 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
+}

vendor/github.com/lxn/win/oleaut32_amd64.go

+// 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*/
+}

vendor/github.com/lxn/win/opengl32.go

+// 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
+}

vendor/github.com/lxn/win/pdh.go

+// 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)
+}

vendor/github.com/lxn/win/shdocvw.go

+// 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
+}

vendor/github.com/lxn/win/shell32.go

+// 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
+}

vendor/github.com/lxn/win/shobj.go

+// 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)
+}

vendor/github.com/lxn/win/shobj_386.go

+// 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)
+}

vendor/github.com/lxn/win/shobj_amd64.go

+// 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)
+}

vendor/github.com/lxn/win/statusbar.go

+// 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

vendor/github.com/lxn/win/syslink.go

+// 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
+}

vendor/github.com/lxn/win/tab.go

+// 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
+}

vendor/github.com/lxn/win/toolbar.go

+// 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
+}

vendor/github.com/lxn/win/tooltip.go

+// 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
+}

vendor/github.com/lxn/win/treeview.go

+// 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
+}

vendor/github.com/lxn/win/updown.go

+// 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
+}

vendor/github.com/lxn/win/user32.go

+// 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)
+}

vendor/github.com/lxn/win/uxtheme.go

+// 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)
+}

vendor/github.com/lxn/win/win.go

+// 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
+}

vendor/github.com/lxn/win/winspool.go

+// 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
+}