func (x *Imp) changeWithMouse(p Period, vertical bool, a, l, c, l0, c0 uint) {
//
if !scr.MouseEx() {
return
}
switch p {
case Daily, Decadic:
return
default:
}
lm, cm := scr.MousePos()
// if p == Yearly { SM += leftMargin }
y := x.Clone().(*Imp)
y.SetBeginning(p)
A := y.Clone().(*Imp)
y.SetFormat(Dd_mm_yy)
n := length[x.fmt]
var lpos, cpos uint
for {
n = length[x.fmt]
if !y.Equiv(A, p) {
break
}
switch p {
case Weekly:
lpos, cpos = y.PosInWeek(vertical, a)
lpos += l0
cpos += c0
case Monthly:
lpos, cpos = y.PosInMonth(vertical, a, l, c)
lpos += l0
cpos += c0
case Quarterly:
errh.Error("in "+pack+" not yet implemented", 3)
return
case HalfYearly:
errh.Error("in "+pack+" not yet implemented", 6)
return
case Yearly:
n = 2
lpos, cpos = y.PosInYear()
default:
}
if lm == lpos && cpos <= cm && cm < cpos+n {
y.Copy(x)
break
} else {
y.Inc(Daily)
}
}
}
func NodesSelected() bool {
//
scr.MouseCursor(true)
g := false
for {
errh.Hint("Start auswählen")
if ausgewaehlt(Ecke) { // Ecke aktuell
Graph.Position(true) // Ecke postaktuell
Write()
errh.Hint("Ziel auswählen")
if ausgewaehlt(Ecke1) { // Ecke1 aktuell
errh.DelHint()
if Graph.Positioned() {
errh.Error("Fehler: Start und Ziel sind gleich !", 0)
} else {
g = true
break
}
}
} else {
break
}
}
Write()
errh.DelHint()
scr.MouseCursor(false)
return g
}
func (f *Imp) On(a, b int, t uint) bool {
//
if !f.Empty() {
switch f.sort {
case Pointset, Segments:
return scr.OnSegments(f.x, f.y, a, b, t)
case Polygon:
return scr.OnPolygon(f.x, f.y, a, b, t)
case Curve:
return scr.OnCurve(f.x, f.y, a, b, t)
case InfLine:
return scr.OnInfLine(f.x[0], f.y[0], f.x[1], f.y[1], a, b, t)
case Rectangle:
return scr.OnRectangle(f.x[0], f.y[0], f.x[1], f.y[1], a, b, t)
case Circle:
return scr.OnCircle(f.x[0], f.y[0], uint(f.x[1]), a, b, t)
case Ellipse:
return scr.OnEllipse(f.x[0], f.y[0], uint(f.x[1]), uint(f.y[1]), a, b, t)
case Text:
if len(f.x) != 2 {
errh.Error("Incident case Text: len (f.x) ==", uint(len(f.x)))
}
return scr.OnRectangle(f.x[0], f.y[0], f.x[1], f.y[1], a, b, t) // crash: TODO
case Image:
return scr.InRectangle(f.x[0], f.y[0], f.x[1], f.y[1], a, b) // , t
}
}
return false
}
func (x *Imp) ActualizePred(p Pred) {
//
n := x.nodeAnchor.nextN
if n == x.nodeAnchor {
errh.Error("#", 10)
return
}
if !p(x.actual.content) {
// errh.Error ("#", 11)
return
}
x.clearSubgraph()
if !x.ConnCond(p) {
// errh.Error ("#", 12)
return
}
x.preBreadth()
if x.edgeAnchor.attrib == nil {
x.breadthfirstSearch(p)
} else {
// errh.Error ("shortest Path", 0)
x.searchShortestPath(p)
}
x.path = nil
n = x.actual
for n != nil {
x.path = insert(x.path, n, 0)
n = n.predecessor
}
x.defineSubgraph(x.actual)
}
func Select() {
//
name, filename := sel.Names("Graphik:", suffix, 64, 0, 0, col.ScreenF, col.ScreenB)
if name == "" {
errh.Error("nicht vorhanden", 0)
Clr()
} else {
Name(filename)
}
}
func (x *Imp) Edit(l, c uint) {
//
s := x.String()
w := uint(len(s))
N := scr.NColumns()
if c >= N-w {
x.Write(l, c)
errh.Error("zu wenig Platz auf dem Bildschirm", 0) // TODO
return
}
bx.Wd(N - 1 - c)
bx.Edit(&s, l, c)
for {
if x.Defined(s) {
break
} else {
errh.Error("keine Zahl", 0)
}
}
x.Write(l, c)
}
func (x *Imp) Edit(l, c uint) {
//
x.Write(l, c)
s := x.String()
err := uint(0)
for {
bx.Edit(&s, l, c)
if x.Defined(s) {
s = x.String()
bx.Write(s, l, c)
return
} else {
err++
switch err {
case 1: // --> errh.WriteError
errh.Error("Die Uhrzeitangabe ist unverständlich!", 0) // , l + 1, c)
case 2:
errh.Error("Bitte wiederholen Sie die Uhrzeitangabe, sie ist immer noch unverständlich !", 0) // , l + 1, c)
case 3:
errh.Error("Jetzt passen Sie doch gefälligst auf !", 0) // l + 1, c)
case 4:
errh.Error("Was soll der Quatsch? Ist das eine Uhrzeit ?", 0) // l + 1, c)
case 5:
errh.Error("Schaffen Sie es nicht, eine Uhrzeit richtig einzugeben ?", 0) // l + 1, c)
default:
errh.Error("Vergessen Sie's ...", 0) // , l + 1, c)
x.Actualize()
return
}
}
}
}
func Want(y, m, d uint) {
//
wanted := day.New()
wanted.SetFormat(day.Yymmdd)
if wanted.Set(d, m, 2000+y) {
if v.Less(wanted) {
errh.Error("Your murus "+v.String()+" is outdated. You need "+wanted.String()+".", 0)
ker.Halt(-1)
}
} else {
ker.Panic("parameters for v.Want are nonsense")
}
}
func (x *Imp) Edit(l, c uint) {
//
x.Write(l, c)
s := x.String()
for {
bx.Edit(&s, l, c)
if x.Defined(s) {
break
} else {
errh.Error("falsche Eingabe", 0)
}
}
}
func init() {
//
// var x World = New(); if x == nil {} // ok
if !scr.Switchable(scr.WVGApp) {
errh.Error("Bildschirmauflösung kleiner als 1024 x 576", 0)
ker.Terminate()
os.Exit(0)
} else {
scr.Switch(scr.WVGApp)
}
help[0] = "Hilfe ist noch nicht implementiert" // TODO
files.Cd0()
}
func (F *files) read(B []byte) uint {
//
F.open()
if !F.isOpen {
errh.Error(F.file.Name(), uint(F.offset))
}
r := len(B)
// r, F.err = F.file.ReadAt (B, int64(F.offset)) // macht Zicken
_ /* off */, _ = F.file.Seek(int64(F.offset), 0) // ; F.report ("read", "Seek at offset", uint(off))
r, _ = F.file.Read(B) // ; F.report ("Read", "at offset", uint(off))
F.offset += uint64(r)
return uint(r)
}
func (x *Imp) Edit(l, c uint) {
//
x.Write(l, c)
s := x.String()
for {
bx.Edit(&s, l, c)
if x.Defined(s) {
break
} else {
errh.Error("keine Zahl", 0)
}
}
x.Write(l, c)
}
func (x *Imp) Edit(l, c uint) {
//
bx.Wd(width)
s := x.String()
for {
bx.Edit(&s, l, c)
if x.Defined(s) {
break
} else {
errh.Error("keine Telefonnummer", 0)
}
}
x.Write(l, c)
}
func (x *Imp) Edit(l, c uint) {
//
s := x.String()
bx.Colours(x.cF, x.cB)
for {
bx.Edit(&s, l, c)
if x.Defined(s) {
break
} else {
errh.Error("kein Geldbetrag", 0) // l + 1, c)
}
}
x.Write(l, c)
}
func (x *Imp) Edit(l, c uint) {
//
s := x.String()
bx.Colours(x.cF, x.cB)
for {
bx.Edit(&s, l, c)
if x.Defined(s) {
break
} else {
errh.Error("Format: Z = \"0\"|\"1\"|...|\"9\", [\"+\"|\"-\"] Z{Z}[/Z{Z}]; jeweils maximal 9 Ziffern", 0)
}
}
x.reduce()
x.Write(l, c)
}
func (x *Imp) Edit(l, c uint) {
// func (v *Imp) Edit (p ... uint) {
//
s := x.String()
m := uint(len(s))
bx.Wd(m)
for {
bx.Edit(&s, l, c)
// bx.Edit (&s, p[0], p[1])
if x.Defined(s) {
break
} else {
errh.Error("kein Vektor", 0)
}
}
}
func (x *Imp) Edit(Z, S uint) {
//
T := txt[x.a]
loop:
for {
bx.Edit(&T, Z, S)
for a := undef; a < NAttrs; a++ {
if T[0] == txt[a][0] {
x.a = a
x.Write(Z, S)
break loop
}
}
errh.Error(Hilfetext, 0)
}
}
func main() {
const a = 100
var p []string = []string{"Anaxagoras", "Aristoteles", "Cicero", "Jemand", "Demokrit", "Diogenes", "Epikur", "Heraklit", "Platon", "Protagoras", "Pythagoras", "Sokrates", "Thales", "Niemand"}
var x, y uint
for _, s := range p {
img.Get(s, x, y)
errh.Error(s, 0)
if x+2*a < scr.NX() {
x += a
} else {
x = 0
y = a
}
}
errh.Error2("", uint(len(p)), "Philosophen", 0)
ker.Terminate()
}
func (x *Imp) Edit(l, c uint) {
//
bx.Wd(x.length)
bx.Colours(x.cF, x.cB)
var input string
for {
input = x.rep[x.val]
bx.Write(input, l, c)
bx.Edit(&input, l, c)
if x.Defined(input) {
break
} else {
errh.Error("Eingabe unverständlich", 0) // , l + 1, c)
}
}
x.Write(l, c)
}
func edit(z *int, l, c uint) {
//
w := Wd(*z)
if width > w {
w = width
}
bx.Wd(w)
s := StringFmt(*z, w)
for {
bx.Edit(&s, l, c+1-w)
if defined(z, s) {
break
} else {
errh.Error("keine Zahl", 0) // , l + 1, c)
}
}
bx.Write(StringFmt(*z, w), l, c+1-w)
}
func (x *Imp) Edit(Z, S uint) {
//
bx.Colours(x.cF, x.cB)
var l uint
for {
switch x.fmt {
case Tld:
l = 2
bx.Edit(&x.att.tld, Z, S)
case Long:
l = length
bx.Edit(&x.att.name, Z, S)
default:
return
}
var T uint
if kbd.LastCommand(&T) == kbd.LookFor {
n := uint(x.cnt)
sel.Select(func(P, Z, S uint, V, H col.Colour) { x.att = Folge[country(P)]; x.SetColours(V, H); x.Write(Z, S) },
noNations, scr.NLines(), l, &n, Z, S, x.cB, x.cF)
if country(n) == noNations {
n = uint(x.cnt) // Nation unverändert
} else {
x.cnt = country(n)
}
x.att = Folge[x.cnt]
break
} else {
var ok bool
switch x.fmt {
case Tld:
ok = x.Defined(x.att.tld)
case Long:
ok = x.Defined(x.att.name)
}
if ok {
break
} else {
errh.Error("kein Land", 0)
}
}
}
x.Write(Z, S)
}
func (x *Imp) SetFormat(p day.Period) {
//
aktuellesFormat = p
dz = 1
// if x.anzahl == 0 { return }
switch aktuellesFormat {
case day.Daily:
x.termin[0].SetFormat(termin.Lang)
case day.Weekly:
x.termin[0].SetFormat(termin.Kurz)
case day.Monthly:
x.termin[0].SetFormat(termin.Kurz) // GanzKurz
dz = 0
// aus den Terminen werden nur die Terminattribute gebraucht
default:
errh.Error("seq.SetFormat default: Quatsch", 0)
x.termin[0].SetFormat(termin.GanzKurz)
dz = 0
}
}
func clearAll(D *day.Imp) {
//
switch period {
case day.Monthly, day.Weekly:
if D.Empty() {
return
}
default:
return
}
D1 := day.New()
D1.Copy(D)
D1.SetBeginning(period)
cal.SetFormat(period)
for D.Equiv(D1, period) {
l, c := pos(D1)
errh.Error("Tag Nr.", D1.OrdDay())
cal.ClearDay(D1, l0+l, c0+c)
D1.Inc(day.Daily)
}
}
func (x *Imp) Edit(l, c uint) {
//
x.Write(l, c)
s := x.String()
for {
bx.Edit(&s, l, c)
var d uint
cmd := kbd.LastCommand(&d)
if cmd == kbd.LookFor {
if x.selected(l, c) {
break
}
}
if x.Defined(s) {
break
} else {
errh.Error("geht nicht", 0)
}
}
x.Write(l, c)
}
func New0(a Any, h string, p uint16, o bool) *Imp {
//
if str.Empty(h) || p >= 1<<16-Port0 {
return nil
}
if a == nil {
a = false
}
x := new(Imp)
if tst {
println("nchan.New0 started for host", h, "/ port", p)
}
x.object, x.width = Clone(a), Codelen(a)
str.RemSpaces(&h)
x.farHost = host.New()
if !x.farHost.Defined(h) {
errh.Error("Hostname "+h+" is not resolvable", 0)
Stop(pack, 1)
}
x.isServer = host.Local(h)
x.server = h
x.port = Port0 + p
x.oneOne = o
if x.oneOne {
if x.isServer {
x.isServer = first(x.port)
} else {
x.isServer = x.farHost.Sonstewas()
}
}
x.buf = make([]byte, x.width)
// x.info = true
if tst {
println("nchan.New0 for host", h, "is done")
}
return x
}
func NeuerRoboter() *Imp {
//
var archiviert bool
r := Roboterwelt.schatten.freieNummer(&archiviert)
if r == niemand { // nix geht mehr
// errh.Error ("Die Roboterwelt ist voll !", 0)
return nil // besser: Error erzeugen, der abgefragt werden kann
}
R := new(Imp)
if archiviert {
// println ("NeuerRoboter schon im Archiv enthalten")
Roboterwelt.schatten.restaurieren(R, r)
} else {
R.nr = r
// println ("NeuerRoboter hat die Nummer ", r)
R.Y = 0
R.X = uint(R.nr)
if !platzDa(&(R.Y), &(R.X)) { // Vorsicht, X jetzt erhöht, weil schon im Schattenarchiv !
// println ("Neuer Roboter: nach ! platzDa, Pos = ", R.Y, "/", R.X)
errh.Error("kein Platz mehr frei für Roboter", 0)
return nil
}
R.richtung = Sued
R.tasche = MaxK
for y := null; y < nY; y++ {
for x := null; x < nX; x++ {
if y == R.Y && x == R.X {
R.tasche -= Roboterwelt.kloetze(y, x)
}
}
}
Roboterwelt.schatten.archivieren(R)
}
R.aktionen = make([]Aktion, 0)
return R
}
func tst(n uint) {
//
println("Testpunkt ", n)
return
errh.Error("Testpunkt", n)
}
func (R *Imp) FehlerMelden(Text string, n uint) {
//
errh.Error(Text, n)
}
func (f *Imp) Edit() {
//
if f.Empty() {
scr.Colour(f.colour)
f.x, f.y = make([]int, 1), make([]int, 1)
f.x[0], f.y[0] = scr.MousePosGr()
switch f.sort {
case Pointset, Segments, Polygon, Curve:
f.editN()
case InfLine, Rectangle, Circle, Ellipse:
f.edit1()
case Text:
f.editText()
case Image:
// ALLOCATE (Imageptr, Groesse())
// img.Get (tx [...], Imageptr)
f.editImage()
}
if f.x == nil {
f.Clr()
}
} else {
n := uint(len(f.x))
errh.Error("Figur hat Länge", n)
switch f.sort {
case Text:
f.editText()
case Image:
f.editImage()
default:
f.Erase()
f.Invert()
if true { // f.sort == Curve {
for i := uint(0); i < n; i++ {
f.mark(i)
}
}
i := f.uM()
f.x[i], f.y[i] = scr.MousePosGr()
loop:
for {
scr.MouseCursor(true)
c, _ := kbd.Command()
switch c {
case kbd.Esc:
break loop
case kbd.Enter, kbd.Tab, kbd.LookFor:
f.colour = sel.Colour()
case kbd.Here:
break loop
case kbd.There:
i = f.uM()
case kbd.Push, kbd.Thither:
if i < n {
f.Invert()
f.mark(i)
f.x[i], f.y[i] = scr.MousePosGr()
f.mark(i)
f.Invert()
if c == kbd.Thither {
i = n
} // ? ? ?
}
case kbd.This:
switch f.sort {
case Pointset, Segments, Polygon, Curve:
if f.x == nil {
f.Clr()
} else {
for i := uint(0); i < n; i++ {
f.mark(i)
}
f.Erase()
n-- // ? ? ?
f.Invert()
for i := uint(0); i < n; i++ {
f.mark(i)
}
}
}
}
errh.Hint(c.String())
}
f.Invert()
if true { // sort != Text {
for i := uint(0); i < n; i++ {
f.mark(i)
}
}
f.Write()
}
}
}
func (x *Imp) Edit(l, c uint) {
//
x.Write(l, c)
n := uint(0)
loop_n:
for {
i := uint(0)
loop_i:
for {
weg := false
switch i {
case 0: // lang
for {
for {
x.lang[n].Edit(l+lLa[x.f][n], c+cLa[x.f][n])
if x.lang[n].Ord() >= 2 && // Englisch
x.lang[n].Ord() <= 12 { // Griechisch
break
} else {
errh.Error("keine Fremdsprache", 0)
}
}
if x.lang[n].Empty() {
if n > 1 {
weg = true
break
} else {
errh.Error2("", n+1, ". Fremdsprache fehlt", 0)
}
} else {
break
}
}
case 1: // from
if weg {
x.from[n].Clr()
x.from[n].Write(l+lFr[x.f][n], c+cFr[x.f][n])
} else {
x.from[n].Edit(l+lFr[x.f][n], c+cFr[x.f][n])
}
case 2: // to
if weg {
x.to[n].Clr()
x.to[n].Write(l+lTo[x.f][n], c+cTo[x.f][n])
} else {
for {
x.to[n].Edit(l+lTo[x.f][n], c+cTo[x.f][n])
if x.to[n].Empty() || x.to[n].Val() == 0 && x.to[n].Val() >= 12 {
errh.Error("geht nich", x.to[n].Val())
} else {
break
}
}
}
}
if i < 2 {
i++
} else {
if x.from[n].Eq(x.to[n]) || x.from[n].Less(x.to[n]) {
break loop_i
} else {
i = 1
}
}
} // loop_i
if n+1 < max {
n++
} else {
k := uint(0)
if x.multiple(&k) {
errh.Error2("Die", k+1, ". Fremdsprache kommt mehrfach vor", 0)
} else {
break loop_n
}
}
}
}