Golang errh.Error函数代码示例

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 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(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 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) 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)
	}
}