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