Esempio n. 1
0
// Sorts 'count' child elements starting at index 'start'.  Uses comparator to define the
// order.  Comparator should return -1, or 0, or 1 to indicate less, equal or greater
func (e *Element) SortChildrenRange(start, count uint, comparator func(*Element, *Element) int) {
	end := start + count
	arg := uintptr(unsafe.Pointer(&comparator))
	if ret := C.HTMLayoutSortElements(e.handle, C.UINT(start), C.UINT(end), (*[0]byte)(unsafe.Pointer(goElementComparator)), C.LPVOID(arg)); ret != HLDOM_OK {
		domPanic(ret, "Failed to sort elements")
	}
}
Esempio n. 2
0
func (this *Hotkeys) AddHotkey(ModKey, Vk uint, callback Callback) int {
	hotkey := new(Hotkey)
	hotkey.ModKey = C.UINT(ModKey)
	hotkey.Vk = C.UINT(Vk)
	hotkey.Callback = callback
	this.hotkeys[this.id] = hotkey
	oldId := this.id
	this.id++
	return int(oldId)
}
Esempio n. 3
0
// Sets the specified flag to "on" or "off" according to the value of the provided boolean
func (e *Element) SetState(flag uint32, on bool) {
	addBits := uint32(0)
	clearBits := uint32(0)
	if on {
		addBits = flag
	} else {
		clearBits = flag
	}
	shouldUpdate := C.BOOL(1)
	if ret := C.HTMLayoutSetElementState(e.handle, C.UINT(addBits), C.UINT(clearBits), shouldUpdate); ret != HLDOM_OK {
		domPanic(ret, "Failed to set element state flag")
	}
}
Esempio n. 4
0
func (e *Element) Child(index uint) *Element {
	var child C.HELEMENT
	if ret := C.HTMLayoutGetNthChild(e.handle, C.UINT(index), &child); ret != HLDOM_OK {
		domPanic(ret, "Failed to get child at index: ", index)
	}
	return NewElementFromHandle(HELEMENT(child))
}
Esempio n. 5
0
// Let's find a suitable pixel format -- first try with antialiasing
func BestwglChoosePixelFormatARB(procs *C.wglProcs, hdc C.HDC, bitsPerPixel uint, settings *ContextSettings) C.int {
	if settings.AntialiasingLevel <= 0 {
		return 0
	}
	if procs.p_wglChoosePixelFormatARB == nil {
		return 0
	}

	AttribIList := [...]C.int{
		C.WGL_DRAW_TO_WINDOW_ARB, C.GL_TRUE,
		C.WGL_SUPPORT_OPENGL_ARB, C.GL_TRUE,
		C.WGL_ACCELERATION_ARB, C.WGL_FULL_ACCELERATION_ARB,
		C.WGL_DOUBLE_BUFFER_ARB, C.GL_TRUE,
		C.WGL_SAMPLE_BUFFERS_ARB, C.GL_TRUE, // turn on antialiasing
		C.WGL_SAMPLES_ARB, C.int(settings.AntialiasingLevel),
		0, 0,
	}
	AttribFList := []C.FLOAT{0, 0}

	// Let's check how many formats are supporting our requirements
	const formats_size = 128
	var formats [formats_size]C.int
	var nbFormats C.UINT
	for settings.AntialiasingLevel > 0 {
		if C.__wglChoosePixelFormatARB(procs, hdc, &AttribIList[0], &AttribFList[0], formats_size, &formats[0], &nbFormats) == C.TRUE &&
			nbFormats > 0 {
			break
		}
		nbFormats = 0 // reset this

		// Decrease the antialiasing level until we find a valid one
		settings.AntialiasingLevel--
		AttribIList[11]--
	}

	bestScore := uint(1<<32 - 1)
	var bestFormat C.int
	for i := C.UINT(0); bestScore != 0 && i < nbFormats; i++ {
		// Get the current format's attributes
		attributes := C.PIXELFORMATDESCRIPTOR{
			nSize:    C.PIXELFORMATDESCRIPTOR_size,
			nVersion: 1,
		}
		if C.__DescribePixelFormat(hdc, formats[i], C.PIXELFORMATDESCRIPTOR_size, &attributes) == 0 {
			return 0
		}

		// Evaluate the current configuration
		color := uint(attributes.cRedBits + attributes.cGreenBits + attributes.cBlueBits + attributes.cAlphaBits)
		score := EvaluateFormat(bitsPerPixel, *settings, color, uint(attributes.cDepthBits), uint(attributes.cStencilBits), settings.AntialiasingLevel)

		// Keep it if it's better than the current best
		if score < bestScore {
			bestScore = score
			bestFormat = formats[i]
		}
	}

	return bestFormat
}
Esempio n. 6
0
// For delivering programmatic events to this element.
// Returns true if the event was handled, false otherwise
func (e *Element) SendEvent(eventCode uint, source *Element, reason uint32) bool {
	var handled C.BOOL = 0
	if ret := C.HTMLayoutSendEvent(e.handle, C.UINT(eventCode), source.handle, C.UINT_PTR(reason), &handled); ret != HLDOM_OK {
		domPanic(ret, "Failed to send event")
	}
	return handled != 0
}
Esempio n. 7
0
func (e *Element) getRect(rectTypeFlags uint32) (left, top, right, bottom int) {
	r := Rect{}
	if ret := C.HTMLayoutGetElementLocation(e.handle, (C.LPRECT)(unsafe.Pointer(&r)), C.UINT(rectTypeFlags)); ret != HLDOM_OK {
		domPanic(ret, "Failed to get element rect")
	}
	return int(r.Left), int(r.Top), int(r.Right), int(r.Bottom)
}
Esempio n. 8
0
func virtualKeyCodeToSF(vkey C.WPARAM, flags C.LPARAM) Key {
	if key, ok := keyboard_vkeys_map[C.int(vkey)]; ok {
		return key
	}

	switch vkey {
	// Check the scancode to distinguish between left and right shift
	case C.VK_SHIFT:
		scancode := C.UINT((flags & (0xFF << 16)) >> 16)
		if scancode == lShift {
			return KeyLShift
		}
		return KeyRShift

	// Check the "extended" flag to distinguish between left and right alt
	case C.VK_MENU:
		if C.__HIWORD(C.DWORD(flags))&C.KF_EXTENDED != 0 {
			return KeyRAlt
		}
		return KeyLAlt

	// Check the "extended" flag to distinguish between left and right control
	case C.VK_CONTROL:
		if C.__HIWORD(C.DWORD(flags))&C.KF_EXTENDED != 0 {
			return KeyRControl
		}
		return KeyLControl

	}

	return KeyUnknown
}
Esempio n. 9
0
func (e *Element) AttrByIndex(index int) (string, string) {
	szValue := (*C.WCHAR)(nil)
	szName := (*C.CHAR)(nil)
	if ret := C.HTMLayoutGetNthAttribute(e.handle, C.UINT(index), (*C.LPCSTR)(&szName), (*C.LPCWSTR)(&szValue)); ret != HLDOM_OK {
		domPanic(ret, fmt.Sprintf("Failed to get attribute by index: %u", index))
	}
	return C.GoString((*C.char)(szName)), utf16ToString((*uint16)(szValue))
}
Esempio n. 10
0
// Load html contents into window
func LoadHtml(hwnd uint32, data []byte, baseUrl string) error {
	if len(data) > 0 {
		if ok := C.HTMLayoutLoadHtmlEx(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.BYTE)(&data[0]),
			C.UINT(len(data)), (*C.WCHAR)(stringToUtf16Ptr(baseUrl))); ok == 0 {
			return errors.New("HTMLayoutLoadHtmlEx failed")
		}
	}
	return nil
}
Esempio n. 11
0
func ProcND(hwnd win.HWND, msg uint, wParam uintptr, lParam uintptr) (ret int, handled bool) {
	var bHandled C.BOOL
	// ret = uintptr(syssciterProcND(HWND(hwnd), msg, wParam, lParam, &bHandled))
	ret = int(C.SciterProcND(C.HWINDOW(unsafe.Pointer(hwnd)), C.UINT(msg), C.WPARAM(wParam), C.LPARAM(lParam), &bHandled))
	if bHandled == 0 {
		handled = false
	} else {
		handled = true
	}
	return
}
Esempio n. 12
0
// Searches up the parent chain to find the first element that matches the given selector.
// Includes the element in the search.  Depth indicates how far the search should progress.
// Depth = 1 means only consider this element.  Depth = 0 means search all the way up to the
// root.  Any other positive value of depth limits the length of the search.
func (e *Element) SelectParentLimit(selector string, depth int) *Element {
	szSelector := C.CString(selector)
	defer C.free(unsafe.Pointer(szSelector))
	var parent C.HELEMENT
	if ret := C.HTMLayoutSelectParent(e.handle, (*C.CHAR)(szSelector), C.UINT(depth), &parent); ret != HLDOM_OK {
		domPanic(ret, "Failed to select parent dom elements, selector: '", selector, "'")
	}
	if parent != nil {
		return NewElementFromHandle(HELEMENT(parent))
	}
	return nil
}
Esempio n. 13
0
// rect is the display area
func CreateWindow(createFlags WindowCreationFlag, rect *Rect, delegate uintptr, delegateParam uintptr, parent C.HWINDOW) C.HWINDOW {
	// set default size
	if rect == nil {
		rect = DefaultRect
	}
	// create window
	hwnd := C.SciterCreateWindow(
		C.UINT(createFlags),
		(*C.RECT)(unsafe.Pointer(rect)),
		nil,
		(C.LPVOID)(delegateParam),
		parent)
	// in case of NULL
	if int(uintptr(unsafe.Pointer(hwnd))) == 0 {
		return BAD_HWINDOW
	}
	return hwnd
}
Esempio n. 14
0
func (e *Element) Update(restyle, restyleDeep, remeasure, remeasureDeep, render bool) {
	var flags uint32
	if restyle {
		if restyleDeep {
			flags |= RESET_STYLE_DEEP
		} else {
			flags |= RESET_STYLE_THIS
		}
	}
	if remeasure {
		if remeasureDeep {
			flags |= MEASURE_DEEP
		} else {
			flags |= MEASURE_INPLACE
		}
	}
	if render {
		flags |= REDRAW_NOW
	}
	if ret := C.HTMLayoutUpdateElementEx(e.handle, C.UINT(flags)); ret != HLDOM_OK {
		domPanic(ret, "Failed to update element")
	}
}
Esempio n. 15
0
func (e *Element) AppendChild(child *Element) {
	count := e.ChildCount()
	if ret := C.HTMLayoutInsertElement(child.handle, e.handle, C.UINT(count)); ret != HLDOM_OK {
		domPanic(ret, "Failed to append child element")
	}
}
Esempio n. 16
0
func (e *Element) AttachHandler(handler *EventHandler) {
	attachedHandlers, hasAttachments := eventHandlers[e.handle]
	if hasAttachments {
		if _, exists := attachedHandlers[handler]; exists {
			// This exact event handler is already attached to this exact element.
			return
		}
	}

	// Don't let the caller disable ATTACH/DETACH events, otherwise we
	// won't know when to throw out our event handler object
	subscription := handler.Subscription()
	subscription &= ^uint32(DISABLE_INITIALIZATION & 0xffffffff)

	tag := uintptr(unsafe.Pointer(handler))
	if subscription == HANDLE_ALL {
		if ret := C.HTMLayoutAttachEventHandler(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
			domPanic(ret, "Failed to attach event handler to element")
		}
	} else {
		if ret := C.HTMLayoutAttachEventHandlerEx(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK {
			domPanic(ret, "Failed to attach event handler to element")
		}
	}

	if !hasAttachments {
		eventHandlers[e.handle] = make(map[*EventHandler]bool, 8)
	}
	eventHandlers[e.handle][handler] = true
}
Esempio n. 17
0
// Main htmlayout wndproc
func ProcNoDefault(hwnd, msg uint32, wparam, lparam uintptr) (uintptr, bool) {
	var handled C.BOOL = 0
	var result C.LRESULT = C.HTMLayoutProcND(C.HWND(C.HANDLE(uintptr(hwnd))), C.UINT(msg),
		C.WPARAM(wparam), C.LPARAM(lparam), &handled)
	return uintptr(result), handled != 0
}
Esempio n. 18
0
// Replaces the whole set of state flags with the specified value
func (e *Element) SetStateFlags(flags uint32) {
	shouldUpdate := C.BOOL(1)
	if ret := C.HTMLayoutSetElementState(e.handle, C.UINT(flags), C.UINT(^flags), shouldUpdate); ret != HLDOM_OK {
		domPanic(ret, "Failed to set element state flags")
	}
}
Esempio n. 19
0
func (e *Element) SetText(text string) {
	szText := C.CString(text)
	defer C.free(unsafe.Pointer(szText))
	if ret := C.HTMLayoutSetElementInnerText(e.handle, (*C.BYTE)(unsafe.Pointer(szText)), C.UINT(len(text))); ret != HLDOM_OK {
		domPanic(ret, "Failed to replace element's text")
	}
}
Esempio n. 20
0
func (e *Element) SetTimer(ms int) {
	if ret := C.HTMLayoutSetTimer(e.handle, C.UINT(ms)); ret != HLDOM_OK {
		domPanic(ret, "Failed to set timer")
	}
}
Esempio n. 21
0
// This is the same as AttachHandler, except that behaviors are singleton instances stored
// in a master map.  They may be shared among many elements since they have no state.
// The only reason we keep a separate set of the behaviors is so that the event handler
// dispatch method can tell if an event handler is a behavior or a regular handler.
func (e *Element) attachBehavior(handler *EventHandler) {
	tag := uintptr(unsafe.Pointer(handler))
	if subscription := handler.Subscription(); subscription == HANDLE_ALL {
		if ret := C.HTMLayoutAttachEventHandler(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
			domPanic(ret, "Failed to attach event handler to element")
		}
	} else {
		if ret := C.HTMLayoutAttachEventHandlerEx(e.handle, (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK {
			domPanic(ret, "Failed to attach event handler to element")
		}
	}
}
Esempio n. 22
0
func (s *ScnLoadData) SetData(data []byte) {
	s.outData = (C.LPCBYTE)(unsafe.Pointer((&data[0])))
	s.outDataSize = C.UINT(len(data))
}
Esempio n. 23
0
func AttachWindowEventHandler(hwnd uint32, handler *EventHandler) {
	key := uintptr(hwnd)
	tag := uintptr(unsafe.Pointer(handler))

	if _, exists := windowEventHandlers[hwnd]; exists {
		if ret := C.HTMLayoutWindowDetachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK {
			domPanic(ret, "Failed to detach event handler from window before adding the new one")
		}
	}

	// Overwrite if it exists
	windowEventHandlers[hwnd] = handler

	// Don't let the caller disable ATTACH/DETACH events, otherwise we
	// won't know when to throw out our event handler object
	subscription := handler.Subscription()
	subscription &= ^uint32(DISABLE_INITIALIZATION & 0xffffffff)

	if ret := C.HTMLayoutWindowAttachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK {
		domPanic(ret, "Failed to attach event handler to window")
	}
}
Esempio n. 24
0
// For asynchronously delivering programmatic events to this element.
func (e *Element) PostEvent(eventCode uint, source *Element, reason uint32) {
	if ret := C.HTMLayoutPostEvent(e.handle, C.UINT(eventCode), source.handle, C.UINT(reason)); ret != HLDOM_OK {
		domPanic(ret, "Failed to post event")
	}
}
Esempio n. 25
0
func MessageBox(text string, caption string, style int) int {
	cText := C.CString(text)
	cCaption := C.CString(caption)
	result := C.MessageBox(nil, (*C.CHAR)(unsafe.Pointer(cText)), (*C.CHAR)(unsafe.Pointer(cCaption)), C.UINT(style))
	C.free(unsafe.Pointer(cText))
	C.free(unsafe.Pointer(cCaption))
	return int(result)
}
Esempio n. 26
0
func (e *Element) InsertChild(child *Element, index uint) {
	if ret := C.HTMLayoutInsertElement(child.handle, e.handle, C.UINT(index)); ret != HLDOM_OK {
		domPanic(ret, "Failed to insert child element at index: ", index)
	}
}