Ejemplo n.º 1
0
func (B *Imp) Edit(s *string, l, c uint) {
	//
	if l >= scr.NLines() {
		return
	}
	if c >= scr.NColumns() {
		return
	}
	n, b := uint(len(*s)), B.width
	if c+b > scr.NColumns() {
		B.width = scr.NColumns() - c
	}
	if B.width == 0 {
		B.width = n
	}
	//  if B.width > n { B.width = n }
	if B.width < n {
		Norm(s, B.width)
	}
	B.graphical = false
	if B.numerical || B.TRnumerical {
		B.editNumber(false, s, scr.NX1()*c, scr.NY1()*l)
	} else {
		B.editText(false, s, scr.NX1()*c, scr.NY1()*l)
	}
	B.width = b
}
Ejemplo n.º 2
0
func (f *Imp) editText() {
	//
	if f.sort != Text {
		return
	}
	scr.MouseCursor(false)
	bx.Wd(lenText)
	bx.ColourF(f.colour)
	x1 := f.x[0] + int(lenText*scr.NX1()) - 1
	if x1 >= xx {
		x1 = xx - 1
	}
	y1 := f.y[0] + int(scr.NY1()) - 1
	if y1 >= yy {
		y1 = yy - 1
	}
	scr.SaveGr(uint(f.x[0]), uint(f.y[0]), uint(x1), uint(y1))
	bx.SetTransparent(false)
	f.tx = str.Clr(lenText) // wörkeraunt
	bx.EditGr(&f.tx, uint(f.x[0]), uint(f.y[0]))
	bx.SetTransparent(true)
	scr.RestoreGr(uint(f.x[0]), uint(f.y[0]), uint(x1), uint(y1))
	var T uint
	if kbd.LastCommand(&T) == kbd.Enter {
		bx.SetTransparent(true)
		//    scr.RestoreGr (f.x[0], f.y[0], x1, y1)
		bx.WriteGr(f.tx, f.x[0], f.y[0])
		k := str.ProperLen(f.tx)
		x0 := make([]int, 2)
		x0[0] = f.x[0]
		f.x = x0
		y0 := make([]int, 2)
		y0[0] = f.y[0]
		f.y = y0
		f.x[1] = f.x[0] + int(scr.NX1()*k) - 1
		f.y[1] = f.y[0] + int(scr.NY1()) - 1
		scr.WarpMouseGr(f.x[0], f.y[1])
	} else {
		//    f.tx = str.Clr (lenText)
		//    bx.WriteGr (f.tx, f.x[0], f.y[0])
		//    f.tx = ""
		//    f.x, f.y = nil, nil
	}
	scr.MouseCursor(true)
}
Ejemplo n.º 3
0
func (B *Imp) Clr(L, C uint) {
	//
	if B.width == 0 {
		return
	}
	scr.Lock()
	scr.Colours(col.ScreenF, col.ScreenB)
	scr.WriteGr(Clr(B.width), int(scr.NX1()*C), int(scr.NY1()*L))
	scr.Unlock()
}
Ejemplo n.º 4
0
func (x *Imp) write() {
	//
	r := x.Radius()
	/*
	   if r <= R0 {
	     scr.CircleFull (int(x.x), int(x.y), R0)
	   } else {
	     for n:= uint(0); n <= 1; n++ {
	       scr.Circle (int(x.x), int(x.y), r + n)
	     }
	   }
	*/
	if x.length > 0 {
		n := str.ProperLen(x.name)
		xx := x.x - (n*scr.NX1())/2 + 1
		yy := x.y - scr.NY1()/2 + 1
		switch x.lab {
		case zentral:

		case rechts:
			xx = x.x + scr.NX1() + 1
		case oben:
			yy -= 5 * scr.NY1() / 6
		case links:
			xx = x.x - n*scr.NX1() - scr.NX1() + 1
		case unten:
			yy += 5 * scr.NY1() / 6
		}
		bx.SetTransparent(transparent)
		bx.Wd(x.length)
		bx.WriteGr(x.name, int(xx), int(yy))
	}
	if r <= R0 {
		scr.CircleFull(int(x.x), int(x.y), R0)
	} else {
		for n := uint(0); n <= 1; n++ {
			scr.Circle(int(x.x), int(x.y), r+n)
		}
	}
}
Ejemplo n.º 5
0
func (x *Imp) Edit() {
	//
	if x.length > 0 {
		B := (x.length * scr.NX1()) / 2
		H := scr.NY1() / 2
		bx.Wd(x.length)
		bx.ColourF(Farbe[0])
		bx.EditGr(&x.name, x.x-B+1, x.y-H+1)
		N := str.Clr(x.length)
		bx.WriteGr(N, int(x.x-B+1), int(x.y-H+1))
	}
	x.write()
}
Ejemplo n.º 6
0
func (x *Imp) pos(n, n1 *node.Imp, d bool) (uint, uint, uint, uint, bool) {
	//
	x.x, x.y = n.Pos()
	x.x1, x.y1 = n1.Pos()
	if x.x == x.x1 && x.y == x.y1 {
		return 0, 0, 0, 0, false
	}
	dx := math.Abs(float64(x.x) - float64(x.x1))
	dy := math.Abs(float64(x.y) - float64(x.y1))
	if dx*dx+dy*dy < 0.001 {
		return 0, 0, 0, 0, false
	}
	d0 := 1.0 / math.Sqrt(dx*dx+dy*dy)
	dx, dy = d0*dx, d0*dy
	r := n.Radius()
	h := uint(dx*float64(r+r0+1)+0.5) + 1
	if x.x < x.x1 {
		x.x += h
		x.x1 -= h
	} else {
		x.x -= h
		x.x1 += h
	}
	h = uint(dy*float64(r+r0+1)+0.5) + 1
	if x.y < x.y1 {
		x.y += h
		x.y1 -= h
	} else {
		x.y -= h
		x.y1 += h
	}
	x0 := (x.x+x.x1)/2 - (zk*scr.NX1())/2 + 1
	y0 := (x.y+x.y1)/2 - scr.NY1()/2 + 1
	var x1, y1 uint
	//  x1, y1 = (x.x + 7 * x.x1) / 8, (x.y + 7 * x.y1) / 8
	if d {
		x1, y1 = x.x1, x.y1
	} else {
		x1, y1 = x.x, x.y
	}
	return x0, y0, x1, y1, true
}
Ejemplo n.º 7
0
func New(h bool) *Imp {
	//
	B := new(Imp)
	l := scr.NLines()
	c := scr.NX()
	B.max = 100
	B.horizontal = h
	B.value = 0
	if h {
		B.width = c
		B.height = scr.NY1()
		B.Locate(0, (l-1)*B.height, B.width, B.height)
	} else {
		B.width = scr.NX1()
		B.height = scr.NY()
		B.Locate(c-B.width, 0, B.width, B.height)
	}
	B.cF, B.cB = col.HintF, col.HintB
	B.Locate(B.x0, B.y0, B.width, B.height)
	return B
}
Ejemplo n.º 8
0
func init() {
	//
	scr.Switch(scr.TXT)
	cF, cB = col.LightMagenta, col.Black
	// scr.Colours (cF, cB)
	lengthF, timeF = col.Red, col.LightBlue
	trackTimeF, ctrlF = col.Colour3(191, 191, 255), col.Colour3(63, 111, 255)
	for c := cdker.Controller(0); c < cdker.NCtrl; c++ {
		ctrlText[c] = cdker.Ctrltext[c]
		str.Center(&ctrlText[c], wr)
		lv[c] = l0 + 3*uint(c)
	}
	timeText = [2]string{"tracktime", "total time"}
	str.Center(&timeText[0], wr)
	str.Center(&timeText[1], wr)
	lt = [2]uint{l1 + 2, l1 + 2 + 3}
	bx = box.New()
	bx.Wd(wr)
	bx.Colours(col.HintF, col.HintB)
	bx.Colours(trackTimeF, cB)
	bx.Write(" track", l1, cr+wr-6-2)
	cw, lh := scr.NX1(), scr.NY1()
	bx.Colours(cF, cB)
	bx.Wd(wr)
	for c := cdker.Controller(0); c < cdker.NCtrl; c++ {
		ctrlBar[c] = pbar.New(true)
		ctrlBar[c].Def(cdker.MaxVol)
		ctrlBar[c].SetColours(ctrlF, cB)
		ctrlBar[c].Locate(cr*cw, lv[c]*lh, wr*cw, lh)
		bx.Write(ctrlText[c], lv[c]+1, cr)
	}
	for i := 0; i < 2; i++ {
		timeBar[i] = pbar.New(true)
		timeBar[i].SetColours(ctrlF, cB)
		timeBar[i].Locate(cr*cw, lt[i]*lh, wr*cw, lh)
		bx.Write(timeText[i], lt[i]+1, cr)
	}
	scr.MouseCursor(true)
	scr.WarpMouse(lv[cdker.All]+1, cr+wr/4)
}
Ejemplo n.º 9
0
func (f *Imp) Decode(B []byte) {
	//
	a := uint(0)
	f.sort = Sort(B[a])
	a++
	col.Decode(&f.colour, B[a:a+3])
	a += 3
	n := uint(0)
	n = Decode(uint(0), B[a:a+clz]).(uint)
	a += clz
	if f.sort < Text {
		f.x, f.y = make([]int, n), make([]int, n)
		for i := uint(0); i < n; i++ {
			f.x[i] = Decode(f.x[i], B[a:a+clz]).(int)
			a += clz
			f.y[i] = Decode(f.y[i], B[a:a+clz]).(int)
			a += clz
		}
	} else { // sort == Text, Image
		f.x, f.y = make([]int, 2), make([]int, 2)
		f.x[0] = Decode(f.x[0], B[a:a+clz]).(int)
		a += clz
		f.y[0] = Decode(f.y[0], B[a:a+clz]).(int)
		a += clz
		if f.sort == Image {
			f.x[1] = Decode(f.x[1], B[a:a+clz]).(int)
			a += clz
			f.y[1] = Decode(f.y[1], B[a:a+clz]).(int)
			a += clz
		}
		f.tx = string(B[a : a+n])
		a += n
		if f.sort == Text {
			f.x[1] = f.x[0] + int(scr.NX1()*n) - 1
			f.y[1] = f.y[0] + int(scr.NY1()) - 1
		}
	}
	f.filled = B[a]%2 == 1
	f.marked = (B[a]/2)%2 == 1
}
Ejemplo n.º 10
0
func (B *Imp) write(Text string, x, y uint) {
	//
	scr.Lock()
	scr.Colours(B.cF, B.cB)
	if B.transparent {
		scr.SwitchTransparence(true)
	}
	y1 := B.width
	if y1 > uint(len(Text)) {
		y1 = uint(len(Text))
	}
	for x1 := B.index; x1 < y1; x1++ {
		if B.graphical {
			scr.Write1Gr(Text[x1], int(x+scr.NX1()*x1), int(y))
		} else {
			scr.Write1(Text[x1], y/scr.NY1(), x/scr.NX1()+x1)
		}
	}
	if B.transparent {
		scr.SwitchTransparence(false)
	}
	scr.Unlock()
}
Ejemplo n.º 11
0
func drive(cc, cl, cb col.Colour, d chan bool) {
	//
	nx, nx1, ny1 := int(scr.NX()), int(scr.NX1()), int(scr.NY1())
	dw := 96 * nx1
	x0 := (nx - dw) / 2
	x1 := x0 + dw - car.W
	y0 := ((int(scr.NLines())-31)/2 + 3) * ny1
	dr(x0, x1, y0, cc, false)
	dr(x0, x1, y0+2*ny1, cl, false)
	dr(x0, x1, y0+3*ny1, cl, false)
	joke(x0, x1, y0, nx1, ny1, 2, 4, 48, cl, "nsp", true)
	dr(x0, x1, y0+19*ny1, cl, false)
	dr(x0, x0+68*nx1, y0+20*ny1, cl, false)
	csb := col.ScreenB
	col.ScreenB = col.Black
	dr(x0+69*nx1, nx, y0+20*ny1, col.FlashRed, true)
	col.ScreenB = csb
	joke(x0, x1, y0, nx1, ny1, 67, 21, 14, cl, "fire", false)
	joke(x0, x1, y0, nx1, ny1, 48, 22, 15, cl, "mca", false)
	moon(x0 + 90*nx1)
	dr(x0, x1, y0+26*ny1, cc, false)
	d <- true
}
Ejemplo n.º 12
0
func main() {
	//
	if !scr.MouseEx() {
		return
	}
	var symbol [Nfigure]byte
	symbol[line] = 'S'      // "Strecke"
	symbol[rectangle] = 'R' // "Rechteck"
	symbol[circle] = 'K'    // "Kreis"
	symbol[ellipse] = 'E'   // "Ellipse"
	X, Y := 0, 0
	X1, Y1 := scr.NX(), scr.NY()
	//  Farbe, Papier:= col.LightWhite, col.Black
	Farbe, Papier := col.Black, col.LightWhite
	col.ScreenF, col.ScreenB = Farbe, Papier
	scr.Cls()
	paintColour := Farbe
	scr.Colour(paintColour)
	//  Staerke = 3
	bx := box.New()
	bx.Wd(20)
	bx.Colours(Papier, Farbe)
	Name := env.Par(1)
	if str.Empty(Name) {
		Name = "temp"
	}
	scr.Save(0, 0, 20, 1)
	for {
		bx.Edit(&Name, 0, 0)
		if !str.Empty(Name) {
			str.RemSpaces(&Name)
			break
		}
	}
	scr.Restore(0, 0, 20, 1)
	img.Get(Name, uint(X), uint(Y))
	scr.MouseCursor(true)
	Figur := figure(rectangle)
	var x, y, x0, y0 int
loop:
	for {
		scr.Colour(paintColour)
		Zeichen, Kommando, T := kbd.Read()
		switch Kommando {
		case kbd.None:
			x, y = scr.MousePosGr()
			scr.SwitchTransparence(true)
			scr.Write1Gr(Zeichen, x, y-int(scr.NY1()))
			//    scr.WarpMouse (x + scr.NX1(), y)
		case kbd.Esc:
			break loop
		case kbd.Back:
			switch T {
			case 0:
				x, y = scr.MousePosGr()
				x -= int(scr.NX1())
				scr.Colour(Papier)
				scr.Write1Gr(' ', x, y-int(scr.NY1()))
				//        scr.RectangleFull (x, y - scr.NY1(), x + scr.NX1(), y)
				//        scr.WarpMouseGr (x, y)
				scr.Colour(paintColour)
			default:
				scr.Cls()
			}
			/*
			   case kbd.Ins:
			     img.Write (X, Y, X1, Y1 - 16, Name)
			     box.Edit (Feld, Name, scr.Zeilenzahl () - 1, 0)
			     img.Get (X, Y, Name)
			*/
		case kbd.Help:
			paintColour = sel.Colour()
			//    case kbd.LookFor:
			//      Staerke = Strichstaerken.Staerke()
		case kbd.Enter:
			if T > 0 {
				x0, y0 = scr.MousePosGr()
				//        scr.Fill1 (x0, y0)
			}
		case kbd.PrintScr:
			img.Print(uint(X), uint(Y), X1, Y1-16)
		case kbd.Tab:
			if T == 0 {
				if Figur+1 < Nfigure {
					Figur++
				} else {
					Figur = figure(0)
				}
			} else {
				if Figur > 0 {
					Figur--
				} else {
					Figur = figure(Nfigure - 1)
				}
			}
			scr.Colours(col.White, Papier)
			scr.Write1(symbol[Figur], scr.NY()-1, 0)
		case kbd.Here:
			x0, y0 = scr.MousePosGr()
			scr.CircleFull(x0, y0, 3/2)
		case kbd.Pull:
			x, y = scr.MousePosGr()
			scr.Line(x0, y0, x, y)
			x0, y0 = x, y
		case kbd.Hither:
			x, y = scr.MousePosGr()
			scr.Line(x0, y0, x, y)
		case kbd.There:
			x0, y0 = scr.MousePosGr()
			x, y = x0, y0
		case kbd.Push:
			paint(Figur, inv, x0, y0, x, y)
			x, y = scr.MousePosGr()
			paint(Figur, inv, x0, y0, x, y)
		case kbd.Thither:
			paint(Figur, inv, x0, y0, x, y)
			//      scr.Colour (paintColour)
			x, y = scr.MousePosGr()
			paint(Figur, border, x0, y0, x, y)
			x0, y0 = x, y
		case kbd.This:
			x0, y0 = scr.MousePosGr()
			x, y = x0, y0
		case kbd.Move:
			scr.LineInv(x0, y0, x, y)
			x, y = scr.MousePosGr()
			scr.LineInv(x0, y0, x, y)
		case kbd.Thus:
			scr.LineInv(x0, y0, x, y)
			x, y = scr.MousePosGr()
			scr.Line(x0, y0, x, y)
			x0, y0 = x, y
		}
	}
	scr.Save(0, 0, 20, 1)
	for {
		bx.Edit(&Name, 0, 0)
		// TODO make sure, that "Name" is x{x|y} where x is letter, y is digit
		if !str.Empty(Name) {
			str.RemSpaces(&Name)
			break
		}
	}
	scr.Restore(0, 0, 20, 1)
	img.Put(Name, uint(X), uint(Y), X1, Y1)
	ker.Terminate()
}
Ejemplo n.º 13
0
func (x *Imp) Write(aktuell bool) {
	//
	xx, yy := scale.Scale(x.breite, x.länge)
	lw := scr.ActLinewidth()
	scr.SetLinewidth(scr.Thin)
	if aktuell {
		scr.Colours(linie.Farbe[x.linie], col.ScreenB)
	} else { // umstieg
		scr.Colours(col.Black, col.ScreenB)
	}
	const r = 2
	if xx >= r && yy >= r {
		scr.Circle(xx, yy, r)
		//    scr.Colour (col.ScreenB)
		scr.CircleFull(xx, yy, r-1)
	}
	scr.SetLinewidth(lw)
	n := int(str.ProperLen(x.name))
	if n <= 2 {
		return
	}
	n1 := int(str.ProperLen(x.name1))
	if n1 > n {
		n = n1
	}
	xn, yn := 0, 0
	w, h := int(scr.NX1()), int(scr.NY1())
	switch x.beschriftung {
	case 'r':
		xn = xx + w + 1
		if n1 == 0 {
			yn = yy - h/2
		} else {
			yn = yy - h
		}
	case 'o':
		xn = xx - (n*w)/2 + 1
		if n1 == 0 {
			yn = yy - h - 1
		} else {
			yn = yy - 2*h - 1
		}
	case 'l':
		xn = xx - n*w - w + 1
		if n1 == 0 {
			yn = yy - h/2
		} else {
			yn = yy - h
		}
	case 'u':
		xn = xx - (n*w)/2 + 1
		yn = yy + h/2 - 2
	default:
		xn = xx - (n*w)/2 + 1
		if n1 == 0 {
			yn = yy - h/2
		} else {
			yn = yy - h
		}
	}
	xxx := x.name
	for i := uint(0); i < uint(len(xxx)); i++ {
		if xxx[i] == '_' {
			str.Replace(&xxx, i, ' ')
		}
	}
	xxx1 := x.name1
	for i := uint(0); i < uint(len(xxx1)); i++ {
		if xxx1[i] == '_' {
			str.Replace(&xxx1, i, ' ')
		}
	}
	if aktuell {
		scr.Colours(linie.Farbe[x.linie], col.ScreenB)
	} else { // umstieg
		scr.Colours(col.Black, col.ScreenB)
		scr.Colours(col.Black, col.Pink)
	}
	scr.WriteGr(xxx, xn, yn)
	scr.WriteGr(xxx1, xn, yn+h+0)
}
Ejemplo n.º 14
0
func select_(write WritingCol, n, h, w uint, i *uint, l, c uint, f, b col.Colour) {
	//
	if n == 0 {
		ker.Stop(pack, 1)
	}
	if n == 1 {
		*i = 0
		return
	}
	if h == 0 {
		ker.Stop(pack, 2)
	}
	if h > n {
		h = n
	}
	if w == 0 {
		w = scr.NColumns()
	}
	if w > scr.NColumns() {
		w = scr.NColumns()
	}
	if c+w > scr.NColumns() {
		c = scr.NColumns() - w
	}
	// so, dass letzte Zeile frei bleibt
	if l+h >= scr.NLines() {
		h = scr.NLines() - l - 1
	}
	if *i >= n {
		*i = n - 1
	}
	MouseOn := scr.MouseCursorOn()
	var x, y int
	if MouseOn {
		scr.MouseCursor(false)
		x, y = scr.MousePosGr()
	}
	scr.WarpMouse(l+*i, c)
	scr.Save(l, c, w, h)
	i0, n0 := uint(0), uint(0)
	if *i == 0 {
		n0 = 1
	} // else { n0 = 0 }
	neu := true
loop:
	for {
		if *i < i0 {
			i0 = *i
			neu = true
		} else if *i > i0+h-1 {
			i0 = *i - (h - 1)
			neu = true
		} else {
			neu = *i != n0
		}
		if neu {
			neu = false
			var cF, cB col.Colour
			for j := uint(0); j < h; j++ {
				if i0+j == *i {
					cF, cB = f, b
				} else {
					cF, cB = b, f
				}
				write(i0+j, l+j, c, cF, cB)
			}
		}
		n0 = *i
		C, d := kbd.Command()
		switch C {
		case kbd.Esc, kbd.Thither:
			*i = n
			break loop
		case kbd.Enter, kbd.Hither:
			break loop
		case kbd.Left, kbd.Up:
			if d == 0 {
				if *i > 0 {
					*i--
				}
			} else {
				if *i >= 10 {
					*i -= 10
				}
			}
		case kbd.Right, kbd.Down:
			if d == 0 {
				if *i+1 < n {
					*i++
				}
			} else {
				if *i+10 < n {
					*i += 10
				}
			}
		case kbd.Pos1:
			*i = 0
		case kbd.End:
			*i = n - 1
		case kbd.Go:
			_, yM := scr.MousePosGr()
			if uint(yM) <= l*scr.NY1()+scr.NY1()/2 {
				if *i > 0 {
					*i--
				}
			} else if uint(yM) >= (l+h)*scr.NY1() {
				if *i < n-1 {
					*i++
				}
			} else {
				*i = i0 + uint(yM)/scr.NY1() - l
			}
			/*
			   case kbd.Help:
			     errh.Hint (errh.zumAuswaehlen)
			     kbd.Wait (true)
			     errh.DelHint()
			*/
		}
	}
	scr.Restore(l, c, w, h)
	if MouseOn {
		scr.MouseCursor(true)
		scr.WarpMouseGr(x, y)
	}
}
Ejemplo n.º 15
0
func (B *Imp) editNumber(imGraphikmodus bool, Text *string, x, y uint) {
	//
	var (
		char        byte
		cursorshape scr.Shape
		temp        uint
		firstTime   bool
	)
	B.graphical = imGraphikmodus
	//  if B.usesMouse { scr.SwitchMouseCursor (true) }
	Norm(Text, B.width)
	B.overwritable = !Empty(*Text)
	Move(Text, false)
	B.index = 0
	B.write(*Text, x, y)
	B.index = B.width
	if B.TRnumerical {
		firstTime = true
		edited = false
		// Zahl beim ersten Lesen eines Zeichens zurücksetzen, s.u.
	} else {
		edited = true
	}
	for {
		getStatus(Text)
		if B.overwritable {
			cursorshape = scr.Block
		} else {
			cursorshape = scr.Understroke
		}
		if B.graphical {
			scr.WarpGr(x+scr.NX1()*B.index, y, cursorshape)
		} else {
			scr.Warp(y/scr.NY1(), x/scr.NX1()+B.index, cursorshape) // Off
		}
		for {
			char, B.command, B.depth = kbd.Read()
			switch char {
			case 0: // Command
				break
			case '0', '1', '2', '3', '4', '5', '6', '7', '8', '9':
				if B.TRnumerical {
					if firstTime {
						*Text = Clr(B.width)
						status = start
						firstTime = false
						edited = true
					}
				}
				if status == start {
					status = bp
					break
				} else if status == ee {
					if Contains(*Text, 'E', &temp) {
						if temp >= B.width-3 { // not more than 2 digits after 'E'
							break
						}
					}
				} else {
					break
				}
			case '-':
				if B.TRnumerical {
					kbd.DepositCommand(kbd.None)
					kbd.DepositByte(char)
					return
				} else {
					if Empty(*Text) || (*Text)[B.width-1] == 'E' {
						break
					}
				}
			case '.', ',':
				if status == bp {
					status = ap
					break
				}
			case 'E':
				if B.numerical || B.TRnumerical {
					if status == ap && // noch Platz für zwei Zeichen
						(*Text)[0] == space && (*Text)[1] == space {
						status = ee
						if B.numerical {
							break
						} else {
							Rem(Text, B.width-2, 2)
							*Text = *Text + "E+"
							char = 0
							break
						}
					}
				}
			case 'v':
				char = 0
				if B.TRnumerical { // || B.numerical {
					if status == bp || status == ap {
						temp = 0
						for (*Text)[temp] == space {
							temp++
						}
						if (*Text)[temp] == '-' {
							Replace(Text, temp, '+')
							break
						} else if (*Text)[temp] == '+' {
							Replace(Text, temp, '-')
							break
						} else if temp > 0 {
							Replace(Text, temp-1, '-')
							break
						}
					} else if status == ee {
						if Contains(*Text, 'E', &temp) {
							if (*Text)[temp+1] == '-' {
								Replace(Text, temp+1, '+')
								break
							} else if (*Text)[temp+1] == '+' {
								Replace(Text, temp+1, '-')
								break
							}
						}
					}
				}
			default:
				if B.TRnumerical {
					// >>> Besser wäre dies nur für den Fall, dass 'Zeichen' ein Funktionszeichen aus dem Zahlen-Modul ist:
					kbd.DepositCommand(kbd.None)
					kbd.DepositByte(char)
					return
				}
			}
		}
		if B.graphical {
			scr.WarpGr(x+scr.NX1()*B.index, y, scr.Off)
		} else {
			scr.Warp(y/scr.NY1(), x/scr.NX1()+B.index, scr.Off)
		}
		if B.command == kbd.None {
			if B.index == B.width {
				if B.overwritable {
					B.overwritable = false
				}
				if char == 0 { // change of sign or exponent
					temp = B.index
					B.index = 0
					B.write(*Text, x, y)
					B.index = temp
				} else if B.possibleNumerical(Text, x, y) {
					temp = B.index
					B.index = 0
					B.write(*Text, x, y)
					B.index = temp
					Replace(Text, B.index-1, char)
					scr.Lock()
					scr.Colours(B.cF, B.cB)
					if B.graphical {
						scr.Write1Gr(char, int(x+scr.NX1()*(B.index-1)), int(y))
					} else {
						scr.Write1(char, y/scr.NY1(), x/scr.NX1()+B.index-1)
					}
					scr.Unlock()
				} else {
				}
			} else {
				// see editText
			}
		} else {
			if B.doneNumerical(Text, x, y) {
				break
			}
		}
	}
	// if B.usesMouse { scr.SwitchMouseCursor (false) }
}
Ejemplo n.º 16
0
func (B *Imp) editText(imGraphikmodus bool, Text *string, x, y uint) {
	//
	var char byte
	var cursorshape scr.Shape
	B.graphical = imGraphikmodus
	// if B.usesMouse { scr.SwitchMouseCursor (true) }
	Norm(Text, B.width)
	B.overwritable = !Empty(*Text)
	B.index = 0
	B.write(*Text, x, y)
	B.overwritable = !Empty(*Text)
	B.write(*Text, x, y)
	if B.start > 0 && B.start < B.width {
		B.index = B.start
		B.start = 0
	} else {
		B.index = 0
	}
	for {
		if B.overwritable {
			cursorshape = scr.Block
		} else {
			cursorshape = scr.Understroke
		}
		if B.graphical {
			scr.WarpGr(x+scr.NX1()*B.index, y, cursorshape)
		} else {
			scr.Warp(y/scr.NY1(), x/scr.NX1()+B.index, cursorshape)
		}
		for {
			char, B.command, B.depth = kbd.Read()
			if B.command < kbd.Go {
				break
			}
		}
		edited = char != byte(0)
		if B.graphical {
			scr.WarpGr(x+scr.NX1()*B.index, y, scr.Off)
		} else {
			scr.Warp(y/scr.NY1(), x/scr.NX1()+B.index, scr.Off)
		}
		if B.command == kbd.None {
			if B.index == B.width {
				// see editNumber
			} else {
				if B.possible(Text, x, y) {
					Replace(Text, B.index, char)
					scr.Lock()
					scr.Colours(B.cF, B.cB)
					if B.graphical {
						scr.Write1Gr(char, int(x+scr.NX1()*B.index), int(y))
					} else {
						scr.Write1(char, y/scr.NY1(), x/scr.NX1()+B.index)
					}
					scr.Unlock()
					B.index++
				}
			}
		} else {
			if B.done(Text, x, y) {
				break
			}
		}
	}
	// if B.usesMouse { scr.SwitchMouseCursor (false) }
}
Ejemplo n.º 17
0
func ausgeben1(a arten, r Richtung, y uint, x uint, f, b col.Colour) {
	//
	y0 := (zellengroesse / int(scr.NY1())) * int(y+1)
	x0 := (zellengroesse / int(scr.NX1())) * int(x)
	x0 *= int(scr.NX1())
	y0 = int(scr.NY1()) * (y0) // * (y0 - 1)
	if a == nichts {           // schneller:
		scr.Colour(farbeH)
		scr.RectangleFull(x0+1, y0+1, x0+zellengroesse-2, y0+zellengroesse-1)
		scr.Colour(randfarbe)
		scr.Rectangle(x0, y0, x0+zellengroesse-1, y0+zellengroesse-1)
	} else {
		// Datenstrukturen zur Beschleunigung der Ausgabe unter X um das 171-fache
		// durch Reduktion der Aufrufe von X-Routinen von 2 * 32 * 32 = 2048 auf 2 * 6 = 12:
		const (
			n  = 6 // Farbzahl
			zz = zellengroesse * zellengroesse
		)
		var (
			nr    int
			zelle [zellengroesse][zellengroesse]int
		)
		for dy := 0; dy < zellengroesse; dy++ {
			for dx := 0; dx < zellengroesse; dx++ {
				nr = 0 // farbeH
				switch bild[a][dy][dx] {
				case 'o':
					nr = 1 // F
				case 'x':
					nr = 2 // randfarbe
				case '+':
					nr = 3 // farbeV
				case 'k':
					if Roboterwelt.kloetze(y, x) > 0 {
						nr = 4 // B
					}
				case 'm':
					if Roboterwelt.markiert(y, x) {
						nr = 4 // B
					}
				case ' ':
					if a == mauer {
						nr = 5 // mauerfarbe
					} else {
						nr = 0 // farbeH
					}
				default:
					return // stop
				}
				if a != einRoboter {
					r = Nord
				}
				switch r {
				case Nord:
					zelle[dx][dy] = nr
				case West:
					zelle[dy][dx] = nr
				case Sued:
					zelle[dx][zellengroesse-1-dy] = nr
				case Ost:
					zelle[zellengroesse-1-dy][dx] = nr
				}
			}
		}
		var (
			anzahl [n]int
			xx, yy [n][zz]int
		)
		for dy := 0; dy < zellengroesse; dy++ {
			for dx := 0; dx < zellengroesse; dx++ {
				nr = zelle[dx][dy]
				xx[nr][anzahl[nr]] = x0 + dx
				yy[nr][anzahl[nr]] = y0 + dy
				anzahl[nr]++
			}
		}
		c := [n]col.Colour{farbeH, f, randfarbe, farbeV, b, mauerfarbe}
		for i := 0; i < n; i++ {
			scr.Colour(c[i])
			scr.Pointset(xx[i][:], yy[i][:])
		}
	}
}
Ejemplo n.º 18
0
func (R *Imp) Manipulieren(K kbd.Comm, T uint) {
	//
	s := schrittweise
	schrittweise = false
	amEditieren = true
	switch K {
	case kbd.Esc:
		return
	case kbd.Enter:
		if T == 0 {
			if R.Geschoben1() {
			}
		} else {
			R.schiessen()
		}
	case kbd.Left:
		if Sokoban {
			switch R.richtung {
			case Nord:
				R.LinksDrehen()
			case West:

			case Sued:
				R.RechtsDrehen()
			case Ost:
				R.umkehren()
			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			switch R.richtung {
			case Nord:
				R.LinksDrehen()
			case West:
				if T == 0 {
					if R.Gelaufen1() {
					}
				} else {
					for R.Gelaufen1() {
					}
				}
			case Sued:
				R.RechtsDrehen()
			case Ost:
				R.umkehren()
			}
		}
	case kbd.Right:
		if Sokoban {
			switch R.richtung {
			case Nord:
				R.RechtsDrehen()
			case West:
				R.umkehren()
			case Sued:
				R.LinksDrehen()
			case Ost:

			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			switch R.richtung {
			case Nord:
				R.RechtsDrehen()
			case West:
				R.umkehren()
			case Sued:
				R.LinksDrehen()
			case Ost:
				if T == 0 {
					if R.Gelaufen1() {
					}
				} else {
					for R.Gelaufen1() {
					}
				}
			}
		}
	case kbd.Up:
		if Sokoban {
			switch R.richtung {
			case Nord:

			case West:
				R.RechtsDrehen()
			case Sued:
				R.umkehren()
			case Ost:
				R.LinksDrehen()
			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			if T == 2 {
				R.Entmarkieren()
			} else {
				switch R.richtung {
				case Nord:
					if T == 0 {
						if R.Gelaufen1() {
						}
					} else {
						for R.Gelaufen1() {
						}
					}
				case West:
					R.RechtsDrehen()
				case Sued:
					R.umkehren()
				case Ost:
					R.LinksDrehen()
				}
			}
		}
	case kbd.Down:
		if Sokoban {
			switch R.richtung {
			case Nord:
				R.umkehren()
			case West:
				R.LinksDrehen()
			case Sued:

			case Ost:
				R.RechtsDrehen()
			}
			if R.NachbarLeer() {
				if R.Gelaufen1() {
				}
			} else {
				if R.Geschoben1() {
				}
			}
		} else {
			if T == 2 {
				R.Markieren()
			} else {
				switch R.richtung {
				case Nord:
					R.umkehren()
				case West:
					R.LinksDrehen()
				case Sued:
					if T == 0 {
						if R.Gelaufen1() {
						}
					} else {
						for R.Gelaufen1() {
						}
					}
				case Ost:
					R.RechtsDrehen()
				}
			}
		}
	case kbd.Pos1:
		if !Sokoban {
			if R.Gemauert1() {
			}
		}
	case kbd.End:
		if !Sokoban {
			if R.Entmauert1() {
			}
		}
	case kbd.Tab:
		if !Sokoban {
			switch T {
			case 0:
				if Roboterwelt.markiert(R.Y, R.X) {
					R.Entmarkieren()
				} else {
					R.Markieren()
				}
				/*
				     R.Markieren ()
				   1: // unter X funktioniert Umschalt + Tab nicht
				     R.Entmarkieren ()
				   } else {
				     R.allesEntmarkieren ()
				*/
			}
		}
	case kbd.Ins:
		if !Sokoban {
			if R.tasche > 0 {
				R.Legen1()
			}
		}
	case kbd.Del:
		if !Sokoban {
			if T == 0 {
				R.Leeren1()
			} else {
				Roboterwelt.klotzen(R.Y, R.X, 0)
			}
		}
	case kbd.Back:
		for len(R.aktionen) > 0 {
			switch R.letzteAktion() {
			case Links:
				R.linksDrehenZurueck()
			case Rechts:
				R.rechtsDrehenZurueck()
			case Weiter:
				R.laufen1zurueck()
			case Zurueck:
				R.zuruecklaufen1zurueck()
			case KlotzWeg:
				R.leeren1zurueck()
			case KlotzHin:
				R.legen1zurueck()
			case KlotzWeiter:
				R.schieben1zurueck()
			case MarkeHin:
				R.markierenZurueck()
			case MarkeWeg:
				R.entmarkierenZurueck()
			case MauerHin:
				R.mauern1zurueck()
			case MauerWeg:
				R.entmauern1zurueck()
			}
			if T == 0 {
				break
			}
		}
	case kbd.Help:
		if Sokoban {
			errh.WriteHelp(Sokobanhilfe[:])
		} else {
			errh.WriteHelp(Hilfe[:])
		}
	case kbd.LookFor:
		// Roboter wechseln
	case kbd.Act:
		// neuen Roboter initialisieren
	case kbd.Cfg:
		// terminieren (R)
	case kbd.Mark:
		if !Sokoban {
			R.Markieren()
		}
	case kbd.Demark:
		if !Sokoban {
			if T == 0 {
				R.Entmarkieren()
			} else {
				R.allesEntmarkieren()
			}
		}
	case kbd.Paste:

	case kbd.Deposit:

	case kbd.Black:

	case kbd.Red:

	case kbd.Green:

	case kbd.Blue:

	case kbd.PrintScr:
		img.Print(0, 0, scr.NX(), scr.NY()-scr.NY1())
	case kbd.Roll:
		if T == 0 {
			// Roboter wechseln
		} else {
			// terminieren (R)
		}
	case kbd.Pause:
		// Roboter killen
	case kbd.Go:

		/*
		   case kbd.Here:
		     if scr.UnderMouse (2 * R.Y + 1, 4 * R.X, 4, 2) {
		       // ist angeklickt
		     }
		*/
	case kbd.Pull:
		// wenn Roboter getroffen, vorläufig hierhin
	case kbd.Hither:
		// wenn Roboter getroffen, endgültig hierhin
	case kbd.There:

	case kbd.Push:

	case kbd.Thither:

	case kbd.This:

	case kbd.Move:

	case kbd.Thus:

	case kbd.Navigate:

	}
	amEditieren = false
	schrittweise = s
}