├── .gitignore
├── README.md
├── behavior.go
├── element.go
├── event_handler.go
├── get_htmlayout.py
├── htmlayout.go
├── htmlayout_test.go
├── notify_handler.go
└── patch_htmlayout_header.py


/.gitignore:
--------------------------------------------------------------------------------
1 | *.8
2 | _obj/
3 | htmlayout/
4 | HTMLayoutSDK.zip
5 | htmlayout.dll
6 | *.pyc
7 | *.o
8 | _cgo_export.h
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ### What is it?
 2 | Go-htmlayout (gohl) is a Go wrapper of the [HTMLayout](http://www.terrainformatica.com/htmlayout/) library by TerraInformatica.  HTMLayout is a fast, lightweight, and embeddable HTML/CSS rendering component for Windows.
 3 | 
 4 | ### Project status
 5 | Go-htmlayout is written for Go1.  Most of the HTMLayout API has been wrapped (especially dom element related stuff), but there is still more of the HTMLayout API that I haven't tackled yet.  Tests are also incomplete at this point.  In short, this wrapper is probably not ready for serious production use.
 6 | 
 7 | ### Getting started
 8 | Clone the repo.  In the main directory of the repository, run the following to fetch the latest version of HTMLayout:
 9 | 
10 | ```bash
11 | python get_htmlayout.py
12 | ```
13 | 
14 | Though the tests provide an example of how to get started using gohl, there are probably better examples of window creation/management elsewhere on the internet.
15 | 


--------------------------------------------------------------------------------
/behavior.go:
--------------------------------------------------------------------------------
1 | package gohl
2 | 


--------------------------------------------------------------------------------
/element.go:
--------------------------------------------------------------------------------
   1 | package gohl
   2 | 
   3 | /*
   4 | #cgo CFLAGS: -I./htmlayout/include
   5 | #cgo LDFLAGS: ./htmlayout/lib/HTMLayout.lib
   6 | 
   7 | #include <stdlib.h>
   8 | #include <htmlayout.h>
   9 | */
  10 | import "C"
  11 | 
  12 | import (
  13 | 	"fmt"
  14 | 	"errors"
  15 | 	"regexp"
  16 | 	"runtime"
  17 | 	"strconv"
  18 | 	"strings"
  19 | 	"reflect"
  20 | 	"unicode/utf16"
  21 | 	"unsafe"
  22 | )
  23 | 
  24 | const (
  25 | 	HLDOM_OK                = C.HLDOM_OK
  26 | 	HLDOM_INVALID_HWND      = C.HLDOM_INVALID_HWND
  27 | 	HLDOM_INVALID_HANDLE    = C.HLDOM_INVALID_HANDLE
  28 | 	HLDOM_PASSIVE_HANDLE    = C.HLDOM_PASSIVE_HANDLE
  29 | 	HLDOM_INVALID_PARAMETER = C.HLDOM_INVALID_PARAMETER
  30 | 	HLDOM_OPERATION_FAILED  = C.HLDOM_OPERATION_FAILED
  31 | 	HLDOM_OK_NOT_HANDLED    = C.HLDOM_OK_NOT_HANDLED
  32 | 
  33 | 	HV_OK_TRUE = 0xffffffff
  34 | 	HV_OK = C.HV_OK
  35 | 	HV_BAD_PARAMETER = C.HV_BAD_PARAMETER
  36 | 	HV_INCOMPATIBLE_TYPE = C.HV_INCOMPATIBLE_TYPE
  37 | 
  38 | 	STATE_LINK       = 0x00000001 // selector :link,    any element having href attribute
  39 | 	STATE_HOVER      = 0x00000002 // selector :hover,   element is under the cursor, mouse hover  
  40 | 	STATE_ACTIVE     = 0x00000004 // selector :active,  element is activated, e.g. pressed  
  41 | 	STATE_FOCUS      = 0x00000008 // selector :focus,   element is in focus  
  42 | 	STATE_VISITED    = 0x00000010 // selector :visited, aux flag - not used internally now.
  43 | 	STATE_CURRENT    = 0x00000020 // selector :current, current item in collection, e.g. current <option> in <select>
  44 | 	STATE_CHECKED    = 0x00000040 // selector :checked, element is checked (or selected), e.g. check box or itme in multiselect
  45 | 	STATE_DISABLED   = 0x00000080 // selector :disabled, element is disabled, behavior related flag.
  46 | 	STATE_READONLY   = 0x00000100 // selector :read-only, element is read-only, behavior related flag.
  47 | 	STATE_EXPANDED   = 0x00000200 // selector :expanded, element is in expanded state - nodes in tree view e.g. <options> in <select>
  48 | 	STATE_COLLAPSED  = 0x00000400 // selector :collapsed, mutually exclusive with EXPANDED
  49 | 	STATE_INCOMPLETE = 0x00000800 // selector :incomplete, element has images (back/fore/bullet) requested but not delivered.
  50 | 	STATE_ANIMATING  = 0x00001000 // selector :animating, is currently animating 
  51 | 	STATE_FOCUSABLE  = 0x00002000 // selector :focusable, shall accept focus
  52 | 	STATE_ANCHOR     = 0x00004000 // selector :anchor, first element in selection (<select miltiple>), STATE_CURRENT is the current.
  53 | 	STATE_SYNTHETIC  = 0x00008000 // selector :synthetic, synthesized DOM elements - e.g. all missed cells in tables (<td>) are getting this flag
  54 | 	STATE_OWNS_POPUP = 0x00010000 // selector :owns-popup, anchor(owner) element of visible popup. 
  55 | 	STATE_TABFOCUS   = 0x00020000 // selector :tab-focus, element got focus by tab traversal. engine set it together with :focus.
  56 | 	STATE_EMPTY      = 0x00040000 // selector :empty - element is empty. 
  57 | 	STATE_BUSY       = 0x00080000 // selector :busy, element is busy. HTMLayoutRequestElementData will set this flag if
  58 | 	// external data was requested for the element. When data will be delivered engine will reset this flag on the element. 
  59 | 
  60 | 	STATE_DRAG_OVER   = 0x00100000 // drag over the block that can accept it (so is current drop target). Flag is set for the drop target block. At any given moment of time it can be only one such block.
  61 | 	STATE_DROP_TARGET = 0x00200000 // active drop target. Multiple elements can have this flag when D&D is active. 
  62 | 	STATE_MOVING      = 0x00400000 // dragging/moving - the flag is set for the moving element (copy of the drag-source).
  63 | 	STATE_COPYING     = 0x00800000 // dragging/copying - the flag is set for the copying element (copy of the drag-source).
  64 | 	STATE_DRAG_SOURCE = 0x00C00000 // is set in element that is being dragged.
  65 | 
  66 | 	STATE_POPUP   = 0x40000000 // this element is in popup state and presented to the user - out of flow now
  67 | 	STATE_PRESSED = 0x04000000 // pressed - close to active but has wider life span - e.g. in MOUSE_UP it 
  68 | 	// is still on, so behavior can check it in MOUSE_UP to discover CLICK condition.
  69 | 	STATE_HAS_CHILDREN = 0x02000000 // has more than one child.    
  70 | 	STATE_HAS_CHILD    = 0x01000000 // has single child.
  71 | 
  72 | 	STATE_IS_LTR = 0x20000000 // selector :ltr, the element or one of its nearest container has @dir and that dir has "ltr" value
  73 | 	STATE_IS_RTL = 0x10000000 // selector :rtl, the element or one of its nearest container has @dir and that dir has "rtl" value    
  74 | 
  75 | 	RESET_STYLE_THIS = 0x0020 // reset styles - this may require if you have styles dependent from attributes,
  76 | 	RESET_STYLE_DEEP = 0x0010 // use these flags after SetAttribute then. RESET_STYLE_THIS is faster than RESET_STYLE_DEEP.
  77 | 	MEASURE_INPLACE  = 0x0001 // use this flag if you do not expect any dimensional changes - this is faster than REMEASURE
  78 | 	MEASURE_DEEP     = 0x0002 // use this flag if changes of some attributes/content may cause change of dimensions of the element  
  79 | 	REDRAW_NOW       = 0x8000
  80 | 
  81 | 	BAD_HELEMENT = HELEMENT(unsafe.Pointer(uintptr(0)))
  82 | )
  83 | 
  84 | var errorToString = map[HLDOM_RESULT]string{
  85 | 	HLDOM_OK:                "HLDOM_OK",
  86 | 	HLDOM_INVALID_HWND:      "HLDOM_INVALID_HWND",
  87 | 	HLDOM_INVALID_HANDLE:    "HLDOM_INVALID_HANDLE",
  88 | 	HLDOM_PASSIVE_HANDLE:    "HLDOM_PASSIVE_HANDLE",
  89 | 	HLDOM_INVALID_PARAMETER: "HLDOM_INVALID_PARAMETER",
  90 | 	HLDOM_OPERATION_FAILED:  "HLDOM_OPERATION_FAILED",
  91 | 	HLDOM_OK_NOT_HANDLED:    "HLDOM_OK_NOT_HANDLED",
  92 | }
  93 | 
  94 | var valueErrorToString = map[VALUE_RESULT]string{
  95 | 	HV_OK_TRUE: "HV_OK_TRUE", 
  96 | 	HV_OK: "HV_OK",
  97 | 	HV_BAD_PARAMETER: "HV_BAD_PARAMETER",
  98 | 	HV_INCOMPATIBLE_TYPE: "HV_INCOMPATIBLE_TYPE",
  99 | }
 100 | 
 101 | 
 102 | var whitespaceSplitter = regexp.MustCompile(`(\S+)`)
 103 | 
 104 | // DomError represents an htmlayout error with an associated
 105 | // dom error code
 106 | type DomError struct {
 107 | 	Result  HLDOM_RESULT
 108 | 	Message string
 109 | }
 110 | 
 111 | func (e *DomError) Error() string {
 112 | 	return fmt.Sprintf("%s: %s", errorToString[e.Result], e.Message)
 113 | }
 114 | 
 115 | func domResultAsString(result HLDOM_RESULT) string {
 116 | 	return errorToString[result]
 117 | }
 118 | 
 119 | func domPanic(result C.HLDOM_RESULT, message ...interface{}) {
 120 | 	panic(&DomError{HLDOM_RESULT(result), fmt.Sprint(message...)})
 121 | }
 122 | 
 123 | 
 124 | type ValueError struct {
 125 | 	Result  VALUE_RESULT
 126 | 	Message string
 127 | }
 128 | 
 129 | func (e *ValueError) Error() string {
 130 | 	return fmt.Sprintf("%s: %s", valueErrorToString[e.Result], e.Message)
 131 | }
 132 | 
 133 | func valuePanic(result C.UINT, message ...interface{}) {
 134 | 	panic(&ValueError{VALUE_RESULT(result), fmt.Sprint(message...)})
 135 | }
 136 | 
 137 | 
 138 | 
 139 | // Returns the utf-16 encoding of the utf-8 string s,
 140 | // with a terminating NUL added.
 141 | func stringToUtf16(s string) []uint16 {
 142 | 	return utf16.Encode([]rune(s + "\x00"))
 143 | }
 144 | 
 145 | // Returns the utf-8 encoding of the utf-16 sequence s,
 146 | // with a terminating NUL removed.
 147 | func utf16ToString(s *uint16) string {
 148 | 	if s == nil {
 149 | 		panic("null cstring")
 150 | 	}
 151 | 	us := make([]uint16, 0, 256)
 152 | 	for p := uintptr(unsafe.Pointer(s)); ; p += 2 {
 153 | 		u := *(*uint16)(unsafe.Pointer(p))
 154 | 		if u == 0 {
 155 | 			return string(utf16.Decode(us))
 156 | 		}
 157 | 		us = append(us, u)
 158 | 	}
 159 | 	return ""
 160 | }
 161 | 
 162 | func utf16ToStringLength(s *uint16, length int) string {
 163 | 	if s == nil {
 164 | 		panic("null cstring")
 165 | 	}
 166 | 	us := make([]uint16, 0, 256)
 167 | 	for p, i := uintptr(unsafe.Pointer(s)), 0; i < length; p, i = p+2, i+1 {
 168 | 		u := *(*uint16)(unsafe.Pointer(p))
 169 | 		us = append(us, u)
 170 | 	}
 171 | 	return string(utf16.Decode(us))
 172 | }
 173 | 
 174 | // Returns pointer to the utf-16 encoding of
 175 | // the utf-8 string s, with a terminating NUL added.
 176 | func stringToUtf16Ptr(s string) *uint16 {
 177 | 	return &stringToUtf16(s)[0]
 178 | }
 179 | 
 180 | func use(handle HELEMENT) {
 181 | 	if dr := C.HTMLayout_UseElement(handle); dr != HLDOM_OK {
 182 | 		domPanic(dr, "UseElement")
 183 | 	}
 184 | }
 185 | 
 186 | func unuse(handle HELEMENT) {
 187 | 	if handle != nil {
 188 | 		if dr := C.HTMLayout_UnuseElement(handle); dr != HLDOM_OK {
 189 | 			domPanic(dr, "UnuseElement")
 190 | 		}
 191 | 	}
 192 | }
 193 | 
 194 | /*
 195 | Element
 196 | 
 197 | Represents a single DOM element, owns and manages a Handle
 198 | */
 199 | type Element struct {
 200 | 	handle HELEMENT
 201 | }
 202 | 
 203 | // Constructors
 204 | func NewElementFromHandle(h HELEMENT) *Element {
 205 | 	if h == BAD_HELEMENT {
 206 | 		panic("Nil helement")
 207 | 	}
 208 | 	e := &Element{BAD_HELEMENT}
 209 | 	e.setHandle(h)
 210 | 	runtime.SetFinalizer(e, (*Element).finalize)
 211 | 	return e
 212 | }
 213 | 
 214 | func NewElement(tagName string) *Element {
 215 | 	var handle HELEMENT = BAD_HELEMENT
 216 | 	szName := C.CString(tagName)
 217 | 	defer C.free(unsafe.Pointer(szName))
 218 | 	if ret := C.HTMLayoutCreateElement((*C.CHAR)(szName), nil, (*C.HELEMENT)(&handle)); ret != HLDOM_OK {
 219 | 		domPanic(ret, "Failed to create new element")
 220 | 	}
 221 | 	return NewElementFromHandle(handle)
 222 | }
 223 | 
 224 | func RootElement(hwnd uint32) *Element {
 225 | 	var handle HELEMENT = BAD_HELEMENT
 226 | 	if ret := C.HTMLayoutGetRootElement(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.HELEMENT)(&handle)); ret != HLDOM_OK {
 227 | 		domPanic(ret, "Failed to get root element")
 228 | 	}
 229 | 	return NewElementFromHandle(handle)
 230 | }
 231 | 
 232 | func FocusedElement(hwnd uint32) *Element {
 233 | 	var handle HELEMENT = BAD_HELEMENT
 234 | 	if ret := C.HTMLayoutGetFocusElement(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.HELEMENT)(&handle)); ret != HLDOM_OK {
 235 | 		domPanic(ret, "Failed to get focus element")
 236 | 	}
 237 | 	if handle != BAD_HELEMENT {
 238 | 		return NewElementFromHandle(handle)
 239 | 	}
 240 | 	return nil
 241 | }
 242 | 
 243 | // Finalizer method, only to be called from Release or by
 244 | // the Go runtime
 245 | func (e *Element) finalize() {
 246 | 	// Detach handlers
 247 | 	if attachedHandlers, hasHandlers := eventHandlers[e.handle]; hasHandlers {
 248 | 		for handler := range attachedHandlers {
 249 | 			tag := uintptr(unsafe.Pointer(handler))
 250 | 			C.HTMLayoutDetachEventHandler(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag))
 251 | 		}
 252 | 		delete(eventHandlers, e.handle)
 253 | 	}
 254 | 
 255 | 	// Release the underlying htmlayout handle
 256 | 	unuse(e.handle)
 257 | 	e.handle = BAD_HELEMENT
 258 | }
 259 | 
 260 | func (e *Element) Release() {
 261 | 	// Unregister the finalizer so that it does not get called by Go
 262 | 	// and then explicitly finalize this element
 263 | 	runtime.SetFinalizer(e, nil)
 264 | 	e.finalize()
 265 | }
 266 | 
 267 | func (e *Element) setHandle(h HELEMENT) {
 268 | 	use(h)
 269 | 	unuse(e.handle)
 270 | 	e.handle = h
 271 | }
 272 | 
 273 | func (e *Element) Handle() HELEMENT {
 274 | 	return e.handle
 275 | }
 276 | 
 277 | func (e *Element) Equals(other *Element) bool {
 278 | 	return other != nil && e.handle == other.handle
 279 | }
 280 | 
 281 | // This is the same as AttachHandler, except that behaviors are singleton instances stored
 282 | // in a master map.  They may be shared among many elements since they have no state.
 283 | // The only reason we keep a separate set of the behaviors is so that the event handler
 284 | // dispatch method can tell if an event handler is a behavior or a regular handler.
 285 | func (e *Element) attachBehavior(handler *EventHandler) {
 286 | 	tag := uintptr(unsafe.Pointer(handler))
 287 | 	if subscription := handler.Subscription(); subscription == HANDLE_ALL {
 288 | 		if ret := C.HTMLayoutAttachEventHandler(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
 289 | 			domPanic(ret, "Failed to attach event handler to element")
 290 | 		}
 291 | 	} else {
 292 | 		if ret := C.HTMLayoutAttachEventHandlerEx(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK {
 293 | 			domPanic(ret, "Failed to attach event handler to element")
 294 | 		}
 295 | 	}
 296 | }
 297 | 
 298 | func (e *Element) AttachHandler(handler *EventHandler) {
 299 | 	attachedHandlers, hasAttachments := eventHandlers[e.handle]
 300 | 	if hasAttachments {
 301 | 		if _, exists := attachedHandlers[handler]; exists {
 302 | 			// This exact event handler is already attached to this exact element.
 303 | 			return
 304 | 		}
 305 | 	}
 306 | 
 307 | 	// Don't let the caller disable ATTACH/DETACH events, otherwise we
 308 | 	// won't know when to throw out our event handler object
 309 | 	subscription := handler.Subscription()
 310 | 	subscription &= ^uint32(DISABLE_INITIALIZATION & 0xffffffff)
 311 | 
 312 | 	tag := uintptr(unsafe.Pointer(handler))
 313 | 	if subscription == HANDLE_ALL {
 314 | 		if ret := C.HTMLayoutAttachEventHandler(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
 315 | 			domPanic(ret, "Failed to attach event handler to element")
 316 | 		}
 317 | 	} else {
 318 | 		if ret := C.HTMLayoutAttachEventHandlerEx(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK {
 319 | 			domPanic(ret, "Failed to attach event handler to element")
 320 | 		}
 321 | 	}
 322 | 
 323 | 	if !hasAttachments {
 324 | 		eventHandlers[e.handle] = make(map[*EventHandler]bool, 8)
 325 | 	}
 326 | 	eventHandlers[e.handle][handler] = true
 327 | }
 328 | 
 329 | func (e *Element) DetachHandler(handler *EventHandler) {
 330 | 	tag := uintptr(unsafe.Pointer(handler))
 331 | 	if attachedHandlers, exists := eventHandlers[e.handle]; exists {
 332 | 		if _, exists := attachedHandlers[handler]; exists {
 333 | 			if ret := C.HTMLayoutDetachEventHandler(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
 334 | 				domPanic(ret, "Failed to detach event handler from element")
 335 | 			}
 336 | 			delete(attachedHandlers, handler)
 337 | 			if len(attachedHandlers) == 0 {
 338 | 				delete(eventHandlers, e.handle)
 339 | 			}
 340 | 			return
 341 | 		}
 342 | 	}
 343 | 	panic("cannot detach, handler was not registered")
 344 | }
 345 | 
 346 | func (e *Element) Update(restyle, restyleDeep, remeasure, remeasureDeep, render bool) {
 347 | 	var flags uint32
 348 | 	if restyle {
 349 | 		if restyleDeep {
 350 | 			flags |= RESET_STYLE_DEEP
 351 | 		} else {
 352 | 			flags |= RESET_STYLE_THIS
 353 | 		}
 354 | 	}
 355 | 	if remeasure {
 356 | 		if remeasureDeep {
 357 | 			flags |= MEASURE_DEEP
 358 | 		} else {
 359 | 			flags |= MEASURE_INPLACE
 360 | 		}
 361 | 	}
 362 | 	if render {
 363 | 		flags |= REDRAW_NOW
 364 | 	}
 365 | 	if ret := C.HTMLayoutUpdateElementEx(e.handle, C.UINT(flags)); ret != HLDOM_OK {
 366 | 		domPanic(ret, "Failed to update element")
 367 | 	}
 368 | }
 369 | 
 370 | func (e *Element) Capture() {
 371 | 	if ret := C.HTMLayoutSetCapture(e.handle); ret != HLDOM_OK {
 372 | 		domPanic(ret, "Failed to set capture for element")
 373 | 	}
 374 | }
 375 | 
 376 | func (e *Element) ReleaseCapture() {
 377 | 	if ok := C.ReleaseCapture(); ok == 0 {
 378 | 		panic("Failed to release capture for element")
 379 | 	}
 380 | }
 381 | 
 382 | // Functions for querying elements
 383 | 
 384 | func (e *Element) Select(selector string) []*Element {
 385 | 	szSelector := C.CString(selector)
 386 | 	defer C.free(unsafe.Pointer(szSelector))
 387 | 	results := make([]*Element, 0, 32)
 388 | 	if ret := C.HTMLayoutSelectElements(e.handle, (*C.CHAR)(szSelector), (*[0]byte)(unsafe.Pointer(goSelectCallback)), C.LPVOID(unsafe.Pointer(&results))); ret != HLDOM_OK {
 389 | 		domPanic(ret, "Failed to select dom elements, selector: '", selector, "'")
 390 | 	}
 391 | 	return results
 392 | }
 393 | 
 394 | // Searches up the parent chain to find the first element that matches the given selector.
 395 | // Includes the element in the search.  Depth indicates how far the search should progress.
 396 | // Depth = 1 means only consider this element.  Depth = 0 means search all the way up to the
 397 | // root.  Any other positive value of depth limits the length of the search.
 398 | func (e *Element) SelectParentLimit(selector string, depth int) *Element {
 399 | 	szSelector := C.CString(selector)
 400 | 	defer C.free(unsafe.Pointer(szSelector))
 401 | 	var parent C.HELEMENT
 402 | 	if ret := C.HTMLayoutSelectParent(e.handle, (*C.CHAR)(szSelector), C.UINT(depth), &parent); ret != HLDOM_OK {
 403 | 		domPanic(ret, "Failed to select parent dom elements, selector: '", selector, "'")
 404 | 	}
 405 | 	if parent != nil {
 406 | 		return NewElementFromHandle(HELEMENT(parent))
 407 | 	}
 408 | 	return nil
 409 | }
 410 | 
 411 | func (e *Element) SelectParent(selector string) *Element {
 412 | 	return e.SelectParentLimit(selector, 0)
 413 | }
 414 | 
 415 | // For delivering programmatic events to this element.
 416 | // Returns true if the event was handled, false otherwise
 417 | func (e *Element) SendEvent(eventCode uint, source *Element, reason uint32) bool {
 418 | 	var handled C.BOOL = 0
 419 | 	if ret := C.HTMLayoutSendEvent(e.handle, C.UINT(eventCode), source.handle, C.UINT_PTR(reason), &handled); ret != HLDOM_OK {
 420 | 		domPanic(ret, "Failed to send event")
 421 | 	}
 422 | 	return handled != 0
 423 | }
 424 | 
 425 | // For asynchronously delivering programmatic events to this element.
 426 | func (e *Element) PostEvent(eventCode uint, source *Element, reason uint32) {
 427 | 	if ret := C.HTMLayoutPostEvent(e.handle, C.UINT(eventCode), source.handle, C.UINT(reason)); ret != HLDOM_OK {
 428 | 		domPanic(ret, "Failed to post event")
 429 | 	}
 430 | }
 431 | 
 432 | //
 433 | // DOM structure accessors/modifiers:
 434 | //
 435 | 
 436 | func (e *Element) ChildCount() uint {
 437 | 	var count C.UINT
 438 | 	if ret := C.HTMLayoutGetChildrenCount(e.handle, &count); ret != HLDOM_OK {
 439 | 		domPanic(ret, "Failed to get child count")
 440 | 	}
 441 | 	return uint(count)
 442 | }
 443 | 
 444 | func (e *Element) Child(index uint) *Element {
 445 | 	var child C.HELEMENT
 446 | 	if ret := C.HTMLayoutGetNthChild(e.handle, C.UINT(index), &child); ret != HLDOM_OK {
 447 | 		domPanic(ret, "Failed to get child at index: ", index)
 448 | 	}
 449 | 	return NewElementFromHandle(HELEMENT(child))
 450 | }
 451 | 
 452 | func (e *Element) Children() []*Element {
 453 | 	slice := make([]*Element, 0, 32)
 454 | 	for i := uint(0); i < e.ChildCount(); i++ {
 455 | 		slice = append(slice, e.Child(i))
 456 | 	}
 457 | 	return slice
 458 | }
 459 | 
 460 | func (e *Element) Index() uint {
 461 | 	var index C.UINT
 462 | 	if ret := C.HTMLayoutGetElementIndex(e.handle, &index); ret != HLDOM_OK {
 463 | 		domPanic(ret, "Failed to get element's index")
 464 | 	}
 465 | 	return uint(index)
 466 | }
 467 | 
 468 | func (e *Element) Parent() *Element {
 469 | 	var parent C.HELEMENT
 470 | 	if ret := C.HTMLayoutGetParentElement(e.handle, &parent); ret != HLDOM_OK {
 471 | 		domPanic(ret, "Failed to get parent")
 472 | 	}
 473 | 	if parent != nil {
 474 | 		return NewElementFromHandle(HELEMENT(parent))
 475 | 	}
 476 | 	return nil
 477 | }
 478 | 
 479 | func (e *Element) InsertChild(child *Element, index uint) {
 480 | 	if ret := C.HTMLayoutInsertElement(child.handle, e.handle, C.UINT(index)); ret != HLDOM_OK {
 481 | 		domPanic(ret, "Failed to insert child element at index: ", index)
 482 | 	}
 483 | }
 484 | 
 485 | func (e *Element) AppendChild(child *Element) {
 486 | 	count := e.ChildCount()
 487 | 	if ret := C.HTMLayoutInsertElement(child.handle, e.handle, C.UINT(count)); ret != HLDOM_OK {
 488 | 		domPanic(ret, "Failed to append child element")
 489 | 	}
 490 | }
 491 | 
 492 | func (e *Element) Detach() {
 493 | 	if ret := C.HTMLayoutDetachElement(e.handle); ret != HLDOM_OK {
 494 | 		domPanic(ret, "Failed to detach element from dom")
 495 | 	}
 496 | }
 497 | 
 498 | func (e *Element) Delete() {
 499 | 	if ret := C.HTMLayoutDeleteElement(e.handle); ret != HLDOM_OK {
 500 | 		domPanic(ret, "Failed to delete element from dom")
 501 | 	}
 502 | 	e.finalize()
 503 | }
 504 | 
 505 | // Makes a deep clone of the receiver, the resulting subtree is not attached to the dom.
 506 | func (e *Element) Clone() *Element {
 507 | 	var clone C.HELEMENT
 508 | 	if ret := C.HTMLayoutCloneElement(e.handle, &clone); ret != HLDOM_OK {
 509 | 		domPanic(ret, "Failed to clone element")
 510 | 	}
 511 | 	return NewElementFromHandle(HELEMENT(clone))
 512 | }
 513 | 
 514 | func (e *Element) Swap(other *Element) {
 515 | 	if ret := C.HTMLayoutSwapElements(e.handle, other.handle); ret != HLDOM_OK {
 516 | 		domPanic(ret, "Failed to swap elements")
 517 | 	}
 518 | }
 519 | 
 520 | // Sorts 'count' child elements starting at index 'start'.  Uses comparator to define the
 521 | // order.  Comparator should return -1, or 0, or 1 to indicate less, equal or greater
 522 | func (e *Element) SortChildrenRange(start, count uint, comparator func(*Element, *Element) int) {
 523 | 	end := start + count
 524 | 	arg := uintptr(unsafe.Pointer(&comparator))
 525 | 	if ret := C.HTMLayoutSortElements(e.handle, C.UINT(start), C.UINT(end), (*[0]byte)(unsafe.Pointer(goElementComparator)), C.LPVOID(arg)); ret != HLDOM_OK {
 526 | 		domPanic(ret, "Failed to sort elements")
 527 | 	}
 528 | }
 529 | 
 530 | func (e *Element) SortChildren(comparator func(*Element, *Element) int) {
 531 | 	e.SortChildrenRange(0, e.ChildCount(), comparator)
 532 | }
 533 | 
 534 | func (e *Element) SetTimer(ms int) {
 535 | 	if ret := C.HTMLayoutSetTimer(e.handle, C.UINT(ms)); ret != HLDOM_OK {
 536 | 		domPanic(ret, "Failed to set timer")
 537 | 	}
 538 | }
 539 | 
 540 | func (e *Element) CancelTimer() {
 541 | 	e.SetTimer(0)
 542 | }
 543 | 
 544 | func (e *Element) Hwnd() uint32 {
 545 | 	var hwnd uint32
 546 | 	if ret := C.HTMLayoutGetElementHwnd(e.handle, (*C.HWND)(unsafe.Pointer(&hwnd)), 0); ret != HLDOM_OK {
 547 | 		domPanic(ret, "Failed to get element's hwnd")
 548 | 	}
 549 | 	return hwnd
 550 | }
 551 | 
 552 | func (e *Element) RootHwnd() uint32 {
 553 | 	var hwnd uint32
 554 | 	if ret := C.HTMLayoutGetElementHwnd(e.handle, (*C.HWND)(unsafe.Pointer(&hwnd)), 1); ret != HLDOM_OK {
 555 | 		domPanic(ret, "Failed to get element's root hwnd")
 556 | 	}
 557 | 	return hwnd
 558 | }
 559 | 
 560 | func (e *Element) Html() string {
 561 | 	var data *C.char
 562 | 	if ret := C.HTMLayoutGetElementHtml(e.handle, (*C.LPBYTE)(unsafe.Pointer(&data)), C.BOOL(0)); ret != HLDOM_OK {
 563 | 		domPanic(ret, "Failed to get inner html")
 564 | 	}
 565 | 	return C.GoString(data)
 566 | }
 567 | 
 568 | func (e *Element) OuterHtml() string {
 569 | 	var data *C.char
 570 | 	if ret := C.HTMLayoutGetElementHtml(e.handle, (*C.LPBYTE)(unsafe.Pointer(&data)), C.BOOL(1)); ret != HLDOM_OK {
 571 | 		domPanic(ret, "Failed to get outer html")
 572 | 	}
 573 | 	return C.GoString(data)
 574 | }
 575 | 
 576 | func (e *Element) Type() string {
 577 | 	var data *C.char
 578 | 	if ret := C.HTMLayoutGetElementType(e.handle, (*C.LPCSTR)(unsafe.Pointer(&data))); ret != HLDOM_OK {
 579 | 		domPanic(ret, "Failed to get element type")
 580 | 	}
 581 | 	return C.GoString(data)
 582 | }
 583 | 
 584 | func (e *Element) SetHtml(html string) {
 585 | 	szHtml := C.CString(html)
 586 | 	defer C.free(unsafe.Pointer(szHtml))
 587 | 	if ret := C.HTMLayoutSetElementHtml(e.handle, (*C.BYTE)(unsafe.Pointer(szHtml)), C.DWORD(len(html)), SIH_REPLACE_CONTENT); ret != HLDOM_OK {
 588 | 		domPanic(ret, "Failed to replace element's html")
 589 | 	}
 590 | }
 591 | 
 592 | func (e *Element) PrependHtml(prefix string) {
 593 | 	szHtml := C.CString(prefix)
 594 | 	defer C.free(unsafe.Pointer(szHtml))
 595 | 	if ret := C.HTMLayoutSetElementHtml(e.handle, (*C.BYTE)(unsafe.Pointer(szHtml)), C.DWORD(len(prefix)), SIH_INSERT_AT_START); ret != HLDOM_OK {
 596 | 		domPanic(ret, "Failed to prepend to element's html")
 597 | 	}
 598 | }
 599 | 
 600 | func (e *Element) AppendHtml(suffix string) {
 601 | 	szHtml := C.CString(suffix)
 602 | 	defer C.free(unsafe.Pointer(szHtml))
 603 | 	if ret := C.HTMLayoutSetElementHtml(e.handle, (*C.BYTE)(unsafe.Pointer(szHtml)), C.DWORD(len(suffix)), SIH_APPEND_AFTER_LAST); ret != HLDOM_OK {
 604 | 		domPanic(ret, "Failed to append to element's html")
 605 | 	}
 606 | }
 607 | 
 608 | func (e *Element) SetText(text string) {
 609 | 	szText := C.CString(text)
 610 | 	defer C.free(unsafe.Pointer(szText))
 611 | 	if ret := C.HTMLayoutSetElementInnerText(e.handle, (*C.BYTE)(unsafe.Pointer(szText)), C.UINT(len(text))); ret != HLDOM_OK {
 612 | 		domPanic(ret, "Failed to replace element's text")
 613 | 	}
 614 | }
 615 | 
 616 | func (e *Element) Text() string {
 617 | 	var data *C.char
 618 | 	if ret := C.HTMLayoutGetElementInnerText(e.handle, (*C.LPBYTE)(unsafe.Pointer(&data))); ret != HLDOM_OK {
 619 | 		domPanic(ret, "Failed to get text")
 620 | 	}
 621 | 	return C.GoString(data)
 622 | }
 623 | 
 624 | 
 625 | //
 626 | // HTML attribute accessors/modifiers:
 627 | //
 628 | 
 629 | // Returns the value of attr and a boolean indicating whether or not that attr exists.
 630 | // If the boolean is true, then the returned string is valid.
 631 | func (e *Element) Attr(key string) (string, bool) {
 632 | 	szValue := (*C.WCHAR)(nil)
 633 | 	szKey := C.CString(key)
 634 | 	defer C.free(unsafe.Pointer(szKey))
 635 | 	if ret := C.HTMLayoutGetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.LPCWSTR)(&szValue)); ret != HLDOM_OK {
 636 | 		domPanic(ret, "Failed to get attribute: ", key)
 637 | 	}
 638 | 	if szValue != nil {
 639 | 		return utf16ToString((*uint16)(szValue)), true
 640 | 	}
 641 | 	return "", false
 642 | }
 643 | 
 644 | func (e *Element) AttrAsFloat(key string) (float64, bool, error) {
 645 | 	var f float64
 646 | 	var err error
 647 | 	if s, exists := e.Attr(key); !exists {
 648 | 		return 0.0, false, nil
 649 | 	} else if f, err = strconv.ParseFloat(s, 64); err != nil {
 650 | 		return 0.0, true, err
 651 | 	}
 652 | 	return float64(f), true, nil
 653 | }
 654 | 
 655 | func (e *Element) AttrAsInt(key string) (int, bool, error) {
 656 | 	var i int
 657 | 	var err error
 658 | 	if s, exists := e.Attr(key); !exists {
 659 | 		return 0, false, nil
 660 | 	} else if i, err = strconv.Atoi(s); err != nil {
 661 | 		return 0, true, err
 662 | 	}
 663 | 	return i, true, nil
 664 | }
 665 | 
 666 | func (e *Element) SetAttr(key string, value interface{}) {
 667 | 	szKey := C.CString(key)
 668 | 	defer C.free(unsafe.Pointer(szKey))
 669 | 	var ret C.HLDOM_RESULT = HLDOM_OK
 670 | 	switch v := value.(type) {
 671 | 	case string:
 672 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(stringToUtf16Ptr(v)))
 673 | 	case float32:
 674 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(stringToUtf16Ptr(strconv.FormatFloat(float64(v), 'g', -1, 64))))
 675 | 	case float64:
 676 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(stringToUtf16Ptr(strconv.FormatFloat(float64(v), 'g', -1, 64))))
 677 | 	case int:
 678 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(stringToUtf16Ptr(strconv.Itoa(v))))
 679 | 	case int32:
 680 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(stringToUtf16Ptr(strconv.FormatInt(int64(v), 10))))
 681 | 	case int64:
 682 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(stringToUtf16Ptr(strconv.FormatInt(v, 10))))
 683 | 	case nil:
 684 | 		ret = C.HTMLayoutSetAttributeByName(e.handle, (*C.CHAR)(szKey), nil)
 685 | 	default:
 686 | 		panic(fmt.Sprintf("Don't know how to format this argument type: %s", reflect.TypeOf(v)))
 687 | 	}
 688 | 	if ret != HLDOM_OK {
 689 | 		domPanic(ret, "Failed to set attribute: "+key)
 690 | 	}
 691 | }
 692 | 
 693 | func (e *Element) RemoveAttr(key string) {
 694 | 	e.SetAttr(key, nil)
 695 | }
 696 | 
 697 | func (e *Element) AttrByIndex(index int) (string, string) {
 698 | 	szValue := (*C.WCHAR)(nil)
 699 | 	szName := (*C.CHAR)(nil)
 700 | 	if ret := C.HTMLayoutGetNthAttribute(e.handle, C.UINT(index), (*C.LPCSTR)(&szName), (*C.LPCWSTR)(&szValue)); ret != HLDOM_OK {
 701 | 		domPanic(ret, fmt.Sprintf("Failed to get attribute by index: %u", index))
 702 | 	}
 703 | 	return C.GoString((*C.char)(szName)), utf16ToString((*uint16)(szValue))
 704 | }
 705 | 
 706 | func (e *Element) AttrCount() uint {
 707 | 	var count C.UINT = 0
 708 | 	if ret := C.HTMLayoutGetAttributeCount(e.handle, &count); ret != HLDOM_OK {
 709 | 		domPanic(ret, "Failed to get attribute count")
 710 | 	}
 711 | 	return uint(count)
 712 | }
 713 | 
 714 | //
 715 | // CSS style attribute accessors/mutators
 716 | //
 717 | 
 718 | // Returns the value of the style and a boolean indicating whether or not that style exists.
 719 | // If the boolean is true, then the returned string is valid.
 720 | func (e *Element) Style(key string) (string, bool) {
 721 | 	szValue := (*C.WCHAR)(nil)
 722 | 	szKey := C.CString(key)
 723 | 	defer C.free(unsafe.Pointer(szKey))
 724 | 	if ret := C.HTMLayoutGetStyleAttribute(e.handle, (*C.CHAR)(szKey), (*C.LPCWSTR)(&szValue)); ret != HLDOM_OK {
 725 | 		domPanic(ret, "Failed to get style: "+key)
 726 | 	}
 727 | 	if szValue != nil {
 728 | 		return utf16ToString((*uint16)(szValue)), true
 729 | 	}
 730 | 	return "", false
 731 | }
 732 | 
 733 | func (e *Element) SetStyle(key string, value interface{}) {
 734 | 	szKey := C.CString(key)
 735 | 	defer C.free(unsafe.Pointer(szKey))
 736 | 	var valuePtr *uint16 = nil
 737 | 
 738 | 	switch v := value.(type) {
 739 | 	case string:
 740 | 		valuePtr = stringToUtf16Ptr(v)
 741 | 	case float32:
 742 | 		valuePtr = stringToUtf16Ptr(strconv.FormatFloat(float64(v), 'g', -1, 64))
 743 | 	case float64:
 744 | 		valuePtr = stringToUtf16Ptr(strconv.FormatFloat(float64(v), 'g', -1, 64))
 745 | 	case int:
 746 | 		valuePtr = stringToUtf16Ptr(strconv.Itoa(v))
 747 | 	case int32:
 748 | 		valuePtr = stringToUtf16Ptr(strconv.FormatInt(int64(v), 10))
 749 | 	case int64:
 750 | 		valuePtr = stringToUtf16Ptr(strconv.FormatInt(v, 10))
 751 | 	case nil:
 752 | 		valuePtr = nil
 753 | 	default:
 754 | 		panic(fmt.Sprintf("Don't know how to format this argument type: %s", reflect.TypeOf(v)))
 755 | 	}
 756 | 
 757 | 	if ret := C.HTMLayoutSetStyleAttribute(e.handle, (*C.CHAR)(szKey), (*C.WCHAR)(valuePtr)); ret != HLDOM_OK {
 758 | 		domPanic(ret, "Failed to set style: "+key)
 759 | 	}
 760 | }
 761 | 
 762 | func (e *Element) RemoveStyle(key string) {
 763 | 	e.SetStyle(key, nil)
 764 | }
 765 | 
 766 | func (e *Element) ClearStyles(key string) {
 767 | 	if ret := C.HTMLayoutSetStyleAttribute(e.handle, nil, nil); ret != HLDOM_OK {
 768 | 		domPanic(ret, "Failed to clear all styles")
 769 | 	}
 770 | }
 771 | 
 772 | //
 773 | // Element state manipulation
 774 | //
 775 | 
 776 | // Gets the whole set of state flags for this element
 777 | func (e *Element) StateFlags() uint32 {
 778 | 	var state C.UINT
 779 | 	if ret := C.HTMLayoutGetElementState(e.handle, &state); ret != HLDOM_OK {
 780 | 		domPanic(ret, "Failed to get element state flags")
 781 | 	}
 782 | 	return uint32(state)
 783 | }
 784 | 
 785 | // Replaces the whole set of state flags with the specified value
 786 | func (e *Element) SetStateFlags(flags uint32) {
 787 | 	shouldUpdate := C.BOOL(1)
 788 | 	if ret := C.HTMLayoutSetElementState(e.handle, C.UINT(flags), C.UINT(^flags), shouldUpdate); ret != HLDOM_OK {
 789 | 		domPanic(ret, "Failed to set element state flags")
 790 | 	}
 791 | }
 792 | 
 793 | // Returns true if the specified flag is "on"
 794 | func (e *Element) State(flag uint32) bool {
 795 | 	return e.StateFlags()&flag != 0
 796 | }
 797 | 
 798 | // Sets the specified flag to "on" or "off" according to the value of the provided boolean
 799 | func (e *Element) SetState(flag uint32, on bool) {
 800 | 	addBits := uint32(0)
 801 | 	clearBits := uint32(0)
 802 | 	if on {
 803 | 		addBits = flag
 804 | 	} else {
 805 | 		clearBits = flag
 806 | 	}
 807 | 	shouldUpdate := C.BOOL(1)
 808 | 	if ret := C.HTMLayoutSetElementState(e.handle, C.UINT(addBits), C.UINT(clearBits), shouldUpdate); ret != HLDOM_OK {
 809 | 		domPanic(ret, "Failed to set element state flag")
 810 | 	}
 811 | }
 812 | 
 813 | //
 814 | // Functions for retrieving/setting the various dimensions of an element
 815 | //
 816 | 
 817 | func (e *Element) Move(x, y int) {
 818 | 	if ret := C.HTMLayoutMoveElement(e.handle, C.INT(x), C.INT(y)); ret != HLDOM_OK {
 819 | 		domPanic(ret, "Failed to move element")
 820 | 	}
 821 | }
 822 | 
 823 | func (e *Element) Resize(x, y, w, h int) {
 824 | 	if ret := C.HTMLayoutMoveElementEx(e.handle, C.INT(x), C.INT(y), C.INT(w), C.INT(h)); ret != HLDOM_OK {
 825 | 		domPanic(ret, "Failed to resize element")
 826 | 	}
 827 | }
 828 | 
 829 | func (e *Element) getRect(rectTypeFlags uint32) (left, top, right, bottom int) {
 830 | 	r := Rect{}
 831 | 	if ret := C.HTMLayoutGetElementLocation(e.handle, (C.LPRECT)(unsafe.Pointer(&r)), C.UINT(rectTypeFlags)); ret != HLDOM_OK {
 832 | 		domPanic(ret, "Failed to get element rect")
 833 | 	}
 834 | 	return int(r.Left), int(r.Top), int(r.Right), int(r.Bottom)
 835 | }
 836 | 
 837 | func (e *Element) ContentBox() (left, top, right, bottom int) {
 838 | 	return e.getRect(CONTENT_BOX)
 839 | }
 840 | 
 841 | func (e *Element) ContentViewBox() (left, top, right, bottom int) {
 842 | 	return e.getRect(CONTENT_BOX | VIEW_RELATIVE)
 843 | }
 844 | 
 845 | func (e *Element) ContentBoxSize() (width, height int) {
 846 | 	l, t, r, b := e.getRect(CONTENT_BOX)
 847 | 	return int(r - l), int(b - t)
 848 | }
 849 | 
 850 | func (e *Element) PaddingBox() (left, top, right, bottom int) {
 851 | 	return e.getRect(PADDING_BOX)
 852 | }
 853 | 
 854 | func (e *Element) PaddingViewBox() (left, top, right, bottom int) {
 855 | 	return e.getRect(PADDING_BOX | VIEW_RELATIVE)
 856 | }
 857 | 
 858 | func (e *Element) PaddingBoxSize() (width, height int) {
 859 | 	l, t, r, b := e.getRect(PADDING_BOX)
 860 | 	return int(r - l), int(b - t)
 861 | }
 862 | 
 863 | func (e *Element) BorderBox() (left, top, right, bottom int) {
 864 | 	return e.getRect(BORDER_BOX)
 865 | }
 866 | 
 867 | func (e *Element) BorderViewBox() (left, top, right, bottom int) {
 868 | 	return e.getRect(BORDER_BOX | VIEW_RELATIVE)
 869 | }
 870 | 
 871 | func (e *Element) BorderBoxSize() (width, height int) {
 872 | 	l, t, r, b := e.getRect(BORDER_BOX)
 873 | 	return int(r - l), int(b - t)
 874 | }
 875 | 
 876 | func (e *Element) MarginBox() (left, top, right, bottom int) {
 877 | 	return e.getRect(MARGIN_BOX)
 878 | }
 879 | 
 880 | func (e *Element) MarginViewBox() (left, top, right, bottom int) {
 881 | 	return e.getRect(MARGIN_BOX | VIEW_RELATIVE)
 882 | }
 883 | 
 884 | func (e *Element) MarginBoxSize() (width, height int) {
 885 | 	l, t, r, b := e.getRect(MARGIN_BOX)
 886 | 	return int(r - l), int(b - t)
 887 | }
 888 | 
 889 | 
 890 | 
 891 | //
 892 | // Functions for retrieving/setting the value in widget input controls
 893 | //
 894 | 
 895 | type textValueParams struct {
 896 | 	MethodId uint32
 897 | 	Text *uint16
 898 | 	Length uint32
 899 | }
 900 | 
 901 | func (e *Element) ValueAsString() (string, error) {
 902 | 	args := &textValueParams{ MethodId: GET_TEXT_VALUE }
 903 | 	ret := C.HTMLayoutCallBehaviorMethod(e.handle, (*C.METHOD_PARAMS)(unsafe.Pointer(args)))
 904 | 	if ret == HLDOM_OK_NOT_HANDLED {
 905 | 		domPanic(ret, "This type of element does not provide data in this way.  Try a <widget>.")
 906 | 	} else if ret != HLDOM_OK {
 907 | 		domPanic(ret, "Could not get text value")
 908 | 	}
 909 | 	if args.Text == nil {
 910 | 		return "", errors.New("Nil string pointer")
 911 | 	}
 912 | 	return utf16ToStringLength(args.Text, int(args.Length)), nil
 913 | }
 914 | 
 915 | func (e *Element) SetValue(value interface{}) {
 916 | 	switch v := value.(type) {
 917 | 	case string:
 918 | 		args := &textValueParams{
 919 | 			MethodId: SET_TEXT_VALUE,
 920 | 			Text: stringToUtf16Ptr(v),
 921 | 			Length: uint32(len(v)),
 922 | 		}
 923 | 		ret := C.HTMLayoutCallBehaviorMethod(e.handle, (*C.METHOD_PARAMS)(unsafe.Pointer(args)))
 924 | 		if ret == HLDOM_OK_NOT_HANDLED {
 925 | 			domPanic(ret, "This type of element does not accept data in this way.  Try a <widget>.")
 926 | 		} else if ret != HLDOM_OK {
 927 | 			domPanic(ret, "Could not set text value")
 928 | 		}
 929 | 	default:
 930 | 		panic("Don't know how to set values of this type")
 931 | 	}
 932 | }
 933 | 
 934 | 
 935 | 
 936 | //
 937 | // The following are not strictly wrappers of htmlayout functions, but rather convenience 
 938 | // functions that are helpful in common use cases
 939 | //
 940 | 
 941 | func (e *Element) Describe() string {
 942 | 	s := e.Type()
 943 | 	if value, exists := e.Attr("id"); exists {
 944 | 		s += "#" + value
 945 | 	}
 946 | 	if value, exists := e.Attr("class"); exists {
 947 | 		values := strings.Split(value, " ")
 948 | 		for _, v := range values {
 949 | 			s += "." + v
 950 | 		}
 951 | 	}
 952 | 	return s
 953 | }
 954 | 
 955 | // Returns the first of the child elements matching the selector.  If no elements
 956 | // match, the function panics
 957 | func (e *Element) SelectFirst(selector string) *Element {
 958 | 	results := e.Select(selector)
 959 | 	if len(results) == 0 {
 960 | 		panic(fmt.Sprintf("No elements match selector '%s'", selector))
 961 | 	}
 962 | 	return results[0]
 963 | }
 964 | 
 965 | // Returns the only child element that matches the selector.  If no elements match
 966 | // or more than one element matches, the function panics
 967 | func (e *Element) SelectUnique(selector string) *Element {
 968 | 	results := e.Select(selector)
 969 | 	if len(results) == 0 {
 970 | 		panic(fmt.Sprintf("No elements match selector '%s'", selector))
 971 | 	} else if len(results) > 1 {
 972 | 		panic(fmt.Sprintf("More than one element match selector '%s'", selector))
 973 | 	}
 974 | 	return results[0]
 975 | }
 976 | 
 977 | // A wrapper of SelectUnique that auto-prepends a hash to the provided id.
 978 | // Useful when selecting elements base on a programmatically retrieved id (which does
 979 | // not already have the hash on it)
 980 | func (e *Element) SelectId(id string) *Element {
 981 | 	return e.SelectUnique(fmt.Sprintf("#%s", id))
 982 | }
 983 | 
 984 | //
 985 | // Functions for manipulating the set of classes applied to this element:
 986 | //
 987 | 
 988 | // Returns true if the specified class is among those listed in the "class" attribute.
 989 | func (e *Element) HasClass(class string) bool {
 990 | 	if classList, exists := e.Attr("class"); !exists {
 991 | 		return false
 992 | 	} else if classes := whitespaceSplitter.FindAllString(classList, -1); classes == nil {
 993 | 		return false
 994 | 	} else {
 995 | 		for _, item := range classes {
 996 | 			if class == item {
 997 | 				return true
 998 | 			}
 999 | 		}
1000 | 	}
1001 | 	return false
1002 | }
1003 | 
1004 | // Adds the specified class to the classes listed in the "class" attribute, or does nothing
1005 | // if this class is already included in the list.
1006 | func (e *Element) AddClass(class string) {
1007 | 	if classList, exists := e.Attr("class"); !exists {
1008 | 		e.SetAttr("class", class)
1009 | 	} else if classes := whitespaceSplitter.FindAllString(classList, -1); classes == nil {
1010 | 		e.SetAttr("class", class)
1011 | 	} else {
1012 | 		for _, item := range classes {
1013 | 			if class == item {
1014 | 				return
1015 | 			}
1016 | 		}
1017 | 		classes = append(classes, class)
1018 | 		e.SetAttr("class", strings.Join(classes, " "))
1019 | 	}
1020 | }
1021 | 
1022 | // Removes the specified class from the classes listed in the "class" attribute, or does nothing
1023 | // if this class is not included in the list.
1024 | func (e *Element) RemoveClass(class string) {
1025 | 	if classList, exists := e.Attr("class"); exists {
1026 | 		if classes := whitespaceSplitter.FindAllString(classList, -1); classes != nil {
1027 | 			for i, item := range classes {
1028 | 				if class == item {
1029 | 					// Delete the item from the list
1030 | 					classes = append(classes[:i], classes[i+1:]...)
1031 | 					e.SetAttr("class", strings.Join(classes, " "))
1032 | 					return
1033 | 				}
1034 | 			}
1035 | 		}
1036 | 	}
1037 | }
1038 | 


--------------------------------------------------------------------------------
/event_handler.go:
--------------------------------------------------------------------------------
 1 | package gohl
 2 | 
 3 | type EventHandler struct {
 4 | 	OnAttached      func(he HELEMENT)
 5 | 	OnDetached      func(he HELEMENT)
 6 | 	OnMouse         func(he HELEMENT, params *MouseParams) bool
 7 | 	OnKey           func(he HELEMENT, params *KeyParams) bool
 8 | 	OnFocus         func(he HELEMENT, params *FocusParams) bool
 9 | 	OnDraw          func(he HELEMENT, params *DrawParams) bool
10 | 	OnTimer         func(he HELEMENT, params *TimerParams) bool
11 | 	OnBehaviorEvent func(he HELEMENT, params *BehaviorEventParams) bool
12 | 	OnMethodCall    func(he HELEMENT, params *MethodParams) bool
13 | 	OnDataArrived   func(he HELEMENT, params *DataArrivedParams) bool
14 | 	OnSize          func(he HELEMENT)
15 | 	OnScroll        func(he HELEMENT, params *ScrollParams) bool
16 | 	OnExchange      func(he HELEMENT, params *ExchangeParams) bool
17 | 	OnGesture       func(he HELEMENT, params *GestureParams) bool
18 | }
19 | 
20 | func (e *EventHandler) Subscription() uint32 {
21 | 	var subscription uint32 = 0
22 | 	add := func(f interface{}, flag uint32) {
23 | 		if f != nil {
24 | 			subscription |= flag
25 | 		}
26 | 	}
27 | 
28 | 	// OnAttached and OnDetached purposely omitted, since we must receive these events
29 | 	add(e.OnMouse, HANDLE_MOUSE)
30 | 	add(e.OnKey, HANDLE_KEY)
31 | 	add(e.OnFocus, HANDLE_FOCUS)
32 | 	add(e.OnDraw, HANDLE_DRAW)
33 | 	add(e.OnTimer, HANDLE_TIMER)
34 | 	add(e.OnBehaviorEvent, HANDLE_BEHAVIOR_EVENT)
35 | 	add(e.OnMethodCall, HANDLE_METHOD_CALL)
36 | 	add(e.OnDataArrived, HANDLE_DATA_ARRIVED)
37 | 	add(e.OnSize, HANDLE_SIZE)
38 | 	add(e.OnScroll, HANDLE_SCROLL)
39 | 	add(e.OnExchange, HANDLE_EXCHANGE)
40 | 	add(e.OnGesture, HANDLE_GESTURE)
41 | 
42 | 	return subscription
43 | }
44 | 


--------------------------------------------------------------------------------
/get_htmlayout.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import zipfile
 3 | import urllib2
 4 | import shutil
 5 | import patch_htmlayout_header
 6 | 
 7 | URL = "http://www.terrainformatica.com/htmlayout/HTMLayoutSDK.zip"
 8 | PATH = "./HTMLayoutSDK.zip"
 9 | TARGET = "./htmlayout"
10 | DLL = os.path.join(TARGET, "bin", "htmlayout.dll")
11 | DLL_TEST_DEST = os.path.join(os.path.basename(DLL))
12 | 
13 | """
14 | Borrowed this unzipper from:
15 | http://code.activestate.com/recipes/252508-file-unzip/
16 | """
17 | class Unzipper:
18 |     def __init__(self, verbose = False, percent = 10):
19 |         self.verbose = verbose
20 |         self.percent = percent
21 |         
22 |     def extract(self, file, dir):
23 |         if not dir.endswith(':') and not os.path.exists(dir):
24 |             os.mkdir(dir)
25 | 
26 |         zf = zipfile.ZipFile(file)
27 | 
28 |         # create directory structure to house files
29 |         self._createstructure(file, dir)
30 | 
31 |         num_files = len(zf.namelist())
32 |         percent = self.percent
33 |         divisions = 100 / percent
34 |         perc = int(num_files / divisions)
35 | 
36 |         # extract files to directory structure
37 |         for i, name in enumerate(zf.namelist()):
38 |             if self.verbose == True:
39 |                 print("Extracting %s" % name)
40 |             elif perc > 0 and (i % perc) == 0 and i > 0:
41 |                 complete = int (i / perc) * percent
42 |                 print("%s%% complete" % complete)
43 |             if not name.endswith('/'):
44 |                 outfile = open(os.path.join(dir, name), 'wb')
45 |                 outfile.write(zf.read(name))
46 |                 outfile.flush()
47 |                 outfile.close()
48 | 
49 |     def _createstructure(self, file, dir):
50 |         self._makedirs(self._listdirs(file), dir)
51 | 
52 |     def _makedirs(self, directories, basedir):
53 |         """ Create any directories that don't currently exist """
54 |         for dir in directories:
55 |             curdir = os.path.join(basedir, dir)
56 |             if not os.path.exists(curdir):
57 |                 os.mkdir(curdir)
58 | 
59 |     def _listdirs(self, file):
60 |         """ Grabs all the directories in the zip structure
61 |         This is necessary to create the structure before trying
62 |         to extract the file to it. """
63 |         zf = zipfile.ZipFile(file)
64 |         dirs = []
65 |         for name in zf.namelist():
66 |             if name.endswith('/'):
67 |                 dirs.append(name)
68 |         dirs.sort()
69 |         return dirs
70 | 
71 | 
72 | 
73 | def main():
74 |     if os.path.exists(PATH):
75 |         os.remove(PATH)
76 |     if os.path.exists(TARGET):
77 |         shutil.rmtree(TARGET)
78 |     print("Downloading sdk...")
79 |     with open(PATH, "wb") as dest:
80 |         source = urllib2.urlopen(URL)
81 |         dest.write(source.read())
82 |         source.close()
83 |     print("Download complete, extracting...")
84 |     os.mkdir(TARGET)
85 |     z = Unzipper()
86 |     z.extract(PATH, TARGET)
87 |     print("Extraction complete, patching...")
88 |     patch_htmlayout_header.main()
89 |     print("Copying htmlayout.dll into src folder so that tests can run...")
90 |     shutil.copyfile(DLL, DLL_TEST_DEST)
91 |     print("Finished.")
92 | 
93 | if __name__ == "__main__":
94 |     main()


--------------------------------------------------------------------------------
/htmlayout.go:
--------------------------------------------------------------------------------
  1 | package gohl
  2 | 
  3 | /*
  4 | #cgo CFLAGS: -I./htmlayout/include
  5 | #cgo LDFLAGS: ./htmlayout/lib/HTMLayout.lib
  6 | 
  7 | #include <stdlib.h>
  8 | #include <htmlayout.h>
  9 | */
 10 | import "C"
 11 | 
 12 | import (
 13 | 	"log"
 14 | 	"errors"
 15 | 	"syscall"
 16 | 	"unsafe"
 17 | )
 18 | 
 19 | const (
 20 | 
 21 | 	// HTMLayout Notify Events
 22 | 	HLN_CREATE_CONTROL    = C.HLN_CREATE_CONTROL
 23 | 	HLN_LOAD_DATA         = C.HLN_LOAD_DATA
 24 | 	HLN_CONTROL_CREATED   = C.HLN_CONTROL_CREATED
 25 | 	HLN_DATA_LOADED       = C.HLN_DATA_LOADED
 26 | 	HLN_DOCUMENT_COMPLETE = C.HLN_DOCUMENT_COMPLETE
 27 | 	HLN_UPDATE_UI         = C.HLN_UPDATE_UI
 28 | 	HLN_DESTROY_CONTROL   = C.HLN_DESTROY_CONTROL
 29 | 	HLN_ATTACH_BEHAVIOR   = C.HLN_ATTACH_BEHAVIOR
 30 | 	HLN_BEHAVIOR_CHANGED  = C.HLN_BEHAVIOR_CHANGED
 31 | 	HLN_DIALOG_CREATED    = C.HLN_DIALOG_CREATED
 32 | 	HLN_DIALOG_CLOSE_RQ   = C.HLN_DIALOG_CLOSE_RQ
 33 | 	HLN_DOCUMENT_LOADED   = C.HLN_DOCUMENT_LOADED
 34 | 
 35 | 	// PhaseMask
 36 | 	BUBBLING = uint32(C.BUBBLING) // bubbling (emersion) phase
 37 | 	SINKING  = uint32(C.SINKING)  // capture (immersion) phase, this flag is or'ed with EVENTS codes below
 38 | 	HANDLED  = uint32(C.HANDLED)  // event already processed.
 39 | 
 40 | 	// EventGroups
 41 | 	HANDLE_INITIALIZATION = C.HANDLE_INITIALIZATION /** attached/detached */
 42 | 	HANDLE_MOUSE          = C.HANDLE_MOUSE          /** mouse events */
 43 | 	HANDLE_KEY            = C.HANDLE_KEY            /** key events */
 44 | 	HANDLE_FOCUS          = C.HANDLE_FOCUS          /** focus events, if this flag is set it also means that element it attached to is focusable */
 45 | 	HANDLE_SCROLL         = C.HANDLE_SCROLL         /** scroll events */
 46 | 	HANDLE_TIMER          = C.HANDLE_TIMER          /** timer event */
 47 | 	HANDLE_SIZE           = C.HANDLE_SIZE           /** size changed event */
 48 | 	HANDLE_DRAW           = C.HANDLE_DRAW           /** drawing request (event) */
 49 | 	HANDLE_DATA_ARRIVED   = C.HANDLE_DATA_ARRIVED   /** requested data () has been delivered */
 50 | 	HANDLE_BEHAVIOR_EVENT = C.HANDLE_BEHAVIOR_EVENT /** secondary, synthetic events: 
 51 | 	BUTTON_CLICK, HYPERLINK_CLICK, etc., 
 52 | 	a.k.a. notifications from intrinsic behaviors */
 53 | 	HANDLE_METHOD_CALL     = C.HANDLE_METHOD_CALL     /** behavior specific methods */
 54 | 	HANDLE_EXCHANGE        = C.HANDLE_EXCHANGE        /** system drag-n-drop */
 55 | 	HANDLE_GESTURE         = C.HANDLE_GESTURE         /** touch input events */
 56 | 	HANDLE_ALL             = C.HANDLE_ALL             /** all of them */
 57 | 	DISABLE_INITIALIZATION = C.DISABLE_INITIALIZATION /** disable INITIALIZATION events to be sent. */
 58 | 
 59 | 	// KeyboardStates
 60 | 	CONTROL_KEY_PRESSED = C.CONTROL_KEY_PRESSED
 61 | 	SHIFT_KEY_PRESSED   = C.SHIFT_KEY_PRESSED
 62 | 	ALT_KEY_PRESSED     = C.ALT_KEY_PRESSED
 63 | 
 64 | 	// InitializationEvents
 65 | 	BEHAVIOR_DETACH = C.BEHAVIOR_DETACH
 66 | 	BEHAVIOR_ATTACH = C.BEHAVIOR_ATTACH
 67 | 
 68 | 	// DraggingType
 69 | 	NO_DRAGGING   = C.NO_DRAGGING
 70 | 	DRAGGING_MOVE = C.DRAGGING_MOVE
 71 | 	DRAGGING_COPY = C.DRAGGING_COPY
 72 | 
 73 | 	// MouseButtons
 74 | 	MAIN_MOUSE_BUTTON   = C.MAIN_MOUSE_BUTTON //aka left button
 75 | 	PROP_MOUSE_BUTTON   = C.PROP_MOUSE_BUTTON //aka right button
 76 | 	MIDDLE_MOUSE_BUTTON = C.MIDDLE_MOUSE_BUTTON
 77 | 	X1_MOUSE_BUTTON     = C.X1_MOUSE_BUTTON
 78 | 	X2_MOUSE_BUTTON     = C.X2_MOUSE_BUTTON
 79 | 
 80 | 	// MouseEvents
 81 | 	MOUSE_ENTER  = C.MOUSE_ENTER
 82 | 	MOUSE_LEAVE  = C.MOUSE_LEAVE
 83 | 	MOUSE_MOVE   = C.MOUSE_MOVE
 84 | 	MOUSE_UP     = C.MOUSE_UP
 85 | 	MOUSE_DOWN   = C.MOUSE_DOWN
 86 | 	MOUSE_DCLICK = C.MOUSE_DCLICK
 87 | 	MOUSE_WHEEL  = C.MOUSE_WHEEL
 88 | 	MOUSE_TICK   = C.MOUSE_TICK   // mouse pressed ticks
 89 | 	MOUSE_IDLE   = C.MOUSE_IDLE   // mouse stay idle for some time
 90 | 	DROP         = C.DROP         // item dropped, target is that dropped item 
 91 | 	DRAG_ENTER   = C.DRAG_ENTER   // drag arrived to the target element that is one of current drop targets.  
 92 | 	DRAG_LEAVE   = C.DRAG_LEAVE   // drag left one of current drop targets. target is the drop target element.  
 93 | 	DRAG_REQUEST = C.DRAG_REQUEST // drag src notification before drag start. To cancel - return true from handler.
 94 | 	MOUSE_CLICK  = C.MOUSE_CLICK  // mouse click event
 95 | 	DRAGGING     = C.DRAGGING     // This flag is 'ORed' with MOUSE_ENTER..MOUSE_DOWN codes if dragging operation is in effect.
 96 | 	// E.g. event DRAGGING | MOUSE_MOVE is sent to underlying DOM elements while dragging.
 97 | 
 98 | 	// CursorType
 99 | 	CURSOR_ARROW       = C.CURSOR_ARROW       //0
100 | 	CURSOR_IBEAM       = C.CURSOR_IBEAM       //1
101 | 	CURSOR_WAIT        = C.CURSOR_WAIT        //2
102 | 	CURSOR_CROSS       = C.CURSOR_CROSS       //3
103 | 	CURSOR_UPARROW     = C.CURSOR_UPARROW     //4
104 | 	CURSOR_SIZENWSE    = C.CURSOR_SIZENWSE    //5
105 | 	CURSOR_SIZENESW    = C.CURSOR_SIZENESW    //6
106 | 	CURSOR_SIZEWE      = C.CURSOR_SIZEWE      //7
107 | 	CURSOR_SIZENS      = C.CURSOR_SIZENS      //8
108 | 	CURSOR_SIZEALL     = C.CURSOR_SIZEALL     //9 
109 | 	CURSOR_NO          = C.CURSOR_NO          //10
110 | 	CURSOR_APPSTARTING = C.CURSOR_APPSTARTING //11
111 | 	CURSOR_HELP        = C.CURSOR_HELP        //12
112 | 	CURSOR_HAND        = C.CURSOR_HAND        //13
113 | 	CURSOR_DRAG_MOVE   = C.CURSOR_DRAG_MOVE   //14 
114 | 	CURSOR_DRAG_COPY   = C.CURSOR_DRAG_COPY   //15
115 | 
116 | 	// KeyEvents
117 | 	KEY_DOWN = C.KEY_DOWN
118 | 	KEY_UP   = C.KEY_UP
119 | 	KEY_CHAR = C.KEY_CHAR
120 | 
121 | 	// FocusEvents
122 | 	FOCUS_LOST = C.FOCUS_LOST
123 | 	FOCUS_GOT  = C.FOCUS_GOT
124 | 
125 | 	// FocusCause
126 | 	BY_CODE     = C.BY_CODE
127 | 	BY_MOUSE    = C.BY_MOUSE
128 | 	BY_KEY_NEXT = C.BY_KEY_NEXT
129 | 	BY_KEY_PREV = C.BY_KEY_PREV
130 | 
131 | 	// ScrollEvents
132 | 	SCROLL_HOME            = C.SCROLL_HOME
133 | 	SCROLL_END             = C.SCROLL_END
134 | 	SCROLL_STEP_PLUS       = C.SCROLL_STEP_PLUS
135 | 	SCROLL_STEP_MINUS      = C.SCROLL_STEP_MINUS
136 | 	SCROLL_PAGE_PLUS       = C.SCROLL_PAGE_PLUS
137 | 	SCROLL_PAGE_MINUS      = C.SCROLL_PAGE_MINUS
138 | 	SCROLL_POS             = C.SCROLL_POS
139 | 	SCROLL_SLIDER_RELEASED = C.SCROLL_SLIDER_RELEASED
140 | 
141 | 	// GestureCmd
142 | 	GESTURE_REQUEST = C.GESTURE_REQUEST // return true and fill flags if it will handle gestures.
143 | 	GESTURE_ZOOM    = C.GESTURE_ZOOM    // The zoom gesture.
144 | 	GESTURE_PAN     = C.GESTURE_PAN     // The pan gesture.
145 | 	GESTURE_ROTATE  = C.GESTURE_ROTATE  // The rotation gesture.
146 | 	GESTURE_TAP1    = C.GESTURE_TAP1    // The tap gesture.
147 | 	GESTURE_TAP2    = C.GESTURE_TAP2    // The two-finger tap gesture.
148 | 
149 | 	// GestureState
150 | 	GESTURE_STATE_BEGIN   = C.GESTURE_STATE_BEGIN   // starts
151 | 	GESTURE_STATE_INERTIA = C.GESTURE_STATE_INERTIA // events generated by inertia processor
152 | 	GESTURE_STATE_END     = C.GESTURE_STATE_END     // end, last event of the gesture sequence
153 | 
154 | 	// GestureTypeFlags
155 | 	GESTURE_FLAG_ZOOM             = C.GESTURE_FLAG_ZOOM
156 | 	GESTURE_FLAG_ROTATE           = C.GESTURE_FLAG_ROTATE
157 | 	GESTURE_FLAG_PAN_VERTICAL     = C.GESTURE_FLAG_PAN_VERTICAL
158 | 	GESTURE_FLAG_PAN_HORIZONTAL   = C.GESTURE_FLAG_PAN_HORIZONTAL
159 | 	GESTURE_FLAG_TAP1             = C.GESTURE_FLAG_TAP1             // press & tap
160 | 	GESTURE_FLAG_TAP2             = C.GESTURE_FLAG_TAP2             // two fingers tap
161 | 	GESTURE_FLAG_PAN_WITH_GUTTER  = C.GESTURE_FLAG_PAN_WITH_GUTTER  // PAN_VERTICAL and PAN_HORIZONTAL modifiers
162 | 	GESTURE_FLAG_PAN_WITH_INERTIA = C.GESTURE_FLAG_PAN_WITH_INERTIA //
163 | 	GESTURE_FLAGS_ALL             = C.GESTURE_FLAGS_ALL             //
164 | 
165 | 	// DrawEvents
166 | 	DRAW_BACKGROUND = C.DRAW_BACKGROUND
167 | 	DRAW_CONTENT    = C.DRAW_CONTENT
168 | 	DRAW_FOREGROUND = C.DRAW_FOREGROUND
169 | 
170 | 	// ExchangeEvents
171 | 	X_DRAG_ENTER = C.X_DRAG_ENTER
172 | 	X_DRAG_LEAVE = C.X_DRAG_LEAVE
173 | 	X_DRAG       = C.X_DRAG
174 | 	X_DROP       = C.X_DROP
175 | 
176 | 	// ExchangeDataType
177 | 	EXF_UNDEFINED = C.EXF_UNDEFINED
178 | 	EXF_TEXT      = C.EXF_TEXT      // FETCH_EXCHANGE_DATA will receive UTF8 encoded string - plain text
179 | 	EXF_HTML      = C.EXF_HTML      // FETCH_EXCHANGE_DATA will receive UTF8 encoded string - html
180 | 	EXF_HYPERLINK = C.EXF_HYPERLINK // FETCH_EXCHANGE_DATA will receive UTF8 encoded string with pair url\0caption (null separated)
181 | 	EXF_JSON      = C.EXF_JSON      // FETCH_EXCHANGE_DATA will receive UTF8 encoded string with JSON literal
182 | 	EXF_FILE      = C.EXF_FILE      // FETCH_EXCHANGE_DATA will receive UTF8 encoded list of file names separated by nulls
183 | 
184 | 	// ExchangeCommands
185 | 	EXC_NONE = C.EXC_NONE
186 | 	EXC_COPY = C.EXC_COPY
187 | 	EXC_MOVE = C.EXC_MOVE
188 | 	EXC_LINK = C.EXC_LINK
189 | 
190 | 	// BehaviorEvents
191 | 	BUTTON_CLICK             = C.BUTTON_CLICK             // click on button
192 | 	BUTTON_PRESS             = C.BUTTON_PRESS             // mouse down or key down in button
193 | 	BUTTON_STATE_CHANGED     = C.BUTTON_STATE_CHANGED     // checkbox/radio/slider changed its state/value 
194 | 	EDIT_VALUE_CHANGING      = C.EDIT_VALUE_CHANGING      // before text change
195 | 	EDIT_VALUE_CHANGED       = C.EDIT_VALUE_CHANGED       // after text change
196 | 	SELECT_SELECTION_CHANGED = C.SELECT_SELECTION_CHANGED // selection in <select> changed
197 | 	SELECT_STATE_CHANGED     = C.SELECT_STATE_CHANGED     // node in select expanded/collapsed, heTarget is the node
198 | 	POPUP_REQUEST            = C.POPUP_REQUEST            // request to show popup just received, 
199 | 	//     here DOM of popup element can be modifed.
200 | 	POPUP_READY = C.POPUP_READY // popup element has been measured and ready to be shown on screen,
201 | 	//     here you can use functions like ScrollToView.
202 | 	POPUP_DISMISSED = C.POPUP_DISMISSED // popup element is closed,
203 | 	//     here DOM of popup element can be modifed again - e.g. some items can be removed
204 | 	//     to free memory.
205 | 	MENU_ITEM_ACTIVE = C.MENU_ITEM_ACTIVE // menu item activated by mouse hover or by keyboard,
206 | 	MENU_ITEM_CLICK  = C.MENU_ITEM_CLICK  // menu item click, 
207 | 	//   BEHAVIOR_EVENT_PARAMS structure layout
208 | 	//   BEHAVIOR_EVENT_PARAMS.cmd - MENU_ITEM_CLICK/MENU_ITEM_ACTIVE   
209 | 	//   BEHAVIOR_EVENT_PARAMS.heTarget - the menu item, presumably <li> element
210 | 	//   BEHAVIOR_EVENT_PARAMS.reason - BY_MOUSE_CLICK | BY_KEY_CLICK
211 | 	CONTEXT_MENU_SETUP   = C.CONTEXT_MENU_SETUP   // evt.he is a menu dom element that is about to be shown. You can disable/enable items in it.      
212 | 	CONTEXT_MENU_REQUEST = C.CONTEXT_MENU_REQUEST // "right-click", BEHAVIOR_EVENT_PARAMS::he is current popup menu HELEMENT being processed or NULL.
213 | 	// application can provide its own HELEMENT here (if it is NULL) or modify current menu element.
214 | 	VISIUAL_STATUS_CHANGED  = C.VISIUAL_STATUS_CHANGED  // broadcast notification, sent to all elements of some container being shown or hidden   
215 | 	DISABLED_STATUS_CHANGED = C.DISABLED_STATUS_CHANGED // broadcast notification, sent to all elements of some container that got new value of :disabled state
216 | 	POPUP_DISMISSING        = C.POPUP_DISMISSING        // popup is about to be closed
217 | 
218 | 	// "grey" event codes  - notfications from behaviors from this SDK 
219 | 	HYPERLINK_CLICK    = C.HYPERLINK_CLICK    // hyperlink click
220 | 	TABLE_HEADER_CLICK = C.TABLE_HEADER_CLICK // click on some cell in table header, 
221 | 	//     target = C.the cell, 
222 | 	//     reason = C.index of the cell (column number, 0..n)
223 | 	TABLE_ROW_CLICK = C.TABLE_ROW_CLICK // click on data row in the table, target is the row
224 | 	//     target = C.the row, 
225 | 	//     reason = C.index of the row (fixed_rows..n)
226 | 	TABLE_ROW_DBL_CLICK = C.TABLE_ROW_DBL_CLICK // mouse dbl click on data row in the table, target is the row
227 | 	//     target = C.the row, 
228 | 	//     reason = C.index of the row (fixed_rows..n)
229 | 	ELEMENT_COLLAPSED = C.ELEMENT_COLLAPSED // element was collapsed, so far only behavior:tabs is sending these two to the panels
230 | 	ELEMENT_EXPANDED  = C.ELEMENT_EXPANDED  // element was expanded,
231 | 	ACTIVATE_CHILD    = C.ACTIVATE_CHILD    // activate (select) child, 
232 | 	// used for example by accesskeys behaviors to send activation request, e.g. tab on behavior:tabs. 
233 | 	DO_SWITCH_TAB = C.DO_SWITCH_TAB // command to switch tab programmatically, handled by behavior:tabs 
234 | 	// use it as HTMLayoutPostEvent(tabsElementOrItsChild, DO_SWITCH_TAB, tabElementToShow, 0);
235 | 	INIT_DATA_VIEW    = C.INIT_DATA_VIEW    // request to virtual grid to initialize its view
236 | 	ROWS_DATA_REQUEST = C.ROWS_DATA_REQUEST // request from virtual grid to data source behavior to fill data in the table
237 | 	// parameters passed throug DATA_ROWS_PARAMS structure.
238 | 	UI_STATE_CHANGED = C.UI_STATE_CHANGED // ui state changed, observers shall update their visual states.
239 | 	// is sent for example by behavior:richtext when caret position/selection has changed.
240 | 	FORM_SUBMIT = C.FORM_SUBMIT // behavior:form detected submission event. BEHAVIOR_EVENT_PARAMS::data field contains data to be posted.
241 | 	// BEHAVIOR_EVENT_PARAMS::data is of type T_MAP in this case key/value pairs of data that is about 
242 | 	// to be submitted. You can modify the data or discard submission by returning TRUE from the handler.
243 | 	FORM_RESET = C.FORM_RESET // behavior:form detected reset event (from button type = C.reset). BEHAVIOR_EVENT_PARAMS::data field contains data to be reset.
244 | 	// BEHAVIOR_EVENT_PARAMS::data is of type T_MAP in this case key/value pairs of data that is about 
245 | 	// to be rest. You can modify the data or discard reset by returning TRUE from the handler.		 
246 | 	DOCUMENT_COMPLETE            = C.DOCUMENT_COMPLETE // behavior:frame have complete document.
247 | 	HISTORY_PUSH                 = C.HISTORY_PUSH      // behavior:history stuff
248 | 	HISTORY_DROP                 = C.HISTORY_DROP
249 | 	HISTORY_PRIOR                = C.HISTORY_PRIOR
250 | 	HISTORY_NEXT                 = C.HISTORY_NEXT
251 | 	HISTORY_STATE_CHANGED        = C.HISTORY_STATE_CHANGED // behavior:history notification - history stack has changed
252 | 	CLOSE_POPUP                  = C.CLOSE_POPUP           // close popup request,
253 | 	REQUEST_TOOLTIP              = C.REQUEST_TOOLTIP       // request tooltip, BEHAVIOR_EVENT_PARAMS.he <- is the tooltip element.
254 | 	ANIMATION                    = C.ANIMATION             // animation started (reason = C.1) or ended(reason = C.0) on the element.
255 | 	FIRST_APPLICATION_EVENT_CODE = C.FIRST_APPLICATION_EVENT_CODE
256 | 	// all custom event codes shall be greater
257 | 	// than this number. All codes below this will be used
258 | 	// solely by application - HTMLayout will not intrepret it 
259 | 	// and will do just dispatching.
260 | 	// To send event notifications with  these codes use
261 | 	// HTMLayoutSend/PostEvent API.
262 | 
263 | 	// EventReason
264 | 	BY_MOUSE_CLICK = C.BY_MOUSE_CLICK
265 | 	BY_KEY_CLICK   = C.BY_KEY_CLICK
266 | 	SYNTHESIZED    = C.SYNTHESIZED
267 | 
268 | 	// EventChangedReason
269 | 	BY_INS_CHAR  = C.BY_INS_CHAR  // single char insertion
270 | 	BY_INS_CHARS = C.BY_INS_CHARS // character range insertion, clipboard
271 | 	BY_DEL_CHAR  = C.BY_DEL_CHAR  // single char deletion
272 | 	BY_DEL_CHARS = C.BY_DEL_CHARS // character range deletion (selection)
273 | 
274 | 	// BehaviorMethodIdentifiers
275 | 	DO_CLICK                = C.DO_CLICK
276 | 	GET_TEXT_VALUE          = C.GET_TEXT_VALUE
277 | 	SET_TEXT_VALUE          = C.SET_TEXT_VALUE          // p - TEXT_VALUE_PARAMS
278 | 	TEXT_EDIT_GET_SELECTION = C.TEXT_EDIT_GET_SELECTION // p - TEXT_EDIT_SELECTION_PARAMS
279 | 	TEXT_EDIT_SET_SELECTION = C.TEXT_EDIT_SET_SELECTION // p - TEXT_EDIT_SELECTION_PARAMS
280 | 	// Replace selection content or insert text at current caret position.
281 | 	// Replaced text will be selected. 
282 | 	TEXT_EDIT_REPLACE_SELECTION = C.TEXT_EDIT_REPLACE_SELECTION // p - TEXT_EDIT_REPLACE_SELECTION_PARAMS
283 | 	// Set value of type = C."vscrollbar"/"hscrollbar"
284 | 	SCROLL_BAR_GET_VALUE = C.SCROLL_BAR_GET_VALUE
285 | 	SCROLL_BAR_SET_VALUE = C.SCROLL_BAR_SET_VALUE
286 | 	// get current caret position, it returns rectangle that is relative to origin of the editing element.
287 | 	TEXT_EDIT_GET_CARET_POSITION = C.TEXT_EDIT_GET_CARET_POSITION // p - TEXT_CARET_POSITION_PARAMS
288 | 	TEXT_EDIT_GET_SELECTION_TEXT = C.TEXT_EDIT_GET_SELECTION_TEXT // p - TEXT_SELECTION_PARAMS, OutputStreamProc will receive stream of WCHARs
289 | 	TEXT_EDIT_GET_SELECTION_HTML = C.TEXT_EDIT_GET_SELECTION_HTML // p - TEXT_SELECTION_PARAMS, OutputStreamProc will receive stream of BYTEs - utf8 encoded html fragment.
290 | 	TEXT_EDIT_CHAR_POS_AT_XY     = C.TEXT_EDIT_CHAR_POS_AT_XY     // p - TEXT_EDIT_CHAR_POS_AT_XY_PARAMS
291 | 	IS_EMPTY                     = C.IS_EMPTY                     // p - IS_EMPTY_PARAMS // set VALUE_PARAMS::is_empty (false/true) reflects :empty state of the element.
292 | 	GET_VALUE                    = C.GET_VALUE                    // p - VALUE_PARAMS 
293 | 	SET_VALUE                    = C.SET_VALUE                    // p - VALUE_PARAMS 
294 | 	XCALL                        = C.XCALL                        // p - XCALL_PARAMS
295 | 	FIRST_APPLICATION_METHOD_ID  = C.FIRST_APPLICATION_METHOD_ID
296 | 
297 | 	// Content insertion locations
298 | 	SIH_REPLACE_CONTENT   = C.SIH_REPLACE_CONTENT
299 | 	SIH_INSERT_AT_START   = C.SIH_INSERT_AT_START
300 | 	SIH_APPEND_AFTER_LAST = C.SIH_APPEND_AFTER_LAST
301 | 	SOH_REPLACE           = C.SOH_REPLACE
302 | 	SOH_INSERT_BEFORE     = C.SOH_INSERT_BEFORE
303 | 	SOH_INSERT_AFTER      = C.SOH_INSERT_AFTER
304 | 
305 | 	CONTENT_BOX = C.CONTENT_BOX
306 | 	PADDING_BOX = C.PADDING_BOX
307 | 	BORDER_BOX  = C.BORDER_BOX
308 | 	MARGIN_BOX  = C.MARGIN_BOX
309 | 
310 | 	ROOT_RELATIVE      = C.ROOT_RELATIVE      // - or this flag if you want to get HTMLayout window relative coordinates, otherwise it will use nearest windowed container e.g. popup window.
311 | 	SELF_RELATIVE      = C.SELF_RELATIVE      // - "or" this flag if you want to get coordinates relative to the origin of element iself.
312 | 	CONTAINER_RELATIVE = C.CONTAINER_RELATIVE // - position inside immediate container.
313 | 	VIEW_RELATIVE      = C.VIEW_RELATIVE
314 | 
315 | 	T_UNDEFINED = C.T_UNDEFINED
316 |     T_NULL = C.T_NULL
317 |     T_BOOL = C.T_BOOL
318 |     T_INT = C.T_INT
319 |     T_FLOAT = C.T_FLOAT
320 |     T_STRING = C.T_STRING
321 |     T_DATE = C.T_DATE
322 |     T_CURRENCY = C.T_CURRENCY
323 |     T_LENGTH = C.T_LENGTH
324 |     T_ARRAY = C.T_ARRAY
325 |     T_MAP = C.T_MAP
326 |     T_FUNCTION = C.T_FUNCTION
327 |     T_BYTES = C.T_BYTES
328 |     T_OBJECT = C.T_OBJECT
329 |     T_DOM_OBJECT = C.T_DOM_OBJECT
330 | )
331 | 
332 | var (
333 | 	// Hold a reference to handlers that are in-use so that they don't
334 | 	// get garbage collected.
335 | 	notifyHandlers      = make(map[uintptr]*NotifyHandler, 8)
336 | 	windowEventHandlers = make(map[uint32]*EventHandler, 8)
337 | 	eventHandlers       = make(map[HELEMENT]map[*EventHandler]bool, 128)
338 | 	behaviors           = make(map[*EventHandler]int, 32)
339 | )
340 | 
341 | type HELEMENT C.HELEMENT
342 | type HLDOM_RESULT C.HLDOM_RESULT
343 | type VALUE_RESULT C.UINT
344 | 
345 | 
346 | type Point struct {
347 | 	X int32
348 | 	Y int32
349 | }
350 | 
351 | type Size struct {
352 | 	Cx int32
353 | 	Cy int32
354 | }
355 | 
356 | type Rect struct {
357 | 	Left   int32
358 | 	Top    int32
359 | 	Right  int32
360 | 	Bottom int32
361 | }
362 | 
363 | type JsonValue struct {
364 | 	T uint32
365 | 	U uint32
366 | 	D uint64
367 | }
368 | 
369 | type InitializationParams struct {
370 | 	Cmd uint32
371 | }
372 | 
373 | type MouseParams struct {
374 | 	Cmd         uint32 // MouseEvents
375 | 	Target      HELEMENT
376 | 	Pos         Point
377 | 	DocumentPos Point
378 | 	ButtonState uint32
379 | 	AltState    uint32
380 | 	CursorType  uint32
381 | 	IsOnIcon    int32
382 | 
383 | 	Dragging     HELEMENT
384 | 	DraggingMode uint32
385 | }
386 | 
387 | type KeyParams struct {
388 | 	Cmd      uint32 // KeyEvents
389 | 	Target   HELEMENT
390 | 	KeyCode  uint32
391 | 	AltState uint32
392 | }
393 | 
394 | type FocusParams struct {
395 | 	Cmd          uint32 // FocusEvents
396 | 	Target       HELEMENT
397 | 	ByMouseClick int32 // boolean
398 | 	Cancel       int32 // boolean
399 | }
400 | 
401 | type DrawParams struct {
402 | 	Cmd      uint32 // DrawEvents
403 | 	Hdc      uintptr
404 | 	Area     Rect
405 | 	reserved uint32
406 | }
407 | 
408 | type TimerParams struct {
409 | 	TimerId uintptr
410 | }
411 | 
412 | type BehaviorEventParams struct {
413 | 	Cmd    uint32 // Behavior events
414 | 	Target HELEMENT
415 | 	Source HELEMENT
416 | 	Reason uint32
417 | 	Data   JsonValue
418 | }
419 | 
420 | type MethodParams struct {
421 | 	MethodId uint32
422 | }
423 | 
424 | // TODO: Add all the structures derived from MethodParams here...
425 | 
426 | type DataArrivedParams struct {
427 | 	Initiator HELEMENT
428 | 	Data      *byte
429 | 	DataSize  uint32
430 | 	DataType  uint32
431 | 	Status    uint32
432 | 	Uri       *uint16 // Wide character string
433 | }
434 | 
435 | type ScrollParams struct {
436 | 	Cmd      uint32
437 | 	Target   HELEMENT
438 | 	Pos      int32
439 | 	Vertical int32 // bool
440 | }
441 | 
442 | type ExchangeParams struct {
443 | 	Cmd       uint32
444 | 	Target    HELEMENT
445 | 	Pos       Point
446 | 	PosView   Point
447 | 	DataTypes uint32
448 | 	DragCmd   uint32
449 | 	FetchData uintptr // func pointer: typedef BOOL CALLBACK FETCH_EXCHANGE_DATA(EXCHANGE_PARAMS* params, UINT data_type, LPCBYTE* ppDataStart, UINT* pDataLength );
450 | }
451 | 
452 | type GestureParams struct {
453 | 	Cmd       uint32
454 | 	Target    HELEMENT
455 | 	Pos       Point
456 | 	PosView   Point
457 | 	Flags     uint32
458 | 	DeltaTime uint32
459 | 	DeltaXY   Size
460 | 	DeltaV    float64
461 | }
462 | 
463 | // Notify structures
464 | 
465 | type NMHDR struct {
466 | 	HwndFrom uint32
467 | 	IdFrom   uintptr
468 | 	Code     uint32
469 | }
470 | 
471 | type NmhlCreateControl struct {
472 | 	Header         NMHDR
473 | 	Element        HELEMENT
474 | 	InHwndParent   uint32
475 | 	OutHwndControl uint32
476 | 	reserved1      int32
477 | 	reserved2      int32
478 | }
479 | 
480 | type NmhlDestroyControl struct {
481 | 	Header           NMHDR
482 | 	Element          HELEMENT
483 | 	InOutHwndControl uint32
484 | 	reserved1        int32
485 | }
486 | 
487 | type NmhlLoadData struct {
488 | 	Header      NMHDR
489 | 	Uri         *uint16
490 | 	OutData     uintptr
491 | 	OutDataSize int32
492 | 	DataType    uint32
493 | 	Principal   HELEMENT
494 | 	Initiator   HELEMENT
495 | }
496 | 
497 | type NmhlDataLoaded struct {
498 | 	Header   NMHDR
499 | 	Uri      *uint16
500 | 	Data     uintptr
501 | 	DataSize int32
502 | 	DataType uint32
503 | 	Status   uint32
504 | }
505 | 
506 | type NmhlAttachBehavior struct {
507 | 	Header        NMHDR
508 | 	Element       HELEMENT
509 | 	BehaviorName  *C.char
510 | 	ElementProc   uintptr
511 | 	ElementTag    uintptr
512 | 	ElementEvents uint32
513 | }
514 | 
515 | // Main event handler that dispatches to the right element handler
516 | var goElementProc = syscall.NewCallback(func(tag uintptr, he unsafe.Pointer, evtg uint32, params unsafe.Pointer) C.BOOL {
517 | 	handler := (*EventHandler)(unsafe.Pointer(tag))
518 | 	handled := false
519 | 
520 | 	switch evtg {
521 | 	case C.HANDLE_INITIALIZATION:
522 | 		if p := (*InitializationParams)(params); p.Cmd == BEHAVIOR_ATTACH {
523 | 			//log.Print("Attach event handler to ", NewElementFromHandle(HELEMENT(he)).Describe())
524 | 			if handler.OnAttached != nil {
525 | 				handler.OnAttached(HELEMENT(he))
526 | 			}
527 | 		} else if p.Cmd == BEHAVIOR_DETACH {
528 | 			//log.Print("Detach event handler from ", NewElementFromHandle(HELEMENT(he)).Describe())
529 | 			if handler.OnDetached != nil {
530 | 				handler.OnDetached(HELEMENT(he))
531 | 			}
532 | 
533 | 			// If this was a behavior detaching, decrement the reference count and stop tracking
534 | 			// the pointer if the ref count has been exhausted
535 | 			if behaviorRefCount, exists := behaviors[handler]; exists {
536 | 				behaviorRefCount--
537 | 				if behaviorRefCount == 0 {
538 | 					delete(behaviors, handler)
539 | 				} else {
540 | 					behaviors[handler] = behaviorRefCount
541 | 				}
542 | 			}
543 | 		}
544 | 		handled = true
545 | 	case C.HANDLE_MOUSE:
546 | 		if handler.OnMouse != nil {
547 | 			p := (*MouseParams)(params)
548 | 			handled = handler.OnMouse(HELEMENT(he), p)
549 | 		}
550 | 	case C.HANDLE_KEY:
551 | 		if handler.OnKey != nil {
552 | 			p := (*KeyParams)(params)
553 | 			handled = handler.OnKey(HELEMENT(he), p)
554 | 		}
555 | 	case C.HANDLE_FOCUS:
556 | 		if handler.OnFocus != nil {
557 | 			p := (*FocusParams)(params)
558 | 			handled = handler.OnFocus(HELEMENT(he), p)
559 | 		}
560 | 	case C.HANDLE_DRAW:
561 | 		if handler.OnDraw != nil {
562 | 			p := (*DrawParams)(params)
563 | 			handled = handler.OnDraw(HELEMENT(he), p)
564 | 		}
565 | 	case C.HANDLE_TIMER:
566 | 		if handler.OnTimer != nil {
567 | 			p := (*TimerParams)(params)
568 | 			handled = handler.OnTimer(HELEMENT(he), p)
569 | 		}
570 | 	case C.HANDLE_BEHAVIOR_EVENT:
571 | 		if handler.OnBehaviorEvent != nil {
572 | 			p := (*BehaviorEventParams)(params)
573 | 			handled = handler.OnBehaviorEvent(HELEMENT(he), p)
574 | 		}
575 | 	case C.HANDLE_METHOD_CALL:
576 | 		if handler.OnMethodCall != nil {
577 | 			p := (*MethodParams)(params)
578 | 			handled = handler.OnMethodCall(HELEMENT(he), p)
579 | 		}
580 | 	case C.HANDLE_DATA_ARRIVED:
581 | 		if handler.OnDataArrived != nil {
582 | 			p := (*DataArrivedParams)(params)
583 | 			handled = handler.OnDataArrived(HELEMENT(he), p)
584 | 		}
585 | 	case C.HANDLE_SIZE:
586 | 		if handler.OnSize != nil {
587 | 			handler.OnSize(HELEMENT(he))
588 | 		}
589 | 	case C.HANDLE_SCROLL:
590 | 		if handler.OnScroll != nil {
591 | 			p := (*ScrollParams)(params)
592 | 			handled = handler.OnScroll(HELEMENT(he), p)
593 | 		}
594 | 	case C.HANDLE_EXCHANGE:
595 | 		if handler.OnExchange != nil {
596 | 			p := (*ExchangeParams)(params)
597 | 			handled = handler.OnExchange(HELEMENT(he), p)
598 | 		}
599 | 	case C.HANDLE_GESTURE:
600 | 		if handler.OnGesture != nil {
601 | 			p := (*GestureParams)(params)
602 | 			handled = handler.OnGesture(HELEMENT(he), p)
603 | 		}
604 | 	default:
605 | 		log.Panic("Unhandled htmlayout event case: ", evtg)
606 | 	}
607 | 
608 | 	if handled {
609 | 		return C.TRUE
610 | 	}
611 | 	return C.FALSE
612 | })
613 | 
614 | var goNotifyProc = syscall.NewCallback(func(msg uint32, wparam uintptr, lparam uintptr, vparam uintptr) uintptr {
615 | 	if handler, exists := notifyHandlers[vparam]; exists {
616 | 		phdr := (*C.NMHDR)(unsafe.Pointer(lparam))
617 | 
618 | 		switch phdr.code {
619 | 		case HLN_CREATE_CONTROL:
620 | 			if handler.OnCreateControl != nil {
621 | 				return handler.OnCreateControl((*NmhlCreateControl)(unsafe.Pointer(lparam)))
622 | 			}
623 | 		case HLN_CONTROL_CREATED:
624 | 			if handler.OnControlCreated != nil {
625 | 				return handler.OnControlCreated((*NmhlCreateControl)(unsafe.Pointer(lparam)))
626 | 			}
627 | 		case HLN_DESTROY_CONTROL:
628 | 			if handler.OnDestroyControl != nil {
629 | 				return handler.OnDestroyControl((*NmhlDestroyControl)(unsafe.Pointer(lparam)))
630 | 			}
631 | 		case HLN_LOAD_DATA:
632 | 			if handler.OnLoadData != nil {
633 | 				return handler.OnLoadData((*NmhlLoadData)(unsafe.Pointer(lparam)))
634 | 			}
635 | 		case HLN_DATA_LOADED:
636 | 			if handler.OnDataLoaded != nil {
637 | 				return handler.OnDataLoaded((*NmhlDataLoaded)(unsafe.Pointer(lparam)))
638 | 			}
639 | 		case HLN_DOCUMENT_COMPLETE:
640 | 			if handler.OnDocumentComplete != nil {
641 | 				return handler.OnDocumentComplete()
642 | 			}
643 | 		case HLN_ATTACH_BEHAVIOR:
644 | 			params := (*NmhlAttachBehavior)(unsafe.Pointer(lparam))
645 | 			key := C.GoString(params.BehaviorName)
646 | 			if behavior, exists := handler.Behaviors[key]; exists {
647 | 				// Increment the reference count for this behavior
648 | 				if refCount, exists := behaviors[behavior]; exists {
649 | 					behaviors[behavior] = refCount + 1
650 | 				} else {
651 | 					behaviors[behavior] = 1
652 | 				}
653 | 				NewElementFromHandle(params.Element).attachBehavior(behavior)
654 | 			} else {
655 | 				log.Print("No such behavior: ", key)
656 | 			}
657 | 		}
658 | 	}
659 | 	return 0
660 | })
661 | 
662 | var goSelectCallback = syscall.NewCallback(func(he unsafe.Pointer, param uintptr) uintptr {
663 | 	slice := (*[]*Element)(unsafe.Pointer(param))
664 | 	e := NewElementFromHandle(HELEMENT(he))
665 | 	*slice = append(*slice, e)
666 | 	return 0
667 | })
668 | 
669 | var goElementComparator = syscall.NewCallback(func(he1 unsafe.Pointer, he2 unsafe.Pointer, arg uintptr) int {
670 | 	cmp := *(*func(*Element, *Element) int)(unsafe.Pointer(arg))
671 | 	return cmp(NewElementFromHandle(HELEMENT(he1)), NewElementFromHandle(HELEMENT(he2)))
672 | })
673 | 
674 | // Main htmlayout wndproc
675 | func ProcNoDefault(hwnd, msg uint32, wparam, lparam uintptr) (uintptr, bool) {
676 | 	var handled C.BOOL = 0
677 | 	var result C.LRESULT = C.HTMLayoutProcND(C.HWND(C.HANDLE(uintptr(hwnd))), C.UINT(msg),
678 | 		C.WPARAM(wparam), C.LPARAM(lparam), &handled)
679 | 	return uintptr(result), handled != 0
680 | }
681 | 
682 | // Load html contents into window
683 | func LoadHtml(hwnd uint32, data []byte, baseUrl string) error {
684 | 	if len(data) > 0 {
685 | 		if ok := C.HTMLayoutLoadHtmlEx(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.BYTE)(&data[0]),
686 | 			C.UINT(len(data)), (*C.WCHAR)(stringToUtf16Ptr(baseUrl))); ok == 0 {
687 | 			return errors.New("HTMLayoutLoadHtmlEx failed")
688 | 		}
689 | 	}
690 | 	return nil
691 | }
692 | 
693 | // Load resource (file or url) into window
694 | func LoadResource(hwnd uint32, uri string) error {
695 | 	if ok := C.HTMLayoutLoadFile(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.WCHAR)(stringToUtf16Ptr(uri))); ok == 0 {
696 | 		return errors.New("HTMLayoutLoadFile failed")
697 | 	}
698 | 	return nil
699 | }
700 | 
701 | // Call this from your NotifyHandler.HandleLoadData method if you want htmlayout to
702 | // process the data right away so you don't have to provide a buffer in the NmhlLoadData structure.
703 | func DataReady(hwnd uint32, uri *uint16, data []byte) bool {
704 | 	return C.HTMLayoutDataReady(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.WCHAR)(uri), (*C.BYTE)(&data[0]), C.DWORD(len(data))) != 0
705 | }
706 | 
707 | func AttachWindowEventHandler(hwnd uint32, handler *EventHandler) {
708 | 	key := uintptr(hwnd)
709 | 	tag := uintptr(unsafe.Pointer(handler))
710 | 
711 | 	if _, exists := windowEventHandlers[hwnd]; exists {
712 | 		if ret := C.HTMLayoutWindowDetachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
713 | 			domPanic(ret, "Failed to detach event handler from window before adding the new one")
714 | 		}
715 | 	}
716 | 
717 | 	// Overwrite if it exists
718 | 	windowEventHandlers[hwnd] = handler
719 | 
720 | 	// Don't let the caller disable ATTACH/DETACH events, otherwise we
721 | 	// won't know when to throw out our event handler object
722 | 	subscription := handler.Subscription()
723 | 	subscription &= ^uint32(DISABLE_INITIALIZATION & 0xffffffff)
724 | 
725 | 	if ret := C.HTMLayoutWindowAttachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK {
726 | 		domPanic(ret, "Failed to attach event handler to window")
727 | 	}
728 | }
729 | 
730 | func DetachWindowEventHandler(hwnd uint32) {
731 | 	key := uintptr(hwnd)
732 | 	if handler, exists := windowEventHandlers[hwnd]; exists {
733 | 		tag := uintptr(unsafe.Pointer(handler))
734 | 		if ret := C.HTMLayoutWindowDetachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
735 | 			domPanic(ret, "Failed to detach event handler from window")
736 | 		}
737 | 		delete(windowEventHandlers, hwnd)
738 | 	}
739 | }
740 | 
741 | func AttachNotifyHandler(hwnd uint32, handler *NotifyHandler) {
742 | 	key := uintptr(hwnd)
743 | 	// Overwrite if it exists
744 | 	notifyHandlers[key] = handler
745 | 	C.HTMLayoutSetCallback(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goNotifyProc)), C.LPVOID(key))
746 | }
747 | 
748 | func DetachNotifyHandler(hwnd uint32) {
749 | 	key := uintptr(hwnd)
750 | 	if _, exists := notifyHandlers[key]; exists {
751 | 		C.HTMLayoutSetCallback(C.HWND(C.HANDLE(key)), nil, nil)
752 | 		delete(notifyHandlers, key)
753 | 	}
754 | }
755 | 
756 | func DumpObjectCounts() {
757 | 	log.Print("Window notify handlers (", len(notifyHandlers), "): ", notifyHandlers)
758 | 	log.Print("Window event handlers (", len(windowEventHandlers), "): ", windowEventHandlers)
759 | 	log.Print("Element event handlers (", len(eventHandlers), "): ", eventHandlers)
760 | }
761 | 


--------------------------------------------------------------------------------
/htmlayout_test.go:
--------------------------------------------------------------------------------
   1 | package gohl
   2 | 
   3 | import (
   4 | 	"log"
   5 | 	"math"
   6 | 	"regexp"
   7 | 	"strconv"
   8 | 	"syscall"
   9 | 	"testing"
  10 | 	"unsafe"
  11 | )
  12 | 
  13 | const (
  14 | 	WM_CREATE     = 1
  15 | 	WM_DESTROY    = 2
  16 | 	WM_CLOSE      = 16
  17 | 	WM_QUIT       = 0x0012
  18 | 	WM_ERASEBKGND = 0x0014
  19 | 	WM_SHOWWINDOW = 0x0018
  20 | 	WM_USER       = 0x0400
  21 | 	ERROR_SUCCESS = 0
  22 | )
  23 | 
  24 | var (
  25 | 	moduser32 = syscall.NewLazyDLL("user32.dll")
  26 | 
  27 | 	procRegisterClassExW = moduser32.NewProc("RegisterClassExW")
  28 | 	procCreateWindowExW  = moduser32.NewProc("CreateWindowExW")
  29 | 	procDefWindowProcW   = moduser32.NewProc("DefWindowProcW")
  30 | 	procDestroyWindow    = moduser32.NewProc("DestroyWindow")
  31 | 	procPostQuitMessage  = moduser32.NewProc("PostQuitMessage")
  32 | 	procGetMessageW      = moduser32.NewProc("GetMessageW")
  33 | 	procTranslateMessage = moduser32.NewProc("TranslateMessage")
  34 | 	procDispatchMessageW = moduser32.NewProc("DispatchMessageW")
  35 | 	procSendMessageW     = moduser32.NewProc("SendMessageW")
  36 | 	procPostMessageW     = moduser32.NewProc("PostMessageW")
  37 | 
  38 | 	registeredClasses = make(map[string]bool, 4)
  39 | 	testPages         = make(chan string, 1)
  40 | 	testFuncs         = make(chan func(uint32), 1)
  41 | )
  42 | 
  43 | type Wndclassex struct {
  44 | 	Size       uint32
  45 | 	Style      uint32
  46 | 	WndProc    uintptr
  47 | 	ClsExtra   int32
  48 | 	WndExtra   int32
  49 | 	Instance   uint32
  50 | 	Icon       uint32
  51 | 	Cursor     uint32
  52 | 	Background uint32
  53 | 	MenuName   *uint16
  54 | 	ClassName  *uint16
  55 | 	IconSm     uint32
  56 | }
  57 | 
  58 | type Msg struct {
  59 | 	Hwnd    uint32
  60 | 	Message uint32
  61 | 	Wparam  int32
  62 | 	Lparam  int32
  63 | 	Time    uint32
  64 | 	Pt      Point
  65 | }
  66 | 
  67 | func RegisterClassEx(wndclass *Wndclassex) (atom uint16, err syscall.Errno) {
  68 | 	r0, _, e1 := syscall.Syscall(procRegisterClassExW.Addr(), 1, uintptr(unsafe.Pointer(wndclass)), 0, 0)
  69 | 	atom = uint16(r0)
  70 | 	if atom == 0 {
  71 | 		if e1 != 0 {
  72 | 			err = syscall.Errno(e1)
  73 | 		} else {
  74 | 			err = syscall.EINVAL
  75 | 		}
  76 | 	}
  77 | 	return
  78 | }
  79 | 
  80 | func CreateWindowEx(exstyle uint32, classname *uint16, windowname *uint16, style uint32, x int32, y int32, width int32, height int32, wndparent uint32, menu uint32, instance uint32, param uintptr) (hwnd uint32, err syscall.Errno) {
  81 | 	r0, _, e1 := syscall.Syscall12(procCreateWindowExW.Addr(), 12, uintptr(exstyle), uintptr(unsafe.Pointer(classname)), uintptr(unsafe.Pointer(windowname)), uintptr(style), uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(wndparent), uintptr(menu), uintptr(instance), uintptr(param))
  82 | 	hwnd = uint32(r0)
  83 | 	if hwnd == 0 {
  84 | 		if e1 != 0 {
  85 | 			err = syscall.Errno(e1)
  86 | 		} else {
  87 | 			err = syscall.EINVAL
  88 | 		}
  89 | 	}
  90 | 	return
  91 | }
  92 | 
  93 | func DefWindowProc(hwnd uint32, msg uint32, wparam uintptr, lparam uintptr) (lresult int32) {
  94 | 	r0, _, _ := syscall.Syscall6(procDefWindowProcW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)
  95 | 	lresult = int32(r0)
  96 | 	return
  97 | }
  98 | 
  99 | func DestroyWindow(hwnd uint32) (err syscall.Errno) {
 100 | 	r1, _, e1 := syscall.Syscall(procDestroyWindow.Addr(), 1, uintptr(hwnd), 0, 0)
 101 | 	if int(r1) == 0 {
 102 | 		if e1 != 0 {
 103 | 			err = syscall.Errno(e1)
 104 | 		} else {
 105 | 			err = syscall.EINVAL
 106 | 		}
 107 | 	}
 108 | 	return
 109 | }
 110 | 
 111 | func PostQuitMessage(exitcode int32) {
 112 | 	syscall.Syscall(procPostQuitMessage.Addr(), 1, uintptr(exitcode), 0, 0)
 113 | 	return
 114 | }
 115 | 
 116 | func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err syscall.Errno) {
 117 | 	r0, _, e1 := syscall.Syscall6(procGetMessageW.Addr(), 4, uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax), 0, 0)
 118 | 	ret = int32(r0)
 119 | 	if ret == -1 {
 120 | 		if e1 != 0 {
 121 | 			err = syscall.Errno(e1)
 122 | 		} else {
 123 | 			err = syscall.EINVAL
 124 | 		}
 125 | 	}
 126 | 	return
 127 | }
 128 | 
 129 | func TranslateMessage(msg *Msg) (done bool) {
 130 | 	r0, _, _ := syscall.Syscall(procTranslateMessage.Addr(), 1, uintptr(unsafe.Pointer(msg)), 0, 0)
 131 | 	done = bool(r0 != 0)
 132 | 	return
 133 | }
 134 | 
 135 | func DispatchMessage(msg *Msg) (ret int32) {
 136 | 	r0, _, _ := syscall.Syscall(procDispatchMessageW.Addr(), 1, uintptr(unsafe.Pointer(msg)), 0, 0)
 137 | 	ret = int32(r0)
 138 | 	return
 139 | }
 140 | 
 141 | func SendMessage(hwnd uint32, msg uint32, wparam uintptr, lparam uintptr) (lresult int32) {
 142 | 	r0, _, _ := syscall.Syscall6(procSendMessageW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)
 143 | 	lresult = int32(r0)
 144 | 	return
 145 | }
 146 | 
 147 | func PostMessage(hwnd uint32, msg uint32, wparam uintptr, lparam uintptr) (err syscall.Errno) {
 148 | 	r1, _, e1 := syscall.Syscall6(procPostMessageW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)
 149 | 	if int(r1) == 0 {
 150 | 		if e1 != 0 {
 151 | 			err = syscall.Errno(e1)
 152 | 		} else {
 153 | 			err = syscall.EINVAL
 154 | 		}
 155 | 	}
 156 | 	return
 157 | }
 158 | 
 159 | // Utility functions for creating a testing window, etc
 160 | 
 161 | func registerWindow(callbacks MsgHandlerMap, windowName string) {
 162 | 
 163 | 	wproc := syscall.NewCallback(func(hwnd, msg uint32, wparam uintptr, lparam uintptr) uintptr {
 164 | 		if result, handled := ProcNoDefault(hwnd, msg, wparam, lparam); handled {
 165 | 			return result
 166 | 		}
 167 | 
 168 | 		var rc interface{} = nil
 169 | 		if cb := callbacks[msg]; cb != nil {
 170 | 			rc = cb(hwnd)
 171 | 		}
 172 | 
 173 | 		// Handler provided a return code
 174 | 		if rc != nil {
 175 | 			if code, ok := rc.(int); !ok {
 176 | 				panic("window msg response should be int")
 177 | 			} else {
 178 | 				return uintptr(code)
 179 | 			}
 180 | 		}
 181 | 
 182 | 		// Handler did not provide a return code, use the default window procedure
 183 | 		code := DefWindowProc(hwnd, msg, wparam, lparam)
 184 | 		return uintptr(code)
 185 | 	})
 186 | 
 187 | 	var wc Wndclassex
 188 | 	wc.Size = uint32(unsafe.Sizeof(wc))
 189 | 	wc.WndProc = wproc
 190 | 	wc.Instance = 0
 191 | 	wc.Icon = 0
 192 | 	wc.Cursor = 0
 193 | 	wc.Background = 0
 194 | 	wc.MenuName = nil
 195 | 	wc.ClassName = stringToUtf16Ptr(windowName)
 196 | 	wc.IconSm = 0
 197 | 
 198 | 	if _, errno := RegisterClassEx(&wc); errno != ERROR_SUCCESS {
 199 | 		log.Panic(errno)
 200 | 	}
 201 | }
 202 | 
 203 | func createWindow(windowName string) uint32 {
 204 | 	wcname := stringToUtf16Ptr(windowName)
 205 | 	hwnd, errno := CreateWindowEx(
 206 | 		0,
 207 | 		wcname,
 208 | 		stringToUtf16Ptr("Gohl Test App"),
 209 | 		0,
 210 | 		0, 0, 20, 10,
 211 | 		0, 0, 0, 0)
 212 | 	if errno != ERROR_SUCCESS {
 213 | 		log.Panic(errno)
 214 | 	}
 215 | 	return hwnd
 216 | }
 217 | 
 218 | func pump() {
 219 | 	var m Msg
 220 | 	for {
 221 | 		if r, errno := GetMessage(&m, 0, 0, 0); errno != ERROR_SUCCESS {
 222 | 			panic(errno)
 223 | 		} else if r == 0 {
 224 | 			break
 225 | 		}
 226 | 		TranslateMessage(&m)
 227 | 		DispatchMessage(&m)
 228 | 	}
 229 | }
 230 | 
 231 | func looseEqual(a, b string) bool {
 232 | 	if re, err := regexp.Compile(`\s+`); err != nil {
 233 | 		log.Panic(err)
 234 | 	} else {
 235 | 		a = re.ReplaceAllLiteralString(a, "")
 236 | 		b = re.ReplaceAllLiteralString(b, "")
 237 | 	}
 238 | 	return a == b
 239 | }
 240 | 
 241 | func expectDomError(code HLDOM_RESULT) {
 242 | 	if err := recover(); err == nil {
 243 | 		log.Panic("Expected a DomError but got no error")
 244 | 	} else if de, ok := err.(*DomError); !ok {
 245 | 		log.Panic("Expected DomError, instead got: ", err)
 246 | 	} else if de.Result != code {
 247 | 		log.Panicf("Expected DomError with code %s, but got code %s instead ", domResultAsString(code), domResultAsString(de.Result))
 248 | 	}
 249 | }
 250 | 
 251 | func expectPanic() {
 252 | 	if err := recover(); err == nil {
 253 | 		log.Panic("Expected a panic but didn't get one")
 254 | 	}
 255 | }
 256 | 
 257 | func testWithHtml(html string, test func(hwnd uint32)) {
 258 | 	if !registeredClasses["html"] {
 259 | 		m := make(MsgHandlerMap, 32)
 260 | 		for k, v := range defaultHandlerMap {
 261 | 			m[k] = v
 262 | 		}
 263 | 		m[WM_CREATE] = func(hwnd uint32) interface{} {
 264 | 			ret := defaultHandlerMap[WM_CREATE](hwnd)
 265 | 			if err := LoadHtml(hwnd, []byte(<-testPages), ""); err != nil {
 266 | 				log.Panic(err)
 267 | 			}
 268 | 			(<-testFuncs)(hwnd)
 269 | 			PostMessage(hwnd, WM_CLOSE, 0, 0)
 270 | 			return ret
 271 | 		}
 272 | 		registerWindow(m, "html")
 273 | 		registeredClasses["html"] = true
 274 | 	}
 275 | 	testPages <- html
 276 | 	testFuncs <- test
 277 | 	_ = createWindow("html")
 278 | 	pump()
 279 | }
 280 | 
 281 | // Variables and types for testing
 282 | 
 283 | type MsgHandler func(uint32) interface{}
 284 | type MsgHandlerMap map[uint32]MsgHandler
 285 | 
 286 | var defaultHandlerMap = MsgHandlerMap{
 287 | 	WM_CREATE: func(hwnd uint32) interface{} {
 288 | 		//log.Print("WM_CREATE, hwnd = ", hwnd)
 289 | 		AttachNotifyHandler(hwnd, notifyHandler)
 290 | 		AttachWindowEventHandler(hwnd, windowEventHandler)
 291 | 		return 0
 292 | 	},
 293 | 	WM_SHOWWINDOW: func(hwnd uint32) interface{} {
 294 | 		return 0
 295 | 	},
 296 | 	WM_ERASEBKGND: func(hwnd uint32) interface{} {
 297 | 		return 0
 298 | 	},
 299 | 	WM_CLOSE: func(hwnd uint32) interface{} {
 300 | 		//log.Print("WM_CLOSE, hwnd = ", hwnd)
 301 | 		DetachWindowEventHandler(hwnd)
 302 | 		DetachNotifyHandler(hwnd)
 303 | 		DestroyWindow(hwnd)
 304 | 		return nil
 305 | 	},
 306 | 	WM_DESTROY: func(hwnd uint32) interface{} {
 307 | 		//log.Print("WM_DESTROY, hwnd = ", hwnd)
 308 | 		//DumpObjectCounts()
 309 | 		PostQuitMessage(0)
 310 | 		return 0
 311 | 	},
 312 | }
 313 | 
 314 | // Page templates used for various tests
 315 | var pages = map[string]string{
 316 | 	"empty":       ``,
 317 | 	"page":        `<html><body></body></html>`,
 318 | 	"one-div":     `<div id="a"></div>`,
 319 | 	"two-divs":    `<div id="a"></div><div id="b"></div>`,
 320 | 	"three-divs":  `<div id="a"></div><div id="b"></div><div id="c"></div>`,
 321 | 	"nested-divs": `<div id="a"><div id="b"></div></div>`,
 322 | 	"attr":        `<div id="a" first="5" second="5.1" third="yes"></div>`,
 323 | 	"css":         `<div style="left:10; opacity:0.5; text-align:center;"></div>`,
 324 | 	"classes":     `<div class="one  two three"></div><div></div>`,
 325 | 	"input":	   `<widget type="text" value="test string"></widget>`,
 326 | }
 327 | 
 328 | // Notify handler deals with WM_NOTIFY messages sent by htmlayout
 329 | var notifyHandler = &NotifyHandler{}
 330 | 
 331 | // Window event handler gets first and last chance to process events
 332 | var windowEventHandler = &EventHandler{}
 333 | 
 334 | // Tests:
 335 | 
 336 | func TestBasicWindow(t *testing.T) {
 337 | 	// A channel to receive the hwnd once the window is created
 338 | 	created := make(chan uint32)
 339 | 
 340 | 	// Wait until the window is created, then post a message to close it
 341 | 	go func() {
 342 | 		PostMessage(<-created, WM_CLOSE, 0, 0)
 343 | 	}()
 344 | 
 345 | 	if !registeredClasses["basic"] {
 346 | 		// Setup the window message handlers
 347 | 		// Customize the WM_CREATE handler so that sends the hwnd to our channel
 348 | 		handler := make(MsgHandlerMap, 32)
 349 | 		for k, v := range defaultHandlerMap {
 350 | 			handler[k] = v
 351 | 		}
 352 | 		handler[WM_CREATE] = func(hwnd uint32) interface{} {
 353 | 			created <- hwnd
 354 | 			return defaultHandlerMap[WM_CREATE](hwnd)
 355 | 		}
 356 | 		registerWindow(handler, "basic")
 357 | 	}
 358 | 	_ = createWindow("basic")
 359 | 	pump()
 360 | }
 361 | 
 362 | func TestLoadHtml(t *testing.T) {
 363 | 	testWithHtml(pages["page"], func(hwnd uint32) {})
 364 | }
 365 | 
 366 | func TestRootElement(t *testing.T) {
 367 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 368 | 		if e := RootElement(hwnd); e == nil {
 369 | 			t.Fatal("Could not get root elem")
 370 | 		}
 371 | 	})
 372 | }
 373 | 
 374 | func TestHandle(t *testing.T) {
 375 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 376 | 		e := RootElement(hwnd)
 377 | 		if h := e.Handle(); h == nil {
 378 | 			t.Fatal("Handle was nil")
 379 | 		}
 380 | 	})
 381 | }
 382 | 
 383 | func TestRelease(t *testing.T) {
 384 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 385 | 		e := RootElement(hwnd)
 386 | 		e.Release()
 387 | 		if h := e.Handle(); h != nil {
 388 | 			t.Fatal("Released but handle is not nil, finalizer not called?")
 389 | 		}
 390 | 	})
 391 | }
 392 | 
 393 | func TestChildCount(t *testing.T) {
 394 | 	testWithHtml(pages["two-divs"], func(hwnd uint32) {
 395 | 		root := RootElement(hwnd)
 396 | 		if count := root.ChildCount(); count != 2 {
 397 | 			t.Fatal("Expected two divs as children")
 398 | 		}
 399 | 	})
 400 | }
 401 | 
 402 | func TestChildCount2(t *testing.T) {
 403 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 404 | 		root := RootElement(hwnd)
 405 | 		if count := root.ChildCount(); count != 1 {
 406 | 			t.Fatal("Expected one divs as child")
 407 | 		}
 408 | 	})
 409 | }
 410 | 
 411 | func TestChild(t *testing.T) {
 412 | 	testWithHtml(pages["two-divs"], func(hwnd uint32) {
 413 | 		root := RootElement(hwnd)
 414 | 		d1 := root.Child(0)
 415 | 		d2 := root.Child(1)
 416 | 		if d1 == nil || d2 == nil {
 417 | 			t.Fatal("A child element could not be retrieved by index")
 418 | 		}
 419 | 	})
 420 | }
 421 | 
 422 | func TestIndex(t *testing.T) {
 423 | 	testWithHtml(pages["two-divs"], func(hwnd uint32) {
 424 | 		root := RootElement(hwnd)
 425 | 		d1 := root.Child(0)
 426 | 		d2 := root.Child(1)
 427 | 		if d1.Index() != 0 {
 428 | 			t.Fatal("Expected index 0")
 429 | 		}
 430 | 		if d2.Index() != 1 {
 431 | 			t.Fatal("Expected index 1")
 432 | 		}
 433 | 	})
 434 | }
 435 | 
 436 | func TestEquals(t *testing.T) {
 437 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 438 | 		root := RootElement(hwnd)
 439 | 		d1 := root.Child(0)
 440 | 		if root.Equals(d1) {
 441 | 			t.Fatal("Distinct elems should not be equal")
 442 | 		}
 443 | 		if !d1.Equals(d1) {
 444 | 			t.Fatal("Same elements should be equal")
 445 | 		}
 446 | 	})
 447 | }
 448 | 
 449 | func TestParent(t *testing.T) {
 450 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 451 | 		root := RootElement(hwnd)
 452 | 		d1 := root.Child(0)
 453 | 		d2 := d1.Child(0)
 454 | 
 455 | 		if !d2.Parent().Equals(d1) {
 456 | 			t.Fatal("Parent was not the expected elem")
 457 | 		}
 458 | 		if !d1.Parent().Equals(root) {
 459 | 			t.Fatal("Parent was not the expected elem")
 460 | 		}
 461 | 		if root.Parent() != nil {
 462 | 			t.Fatal("Root's parent should be nil")
 463 | 		}
 464 | 	})
 465 | }
 466 | 
 467 | func TestSelect(t *testing.T) {
 468 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 469 | 		root := RootElement(hwnd)
 470 | 		results := root.Select("div > div")
 471 | 		if len(results) != 1 {
 472 | 			t.Fatal("Expected one result")
 473 | 		}
 474 | 		inner := root.Child(0).Child(0)
 475 | 		if !results[0].Equals(inner) {
 476 | 			t.Fatal("Expected to match inner div")
 477 | 		}
 478 | 	})
 479 | }
 480 | 
 481 | func TestSelectParent(t *testing.T) {
 482 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 483 | 		root := RootElement(hwnd)
 484 | 		if result := root.SelectParent("*:has-child-of-type(div):has-child-of-type(div)"); !result.Equals(root) {
 485 | 			t.Fatal("Expected to match root element")
 486 | 		}
 487 | 	})
 488 | }
 489 | 
 490 | func TestSelectParentLimit(t *testing.T) {
 491 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 492 | 		root := RootElement(hwnd)
 493 | 		d1 := root.Child(0)
 494 | 		d2 := d1.Child(0)
 495 | 
 496 | 		// Depth=0 means search all the way up to root, should match
 497 | 		if result := d2.SelectParentLimit("html", 0); result == nil || !result.Equals(root) {
 498 | 			t.Fatal("Expected to match root elem")
 499 | 		}
 500 | 
 501 | 		// Depth=1 means only consider receiver element, should not match
 502 | 		if result := d2.SelectParentLimit("*:has-child-of-type(div)", 1); result != nil {
 503 | 			t.Fatal("Expected to only check current element and not match it, instead got: ", result.OuterHtml())
 504 | 		}
 505 | 
 506 | 		// Depth=2 means consider first parent, should match
 507 | 		if result := d2.SelectParentLimit("*:has-child-of-type(div)", 2); result == nil || !result.Equals(root.Child(0)) {
 508 | 			t.Fatal("Expected to match outer div, instead got: ", result.OuterHtml())
 509 | 		}
 510 | 	})
 511 | }
 512 | 
 513 | func TestType(t *testing.T) {
 514 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 515 | 		root := RootElement(hwnd)
 516 | 		elemType := root.Type()
 517 | 		if elemType != "html" {
 518 | 			t.Fatal("Type of root elem should be 'html', instead got: ", elemType)
 519 | 		}
 520 | 		elemType = root.Child(0).Type()
 521 | 		if elemType != "div" {
 522 | 			t.Fatal("Type of first child elem should be 'div', instead got: ", elemType)
 523 | 		}
 524 | 	})
 525 | }
 526 | 
 527 | func TestOuterHtml(t *testing.T) {
 528 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 529 | 		root := RootElement(hwnd)
 530 | 		expected := "<html>" + pages["nested-divs"] + "</html>"
 531 | 		if !looseEqual(expected, root.OuterHtml()) {
 532 | 			t.Fatal("Outer html of root elem not as expected")
 533 | 		}
 534 | 	})
 535 | }
 536 | 
 537 | func TestHtml(t *testing.T) {
 538 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 539 | 		root := RootElement(hwnd)
 540 | 		if !looseEqual(root.Html(), pages["nested-divs"]) {
 541 | 			t.Fatal("Inner html of root elem should match original html")
 542 | 		}
 543 | 
 544 | 		d1 := root.Child(0)
 545 | 		if !looseEqual(d1.Html(), `<div id="b"></div>`) {
 546 | 			t.Fatal("Inner html of first div should match html of innermost div")
 547 | 		}
 548 | 
 549 | 		d2 := d1.Child(0)
 550 | 		if !looseEqual(d2.Html(), ``) {
 551 | 			t.Fatal("Inner html of innermost div be the div's contents")
 552 | 		}
 553 | 	})
 554 | }
 555 | 
 556 | func TestInsertChild(t *testing.T) {
 557 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 558 | 		root := RootElement(hwnd)
 559 | 		d := root.Child(0)
 560 | 		e := NewElement("div")
 561 | 		d.InsertChild(e, 0)
 562 | 		if !looseEqual(d.Html(), `<div></div>`) {
 563 | 			t.Fatal("Inserting element created unexpected html: ", d.Html())
 564 | 		}
 565 | 		e = NewElement("span")
 566 | 		d.InsertChild(e, 0)
 567 | 		if !looseEqual(d.Html(), `<span></span><div></div>`) {
 568 | 			t.Fatal("Inserting element created unexpected html: ", d.Html())
 569 | 		}
 570 | 	})
 571 | }
 572 | 
 573 | func TestAppendChild(t *testing.T) {
 574 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 575 | 		root := RootElement(hwnd)
 576 | 		d := root.Child(0)
 577 | 		e := NewElement("div")
 578 | 		d.AppendChild(e)
 579 | 		if !looseEqual(d.Html(), `<div></div>`) {
 580 | 			t.Fatal("Inserting element created unexpected html: ", d.Html())
 581 | 		}
 582 | 		e = NewElement("span")
 583 | 		d.AppendChild(e)
 584 | 		if !looseEqual(d.Html(), `<div></div><span></span>`) {
 585 | 			t.Fatal("Inserting element created unexpected html: ", d.Html())
 586 | 		}
 587 | 	})
 588 | }
 589 | 
 590 | func TestDetach(t *testing.T) {
 591 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 592 | 		root := RootElement(hwnd)
 593 | 		d := root.Child(0)
 594 | 		inner := d.Child(0)
 595 | 
 596 | 		// Pull the inner div out of the dom
 597 | 		inner.Detach()
 598 | 		if !looseEqual(d.Html(), ``) {
 599 | 			t.Fatal("Element should not have any contents after detaching its only child")
 600 | 		}
 601 | 
 602 | 		// Put it back in
 603 | 		d.AppendChild(inner)
 604 | 		if !looseEqual(d.Html(), inner.OuterHtml()) {
 605 | 			t.Fatal("Element should not have any contents after detaching its only child")
 606 | 		}
 607 | 	})
 608 | }
 609 | 
 610 | func TestDelete(t *testing.T) {
 611 | 	testWithHtml(pages["nested-divs"], func(hwnd uint32) {
 612 | 		root := RootElement(hwnd)
 613 | 		d := root.Child(0)
 614 | 		inner := d.Child(0)
 615 | 
 616 | 		inner.Delete()
 617 | 		if !looseEqual(d.Html(), ``) {
 618 | 			t.Fatal("Element should not have any contents after detaching its only child")
 619 | 		}
 620 | 
 621 | 		// Should not be able to put the deleted element back in, should get invalid handle error
 622 | 		func() {
 623 | 			defer expectDomError(HLDOM_INVALID_HANDLE)
 624 | 			d.AppendChild(inner)
 625 | 		}()
 626 | 	})
 627 | }
 628 | 
 629 | func TestClone(t *testing.T) {
 630 | 	testWithHtml(`<div>a</div>`, func(hwnd uint32) {
 631 | 		root := RootElement(hwnd)
 632 | 		clone := root.Child(0).Clone()
 633 | 		if clone.Type() != "div" {
 634 | 			t.Fatal("Clone should have same type as original")
 635 | 		}
 636 | 		if !looseEqual(clone.Html(), `a`) {
 637 | 			t.Fatal("Clone should have same contents as original")
 638 | 		}
 639 | 	})
 640 | }
 641 | 
 642 | func TestSwap(t *testing.T) {
 643 | 	testWithHtml(pages["two-divs"], func(hwnd uint32) {
 644 | 		root := RootElement(hwnd)
 645 | 		a := root.Child(0)
 646 | 		b := root.Child(1)
 647 | 		a.Swap(b)
 648 | 		if !looseEqual(root.Html(), `<div id="b"></div><div id="a"></div>`) {
 649 | 			t.Fatal("Clone should have same contents as original")
 650 | 		}
 651 | 	})
 652 | }
 653 | 
 654 | func TestSortChildren(t *testing.T) {
 655 | 	cmp := func(a, b *Element) int {
 656 | 		first := a.Html()[0]
 657 | 		second := b.Html()[0]
 658 | 		if first == second {
 659 | 			return 0
 660 | 		} else if first > second {
 661 | 			return 1
 662 | 		}
 663 | 		return -1
 664 | 	}
 665 | 	testWithHtml(`<div>c</div><div>b</div><div>a</div>`, func(hwnd uint32) {
 666 | 		root := RootElement(hwnd)
 667 | 		root.SortChildren(cmp)
 668 | 		if !looseEqual(root.Html(), `<div>a</div><div>b</div><div>c</div>`) {
 669 | 			t.Fatal("Sorted elements should be in alphabetically descending order")
 670 | 		}
 671 | 	})
 672 | }
 673 | 
 674 | func TestSortChildrenRange(t *testing.T) {
 675 | 	cmp := func(a, b *Element) int {
 676 | 		first := a.Html()[0]
 677 | 		second := b.Html()[0]
 678 | 		if first == second {
 679 | 			return 0
 680 | 		} else if first > second {
 681 | 			return 1
 682 | 		}
 683 | 		return -1
 684 | 	}
 685 | 	testWithHtml(`<div>c</div><div>b</div><div>a</div>`, func(hwnd uint32) {
 686 | 		root := RootElement(hwnd)
 687 | 		root.SortChildrenRange(0, 2, cmp)
 688 | 		if !looseEqual(root.Html(), `<div>b</div><div>c</div><div>a</div>`) {
 689 | 			t.Fatal("First two elements should be in alphabetically descending order")
 690 | 		}
 691 | 	})
 692 | }
 693 | 
 694 | func TestHwnd(t *testing.T) {
 695 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 696 | 		root := RootElement(hwnd)
 697 | 		if root.Hwnd() != hwnd {
 698 | 			t.Fatal("Root should report the same hwnd it was created with")
 699 | 		}
 700 | 		if root.Child(0).Hwnd() != hwnd {
 701 | 			t.Fatal("Child should report same hwnd as its root")
 702 | 		}
 703 | 	})
 704 | }
 705 | 
 706 | // TODO: Figure out how this test should differ from the test for Hwnd()
 707 | func TestRootHwnd(t *testing.T) {
 708 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 709 | 		root := RootElement(hwnd)
 710 | 		if root.RootHwnd() != hwnd {
 711 | 			t.Fatal("Root should report the same root hwnd it was created with")
 712 | 		}
 713 | 		if root.Child(0).RootHwnd() != hwnd {
 714 | 			t.Fatal("Child should report same root hwnd as its root")
 715 | 		}
 716 | 	})
 717 | }
 718 | 
 719 | func TestSetHtml(t *testing.T) {
 720 | 	d := NewElement("div")
 721 | 
 722 | 	// Should not be able to set html on an element that is not part of a dom
 723 | 	func() {
 724 | 		defer expectDomError(HLDOM_PASSIVE_HANDLE)
 725 | 		d.SetHtml("<span></span>")
 726 | 	}()
 727 | 
 728 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 729 | 		root := RootElement(hwnd)
 730 | 		d := root.Child(0)
 731 | 		d.SetHtml("<span></span>")
 732 | 		if !looseEqual(d.Html(), `<span></span>`) {
 733 | 			t.Fatal("Element should contain new html")
 734 | 		}
 735 | 	})
 736 | }
 737 | 
 738 | func TestPrependHtml(t *testing.T) {
 739 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 740 | 		root := RootElement(hwnd)
 741 | 		root.PrependHtml("<span></span>")
 742 | 		if !looseEqual(root.Html(), `<span></span><div id="a"></div>`) {
 743 | 			t.Fatal("Expected prepended html in front of existing contents")
 744 | 		}
 745 | 	})
 746 | }
 747 | 
 748 | func TestAppendHtml(t *testing.T) {
 749 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 750 | 		root := RootElement(hwnd)
 751 | 		root.AppendHtml("<span></span>")
 752 | 		if !looseEqual(root.Html(), `<div id="a"></div><span></span>`) {
 753 | 			t.Fatal("Expected appended html at the end of existing contents")
 754 | 		}
 755 | 	})
 756 | }
 757 | 
 758 | func TestSetText(t *testing.T) {
 759 | 	testWithHtml(pages["one-div"], func(hwnd uint32) {
 760 | 		root := RootElement(hwnd)
 761 | 		root.SetText("Hi")
 762 | 		if !looseEqual(root.Html(), `Hi`) {
 763 | 			t.Fatal("Setting the text should have replaced inner html")
 764 | 		}
 765 | 	})
 766 | }
 767 | 
 768 | func TestAttrCount(t *testing.T) {
 769 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 770 | 		root := RootElement(hwnd)
 771 | 		d := root.Child(0)
 772 | 		if count := d.AttrCount(); count != 4 {
 773 | 			t.Fatal("Expected four attributes on div")
 774 | 		}
 775 | 	})
 776 | }
 777 | 
 778 | func TestAttrByIndex(t *testing.T) {
 779 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 780 | 		root := RootElement(hwnd)
 781 | 		d := root.Child(0)
 782 | 		expectedKeys := []string{"id", "first", "second", "third"}
 783 | 		expectedValues := []string{"a", "5", "5.1", "yes"}
 784 | 		for i := range expectedKeys {
 785 | 			key, val := d.AttrByIndex(i)
 786 | 			if key != expectedKeys[i] || val != expectedValues[i] {
 787 | 				t.Fatal("Expected (%s,%s), got (%s, %s)", expectedKeys[i], expectedValues[i], key, val)
 788 | 			}
 789 | 		}
 790 | 	})
 791 | }
 792 | 
 793 | func TestAttr(t *testing.T) {
 794 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 795 | 		root := RootElement(hwnd)
 796 | 		d := root.Child(0)
 797 | 
 798 | 		if first, exists := d.Attr("first"); !exists {
 799 | 			t.Fatal("Should exist")
 800 | 		} else if first != "5" {
 801 | 			t.Fatal("Unexpected value: ", first)
 802 | 		}
 803 | 
 804 | 		if second, exists := d.Attr("second"); !exists {
 805 | 			t.Fatal("Should exist")
 806 | 		} else if second != "5.1" {
 807 | 			t.Fatal("Unexpected value: ", second)
 808 | 		}
 809 | 
 810 | 		if third, exists := d.Attr("third"); !exists {
 811 | 			t.Fatal("Should exist")
 812 | 		} else if third != "yes" {
 813 | 			t.Fatal("Unexpected value: ", third)
 814 | 		}
 815 | 
 816 | 		if _, exists := d.Attr("invalid"); exists {
 817 | 			t.Fatal("Should not exist")
 818 | 		}
 819 | 	})
 820 | }
 821 | 
 822 | func TestAttrAsFloatOnInt(t *testing.T) {
 823 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 824 | 		root := RootElement(hwnd)
 825 | 		d := root.Child(0)
 826 | 
 827 | 		if value, exists, err := d.AttrAsFloat("first"); err != nil {
 828 | 			t.Fatal(err)
 829 | 		} else if !exists {
 830 | 			t.Fatal("Should exist")
 831 | 		} else if math.Abs(value-float64(5.0)) > float64(0.0001) {
 832 | 			t.Fatal("Unexpected value: ", value)
 833 | 		}
 834 | 	})
 835 | }
 836 | 
 837 | func TestAttrAsFloatOnFloat(t *testing.T) {
 838 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 839 | 		root := RootElement(hwnd)
 840 | 		d := root.Child(0)
 841 | 
 842 | 		if value, exists, err := d.AttrAsFloat("second"); err != nil {
 843 | 			t.Fatal(err)
 844 | 		} else if !exists {
 845 | 			t.Fatal("Should exist")
 846 | 		} else if math.Abs(value-float64(5.1)) > float64(0.0001) {
 847 | 			t.Fatal("Unexpected value: ", value)
 848 | 		}
 849 | 	})
 850 | }
 851 | 
 852 | func TestAttrAsFloatOnString(t *testing.T) {
 853 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 854 | 		root := RootElement(hwnd)
 855 | 		d := root.Child(0)
 856 | 
 857 | 		if _, exists, err := d.AttrAsFloat("third"); !exists {
 858 | 			t.Fatal("Should exist")
 859 | 		} else if err == nil {
 860 | 			t.Fatal("Expected error")
 861 | 		} else if _, ok := err.(*strconv.NumError); !ok {
 862 | 			t.Fatal("Expected NumError")
 863 | 		}
 864 | 	})
 865 | }
 866 | 
 867 | func TestAttrAsFloatOnInvalid(t *testing.T) {
 868 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 869 | 		root := RootElement(hwnd)
 870 | 		d := root.Child(0)
 871 | 
 872 | 		if _, exists, err := d.AttrAsFloat("invalid"); err != nil || exists {
 873 | 			t.Fatal()
 874 | 		}
 875 | 	})
 876 | }
 877 | 
 878 | func TestAttrAsIntOnInt(t *testing.T) {
 879 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 880 | 		root := RootElement(hwnd)
 881 | 		d := root.Child(0)
 882 | 
 883 | 		if value, exists, err := d.AttrAsInt("first"); err != nil {
 884 | 			t.Fatal(err)
 885 | 		} else if !exists {
 886 | 			t.Fatal("Should Exist")
 887 | 		} else if value != 5 {
 888 | 			t.Fatal("Expected integer 5")
 889 | 		}
 890 | 	})
 891 | }
 892 | 
 893 | func TestAttrAsIntOnFloat(t *testing.T) {
 894 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 895 | 		root := RootElement(hwnd)
 896 | 		d := root.Child(0)
 897 | 
 898 | 		if _, exists, err := d.AttrAsInt("second"); !exists {
 899 | 			t.Fatal("Should exist")
 900 | 		} else if err == nil {
 901 | 			t.Fatal("Expected error while parsing")
 902 | 		} else if _, ok := err.(*strconv.NumError); !ok {
 903 | 			t.Fatal("Expected NumError")
 904 | 		}
 905 | 	})
 906 | }
 907 | 
 908 | func TestAttrAsIntOnString(t *testing.T) {
 909 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 910 | 		root := RootElement(hwnd)
 911 | 		d := root.Child(0)
 912 | 
 913 | 		if _, exists, err := d.AttrAsInt("third"); !exists {
 914 | 			t.Fatal("Should exist")
 915 | 		} else if err == nil {
 916 | 			t.Fatal("Expected error while parsing")
 917 | 		} else if _, ok := err.(*strconv.NumError); !ok {
 918 | 			t.Fatal("Expected NumError")
 919 | 		}
 920 | 	})
 921 | }
 922 | 
 923 | func TestAttrAsIntOnInvalid(t *testing.T) {
 924 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 925 | 		root := RootElement(hwnd)
 926 | 		d := root.Child(0)
 927 | 
 928 | 		if _, exists, err := d.AttrAsFloat("invalid"); err != nil || exists {
 929 | 			t.Fatal()
 930 | 		}
 931 | 	})
 932 | }
 933 | 
 934 | func TestRemoveAttr(t *testing.T) {
 935 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 936 | 		root := RootElement(hwnd)
 937 | 		d := root.Child(0)
 938 | 		if _, exists := d.Attr("second"); !exists {
 939 | 			t.Fatal("Should exist")
 940 | 		} else {
 941 | 			d.RemoveAttr("second")
 942 | 			if _, exists := d.Attr("second"); exists {
 943 | 				t.Fatal("Should not exist")
 944 | 			}
 945 | 		}
 946 | 		// Removing a nonexistent attr should do nothing
 947 | 		d.RemoveAttr("invalid")
 948 | 	})
 949 | }
 950 | 
 951 | func TestSetAttrFloat32(t *testing.T) {
 952 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 953 | 		root := RootElement(hwnd)
 954 | 		d := root.Child(0)
 955 | 		pi := 3.14159
 956 | 		d.SetAttr("myFloat32", float32(pi))
 957 | 
 958 | 		if s, exists := d.Attr("myFloat32"); !exists {
 959 | 			t.Fatal("Should exist")
 960 | 		} else if f, err := strconv.ParseFloat(s, 64); err != nil {
 961 | 			t.Fatal(err)
 962 | 		} else if math.Abs(f-float64(pi)) > float64(0.0001) {
 963 | 			t.Fatal("Unexpected value: ", f)
 964 | 		}
 965 | 	})
 966 | }
 967 | 
 968 | func TestSetAttrFloat64(t *testing.T) {
 969 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 970 | 		root := RootElement(hwnd)
 971 | 		d := root.Child(0)
 972 | 		pi := 3.14159
 973 | 		d.SetAttr("myFloat64", float64(pi))
 974 | 
 975 | 		if s, exists := d.Attr("myFloat64"); !exists {
 976 | 			t.Fatal("Should exist")
 977 | 		} else if f, err := strconv.ParseFloat(s, 64); err != nil {
 978 | 			t.Fatal("Could not parse attr string as float")
 979 | 		} else if math.Abs(f-float64(pi)) > float64(0.0001) {
 980 | 			t.Fatal("Unexpected value: ", f)
 981 | 		}
 982 | 	})
 983 | }
 984 | 
 985 | func TestSetAttrString(t *testing.T) {
 986 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
 987 | 		root := RootElement(hwnd)
 988 | 		d := root.Child(0)
 989 | 		d.SetAttr("myString", "hello")
 990 | 
 991 | 		if s, exists := d.Attr("myString"); !exists {
 992 | 			t.Fatal("Should exist")
 993 | 		} else if s != "hello" {
 994 | 			t.Fatal("Unexpected value: ", s)
 995 | 		}
 996 | 	})
 997 | }
 998 | 
 999 | func TestSetAttrInt(t *testing.T) {
1000 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
1001 | 		root := RootElement(hwnd)
1002 | 		d := root.Child(0)
1003 | 		d.SetAttr("myInt", 9)
1004 | 
1005 | 		if s, exists := d.Attr("myInt"); !exists {
1006 | 			t.Fatal("Should exist")
1007 | 		} else if s != "9" {
1008 | 			t.Fatal("Unexpected value: ", s)
1009 | 		}
1010 | 	})
1011 | }
1012 | 
1013 | func TestSetAttrOverwrite(t *testing.T) {
1014 | 	testWithHtml(pages["attr"], func(hwnd uint32) {
1015 | 		root := RootElement(hwnd)
1016 | 		d := root.Child(0)
1017 | 
1018 | 		// Test overwriting an attr that already exists
1019 | 		d.SetAttr("id", "hai")
1020 | 		if s, exists := d.Attr("id"); !exists {
1021 | 			t.Fatal("Should exist")
1022 | 		} else if s != "hai" {
1023 | 			t.Fatal("Expected to overwrite attr")
1024 | 		}
1025 | 	})
1026 | }
1027 | 
1028 | func TestHasClass(t *testing.T) {
1029 | 	testWithHtml(pages["classes"], func(hwnd uint32) {
1030 | 		root := RootElement(hwnd)
1031 | 		d := root.Child(0)
1032 | 		d2 := root.Child(1)
1033 | 
1034 | 		if !d.HasClass("two") {
1035 | 			t.Fatal("Should have class 'two'")
1036 | 		}
1037 | 		if d.HasClass("nope") {
1038 | 			t.Fatal("Should not have class 'nope'")
1039 | 		}
1040 | 		if d2.HasClass("nope") {
1041 | 			t.Fatal("Should not have class 'nope'")
1042 | 		}
1043 | 	})
1044 | }
1045 | 
1046 | func TestAddClass(t *testing.T) {
1047 | 	testWithHtml(pages["classes"], func(hwnd uint32) {
1048 | 		root := RootElement(hwnd)
1049 | 		d := root.Child(0)
1050 | 		d2 := root.Child(1)
1051 | 
1052 | 		var classes string
1053 | 		var exists bool
1054 | 
1055 | 		d.AddClass("four")
1056 | 		if classes, exists = d.Attr("class"); !exists {
1057 | 			t.Fatal("Should exist")
1058 | 		}
1059 | 		if classes != "one two three four" {
1060 | 			t.Fatalf("Unexpected class attr value: '%s'", classes)
1061 | 		}
1062 | 
1063 | 		d.AddClass("two")
1064 | 		if classes, exists = d.Attr("class"); !exists {
1065 | 			t.Fatal("Should exist")
1066 | 		}
1067 | 		if classes != "one two three four" {
1068 | 			t.Fatalf("Unexpected class attr value: '%s'", classes)
1069 | 		}
1070 | 
1071 | 		d2.AddClass("one")
1072 | 		if classes, exists = d2.Attr("class"); !exists {
1073 | 			t.Fatal("Should exist")
1074 | 		}
1075 | 		if classes != "one" {
1076 | 			t.Fatalf("Unexpected class attr value: '%s'", classes)
1077 | 		}
1078 | 	})
1079 | }
1080 | 
1081 | func TestRemoveClass(t *testing.T) {
1082 | 	testWithHtml(pages["classes"], func(hwnd uint32) {
1083 | 		root := RootElement(hwnd)
1084 | 		d := root.Child(0)
1085 | 		d2 := root.Child(1)
1086 | 
1087 | 		var classes string
1088 | 		var exists bool
1089 | 
1090 | 		d.RemoveClass("one")
1091 | 		if classes, exists = d.Attr("class"); !exists {
1092 | 			t.Fatal("Should exist")
1093 | 		}
1094 | 		if classes != "two three" {
1095 | 			t.Fatalf("Unexpected class attr value: '%s'", classes)
1096 | 		}
1097 | 
1098 | 		d.RemoveClass("three")
1099 | 		if classes, exists = d.Attr("class"); !exists {
1100 | 			t.Fatal("Should exist")
1101 | 		}
1102 | 		if classes != "two" {
1103 | 			t.Fatalf("Unexpected class attr value: '%s'", classes)
1104 | 		}
1105 | 
1106 | 		d.RemoveClass("nope")
1107 | 		if classes, exists = d.Attr("class"); !exists {
1108 | 			t.Fatal("Should exist")
1109 | 		}
1110 | 		if classes != "two" {
1111 | 			t.Fatalf("Unexpected class attr value: '%s'", classes)
1112 | 		}
1113 | 
1114 | 		d2.RemoveClass("nope")
1115 | 		if classes, exists = d2.Attr("class"); exists {
1116 | 			t.Fatal("Should not exist")
1117 | 		}
1118 | 	})
1119 | }
1120 | 
1121 | func TestStyle(t *testing.T) {
1122 | 	testWithHtml(pages["css"], func(hwnd uint32) {
1123 | 		root := RootElement(hwnd)
1124 | 		d := root.Child(0)
1125 | 
1126 | 		if s, exists := d.Style("left"); !exists {
1127 | 			t.Fatal("Should exist")
1128 | 		} else if s != "10px" {
1129 | 			t.Fatal("Unexpected value for style 'left'")
1130 | 		}
1131 | 
1132 | 		if s, exists := d.Style("opacity"); !exists {
1133 | 			t.Fatal("Should exist")
1134 | 		} else if f, err := strconv.ParseFloat(s, 64); err != nil {
1135 | 			t.Fatal(err)
1136 | 		} else if math.Abs(f-float64(0.5)) > float64(0.05) {
1137 | 			t.Fatal("Unexpected value: ", s)
1138 | 		}
1139 | 
1140 | 		if s, exists := d.Style("text-align"); !exists {
1141 | 			t.Fatal("Should exist")
1142 | 		} else if s != "center" {
1143 | 			t.Fatal("Unexpected value: ", s)
1144 | 		}
1145 | 
1146 | 		if _, exists := d.Style("invalid"); exists {
1147 | 			t.Fatal("Should not exist")
1148 | 		}
1149 | 	})
1150 | }
1151 | 
1152 | func TestSetStyleFloat32(t *testing.T) {
1153 | 	testWithHtml(pages["css"], func(hwnd uint32) {
1154 | 		root := RootElement(hwnd)
1155 | 		d := root.Child(0)
1156 | 
1157 | 		d.SetStyle("opacity", float32(0.75))
1158 | 		if s, exists := d.Style("opacity"); !exists {
1159 | 			t.Fatal("Should exist")
1160 | 		} else if f, err := strconv.ParseFloat(s, 64); err != nil {
1161 | 			t.Fatal(err)
1162 | 		} else if math.Abs(f-float64(0.75)) > float64(0.05) {
1163 | 			log.Print(s)
1164 | 			t.Fatal("Unexpected value: ", f)
1165 | 		}
1166 | 	})
1167 | }
1168 | 
1169 | func TestSetStyleFloat64(t *testing.T) {
1170 | 	testWithHtml(pages["css"], func(hwnd uint32) {
1171 | 		root := RootElement(hwnd)
1172 | 		d := root.Child(0)
1173 | 
1174 | 		d.SetStyle("opacity", float64(0.75))
1175 | 		if s, exists := d.Style("opacity"); !exists {
1176 | 			t.Fatal("Should exist")
1177 | 		} else if f, err := strconv.ParseFloat(s, 64); err != nil {
1178 | 			t.Fatal(err)
1179 | 		} else if math.Abs(f-float64(0.75)) > float64(0.05) {
1180 | 			t.Fatal("Unexpected value: ", f)
1181 | 		}
1182 | 	})
1183 | }
1184 | 
1185 | func TestSetStyleString(t *testing.T) {
1186 | 	testWithHtml(pages["css"], func(hwnd uint32) {
1187 | 		root := RootElement(hwnd)
1188 | 		d := root.Child(0)
1189 | 
1190 | 		d.SetStyle("font-family", "hello")
1191 | 		if s, exists := d.Style("font-family"); !exists {
1192 | 			t.Fatal("Should exist")
1193 | 		} else if s != "hello" {
1194 | 			t.Fatal("Unexpected value: ", s)
1195 | 		}
1196 | 	})
1197 | }
1198 | 
1199 | func TestSetStyleInt(t *testing.T) {
1200 | 	testWithHtml(pages["css"], func(hwnd uint32) {
1201 | 		root := RootElement(hwnd)
1202 | 		d := root.Child(0)
1203 | 
1204 | 		d.SetStyle("height", 9)
1205 | 		if s, exists := d.Style("height"); !exists {
1206 | 			t.Fatal("Should exist")
1207 | 		} else if s != "9px" {
1208 | 			t.Fatal("Unexpected value: ", s)
1209 | 		}
1210 | 	})
1211 | }
1212 | 
1213 | func TestSetStyleOverwrite(t *testing.T) {
1214 | 	testWithHtml(pages["css"], func(hwnd uint32) {
1215 | 		root := RootElement(hwnd)
1216 | 		d := root.Child(0)
1217 | 
1218 | 		// Test overwriting a style that already exists
1219 | 		d.SetStyle("left", 99)
1220 | 		if s, exists := d.Style("left"); !exists {
1221 | 			t.Fatal("Should exist")
1222 | 		} else if s != "99px" {
1223 | 			t.Fatal("Expected to overwrite style")
1224 | 		}
1225 | 	})
1226 | }
1227 | 
1228 | func TestAttachSameHandlerToTwoElements(t *testing.T) {
1229 | 	testWithHtml(pages["two-divs"], func(hwnd uint32) {
1230 | 		root := RootElement(hwnd)
1231 | 		d1 := root.Child(0)
1232 | 		d2 := root.Child(1)
1233 | 
1234 | 		handler := &EventHandler{}
1235 | 		d1.AttachHandler(handler)
1236 | 		d2.AttachHandler(handler)
1237 | 		d2.DetachHandler(handler)
1238 | 		d1.DetachHandler(handler)
1239 | 	})
1240 | }
1241 | 
1242 | // func TestControlValueType(t *testing.T) {
1243 | // 	testWithHtml(pages["input"], func(hwnd uint32) {
1244 | // 		input := RootElement(hwnd).Child(0)
1245 | // 		if dataType := input.ValueType(); dataType != T_STRING {
1246 | // 			t.Fatal("Value type should be string")
1247 | // 		}
1248 | // 	})
1249 | // }
1250 | 
1251 | func TestValueAsString(t *testing.T) {
1252 | 	testWithHtml(pages["input"], func(hwnd uint32) {
1253 | 		input := RootElement(hwnd).Child(0)
1254 | 		if s, err := input.ValueAsString(); err != nil {
1255 | 			t.Fatal(err)
1256 | 		} else if s != "test string" {
1257 | 			t.Fatal("Unexpected value: ", s)
1258 | 		}
1259 | 	})
1260 | }
1261 | 
1262 | func TestSetValueString(t *testing.T) {
1263 | 	testWithHtml(pages["input"], func(hwnd uint32) {
1264 | 		input := RootElement(hwnd).Child(0)
1265 | 		input.SetValue("woohoo")
1266 | 		if s, err := input.ValueAsString(); err != nil {
1267 | 			t.Fatal(err)
1268 | 		} else if s != "woohoo" {
1269 | 			t.Fatal("Unexpected value: ", s)
1270 | 		}
1271 | 	})
1272 | }
1273 | 


--------------------------------------------------------------------------------
/notify_handler.go:
--------------------------------------------------------------------------------
 1 | package gohl
 2 | 
 3 | type NotifyHandler struct {
 4 | 	Behaviors          map[string]*EventHandler
 5 | 	OnCreateControl    func(params *NmhlCreateControl) uintptr
 6 | 	OnControlCreated   func(params *NmhlCreateControl) uintptr
 7 | 	OnDestroyControl   func(params *NmhlDestroyControl) uintptr
 8 | 	OnLoadData         func(params *NmhlLoadData) uintptr
 9 | 	OnDataLoaded       func(params *NmhlDataLoaded) uintptr
10 | 	OnDocumentComplete func() uintptr
11 | }
12 | 


--------------------------------------------------------------------------------
/patch_htmlayout_header.py:
--------------------------------------------------------------------------------
 1 | import sys
 2 | import os
 3 | import operator
 4 | import shutil
 5 | import re
 6 | 
 7 | BASE = "./htmlayout/include"
 8 | REPLACEMENTS = {
 9 | 	"htmlayout_dom.h": [
10 | 		(r"struct htmlayout_dom_element;", r"typedef struct htmlayout_dom_element htmlayout_dom_element;", 1),
11 | 	],
12 | 	"htmlayout_behavior.h": [
13 | 		(r"struct EXCHANGE_PARAMS;", r"typedef struct EXCHANGE_PARAMS EXCHANGE_PARAMS;", 1),
14 | 	],
15 | }
16 | 
17 | def apply_replacements(path):
18 | 	with open(os.path.join(BASE, path), "r+") as file:
19 | 		s = file.read()
20 | 		for find, replace, count in REPLACEMENTS[path]:
21 | 			s = re.sub(find, replace, s, count)
22 | 		file.seek(0)
23 | 		file.write(s)
24 | 		file.truncate()
25 | 
26 | def restore_backups():
27 | 	for filename in REPLACEMENTS:
28 | 		path = os.path.join(BASE, filename)
29 | 		original = path+".original"
30 | 		if os.path.exists(original):
31 | 			shutil.move(original, path)
32 | 
33 | def main():
34 | 	if not os.path.exists(BASE):
35 | 		print("You must install the htmlayout sdk alongside this script in a folder called 'htmlayout'")
36 | 		return
37 | 	paths = [os.path.join(BASE, filename) for filename in REPLACEMENTS]
38 | 	existance = [os.path.exists(path) for path in paths]
39 | 	if False in existance:
40 | 		print("Could not find the following files to patch: "+missing)
41 | 		return
42 | 	for path in paths:
43 | 		dst = path+".original"
44 | 		if os.path.exists(dst):
45 | 			print("Patch has already been applied (backup '%s' exists)" % dst)
46 | 			return
47 | 		shutil.copyfile(path, dst)	
48 | 	for filename in REPLACEMENTS:
49 | 		apply_replacements(filename)
50 | 	print("Patch complete")
51 | 
52 | if __name__ == "__main__":
53 | 	if len(sys.argv) == 2 and sys.argv[1] == "restore":
54 | 		restore_backups()
55 | 	else:
56 | 		main()


--------------------------------------------------------------------------------