Ejemplo n.º 1
0
func writeLicense(project, version, author string, f, cl, b col.Colour, g []string, Text *string) {
	//
	pre()
	post()
	w, h := uint(len(g[0])), uint(25) /* == len (license), see func init */ +6
	l, c := (NLines()-h)/2, (NColumns()-w)/2
	//  l0, c0:= l, c
	//  scr.Save (l, c, width, height)
	licenseBox.Wd(w)
	licenseBox.Colours(cl, b)
	emptyLine := str.Clr(w)
	licenseBox.Write(emptyLine, l, c)
	l++
	var s string
	str.Set(&s, project+" v. "+version)
	str.Center(&s, w)
	licenseBox.Write(s, l, c)
	l++
	licenseBox.Write(emptyLine, l, c)
	l++
	str.Set(&s, "(c) "+author)
	str.Center(&s, w)
	licenseBox.Colours(f, b)
	licenseBox.Write(s, l, c)
	l++ // l, c = 30, 52
	licenseBox.Colours(cl, b)
	licenseBox.Write(emptyLine, l, c)
	l++
	for i := 0; i < len(g); i++ {
		licenseBox.Write(g[i], l, c)
		l++
	}
	licenseBox.Write(emptyLine, l, c)
	l++
	licenseBox.Colours(f, b)
	/*
	   var line string
	   if DocExists {
	     str.Set (&line, "ausführliche Bedienungshinweise: siehe Dokumentation")
	   } else {
	     line = env.Parameter (0)
	     if line == "murus" {
	       line = str.Clr (w)
	     } else {
	       str.Set (&line, "kurze Bedienungshinweise: F1-Taste")
	     }
	   }
	   if ! str.Empty (line) { str.Center (&line, w) }
	   licenseBox.Write (line, l, c); l ++
	   licenseBox.Write (emptyLine, l, c)
	*/
	//  kbd.Wait (true)
	//  scr.Restore (l0, c0, w, height)
}
Ejemplo n.º 2
0
func def(n country, N string, I string, D string, V uint16, K, O string) {
	//
	Folge[n].tld = D
	str.Set(&Folge[n].name, N)
	Folge[n].iso = I
	Folge[n].prefix = V
	Folge[n].kfz = K
	Folge[n].ioc = O
}
Ejemplo n.º 3
0
func (x *Imp) Defined(s string) bool {
	//
	if uint(len(s)) > x.length {
		return false
	}
	str.Set(&(x.content), s)
	str.Norm(&(x.content), x.length)
	return true
}
Ejemplo n.º 4
0
func names(mask, suffix string, n uint, l, c uint, f, b col.Colour) (string, string) {
	//
	t, t1 := uint(len(mask)), uint(0)
	if t > 0 {
		t1 = 1 + t
	}
	scr.Save(l, c, t1+n, 1)
	if t > 0 {
		mbx.Wd(t)
		mbx.ColoursScreen()
		mbx.Write(mask, l, c)
	}
	bx.Wd(n)
	bx.Colours(f, b)
	ptSuffix = "." + suffix
	errh.Hint("falls Dateien vorhanden, auswählen F2-, dann Pfeil-/Eingabetaste, ggf. Esc")
	name := env.Par(1)
	if name == "" {
		name = str.Clr(n) // Wörkeraunt um Fehler in box/imp.go
	}
	var p uint
	if str.Contains(name, '.', &p) {
		name = str.Part(name, 0, p)
	}
	bx.Edit(&name, l, c+t1)
	str.RemSpaces(&name)
	if str.Contains(name, '.', &p) {
		name = str.Part(name, 0, p)
	}
	filename := name + ptSuffix
	a := files.NumPred(hasSuffix)
	if a > 0 {
		var d uint
		switch kbd.LastCommand(&d) {
		case kbd.Esc:
			return "", "" // str.Clr (n), ""
		case kbd.Enter:
			// entered
		case kbd.LookFor:
			i := uint(0)
			select_(aus, a, a, n, &i, l, c+t1, b, f)
			if i == a {
				return "", "" // str.Clr (n), ""
			} else {
				str.Set(&filename, files.NamePred(hasSuffix, i))
			}
		}
	}
	errh.DelHint()
	str.RemSpaces(&filename)
	if str.Contains(filename, '.', &p) {
		name = str.Part(filename, 0, p)
	}
	scr.Restore(l, c, t1+n, 1)
	return name, filename
}
Ejemplo n.º 5
0
func New(s string) *Imp {
	//
	x := new(Imp)
	str.Set(&x.text, s)
	x.text += " "
	str.Norm(&x.text, scr.NColumns())
	x.isMenu = true
	x.execute = Null
	return x
}
Ejemplo n.º 6
0
func init() {
	//
	h := [...]string{"Start/Ziel auswählen: linke Maustaste   ",
		"                                        ",
		"      größer/kleiner: Eingabe-/Rücktaste",
		"         verschieben: rechte Maustaste  ",
		"                      oder Pfeiltasten  ",
		"                                        ",
		"    Programm beenden: Esc               "}
	help = make([]string, len(h))
	for i, l := range h {
		str.Set(&help[i], l)
	}
	netzAufbauen()
	//  netz.Set (gra.Breadth); netz.Install (wr, wr3)
}
Ejemplo n.º 7
0
func init() {
	//
	h := [...]string{"        neue Ecke: linke Maustaste              ",
		" Ecke verschieben: rechte Maustaste             ",
		"  Ecken verbinden: mittlere Maustaste           ",
		"                                                ",
		"Eckennamen ändern: Vorwahl- und linke Maustaste ",
		"     Ecke löschen: Vorwahl- und rechte Maustaste",
		" Graph ausdrucken: Drucktaste                   ",
		"                                                ",
		"(Vorwahltaste = Umschalt-, Strg- oder Alt-Taste)",
		"                                                ",
		"             Done: Abbruchtaste (Esc)           "}
	help = make([]string, len(h))
	for i, l := range h {
		str.Set(&help[i], l)
	}
	//  scr.Fullscreen ()
	//  scr.Switch (scr.WVGApp)
	//  ker.InstallTerm (Terminate) // goes not :-(
}
Ejemplo n.º 8
0
func New(t byte, s [NFormats][]string) *Imp {
	//
	x := new(Imp)
	x.typ, x.s = t, s
	x.num = uint(len(s[Short]))
	m := [NFormats]uint{uint(0), uint(0)}
	for f := Short; f < NFormats; f++ {
		for i, t := range s[f] {
			str.Set(&s[f][i], t)
			w := uint(len(s[f][i]))
			if m[f] < w {
				m[f] = w
			}
		}
		for i, _ := range s[f] {
			str.Norm(&s[f][i], m[f])
		} // TODO gefährlich
	}
	x.wd = m
	x.cF, x.cB = col.ScreenF, col.ScreenB
	x.f = Short
	return x
}
Ejemplo n.º 9
0
func init() {
	//           1         2         3         4         5         6         7         8         9
	// 012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345
	lic := [...]string{
		" Die Quellen von murus sind lediglich zum Einsatz in der Lehre konstruiert und haben demzufolge ",
		" einen rein akademischen Charakter; sie liefern u.a. eine Reihe von Beispielen für das Lehrbuch ",
		" \"Nichtsequentielle Programmierung mit Go 1 kompakt\" (Springer, 2. Aufl. 2012, 223 S. 14 Abb.). ",
		" Für Lehrzwecke an Universitäten und in Schulen sind die Quelltexte uneingeschränkt verwendbar; ",
		" jegliche Form weitergehender (insbesondere kommerzieller) Nutzung ist jedoch strikt untersagt. ",
		" Davon abweichende Bedingungen sind der schriftlichen Vereinbarung mit dem Urheber vorbehalten. ",
		"                                                                                                ",
		" THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND THE CONTRIBUTORS \"AS IS\" AND ANY EXPRESS ",
		" OR IMPLIED WARRANTIES, INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY ",
		" AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR ",
		" ANY CONTRIBUTOR BE LIABLE  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSE- ",
		" QUENTIAL DAMAGES  (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; ",
		" LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)  HOWEVER CAUSED  AND ON ANY THEORY OF ",
		" LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT  (INCLUDING NEGLIGENCE OR OTHERWISE) ",
		" ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH ",
		" DAMAGE. APART FROM THIS THE TEXT IN GERMAN ABOVE AND BELOW IS A MANDATORY PART OF THE LICENSE. ",
		"                                                                                                ",
		" Die Quelltexte von murus sind mit größter Sorgfalt entwickelt und werden laufend überarbeitet. ",
		" ABER: Es gibt keine Software ohne Bugs - auch in DIESEN Quelltexten stecken sicherlich Fehler. ",
		" Ihre Verwendung in Programmen könnte zu SCHÄDEN führen, z. B. zur Inbrandsetzung von Rechnern, ",
		" zur Entgleisung von Eisenbahnzügen, zum GAU in Atomkraftwerken oder zum Absturz des Mondes ... ",
		" Deshalb wird vor der Einbindung irgendwelcher Quelltexte von murus in Programme zu ernsthaften ",
		" Zwecken AUSDRÜCKLICH GEWARNT ! (Ausgenommen sind nur Demo-Programme zum Einsatz in der Lehre.) ",
		"                                                                                                ",
		" Meldungen entdeckter Fehler und Hinweise auf Unklarheiten werden jederzeit dankbar angenommen. "}
	license = make([]string, len(lic))
	for i, l := range lic {
		str.Set(&license[i], l)
	}

	hintbox.Colours(col.HintF, col.HintB)
	errorbox.Colours(col.ErrorF, col.ErrorB)
	pre()
	post()
	//                                           1         2         3         4         5         6         7
	//                                 012345678901234567890123456789012345678901234567890123456789012345678901234567
	str.Set(&ToWait, "bitte warten ...")
	str.Set(&ToContinue, "weiter: Einter")
	str.Set(&ToContinueOrNot, "weiter: Einter                                                     fertig: Esc")
	str.Set(&ToCancel, "                                                                abbrechen: Esc")
	str.Set(&ToScroll, "blättern: Pfeiltasten                                           abbrechen: Esc")
	str.Set(&ToSelect, "blättern/auswählen/abbrechen: Pfeiltasten/Enter/Esc, Maus bewegen/links/rechts")
	str.Set(&ToChange, "blättern: Pfeiltasten       ändern: Enter       abbrechen: Esc")
	str.Set(&ToSwitch, "blättern: Pfeiltasten    auswählen: Enter    umschalten: Tab    abbrechen: Esc")
	str.Set(&ToSelectWithPrint, "blättern: Pfeiltasten    auswählen: Enter    drucken: Druck     abbrechen: Esc")
	str.Set(&ToPrint, "ausdrucken: Druck                                         fertig: andere Taste")
}
Ejemplo n.º 10
0
func main() {
	//
	h := [...]string{
		// 0         1         2         3         4         5         6         7
		// 012345678901234567890123456789012345678901234567890123456789012345678901234567
		"   Art (Farbe) für neue Figur auswählen: (Umschalt- +) Leer- oder Rolltaste   ",
		//  "                 Schriftgröße auswählen: Alt- + Leer- oder Rolltaste          ",
		"                    neue Figur erzeugen: linke Maustaste,                     ",
		"                                         Streckenzüge, Polygone und Kurven    ",
		"                                         mit rechter Maustaste abschließen,   ",
		"                                         Texteingabe mit Eingabetaste beenden ",
		"                           Figur ändern: Alt- + linke Maustaste, die 'Punkte' ",
		"                                         mit rechter Maustaste verschieben,   ",
		"                                         mit linker Maustaste abschließen     ",
		"                           Figur färben: Umschalt-, Alt- + linke Maustaste    ",
		"             (alle) Figur(en) markieren: (Umschalt- +) F5-Taste oder          ",
		"                                         (Alt- +) mittlere Maustaste          ",
		"          (alle) Figur(en) entmarkieren: (Umschalt- +) F6-Taste oder          ",
		"                                         Umschalt- + (Alt- +) mittl. Maustaste",
		"           markierte Figur(en) kopieren: Umschalt- + linke Maustaste          ",
		"      (markierte) Figur(en) verschieben: (Umschalt- +) rechte Maustaste       ",
		"          (markierte) Figur(en) löschen: (Umschalt- +) Entfernungtaste oder   ",
		"                                         (Umschalt-,) Alt- + rechte Maustaste ",
		"     letzte gelöschte Figur zurückholen: Rücktaste (<-)                       ",
		"          letzte erzeugte Figur löschen: Umschalt- + Rücktaste (<-)           ",
		"letzte gelöschte mark. Fig. zurückholen: Alt- + Rücktaste (<-)                ",
		"Hintergrundfarbe umschalten (auswählen): (Umschalt- +) F4-Taste               ",
		" Figuren aus eBoard holen und markieren: F7-Taste                             ",
		"    markierte Figuren in eBoard ablegen: F8-Taste                             ",
		"                      eBoard ausdrucken: Drucktaste                           ",
		"                           ePen beenden: Abbruchtaste (Esc)                   ",
		"                                                                              ",
		"                  Steuerungstaste (Strg) wirkt wie Umschalttaste              "}
	help := make([]string, len(h))
	for i := 0; i < len(h); i++ {
		str.Set(&help[i], h[i])
	}
	scr.Switch(scr.SXGA)
	actColour = col.ScreenF
	paperColour = col.ScreenB
	//  fo = scr.Normal
	figure = fig2.New()
	newFigure := fig2.New()
	newFigure.SetColour(actColour)
	figures, copiedFigures, image = seq.New(newFigure), seq.New(newFigure), seq.New(newFigure)
	cuttedFigures, depot = seq.New(newFigure), seq.New(newFigure)
	stack = stk.New(newFigure)
	name, filename := names()
	if filename == "" {
		return
	}
	origname := filename
	load(figures, filename)
	//  extract (paperColour)
	write()
	var x0, y0 int // kbd.Push
	var movable bool
	var Schub int
loop:
	for {
		scr.MouseCursor(true)
		//    control(); write()
		c, cmd, d := kbd.Read()
		if cmd == kbd.None {
			switch c {
			case ' ':
				cmd = kbd.Roll
			}
		}
		xm, ym := scr.MousePosGr()
		switch d {
		case 0:
			Schub = 8
		case 1:
			Schub = int(scr.NY() / 40)
		default:
			Schub = int(scr.NX() / 8)
		}
		switch cmd {
		case kbd.Esc:
			break loop
		case kbd.Enter:
			// actualize ?
		case kbd.Back:
			switch d {
			case 0:
				ins(top())
			case 1:
				delLast()
			default:
				getMarked()
			}
		case kbd.Left:
			kick(spc.Right, Schub)
		case kbd.Right:
			Schub = -Schub
			kick(spc.Right, Schub)
		case kbd.Up:
			kick(spc.Top, Schub)
		case kbd.Down:
			Schub = -Schub
			kick(spc.Top, Schub)
		case kbd.Del:
			switch d {
			case 0:
				if deleted(xm, ym) {
					push()
				}
			default:
				delMarked()
			}
		case kbd.Tab:
			// free for use
		case kbd.Help:
			scr.SwitchFontsize(font.Normal)
			errh.WriteHelp(help)
		case kbd.LookFor:
			// wird für die Auswahl des eBoards verwendet - NEIN, sondern:
			load(figures, filename)
			write()
		case kbd.Act:
			//      inject (paperColour)
			store(figures, filename)
		case kbd.Cfg:
			paperColour = sel.Colour()
			bgColour(paperColour)
		case kbd.Mark:
			switch d {
			case 0:
				mark(xm, ym, true)
			case 1:
				markAll(true)
			default:
				showMarked()
			}
		case kbd.Demark:
			switch d {
			case 0:
				mark(xm, ym, false)
			case 1:
				markAll(false)
			default:
				showMarked()
			}
		case kbd.Deposit:
			writeMarked()
		case kbd.Paste:
			readMarked()
		case kbd.PrintScr:
			print(name)
		case kbd.Roll:
			switch d {
			case 0:
				newFigure.Select()
			case 1:
				actColour = sel.Colour()
				newFigure.SetColour(actColour)
			case 2:
				scr.SwitchFontsize(font.Normal)
				//        fo = sel.Size (actColour)
				//        newFigure.SetFont (fo)
			}
		case kbd.Here:
			switch d {
			case 0:
				generate(newFigure)
			case 1:
				copyMarked()
			case 2:
				change(xm, ym)
			case 3:
				setColours(xm, ym, actColour)
			}
		case kbd.There:
			movable = underMouse(uint(xm), uint(ym)) && d <= 1
			x0, y0 = xm, ym // kbd.Push
			switch d {
			case 0:
				if movable {
					cut(xm, ym)
				}
			case 1:
				if movable {
					cutMarked()
				}
			case 2:
				if deleted(xm, ym) {
					push()
				}
			default:
				delMarked()
				write()
			}
		case kbd.Push:
			if movable {
				switch d {
				case 0:
					move(xm-x0, ym-y0)
				case 1:
					moveMarked(xm-x0, ym-y0)
				}
				x0, y0 = scr.MousePosGr()
			}
		case kbd.Thither:
			if movable {
				switch d {
				case 0:
					join()
				case 1:
					joinMarked()
				}
			}
		case kbd.This:
			switch d {
			case 0:
				mark(xm, ym, true)
			case 1:
				mark(xm, ym, false)
			case 2:
				markAll(true)
			case 3:
				markAll(false)
			}
			invMarked()
		case kbd.Thus:
			invMarked()
		}
	}
	markAll(false)
	_, filename = names()
	if filename == "" {
		filename = origname
	}
	//  inject (paperColour)
	store(figures, filename) // -> Terminieren
	ker.Terminate()
}