Scala Event类代码示例

//设置package包名称以及导入依赖的类
package org.danielnixon.progressive.services

import org.danielnixon.progressive.extensions.dom.{ EventTargetWrapper, NodeListSeq }
import org.danielnixon.progressive.shared.Wart
import org.danielnixon.progressive.shared.api.DataAttributes
import org.scalajs.dom.{ Element, Event, MouseEvent, html }

class EventHandlerSetupService(
    refreshService: => RefreshService,
    hijaxService: => HijaxService,
    additionalSetupInitial: html.Body => Unit,
    additionalSetup: Element => Unit
) {

  def setup(element: Element): Unit = {
    additionalSetup(element)

    element.querySelectorAll(s"[${DataAttributes.refresh}]").collect({ case e: Element => e }) foreach { node =>
      refreshService.setupRefresh(node)
    }
  }

  @SuppressWarnings(Array(Wart.AsInstanceOf, Wart.Nothing))
  def setupInitial(body: html.Body): Unit = {

    additionalSetupInitial(body)

    body.on("click", s"a[${DataAttributes.progressive}]") { (e: MouseEvent, element: Element) =>
      hijaxService.ajaxLinkClick(e, element.asInstanceOf[html.Anchor])
    }

    body.on("click", s"form[${DataAttributes.progressive}] button[${DataAttributes.progressive}]") { (e: Event, element: Element) =>
      hijaxService.ajaxSubmitButtonClick(element.asInstanceOf[html.Button])
    }

    body.on("submit", s"form[${DataAttributes.progressive}]") { (e: Event, element: Element) =>
      hijaxService.ajaxFormSubmit(e, element.asInstanceOf[html.Form])
    }

    setup(body)
  }
} 

//设置package包名称以及导入依赖的类
package com.outr.nextui.examples.browser

import com.outr.nextui.browser.ScalaJS
import com.outr.nextui.examples.Examples
import org.scalajs.dom.{Event, document, html}

import scala.scalajs.js.JSApp

object ScalaJSExamples extends JSApp {
  override def main(): Unit = {
    val div = document.createElement("div").asInstanceOf[html.Div]
    Examples().foreach { ui =>
      val a = document.createElement("a").asInstanceOf[html.Anchor]
      a.href = "#"
      a.addEventListener("click", {(evt: Event) =>
        document.body.removeChild(div)
        ScalaJS(ui)
      }, true)
      a.textContent = ui.name
      val p = document.createElement("p").asInstanceOf[html.Paragraph]
      p.appendChild(a)
      div.appendChild(p)
    }
    document.body.appendChild(div)
  }
} 

//设置package包名称以及导入依赖的类
package com.outr.nextui.browser

import com.outr.nextui.ImageView
import com.outr.nextui.model.Image
import org.scalajs.dom.Event
import org.scalajs.dom.raw.HTMLImageElement

class ScalaJSImageView(val component: ImageView) extends ScalaJSComponent {
  override val impl: HTMLImageElement = create[HTMLImageElement]("img")

  override def initialize(): Unit = {
    super.initialize()

    component.image.attach {
      case img if img != Image.Empty => impl.src = img.resource.url.toString
      case _ => impl.src = ""
    }

    impl.addEventListener("load", {(evt: Event) =>
      updateSize(delayed = false)
    }, true)
  }
} 

//设置package包名称以及导入依赖的类
package io.udash.demos.jquery.views

import io.udash._
import org.scalajs.dom.{Element, Event}

abstract class FunctionView extends FinalView {
  import scalatags.JsDom.all._

  protected val content: Element
  protected val script: () => Any

  override def getTemplate: Modifier =
    div(
      content,
      button(
        onclick :+= ((_: Event) => {
          script()
          false
        })
      )("Run script")
    )
} 

//设置package包名称以及导入依赖的类
package io.udash.demos.jquery.views.functions

import io.udash._
import io.udash.demos.jquery.IndexState
import io.udash.demos.jquery.views.FunctionView
import io.udash.wrappers.jquery._
import org.scalajs.dom.{Element, Event}

object OnOneOffViewPresenter extends DefaultViewPresenterFactory[IndexState.type](() => new OnOneOffView)


class OnOneOffView extends FunctionView {
  import scalatags.JsDom.all._

  val onCallback = (_: Element, _: JQueryEvent) =>
    jQ(".demo ul").append(li("This will be added on every click").render)
  val oneCallback = (_: Element, _: JQueryEvent) =>
    jQ(".demo ul").append(li("This will be added only once").render)

  override protected val content = div(cls := "demo")(
    h3(".on() & .one() & .off()"),
    button(id := "click", disabled := "disabled")("Click me"),
    ul(),
    button(
      id := "off",
      disabled := "disabled",
      onclick :+= ((_: Event) => {
        jQ(".demo #click")
          .off("click", onCallback)
          .off("click", oneCallback)
        false
      })
    )("Off")
  ).render

  override protected val script = () => {
    jQ(".demo #click")
      .on("click", onCallback)
      .one("click", oneCallback)

    jQ(".demo button")
      .prop("disabled", "")
  }
} 

//设置package包名称以及导入依赖的类
package io.udash.demos.jquery.views.functions

import io.udash._
import io.udash.demos.jquery.IndexState
import io.udash.demos.jquery.views.FunctionView
import io.udash.wrappers.jquery._
import org.scalajs.dom.{Element, Event}

object AttrViewPresenter extends DefaultViewPresenterFactory[IndexState.type](() => new AttrView)


class AttrView extends FunctionView {
  import scalatags.JsDom.all._

  override protected val content = div(cls := "demo")(
    h3(".attr() & .prop()"),
    input(id := "check1", tpe := "checkbox", checked := "checked"),
    label(`for` := "check1")("Check me"),
    p(),
    button(onclick :+= ((_: Event) => {
      jQ(".demo input").attr("data-checked", "checked").change()
      false
    }))(".attr(\"data-checked\", \"checked\")"),
    button(onclick :+= ((_: Event) => {
      jQ(".demo input").attr("data-checked", "").change()
      false
    }))(".attr(\"data-checked\", \"\")"),
    button(onclick :+= ((_: Event) => {
      jQ(".demo input").attr("data-checked", null).change()
      false
    }))(".attr(\"data-checked\", null)"), br(),
    button(onclick :+= ((_: Event) => {
      jQ(".demo input").prop("checked", true).change()
      false
    }))(".prop(\"checked\", true)"),
    button(onclick :+= ((_: Event) => {
      jQ(".demo input").prop("checked", false).change()
      false
    }))(".prop(\"checked\", false)")
  ).render

  override protected val script = () => {
    jQ(".demo input").change((input: Element, _: JQueryEvent) => {
      jQ(".demo p").html(
        s""".attr('data-checked'): ${jQ(input).attr("data-checked")}<br/>
           |.prop('checked'): ${jQ(input).prop("checked")}<br/>
           |.is(':checked'): ${jQ(input).is(":checked")}""".stripMargin
      )
    }).change()
  }
} 

//设置package包名称以及导入依赖的类
package io.udash.demos.jquery.views.functions

import io.udash._
import io.udash.demos.jquery.IndexState
import io.udash.demos.jquery.views.FunctionView
import io.udash.wrappers.jquery._
import org.scalajs.dom.Event

import scala.scalajs.js

object DeferredViewPresenter extends DefaultViewPresenterFactory[IndexState.type](() => new DeferredView)


class DeferredView extends FunctionView {
  import scalatags.JsDom.all._

  var deferred: JQueryDeferred[js.Function1[Int, js.Any], Int] = null

  override protected val content = div(cls := "demo")(
    h3("Deferred"),
    div(
      div(id := "deferred")("???"),
      button(
        id := "resolve",
        disabled := "disabled",
        onclick := ((ev: Event) => {
          deferred.resolve(5)
        })
      )("Resolve(5)"),
      button(
        id := "reject",
        disabled := "disabled",
        onclick := ((ev: Event) => {
          deferred.reject(-5)
        })
      )("Reject(-5)"),
      button(
        id := "notify",
        disabled := "disabled",
        onclick := ((ev: Event) => {
          deferred.notify(1)
        })
      )("Notify(1)")
    )
  ).render

  override protected val script = () => {
    jQ(".demo button").prop("disabled", "")
    deferred = jQ.deferred[js.Function1[Int, js.Any], Int]()
    jQ("#deferred").text(s"Waiting...")
    deferred.done((i: Int) => jQ("#deferred").text(s"Done: $i"))
    deferred.fail((i: Int) => jQ("#deferred").text(s"Fail: $i"))
    deferred.progress((i: Int) => jQ("#deferred").text(s"Progress: $i"))
  }
} 

//设置package包名称以及导入依赖的类
package scalajs.antdesign

import japgolly.scalajs.react.{CallbackTo, React, ReactComponentU_, ReactNode}
import org.scalajs.dom.Event

import scala.scalajs.js
import scala.scalajs.js.{Dynamic, Object}


  case class Group(onChange: js.UndefOr[Event => CallbackTo[Unit]] = js.undefined,
                   value: js.UndefOr[String] = js.undefined,
                   defaultValue: js.UndefOr[String] = js.undefined,
                   size: js.UndefOr[Size] = js.undefined) {
    def toJS: Object with Dynamic = {
      val p = js.Dynamic.literal()
      onChange.foreach { x =>
        p.updateDynamic("onChange")(
          (v1: Event) => x(v1).runNow()
        )
      }
      value.foreach { x =>
        p.updateDynamic("value")(x)
      }
      defaultValue.foreach { x =>
        p.updateDynamic("defaultValue")(x)
      }
      size.foreach { x =>
        p.updateDynamic("size")(x.id)
      }
      p
    }

    def apply(children: ReactNode*): ReactComponentU_ = {
      val f =
        React.asInstanceOf[js.Dynamic].createFactory(js.Dynamic.global.antd.Radio.Group)
      f(toJS, children.toJsArray).asInstanceOf[ReactComponentU_]
    }
  }
} 

//设置package包名称以及导入依赖的类
package scalajs.antdesign

import japgolly.scalajs.react.{CallbackTo, React, ReactComponentU_, ReactNode}
import org.scalajs.dom.Event

import scala.scalajs.js
import scala.scalajs.js.{Dynamic, Object}


case class Checkbox(checked: js.UndefOr[Boolean] = js.undefined,
                    defaultChecked: js.UndefOr[Boolean] = js.undefined,
                    onChange: js.UndefOr[(Event) => CallbackTo[Unit]] = js.undefined) {
  def toJS: Object with Dynamic = {
    val p = js.Dynamic.literal()
    checked.foreach { x =>
      p.updateDynamic("checked")(x)
    }
    defaultChecked.foreach { x =>
      p.updateDynamic("defaultChecked")(x)
    }
    onChange.foreach { x =>
      p.updateDynamic("onChange")(x)
    }
    p
  }

  def apply(children: ReactNode*): ReactComponentU_ = {
    val f =
      React.asInstanceOf[js.Dynamic].createFactory(js.Dynamic.global.antd.Checkbox)
    f(toJS, children.toJsArray).asInstanceOf[ReactComponentU_]
  }
} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui.views

import scalatags.JsDom.all._
import se.lu.nateko.cp.doi.Doi
import se.lu.nateko.cp.doi.gui.DoiInfo
import se.lu.nateko.cp.doi.gui.DoiAction
import org.scalajs.dom.Event
import org.scalajs.dom.console
import se.lu.nateko.cp.doi.gui.SelectDoi
import se.lu.nateko.cp.doi.gui.DoiRedux
import se.lu.nateko.cp.doi.gui.ThunkActions

class DoiView(doi: Doi, d: DoiRedux.Dispatcher) {

	private[this] var info: Option[DoiInfo] = None
	private[this] var isSelected = false

	private val doiListIcon = span(cls := doiListIconClass).render

	private def doiListIconClass = "glyphicon glyphicon-triangle-" +
		(if(isSelected) "bottom" else "right")

	private val selectDoi: Event => Unit = e => d.dispatch(ThunkActions.selectDoiFetchInfo(doi))

	private val panelBody = div(cls := "panel-body").render

	val element = div(cls := "panel panel-default")(
		div(cls := "panel-heading", onclick := selectDoi, cursor := "pointer")(
			doiListIcon,
			span(cls := "panel-title")(" " + doi.toString)
		),
		panelBody
	).render

	private def updateContentVisibility(): Unit = {
		val display = if(isSelected && info.isDefined) "block" else "none"
		panelBody.style.display = display
	}

	def setSelected(is: Boolean): Unit = {
		isSelected = is
		doiListIcon.className = doiListIconClass
		updateContentVisibility()
	}

	def supplyInfo(doiInfo: DoiInfo): Unit = if(!info.contains(doiInfo)){
		info = Some(doiInfo)
		updateContentVisibility()
		panelBody.innerHTML = ""
		val infoView = new DoiInfoView(doiInfo, d)
		panelBody.appendChild(infoView.element)
	}
	updateContentVisibility()
} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui.widgets

import se.lu.nateko.cp.doi.meta.Name
import scalatags.JsDom.all._
import se.lu.nateko.cp.doi.meta.PersonalName
import se.lu.nateko.cp.doi.meta.GenericName
import org.scalajs.dom.Event
import org.scalajs.dom.Element
import se.lu.nateko.cp.doi.gui.widgets.generic.EntityWidget
import se.lu.nateko.cp.doi.gui.widgets.generic.TextInputWidget
import se.lu.nateko.cp.doi.gui.views.Bootstrap

class NameWidget(init: Name, protected val updateCb: Name => Unit) extends EntityWidget[Name]{

	private[this] var _name = init

	private def isPersonal: Boolean = _name match{
		case _: PersonalName => true
		case _: GenericName => false
	}

	private def getNameElem: Element = _name match{
		case pn: PersonalName => new PersonalNameWidget(pn, newPn => {
				_name = newPn
				updateCb(_name)
			}).element
		case gn: GenericName => new TextInputWidget(gn.name, newGn => {
				_name = GenericName(newGn)
				updateCb(_name)
			}).element
	}

	private var nameElem = getNameElem

	private def checkedModifier(personal: Boolean) = if(personal == isPersonal) Seq(checked := true) else Nil

	private def changeNameType(personal: Boolean): Event => Unit = e => if(isPersonal != personal){
		_name = if(personal) PersonalName("", "") else GenericName("")
		val newNameElem = getNameElem
		nameElem.parentNode.replaceChild(newNameElem, nameElem)
		nameElem = newNameElem
		updateCb(_name)
	}

	private def nameTypeOption(personal: Boolean) =
		input(tpe := "radio", name := "nameType", onchange := changeNameType(personal))(checkedModifier(personal))

	val element = Bootstrap.basicPanel(
		Bootstrap.propValueRow(strong("Name type"))(
			form(nameTypeOption(true), " Personal name", br, nameTypeOption(false), " Organizational name")
		)(paddingBottom := 15),
		Bootstrap.propValueRow(strong("Name"))(nameElem)
	).render
} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui.widgets.generic

import org.scalajs.dom.Event
import scalatags.JsDom.all._


class IntInputWidget(init: Int, protected val updateCb: Int => Unit) extends EntityWidget[Int] {

	val element = input(tpe := "text", cls := "form-control", value := init.toString).render

	element.onkeyup = (_: Event) => {
		try{
			val newVal = element.value.toInt
			highlightError(element, None)
			updateCb(newVal)
		}catch{
			case _: Throwable =>
				highlightError(element, Some("Not a valid integer"))
				updateCb(init)
		}
	}

} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui.widgets.generic

import scalatags.JsDom.all._
import scala.collection.mutable.Buffer
import org.scalajs.dom.Event
import se.lu.nateko.cp.doi.gui.views.Bootstrap

abstract class MultiEntitiesEditWidget[E, W <: EntityWidget[E]](initValues: Seq[E], cb: Seq[E] => Unit){

	protected val title: String
	protected def makeWidget(value: E, updateCb: E => Unit): W
	protected def defaultValue: E
	protected val minAmount: Int

	private val widgets = Buffer.empty[RemovableEntityWidget[E]]

	private def setRemovability(): Unit = if(minAmount > 0) {
		widgets.foreach(_.setRemovability(widgets.length > minAmount))
	}

	private def notifyUpstream(): Unit = cb(widgets.map(_.entityValue))

	private val widgetsParent = div(cls := "col-md-11").render

	private def produceWidget(value: E): Unit = {
		val widgetFactory: (E => Unit) => W = makeWidget(value, _)

		val newWidget = new RemovableEntityWidget[E](widgetFactory, value, _ => notifyUpstream(), widget => {
			widgets -= widget
			widgetsParent.removeChild(widget.element)
			setRemovability()
			notifyUpstream()
		})
		widgetsParent.appendChild(newWidget.element)
		widgets += newWidget
	}
	initValues.foreach(produceWidget)
	setRemovability()

	private val addWidget: Event => Unit = (_: Event) => {
		produceWidget(defaultValue)
		setRemovability()
		notifyUpstream()
	}

	val element = Bootstrap.basicPanel(
		div(cls := "row")(
			div(cls := "col-md-1")(
				span(strong(title)),
				raw("&nbsp;"),
				button(tpe := "button", cls := "btn btn-success", onclick := addWidget, marginBottom := 5)(
					span(cls := "glyphicon glyphicon-plus")
				)
			),
			widgetsParent
		)
	)

} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui.widgets.generic

import org.scalajs.dom.Event
import scalatags.JsDom.all._
import se.lu.nateko.cp.doi.gui.views.Bootstrap

class RemovableEntityWidget[E](
	widgetFactory: (E => Unit) => EntityWidget[E],
	init: E,
	updateCb: E => Unit,
	removeCb: RemovableEntityWidget[E] => Unit
){
	private[this] var _entityValue: E = init
	def entityValue = _entityValue

	private[this] val widget = widgetFactory((e: E) => {
		_entityValue = e
		updateCb(e)
	})

	private[this] val removeButton =
		button(tpe := "button", cls := "btn btn-warning")(
			span(cls := "glyphicon glyphicon-remove")
		).render

	removeButton.onclick = (_: Event) => removeCb(this)

	def setRemovability(removable: Boolean): Unit = {
		removeButton.disabled = !removable
	}

	val element = Bootstrap.basicPanel(
		div(cls := "row")(
			div(cls := "col-md-11")(widget.element),
			div(cls := "col-md-1 spacyrow")(removeButton)
		)
	).render
} 

//设置package包名称以及导入依赖的类
package se.lu.nateko.cp.doi.gui.widgets.generic

import org.scalajs.dom.Event
import scalatags.JsDom.all._
import SelectWidget._

case class SelectOption[T](value: Option[T], id: String, label: String)

class SelectWidget[T](
	options: IndexedSeq[SelectOption[T]],
	init: Option[T],
	protected val updateCb: Option[T] => Unit
) extends EntityWidget[Option[T]] {

	val element = select(cls := "form-control")(options.map(optionElem)).render

	element.onchange = (_: Event) => updateCb(options(element.selectedIndex).value)

	element.selectedIndex = options.indexWhere(_.value == init)
}

object SelectWidget{

	def optionElem[T](optInfo: SelectOption[T]) = {
		option(value := optInfo.id)(optInfo.label)
	}

	def selectOptions(enum: Enumeration, noValueLabelOpt: Option[String]): IndexedSeq[SelectOption[enum.Value]] = {
		noValueLabelOpt.map(SelectOption[enum.Value](None, "", _)).toIndexedSeq ++
		enum.values.toIndexedSeq.map(v =>
			SelectOption(Some(v), v.toString, v.toString)
		)
	}

	def selectOptions[T](noValueLabelOpt: Option[String])(selectVals: T*): IndexedSeq[SelectOption[T]] = {
		noValueLabelOpt.map(SelectOption[T](None, "", _)).toIndexedSeq ++
		selectVals.map(v =>
			SelectOption(Some(v), v.toString, v.toString)
		)
	}

}