// Change the arrows direction and shadow.
343777
func (a *Arrow) Set(at ArrowType, st ShadowType) {
	C.gtk_arrow_set(ARROW(a), C.GtkArrowType(at), C.GtkShadowType(st))
}
551607
func (gdw *NaiveDiffDriver) Changes(id string, idMappings *idtools.IDMappings, parent string, parentMappings *idtools.IDMappings, mountLabel string) ([]archive.Change, error) {
	driver := gdw.ProtoDriver

	if idMappings == nil {
		idMappings = &idtools.IDMappings{}
	}
	if parentMappings == nil {
		parentMappings = &idtools.IDMappings{}
	}

	options := MountOpts{
		MountLabel: mountLabel,
	}
	layerFs, err := driver.Get(id, options)
	if err != nil {
		return nil, err
	}
	defer driver.Put(id)

	parentFs := ""

	if parent != "" {
		options := MountOpts{
			MountLabel: mountLabel,
		}
		parentFs, err = driver.Get(parent, options)
		if err != nil {
			return nil, err
		}
		defer driver.Put(parent)
	}

	return archive.ChangesDirs(layerFs, idMappings, parentFs, parentMappings)
}
271454
func (s *BurnInDestinationSettings) SetShadowYOffset(v int64) *BurnInDestinationSettings {
	s.ShadowYOffset = &v
	return s
}
148621
func (*DefaultScene) Setup(u engo.Updater) {
	w, _ := u.(*ecs.World)

	common.SetBackground(color.White)
	w.AddSystem(&common.RenderSystem{})
	w.AddSystem(&common.MouseRotator{RotationSpeed: rotationSpeed})

	// Create a background; this way we'll see when we actually rotate
	demoutils.NewBackground(w, 300, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})

	// Create a background; this way we'll see when we actually rotate
	bg2 := demoutils.NewBackground(w, 300, worldHeight, color.RGBA{102, 153, 0, 255}, color.RGBA{102, 173, 0, 255})
	bg2.SpaceComponent.Position.X = 500
}
1040703
func (s *BurninDestinationSettings) SetShadowYOffset(v int64) *BurninDestinationSettings {
	s.ShadowYOffset = &v
	return s
}
689437
func (all *assetLruList) MoveToFront(alle *assetLruListElement) {
	if alle.list != all || all.root.next == alle {
		return
	}
	// see comment in assetLruList.Remove about initialization of l
	all.insert(all.remove(alle), &all.root)
}
232663
func (sra ShardReferenceArray) Swap(i, j int) {
	sra[i], sra[j] = sra[j], sra[i]
}
82174
func (s *SetUICustomizationInput) SetCSS(v string) *SetUICustomizationInput {
	s.CSS = &v
	return s
}
874696
func (imd *IMDraw) Push(pts ...pixel.Vec) {
	if _, ok := imd.Color.(pixel.RGBA); !ok {
		imd.Color = pixel.ToRGBA(imd.Color)
	}
	opts := point{
		col:       imd.Color.(pixel.RGBA),
		pic:       imd.Picture,
		in:        imd.Intensity,
		precision: imd.Precision,
		endshape:  imd.EndShape,
	}
	for _, pt := range pts {
		imd.pushPt(pt, opts)
	}
}
491961
func Arrow(w http.ResponseWriter, req *http.Request) {
	arg := func(s string) int { x, _ := strconv.Atoi(req.FormValue(s)); return x }
	dir := arg("dir")
	size := arg("size")
	if size == 0 {
		size = 50
	}
	del := size / 10

	m := image.NewRGBA(image.Rect(0, 0, size, size))

	if dir == 4 {
		draw.Draw(m, m.Bounds(), image.Black, image.ZP, draw.Src)
		draw.Draw(m, image.Rect(5, 5, size-5, size-5), image.White, image.ZP, draw.Src)
	}

	pt := func(x, y int, c color.RGBA) {
		switch dir {
		case 0:
			m.SetRGBA(x, y, c)
		case 1:
			m.SetRGBA(y, size-1-x, c)
		case 2:
			m.SetRGBA(size-1-x, size-1-y, c)
		case 3:
			m.SetRGBA(size-1-y, x, c)
		}
	}

	for y := 0; y < size/2; y++ {
		for x := 0; x < del && x < y; x++ {
			pt(x, y, color.RGBA{0, 0, 0, 255})
		}
		for x := del; x < y-del; x++ {
			pt(x, y, color.RGBA{128, 128, 255, 255})
		}
		for x := max(y-del, 0); x <= y; x++ {
			pt(x, y, color.RGBA{0, 0, 0, 255})
		}
	}
	for y := size / 2; y < size; y++ {
		for x := 0; x < del && x < size-1-y; x++ {
			pt(x, y, color.RGBA{0, 0, 0, 255})
		}
		for x := del; x < size-1-y-del; x++ {
			pt(x, y, color.RGBA{128, 128, 192, 255})
		}
		for x := max(size-1-y-del, 0); x <= size-1-y; x++ {
			pt(x, y, color.RGBA{0, 0, 0, 255})
		}
	}

	w.Header().Set("Cache-Control", "public, max-age=3600")
	w.Write(pngEncode(m))
}
725123
func (s *BurninDestinationSettings) SetShadowXOffset(v int64) *BurninDestinationSettings {
	s.ShadowXOffset = &v
	return s
}
13382
func (prc *RotateProcessor) Change(params imageserver.Params) bool {
	if !params.Has(rotateParam) {
		return false
	}
	params, err := params.GetParams(rotateParam)
	if err != nil {
		return true
	}
	if params.Empty() {
		return false
	}
	if params.Has("rotation") {
		return true
	}
	return false
}
236547
func (h *Hub) SendDraw(options interface{}) {
	pdebug.Printf("START Hub.SendDraw %v", options)
	defer pdebug.Printf("END Hub.SendDraw %v", options)
	send(h.DrawCh(), NewPayload(options), h.isSync)
}
75082
func (v *View) Transform(viewport text.Region) render.Recipe {
	pe := util.Prof.Enter("view.Transform")
	defer pe.Exit()
	v.lock.Lock()
	defer v.lock.Unlock()
	if v.syntax == nil {
		return nil
	}
	cs := v.Settings().String("color_scheme", "")
	scheme := ed.GetColorScheme(cs)
	rr := make(render.ViewRegionMap)
	for k, v := range v.regions {
		rr[k] = *v.Clone()
	}
	rs := render.ViewRegions{Flags: render.SELECTION}
	rs.Regions.AddAll(v.selection.Regions())
	rr["lime.selection"] = rs
	return render.Transform(scheme, rr, viewport)
}
725959
func (gp *GoPdf) Rotate(angle, x, y float64) {
	gp.UnitsToPointsVar(&x, &y)
	gp.getContent().appendRotate(angle, x, y)
}
560439
func (gs *glShader) update() {
	gs.uf = nil
	for _, u := range gs.uniforms {
		gs.uf = append(gs.uf, glhf.Attr{
			Name: u.Name,
			Type: u.Type,
		})
	}
	var shader *glhf.Shader
	mainthread.Call(func() {
		var err error
		shader, err = glhf.NewShader(
			gs.vf,
			gs.uf,
			gs.vs,
			gs.fs,
		)
		if err != nil {
			panic(errors.Wrap(err, "failed to create Canvas, there's a bug in the shader"))
		}
	})

	gs.s = shader
}
279174
func (base *Base) SetStyle(key string, value string) {
	if base.Style == nil {
		base.Style = make(map[string]string)
	}
	base.Style[key] = value
}