Golang Object.Call方法代码示例

// TriggerBindEvent connects the giving event with the provided dom target.
func (dm *DOMRenderer) TriggerBindEvent(event *gjs.Object, root *gjs.Object, source *trees.Event) {
	target := event.Get("target")

	children := root.Call("querySelectorAll", source.Target())
	if children == nil || children == gjs.Undefined {
		return
	}

	kids := js.DOMObjectToList(children)
	var match bool

	for _, item := range kids {
		if item != target {
			continue
		}

		match = true
		break
	}

	// if we match then run the listeners registered.
	if match {
		dispatch.Dispatch(trees.EventBroadcast{
			EventID: source.EventID,
			Event:   trees.NewWrapperEvent(event),
		})
	}
}

// QuerySelectorAll returns the result of querySelectorAll on an object
func QuerySelectorAll(o *js.Object, sel string) []*js.Object {
	if sad := o.Get("querySelectorAll"); sad == nil || sad == js.Undefined {
		return nil
	}

	return DOMObjectToList(o.Call("querySelectorAll", sel))
}

// NewContext takes an HTML5 canvas object and optional context attributes.
// If an error is returned it means you won't have access to WebGL
// functionality.
func NewContext(canvas js.Object, ca *ContextAttributes) (*Context, error) {
	if js.Global.Get("WebGLRenderingContext") == js.Undefined {
		return nil, errors.New("Your browser doesn't appear to support webgl.")
	}

	if ca == nil {
		ca = DefaultAttributes()
	}

	attrs := map[string]bool{
		"alpha":                 ca.Alpha,
		"depth":                 ca.Depth,
		"stencil":               ca.Stencil,
		"antialias":             ca.Antialias,
		"premultipliedAlpha":    ca.PremultipliedAlpha,
		"preserveDrawingBuffer": ca.PreserveDrawingBuffer,
	}
	gl := canvas.Call("getContext", "webgl", attrs)
	if gl == nil {
		gl = canvas.Call("getContext", "experimental-webgl", attrs)
		if gl == nil {
			return nil, errors.New("Creating a webgl context has failed.")
		}
	}
	ctx := new(Context)
	ctx.Object = gl
	return ctx, nil
}

func MakeWorkspace(canvas *js.Object) *Workspace {
	doc := js.Global.Get("document")
	ctx := canvas.Call("getContext", "2d")
	w := &Workspace{
		doc:       doc,
		canvas:    canvas,
		ctx:       ctx,
		x:         canvas.Get("offsetLeft").Int(),
		y:         canvas.Get("offsetTop").Int(),
		dx:        canvas.Get("offsetWidth").Int(),
		dy:        canvas.Get("offsetHeight").Int(),
		images:    make(chan schema.ImageManifest),
		disks:     make(chan string),
		ingresses: make(chan int),
		draw:      make(chan struct{}),
		mouseDown: make(chan point),
		mouseMove: make(chan point),
		mouseUp:   make(chan point),
		makeItSo:  make(chan struct{}),
		cut:       make(chan struct{}),
	}
	doc.Call("addEventListener", "mousedown", js.MakeFunc(w.onMouseDown), "false")
	doc.Call("addEventListener", "mousemove", js.MakeFunc(w.onMouseMove), "false")
	doc.Call("addEventListener", "mouseup", js.MakeFunc(w.onMouseUp), "false")
	go w.run()
	return w
}

func (ws *webSocket) sendPayload(action *Action) (err error) {
	defer func() {
		err = jsError(recover())
	}()

	decodeDataURI := (action.String() == "update_user")

	for _, frame := range action.Payload {
		var data *js.Object = frame

		if decodeDataURI {
			base64 := data.Call("split", ",").Index(1)
			binaryString := js.Global.Call("atob", base64)
			length := binaryString.Length()
			data = js.Global.Get("ArrayBuffer").New(length)
			array := js.Global.Get("Uint8Array").New(data)

			for i := 0; i < length; i++ {
				array.SetIndex(i, binaryString.Call("charCodeAt", i))
			}
		}

		ws.impl.Call("send", data)
	}

	return
}

// DOMObjectToList takes a jsobjects and returns a list of internal objects by calling the item method
func DOMObjectToList(o *js.Object) []*js.Object {
	var out []*js.Object
	length := o.Get("length").Int()
	for i := 0; i < length; i++ {
		out = append(out, o.Call("item", i))
	}
	return out
}

func New(el *js.Object) *Canvas {
	return &Canvas{
		Element: el,
		ctx:     el.Call("getContext", "2d"),
		Width:   el.Get("width").Int(),
		Height:  el.Get("height").Int(),
	}
}

// CleanAllTextNode removes all texts nodes within the container root
func CleanAllTextNode(o *js.Object) {
	for _, to := range ChildNodeList(o) {
		if istx, isem := EmptyTextNode(to); istx {
			if !isem {
				o.Call("removeChild", to)
			}
		}
	}
}

// SpecialAppendChild takes a list of objects and calls appendNode on the given object, but checks if the objects contain an unknownelement with a text tag then strip the tagname and only apply its content
func SpecialAppendChild(o *js.Object, osets ...*js.Object) {
	for _, onode := range osets {
		if strings.ToLower(onode.Get("tagName").String()) == "text" {
			SpecialAppendChild(o, ChildNodeList(onode)...)
			continue
		}
		o.Call("appendChild", onode)
	}
}

func toggleDebugOverlay(e js.Object) {
	e.Call("preventDefault")
	d := js.Global.Get("document").Call("getElementById", "debug_overlay")
	if d.Get("style").Get("display").Str() == "block" {
		d.Get("style").Set("display", "none")
		return
	}
	d.Get("style").Set("display", "block")
}

// BindEvent connects the event with the provided event object and root.
func (dm *DOMRenderer) BindEvent(source *trees.Event, root *gjs.Object) {
	source.Link = func(ev *gjs.Object) { dm.TriggerBindEvent(ev, root, source) }

	root.Call("addEventListener", source.Type, source.Link, true)

	source.Handle.AddEnd(func() {
		root.Call("removeEventListener", source.Type, source.Link, true)
	})
}

// New returns a new Canvas that wraps the <canvas> elem. This will
// most likely be retrieved using
//
//     js.Global.Get("document").Call("getElementById", id)
//
// If the browser doesn't support CanvasRenderingContext2D, an error
// is returned.
func New(elem *js.Object) (*Canvas, error) {
	if js.Global.Get("CanvasRenderingContext2D") == nil {
		return nil, errors.New("Browser doesn't support canvas 2D")
	}

	return &Canvas{
		elem: elem,
		ctx:  elem.Call("getContext", "2d"),
	}, nil
}

func NewCanvas(parent *js.Object, width, height int) *Canvas {
	document := js.Global.Get("document")
	canvas := document.Call("createElement", "canvas")
	parent.Call("appendChild", canvas)

	canvas.Set("width", width)
	canvas.Set("height", height)

	context := canvas.Call("getContext", "2d")

	return &Canvas{canvas, context, image.Rect(0, 0, width, height)}
}

// ContextAppendChild takes a list of objects and calls appendNode on the given object
func ContextAppendChild(o *js.Object, osets ...*js.Object) {
	for _, onode := range osets {

		if doHeadAppend(onode) {
			continue
		}

		if scripts := QuerySelectorAll(onode, "scripts"); len(scripts) != 0 {
			for _, script := range scripts {
				doHeadAppend(script)
			}
		}

		o.Call("appendChild", onode)
	}
}

func createJsWebsocket(scope *js.Object) *Websocket {
	websocketUrl := fmt.Sprintf("ws://%s/chat", GetWindowHost())
	websocket := NewWebsocket(websocketUrl, func(event *js.Object) {
		stringData := event.Get("data").String()

		message := chat.MessageData{}
		json.Unmarshal([]byte(stringData), &message)

		scope.Call("showMessage", message)
		// force refresh scope data for async data binding
		scope.Call("$apply")
		ScrollToChatBottom()
	})

	return websocket
}