go-tg-screenshot-bot

1
// Copyright 2010 The win Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
// +build windows
6

7
package win
8

9
import (
10
	"fmt"
11
	"golang.org/x/sys/windows"
12
	"syscall"
13
	"unsafe"
14
)
15

16
type DISPID int32
17

18
const (
19
	DISPID_BEFORENAVIGATE             DISPID = 100
20
	DISPID_NAVIGATECOMPLETE           DISPID = 101
21
	DISPID_STATUSTEXTCHANGE           DISPID = 102
22
	DISPID_QUIT                       DISPID = 103
23
	DISPID_DOWNLOADCOMPLETE           DISPID = 104
24
	DISPID_COMMANDSTATECHANGE         DISPID = 105
25
	DISPID_DOWNLOADBEGIN              DISPID = 106
26
	DISPID_NEWWINDOW                  DISPID = 107
27
	DISPID_PROGRESSCHANGE             DISPID = 108
28
	DISPID_WINDOWMOVE                 DISPID = 109
29
	DISPID_WINDOWRESIZE               DISPID = 110
30
	DISPID_WINDOWACTIVATE             DISPID = 111
31
	DISPID_PROPERTYCHANGE             DISPID = 112
32
	DISPID_TITLECHANGE                DISPID = 113
33
	DISPID_TITLEICONCHANGE            DISPID = 114
34
	DISPID_FRAMEBEFORENAVIGATE        DISPID = 200
35
	DISPID_FRAMENAVIGATECOMPLETE      DISPID = 201
36
	DISPID_FRAMENEWWINDOW             DISPID = 204
37
	DISPID_BEFORENAVIGATE2            DISPID = 250
38
	DISPID_NEWWINDOW2                 DISPID = 251
39
	DISPID_NAVIGATECOMPLETE2          DISPID = 252
40
	DISPID_ONQUIT                     DISPID = 253
41
	DISPID_ONVISIBLE                  DISPID = 254
42
	DISPID_ONTOOLBAR                  DISPID = 255
43
	DISPID_ONMENUBAR                  DISPID = 256
44
	DISPID_ONSTATUSBAR                DISPID = 257
45
	DISPID_ONFULLSCREEN               DISPID = 258
46
	DISPID_DOCUMENTCOMPLETE           DISPID = 259
47
	DISPID_ONTHEATERMODE              DISPID = 260
48
	DISPID_ONADDRESSBAR               DISPID = 261
49
	DISPID_WINDOWSETRESIZABLE         DISPID = 262
50
	DISPID_WINDOWCLOSING              DISPID = 263
51
	DISPID_WINDOWSETLEFT              DISPID = 264
52
	DISPID_WINDOWSETTOP               DISPID = 265
53
	DISPID_WINDOWSETWIDTH             DISPID = 266
54
	DISPID_WINDOWSETHEIGHT            DISPID = 267
55
	DISPID_CLIENTTOHOSTWINDOW         DISPID = 268
56
	DISPID_SETSECURELOCKICON          DISPID = 269
57
	DISPID_FILEDOWNLOAD               DISPID = 270
58
	DISPID_NAVIGATEERROR              DISPID = 271
59
	DISPID_PRIVACYIMPACTEDSTATECHANGE DISPID = 272
60
	DISPID_NEWWINDOW3                 DISPID = 273
61
)
62

63
var (
64
	IID_IDispatch = IID{0x00020400, 0x0000, 0x0000, [8]byte{0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}
65
)
66

67
const (
68
	DISP_E_MEMBERNOTFOUND = 0x80020003
69
)
70

71
const (
72
	CSC_UPDATECOMMANDS  = ^0x0
73
	CSC_NAVIGATEFORWARD = 0x1
74
	CSC_NAVIGATEBACK    = 0x2
75
)
76

77
type IDispatchVtbl struct {
78
	QueryInterface   uintptr
79
	AddRef           uintptr
80
	Release          uintptr
81
	GetTypeInfoCount uintptr
82
	GetTypeInfo      uintptr
83
	GetIDsOfNames    uintptr
84
	Invoke           uintptr
85
}
86

87
type IDispatch struct {
88
	LpVtbl *IDispatchVtbl
89
}
90

91
type VARTYPE uint16
92

93
const (
94
	VT_EMPTY            VARTYPE = 0
95
	VT_NULL             VARTYPE = 1
96
	VT_I2               VARTYPE = 2
97
	VT_I4               VARTYPE = 3
98
	VT_R4               VARTYPE = 4
99
	VT_R8               VARTYPE = 5
100
	VT_CY               VARTYPE = 6
101
	VT_DATE             VARTYPE = 7
102
	VT_BSTR             VARTYPE = 8
103
	VT_DISPATCH         VARTYPE = 9
104
	VT_ERROR            VARTYPE = 10
105
	VT_BOOL             VARTYPE = 11
106
	VT_VARIANT          VARTYPE = 12
107
	VT_UNKNOWN          VARTYPE = 13
108
	VT_DECIMAL          VARTYPE = 14
109
	VT_I1               VARTYPE = 16
110
	VT_UI1              VARTYPE = 17
111
	VT_UI2              VARTYPE = 18
112
	VT_UI4              VARTYPE = 19
113
	VT_I8               VARTYPE = 20
114
	VT_UI8              VARTYPE = 21
115
	VT_INT              VARTYPE = 22
116
	VT_UINT             VARTYPE = 23
117
	VT_VOID             VARTYPE = 24
118
	VT_HRESULT          VARTYPE = 25
119
	VT_PTR              VARTYPE = 26
120
	VT_SAFEARRAY        VARTYPE = 27
121
	VT_CARRAY           VARTYPE = 28
122
	VT_USERDEFINED      VARTYPE = 29
123
	VT_LPSTR            VARTYPE = 30
124
	VT_LPWSTR           VARTYPE = 31
125
	VT_RECORD           VARTYPE = 36
126
	VT_INT_PTR          VARTYPE = 37
127
	VT_UINT_PTR         VARTYPE = 38
128
	VT_FILETIME         VARTYPE = 64
129
	VT_BLOB             VARTYPE = 65
130
	VT_STREAM           VARTYPE = 66
131
	VT_STORAGE          VARTYPE = 67
132
	VT_STREAMED_OBJECT  VARTYPE = 68
133
	VT_STORED_OBJECT    VARTYPE = 69
134
	VT_BLOB_OBJECT      VARTYPE = 70
135
	VT_CF               VARTYPE = 71
136
	VT_CLSID            VARTYPE = 72
137
	VT_VERSIONED_STREAM VARTYPE = 73
138
	VT_BSTR_BLOB        VARTYPE = 0xfff
139
	VT_VECTOR           VARTYPE = 0x1000
140
	VT_ARRAY            VARTYPE = 0x2000
141
	VT_BYREF            VARTYPE = 0x4000
142
	VT_RESERVED         VARTYPE = 0x8000
143
	VT_ILLEGAL          VARTYPE = 0xffff
144
	VT_ILLEGALMASKED    VARTYPE = 0xfff
145
	VT_TYPEMASK         VARTYPE = 0xfff
146
)
147

148
type VARIANTARG struct {
149
	VARIANT
150
}
151

152
type VARIANT_BOOL int16
153

154
const (
155
	VARIANT_TRUE  VARIANT_BOOL = -1
156
	VARIANT_FALSE VARIANT_BOOL = 0
157
)
158

159
type SAFEARRAYBOUND struct {
160
	CElements uint32
161
	LLbound   int32
162
}
163

164
type SAFEARRAY struct {
165
	CDims      uint16
166
	FFeatures  uint16
167
	CbElements uint32
168
	CLocks     uint32
169
	PvData     uintptr
170
	Rgsabound  [1]SAFEARRAYBOUND
171
}
172

173
//type BSTR *uint16
174

175
func StringToBSTR(value string) *uint16 /*BSTR*/ {
176
	// IMPORTANT: Don't forget to free the BSTR value when no longer needed!
177
	return SysAllocString(value)
178
}
179

180
func BSTRToString(value *uint16 /*BSTR*/) string {
181
	// ISSUE: Is this really ok?
182
	bstrArrPtr := (*[200000000]uint16)(unsafe.Pointer(value))
183

184
	bstrSlice := make([]uint16, SysStringLen(value))
185
	copy(bstrSlice, bstrArrPtr[:])
186

187
	return syscall.UTF16ToString(bstrSlice)
188
}
189

190
func IntToVariantI4(value int32) *VAR_I4 {
191
	return &VAR_I4{vt: VT_I4, lVal: value}
192
}
193

194
func VariantI4ToInt(value *VAR_I4) int32 {
195
	return value.lVal
196
}
197

198
func BoolToVariantBool(value bool) *VAR_BOOL {
199
	return &VAR_BOOL{vt: VT_BOOL, boolVal: VARIANT_BOOL(BoolToBOOL(value))}
200
}
201

202
func VariantBoolToBool(value *VAR_BOOL) bool {
203
	return value.boolVal != 0
204
}
205

206
func StringToVariantBSTR(value string) *VAR_BSTR {
207
	// IMPORTANT: Don't forget to free the BSTR value when no longer needed!
208
	return &VAR_BSTR{vt: VT_BSTR, bstrVal: StringToBSTR(value)}
209
}
210

211
func VariantBSTRToString(value *VAR_BSTR) string {
212
	return BSTRToString(value.bstrVal)
213
}
214

215
func (v *VARIANT) MustLong() int32 {
216
	value, err := v.Long()
217
	if err != nil {
218
		panic(err)
219
	}
220
	return value
221
}
222

223
func (v *VARIANT) Long() (int32, error) {
224
	if v.Vt != VT_I4 {
225
		return 0, fmt.Errorf("Error: Long() v.Vt !=  VT_I4, ptr=%p, value=%+v", v, v)
226
	}
227
	p := (*VAR_I4)(unsafe.Pointer(v))
228
	return p.lVal, nil
229
}
230

231
func (v *VARIANT) SetLong(value int32) {
232
	v.Vt = VT_I4
233
	p := (*VAR_I4)(unsafe.Pointer(v))
234
	p.lVal = value
235
}
236

237
func (v *VARIANT) MustULong() uint32 {
238
	value, err := v.ULong()
239
	if err != nil {
240
		panic(err)
241
	}
242
	return value
243
}
244

245
func (v *VARIANT) ULong() (uint32, error) {
246
	if v.Vt != VT_UI4 {
247
		return 0, fmt.Errorf("Error: ULong() v.Vt !=  VT_UI4, ptr=%p, value=%+v", v, v)
248
	}
249
	p := (*VAR_UI4)(unsafe.Pointer(v))
250
	return p.ulVal, nil
251
}
252

253
func (v *VARIANT) SetULong(value uint32) {
254
	v.Vt = VT_UI4
255
	p := (*VAR_UI4)(unsafe.Pointer(v))
256
	p.ulVal = value
257
}
258

259
func (v *VARIANT) MustBool() VARIANT_BOOL {
260
	value, err := v.Bool()
261
	if err != nil {
262
		panic(err)
263
	}
264
	return value
265
}
266

267
func (v *VARIANT) Bool() (VARIANT_BOOL, error) {
268
	if v.Vt != VT_BOOL {
269
		return VARIANT_FALSE, fmt.Errorf("Error: Bool() v.Vt !=  VT_BOOL, ptr=%p, value=%+v", v, v)
270
	}
271
	p := (*VAR_BOOL)(unsafe.Pointer(v))
272
	return p.boolVal, nil
273
}
274

275
func (v *VARIANT) SetBool(value VARIANT_BOOL) {
276
	v.Vt = VT_BOOL
277
	p := (*VAR_BOOL)(unsafe.Pointer(v))
278
	p.boolVal = value
279
}
280

281
func (v *VARIANT) MustBSTR() *uint16 {
282
	value, err := v.BSTR()
283
	if err != nil {
284
		panic(err)
285
	}
286
	return value
287
}
288

289
func (v *VARIANT) BSTR() (*uint16, error) {
290
	if v.Vt != VT_BSTR {
291
		return nil, fmt.Errorf("Error: BSTR() v.Vt !=  VT_BSTR, ptr=%p, value=%+v", v, v)
292
	}
293
	p := (*VAR_BSTR)(unsafe.Pointer(v))
294
	return p.bstrVal, nil
295
}
296

297
func (v *VARIANT) SetBSTR(value *uint16) {
298
	v.Vt = VT_BSTR
299
	p := (*VAR_BSTR)(unsafe.Pointer(v))
300
	p.bstrVal = value
301
}
302

303
func (v *VARIANT) MustPDispatch() *IDispatch {
304
	value, err := v.PDispatch()
305
	if err != nil {
306
		panic(err)
307
	}
308
	return value
309
}
310

311
func (v *VARIANT) PDispatch() (*IDispatch, error) {
312
	if v.Vt != VT_DISPATCH {
313
		return nil, fmt.Errorf("Error: PDispatch() v.Vt !=  VT_DISPATCH, ptr=%p, value=%+v", v, v)
314
	}
315
	p := (*VAR_PDISP)(unsafe.Pointer(v))
316
	return p.pdispVal, nil
317
}
318

319
func (v *VARIANT) SetPDispatch(value *IDispatch) {
320
	v.Vt = VT_DISPATCH
321
	p := (*VAR_PDISP)(unsafe.Pointer(v))
322
	p.pdispVal = value
323
}
324

325
func (v *VARIANT) MustPVariant() *VARIANT {
326
	value, err := v.PVariant()
327
	if err != nil {
328
		panic(err)
329
	}
330
	return value
331
}
332

333
func (v *VARIANT) PVariant() (*VARIANT, error) {
334
	if v.Vt != VT_BYREF|VT_VARIANT {
335
		return nil, fmt.Errorf("Error: PVariant() v.Vt !=  VT_BYREF|VT_VARIANT, ptr=%p, value=%+v", v, v)
336
	}
337
	p := (*VAR_PVAR)(unsafe.Pointer(v))
338
	return p.pvarVal, nil
339
}
340

341
func (v *VARIANT) SetPVariant(value *VARIANT) {
342
	v.Vt = VT_BYREF | VT_VARIANT
343
	p := (*VAR_PVAR)(unsafe.Pointer(v))
344
	p.pvarVal = value
345
}
346

347
func (v *VARIANT) MustPBool() *VARIANT_BOOL {
348
	value, err := v.PBool()
349
	if err != nil {
350
		panic(err)
351
	}
352
	return value
353
}
354

355
func (v *VARIANT) PBool() (*VARIANT_BOOL, error) {
356
	if v.Vt != VT_BYREF|VT_BOOL {
357
		return nil, fmt.Errorf("Error: PBool() v.Vt !=  VT_BYREF|VT_BOOL, ptr=%p, value=%+v", v, v)
358
	}
359
	p := (*VAR_PBOOL)(unsafe.Pointer(v))
360
	return p.pboolVal, nil
361
}
362

363
func (v *VARIANT) SetPBool(value *VARIANT_BOOL) {
364
	v.Vt = VT_BYREF | VT_BOOL
365
	p := (*VAR_PBOOL)(unsafe.Pointer(v))
366
	p.pboolVal = value
367
}
368

369
func (v *VARIANT) MustPPDispatch() **IDispatch {
370
	value, err := v.PPDispatch()
371
	if err != nil {
372
		panic(err)
373
	}
374
	return value
375
}
376

377
func (v *VARIANT) PPDispatch() (**IDispatch, error) {
378
	if v.Vt != VT_BYREF|VT_DISPATCH {
379
		return nil, fmt.Errorf("PPDispatch() v.Vt !=  VT_BYREF|VT_DISPATCH, ptr=%p, value=%+v", v, v)
380
	}
381
	p := (*VAR_PPDISP)(unsafe.Pointer(v))
382
	return p.ppdispVal, nil
383
}
384

385
func (v *VARIANT) SetPPDispatch(value **IDispatch) {
386
	v.Vt = VT_BYREF | VT_DISPATCH
387
	p := (*VAR_PPDISP)(unsafe.Pointer(v))
388
	p.ppdispVal = value
389
}
390

391
func (v *VARIANT) MustPSafeArray() *SAFEARRAY {
392
	value, err := v.PSafeArray()
393
	if err != nil {
394
		panic(err)
395
	}
396
	return value
397
}
398

399
func (v *VARIANT) PSafeArray() (*SAFEARRAY, error) {
400
	if (v.Vt & VT_ARRAY) != VT_ARRAY {
401
		return nil, fmt.Errorf("Error: PSafeArray() (v.Vt & VT_ARRAY) != VT_ARRAY, ptr=%p, value=%+v", v, v)
402
	}
403
	p := (*VAR_PSAFEARRAY)(unsafe.Pointer(v))
404
	return p.parray, nil
405
}
406

407
func (v *VARIANT) SetPSafeArray(value *SAFEARRAY, elementVt VARTYPE) {
408
	v.Vt = VT_ARRAY | elementVt
409
	p := (*VAR_PSAFEARRAY)(unsafe.Pointer(v))
410
	p.parray = value
411
}
412

413
type DISPPARAMS struct {
414
	Rgvarg            *VARIANTARG
415
	RgdispidNamedArgs *DISPID
416
	CArgs             int32
417
	CNamedArgs        int32
418
}
419

420
var (
421
	// Library
422
	liboleaut32 *windows.LazyDLL
423

424
	// Functions
425
	sysAllocString *windows.LazyProc
426
	sysFreeString  *windows.LazyProc
427
	sysStringLen   *windows.LazyProc
428
)
429

430
func init() {
431
	// Library
432
	liboleaut32 = windows.NewLazySystemDLL("oleaut32.dll")
433

434
	// Functions
435
	sysAllocString = liboleaut32.NewProc("SysAllocString")
436
	sysFreeString = liboleaut32.NewProc("SysFreeString")
437
	sysStringLen = liboleaut32.NewProc("SysStringLen")
438
}
439

440
func SysAllocString(s string) *uint16 /*BSTR*/ {
441
	ret, _, _ := syscall.Syscall(sysAllocString.Addr(), 1,
442
		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(s))),
443
		0,
444
		0)
445

446
	return (*uint16) /*BSTR*/ (unsafe.Pointer(ret))
447
}
448

449
func SysFreeString(bstr *uint16 /*BSTR*/) {
450
	syscall.Syscall(sysFreeString.Addr(), 1,
451
		uintptr(unsafe.Pointer(bstr)),
452
		0,
453
		0)
454
}
455

456
func SysStringLen(bstr *uint16 /*BSTR*/) uint32 {
457
	ret, _, _ := syscall.Syscall(sysStringLen.Addr(), 1,
458
		uintptr(unsafe.Pointer(bstr)),
459
		0,
460
		0)
461

462
	return uint32(ret)
463
}
464