Esempio n. 1
0
func gew() bool {
	//
	var dummy *bahnhof.Imp
	for {
		//    ok:= false
		c, _ := kbd.Command()
		scr.MouseCursor(true)
		switch c {
		case kbd.Esc:
			return false
		case kbd.Enter, kbd.Back, kbd.Left, kbd.Right, kbd.Up, kbd.Down:
			dummy.SkalaEditieren()
			write(false)
		case kbd.Help:
			errh.WriteHelp(help)
		case kbd.Hither:
			if netz.ExPred(func(a Any) bool { return a.(*bahnhof.Imp).UnterMaus() }) {
				return true
			}
		case kbd.There, kbd.Push, kbd.Thither:
			dummy.SkalaEditieren()
			write(false)
			/*
			   case kbd.This:
			     ok = netz.ExPred (func (a Any) bool { return a.(*bahnhof.Imp).UnterMaus() })
			   case kbd.Push:
			     x, y:= scr.MousePosGr ()
			     if ok {
			       bhf:= netz.Get ().(*bahnhof.Imp)
			       bhf.Rescale (uint(x), uint(y))
			       netz.Put (bhf)
			       write (false)
			     }
			*/
		case kbd.PrintScr:
			errh.DelHint()
			img.Print1()
		}
	}
	return false
}
Esempio n. 2
0
func (w *Imp) Edit(l, c uint) { // l, c: fake
	//
	s := w.spec[w.line][w.column]
	sa := s
	y, x := scr.MousePos()
	ya, xa := y, x
loop:
	for {
		s.Write(y0+w.line, 2*w.column)
		ya, xa = y, x
		sa = s
		c, _ := kbd.Command()
		y, x = scr.MousePos()
		if y0 <= y && y < ny+y0 && x < 2*nx {
			w.line, w.column = y-y0, x/2
			s = w.spec[w.line][w.column]
		}
		if ya >= y0 {
			sa.Mark(false)
			sa.Write(ya, 2*(xa/2))
		}
		switch c {
		case kbd.Esc:
			break loop
		case kbd.Enter:
			w.modify()
			w.Write(0, 0)
		case kbd.Help:
			errh.WriteHelp(help[:])
		case kbd.Here:
			s.Inc()
		case kbd.There:
			s.Dec()
		}
		s.Mark(true)
		w.writeNumbers()
	}
	w.terminate()
}
Esempio n. 3
0
func Edit() {
	//
	Write()
	errh.Hint("Graph editieren: Hilfe per F1, fertig: Abbruchtaste (Esc)")
	scr.MouseCursor(true)
loop:
	for {
		K, i := kbd.Command()
		//    errh.DelHint()
		switch K {
		case kbd.Esc:
			break loop
		case kbd.Help:
			errh.WriteHelp(help)
		case kbd.Here: // neue Ecke oder Namen vorhandener Ecke ändern:
			if Graph.ExPred(node.UnderMouse) {
				if i > 0 {
					Ecke = Graph.Get().(*node.Imp) // aktuell: Ecke
					Ecke.Edit()
					Graph.Put(Ecke)
				}
			} else {
				Ecke.Clr()
				Ecke.Locate()
				Ecke.Write(true, true)
				Ecke.Edit()
				Graph.Ins(Ecke)
			}
		case kbd.Del: // Ecke entfernen
			if Graph.ExPred(node.UnderMouse) {
				wr(false, false)
				Graph.Del()
			}
		case kbd.There: // Ecke verschieben
			switch i {
			case 0:
				if Graph.ExPred(node.UnderMouse) {
					wr(false, false)
					wr(false, true)
				loop1:
					for {
						geschoben := false
						kk, _ := kbd.Command()
						switch kk {
						case kbd.Push:
							geschoben = true
							wr(false, true)
							Ecke = Graph.Get().(*node.Imp)
							Ecke.Locate()
							Graph.Put(Ecke)
							wr(false, true)
						case kbd.Thither:
							wr(false, true)
							if geschoben {
								Graph.Put(Ecke)
							}
							wr(true, false)
							break loop1
						}
					}
				}
			default: // Ecke entfernen
				if Graph.ExPred(node.UnderMouse) {
					wr(false, false)
					Graph.Del()
				}
			}
		case kbd.This: // Ecken verbinden / Kante entfernen:
			x0, y0 := scr.MousePosGr()
			x, y := x0, y0
			if Graph.ExPred(node.UnderMouse) {
				Ecke = Graph.Get().(*node.Imp) // Ecke aktuell
				Graph.Position(true)           // Ecke auch postaktuell
			loop2:
				for {
					kk, _ := kbd.Command()
					switch kk {
					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)
						if Graph.ExPred(node.UnderMouse) {
							Ecke1 = Graph.Get().(*node.Imp) // Ecke1 aktuell
							g := Graph.Directed()
							if g {
								Kante.Write(Ecke, Ecke1, g, false, false)
							}
							Kante.Edit(Ecke, Ecke1, g)
							Graph.Edge1(Kante)
							if Kante.Val() == 0 {
								Kante.Write(Ecke, Ecke1, g, false, false)
								Graph.Del1()
							}
						}
						break loop2
					}
				}
			}
		case kbd.PrintScr:
			//      img.Write (".tmp.Graph", 0, 0, scr.NX(), scr.NY())
			//      img.Print()
		}
	}
	errh.DelHint()
}
Esempio n. 4
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
}
Esempio n. 5
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()
}
Esempio n. 6
0
func editiert() bool {
	//
	scr.Cls()
	l0, c0 = 0, 0
	dc = 0
	switch period {
	case day.Decadic:
		actualDay.SetFormat(day.Yyyy)
		actualDay.SetColours(day.YearnumberF, day.YearnumberB)
	case day.Yearly:

	case day.HalfYearly, day.Quarterly:
		ker.Stop("termin.main", 1)
	case day.Monthly:
		l0, c0 = 3, 5
		dc = 12 // 11 dayattr + 1
		actualDay.SetAttribute(setWeekdayColours)
		actualDay.SetFormat(day.Wd)
		actualDay.WriteWeek(true, 3, l0, 2)
		actualDay.WriteWeek(true, 3, l0, 2+6*dc+3)
	case day.Weekly:
		l0, c0 = 2, 2
		dc = 11 // 7 x 11 == 77 < 80
		actualDay.SetAttribute(setWeekdayColours)
		actualDay.SetFormat(day.Wd)
		actualDay.WriteWeek(false, dc, l0, c0)
	case day.Daily:
		cal.Edit(actualDay, l0, c0)
	}
	switch period {
	case day.Weekly, day.Monthly, day.Quarterly, day.Yearly:
		dayattr.WriteActual(l1, c1)
	}
	var startDate = day.New()
	var Original = day.New()
loop:
	for {
		switch period {
		case day.Yearly:
			actualDay.SetFormat(day.Dd)
		case day.Quarterly, day.HalfYearly:
			errh.Error("nicht erreichbarer Punkt", 3)
		case day.Weekly, day.Monthly:
			actualDay.SetFormat(day.Dd_mm_)
		}
		if !actualDay.Equiv(startDate, period) {
			//      clearAll (startDate) // alte Zusatzinformationen löschen
			startDate.Copy(actualDay)
			switch period {
			case day.Yearly:
				dayattr.WriteActual(l1, c1)
				actualDay.SetFormat(day.Dd)
			case day.Monthly, day.Weekly:
				if period == day.Monthly {
					actualDay.SetColours(day.MonthF, day.MonthB)
				} else {
					actualDay.SetColours(day.WeekdayNameF, day.WeekdayNameB)
				}
				actualDay.SetFormat(day.Yyyy)
				actualDay.SetColours(day.YearnumberF, day.YearnumberB)
				actualDay.Write(0, 0)
				actualDay.Write(0, 80-4)
				if period == day.Monthly {
					actualDay.SetFormat(day.M)
				} else {
					actualDay.SetFormat(day.WN)
				}
				actualDay.SetColours(day.MonthF, day.MonthB)
				actualDay.Write(0, 30)
				actualDay.SetFormat(day.Dd_mm_)
			}
			actualDay.SetAttribute(dayattr.Attrib)
			write()
			writeAll(actualDay)
		}
		l, c := pos(actualDay)
		dayattr.Attrib(actualDay)
		Original.Copy(actualDay)
		switch period {
		case day.Daily:

		case day.Weekly:
			actualDay.Edit(l0+l, c0+c+3)
		case day.Monthly, day.Quarterly, day.HalfYearly, day.Yearly:
			actualDay.Edit(l0+l, c0+c)
		case day.Decadic:
			actualDay.Edit(0, 0)
		}
		if actualDay.Empty() {
			actualDay.Copy(Original)
		}
		var d uint
		C := kbd.LastCommand(&d)
		//    actualDay.Write (l0 + l, c0 + c)
		switch C {
		case kbd.Enter:
			for {
				if period == day.Daily {
					return false
				} else {
					period--
					if period == day.HalfYearly {
						period--
					}
					if period == day.Quarterly {
						period--
					}
				}
				if d == 0 {
					return false
				} else {
					d--
				}
			}
		case kbd.Esc, kbd.Back:
			for {
				if period == day.Decadic {
					break loop
				} else {
					period++
					if period == day.Quarterly {
						period++
					}
					if period == day.HalfYearly {
						period++
					}
				}
				if d == 0 {
					return false
				} else {
					d--
				}
			}
		case kbd.Tab:
			dayattr.Change(d == 0)
			write()
			dayattr.WriteActual(l1, c1)
			C = kbd.Enter // see above
		case kbd.Help:
			errh.WriteHelp(help)
		case kbd.LookFor:
			dayattr.Normalize()
			dayattr.WriteActual(l1, c1)
			cal.EditWord(l1, c1+1+8)
			dayattr.Clr()
			cal.LookFor(func(a Any) { dayattr.Actualize(a.(*day.Imp), true) })
			write()
			if period == day.Weekly {
				writeAll(actualDay)
			}
			C = kbd.Enter // so "actualDay" is not influenced
		case kbd.Mark, kbd.Demark:
			dayattr.Actualize(actualDay, C == kbd.Mark)
			dayattr.Attrib(actualDay)
			actualDay.Write(l0+l, c0+c)
			C = kbd.Down
		case kbd.PrintScr: // TODO Zusatzinformationen
			switch period {
			case day.Yearly:
				actualDay.PrintYear(0, 0)
				prt.GoPrint()
				/*
				   case day.Monthly:
				     actualDay.PrintMonth (true, 1, 3, dc, l0, c0)
				     prt.Printout()
				   case day.Daily:
				     cal.Print (0, 0)
				     prt.Printout()
				*/
			}
			/*  case kbd.Here: // , kbd.There, kbd.This:
			      switch period { case day.Yearly:
			        // day.mitMausImJahrAendern (actualDay)
			      case day.Monthly:
			        l0 = 3, c0 = 5; dc = 12
			//        day.mitMausImMonatAendern (actualDay, true, 1, 3, dc, l0, c0)
			      case day.Weekly:
			        l0 = 2, c0 = 2; dc = 11
			//        day.mitMausInWocheAendern (actualDay, false, dc, l0, c0)
			      } */
		default:
			if period == day.Decadic {
				if d == 0 {
					d = 3
				} else {
					d = 5
				}
			}
		}
		switch C {
		case kbd.Here, kbd.There, kbd.This:
			if period == day.Yearly {
				switch C {
				case kbd.Here:
					period = day.Monthly
				case kbd.There:
					period = day.Weekly
				case kbd.This:
					period = day.Daily
				}
				C = kbd.Enter
				return false
			}
		default:
			actualDay.Change(C, d)
		}
	}
	return true
}