@jtschosch
Zugegeben ich war gestern mies drauf, aber deine Art und Weise Informationen einzuholen ist unter aller Sau. Du machst dir nicht mal die Mühe nach zu denken was ich gemeint haben könnte, aber forderst dies ständig von den anderen und mir. Zum Teil ignorierst du Beiträge bzw. verstehst nicht was darin steht. Letzteres ist kein Beinbruch, aber dann musst du uns erklären was du nicht verstanden hast, sonst können wir dir dort nicht helfen. Du machst immer nur einen neuen Thread und postest einen Programmcode der vor drei Posts schonmal zerlegt wurde und dir gesagt wurde welche Stellen verbessert werden müssten.
Das alles ist für mich und warscheinlich für die meisten anderen im Forum sehr frustrierend, weil es so wirkt als würdest du dein Programm aus unseren Snippets zusammen wurschteln. So geht das einfach nicht.
Aber heute habe ich einen guten Tag, also erklär ich mal ein bisschen was und ich hoffe du wirst dich endlich mal am Riemen reißen und zumindest ordentlich formulierte Fragen stellen, in welchen man nicht rätseln muss was du eventuell meinen könntest.
Also noch mal zu deinem Programm. Du möchtest Notizen auf dem Desktop hinterlegen, richtig?
Dann stellen sich zunächst folgende Probleme:
- Die Transparenz, wenn du so etwas machen willst dann lohnt sich nur eine Halbtransparenz, denn erstens ist ein reiner Text auf dem Desktop ziemlich schwer erkennbar wenn man keinen einfarbigen Hintergrund hat und zweitens ist die "transparentcolor" nicht OS unabhängig. Also könnte man ein "alpha"-Attribute setzen, dieses wäre nämlich OS unabhäging. Zumindest fliegt einem keine Exception um die Ohren, sondern es wird höchstens einfach nicht durchsichtig. Das könnte man dann mal ermitteln und für die Systeme wo das nicht funktioniert die Funktion entfernen und bei den anderen einfach als Feature nutzen. - Ganz ehrlich das ist eine Nebensächlichkeit die meistens einfach nur Zeit frisst und im normal Fall einfach Außeracht gelassen werden kann.
- Die Positionierung der Notizen, niemand möchte nur eine Notiz in der Mitte seines Desktops haben. Das geht einfach nicht, so kann man die weder lesen noch verwalten, wenn ich sowas haben möchte dann öffne ich mir einen Editor stell zentrierten Text ein und minimiere den. Was man braucht ist also eine Möglichkeit jede Notiz selbständig auf dem Schwarzen Brett(Desktop) bewegen zu können.
- Verstecken/Verkleinern, wenn man ein Symbol auf dem Destop anklicken möchte ist es für mich nicht besonders praktisch wenn da zwei große 'R's drüberstehen, die Notizen zu verschieben mildert diesen Schmerz auch nur geringfügig. Bei fünf oder mehr Notizen wird das sehr unübersichtlich, also braucht man eine Option die Notizen zusammen klappen lässt. Dann natürlich auch noch eine Option diese wieder auszuklappen.
- Die Konfiguration, niemand möchte bei Notizen lange editieren, das wäre das direkte Gegenteil einer Notiz, oder. Man möchte diese kurz schreiben ablegen und diese dann hinundwieder mal sehen oder besser sogar noch benachrichtigt werden. Bei deinem Konfigurationsprogramm bietet sich mir da schon auf den ersten Klick eine starke Blockade, ich muss ein Programm öffnen um eine Notiz zu konfigurienen?! Was ist wenn ich mehrere Notizen habe, brauche ich dann für jede ein eigenes Programm oder muss ich mir erst noch aus den ganzen IDs das richtige Fenster suchen? Das macht es einem nicht gerade leicht einen Einstieg zu finden, egal wie hübsch die editier Möglichkeiten auch sein mögen.
Alles verläuft auf einen Punkt du brauchst ein Menü in welchem du diese Einstellungen für jede Notiz schnell treffen kannst ohne erst über mehrere Programme gehen zu müssen.
Das erste was du brauchst sind die Daten einer Notiz schön kompakt so das man sie in einem Konfigurationsmenü bearbeiten kann. Das einfachste wäre also zunächst die benötigten Daten zusammen zufassen.
1. Der Text der Notiz. Später dann auch noch die Tags, aber das sollte erstmal keine Rolle spielen.
2. Eine Kurzinformation wäre nicht schlecht, wenn man eine Notiz zusammen klappt.
3. Die Positionen(x, y) auf dem Schwarzen Brett wo die Notiz angeheftet werden soll.
4. Die Größe der Notiz, also wie viel Platz sie auf dem Desktop einnehmen darf.
5. Ob die Notiz eingeklappt ist oder nicht.
6. Als Bonus wie stark die Transparenz sein soll.
Daraus ergibt sich also folgende Strucktur:
Code: Alles auswählen
class NoticeData(object):
def __init__(self, info, text=""):
self.info = info
self.text = text
self.x = 0
self.y = 0
# Größe in Zeilen und Spalten
self.width = 80
self.height = 25
self.alpha = 0.7
self.hide = True
So haben wir ein Objekt was man überall verwenden und später auch Problemlos speichern kann.
Als nächstes sollte dir klar sein das du viel mit Toplevel-Widgets arbeiten musst und deren Positionierung nicht gerade pythonisch ist. Legen ich mir schnell diese vier Funktionen an:
Code: Alles auswählen
def set_position(toplevel, x, y):
toplevel.geometry("+{0}+{1}".format(x, y))
def set_size(toplevel, width, height):
toplevel.geometry("{0}x{1}".format(width, height))
def set_geometry(toplevel, x, y, width, height):
toplevel.geometry("{0}x{1}+{2}+{3}".format(width, height, x, y))
def get_position(toplevel):
geometry = toplevel.geometry()
_, x, y = geometry.split("+")
return int(x), int(y)
Zu beachten ist hierbei das man die Größe nicht mehr ohne weiteres zurück erhalten kann.
Dann sollten man ein Toplevel-Widget pro Notiz haben welches immer das kleine Menü und die Notiz enthält. Übergeben tun wir diesem dann eine Instanz von 'NoticeData', damit es die Einstellungen die dort getroffen wurden nutzen kann.
Code: Alles auswählen
class NoticeWidget(tk.Toplevel):
def __init__(self, master, data, cnf={}, **kwargs):
tk.Toplevel.__init__(self, master, cnf, **kwargs)
self.overrideredirect(True)
set_position(self, data.x, data.y)
self.attributes("-alpha", data.alpha)
self.notice = Notice(self, data)
self.notice.pack(fill="both", side="right")
self.menu = Menu(self, self.notice)
self.menu.pack(expand=True, fill="y", side="left")
Als nächstes sollte man sich überlegen wie 'Notice' am besten aussehen sollte. Ich würde ohne groß zu zögern ein Text-Widget nehmen, da eine Notiz nichts anderes ist als ein Text. Man könnte auch direkt ein Text-Widget setzen aber eine Ableitung kann man sich noch etwas schöner anpassen. Dort könnte man dann später ein einfacheres System für die Tags einfallen lassen z.B. ähnlich dem BBCode.
Code: Alles auswählen
class Notice(tk.Text):
def __init__(self, master, data, cnf={}, **kwargs):
cnf.update({"width":data.width, "height":data.height})
tk.Text.__init__(self, master, cnf, **kwargs)
self.data = data
self.update()
def update(self):
self.config(state="normal")
self.delete("0.0", "end")
self.insert("0.0", self.data.text)
self.config(state="disabled")
Der nächste Punkt wäre dann das Menü, hier würde ich zunächst einige schwächen von Tkinter umgehen und dieses links vom Text platzieren und vertikal ausrichten. So das man die Optionen schön einsehen kann. X = Positionierung, Y = Konfiguration, Z = Ein/Ausklappen und die rechte Seite wird ist eine Instanz von 'Notice'
Code: Alles auswählen
|-|--------------------|
|X| Notiz |
|Y| Notiz |
|Z| Notiz |
|-|--------------------|
Für X nehmen ich den Gripper den ich dir schon geschrieben hatte und erweitere diesen noch um ein Raster, damit man die Notizen später ausrichten kann. Denn für Leute wie mich, ist es unerträglich wenn irgendwas nicht gerade ist
und auf einem Pixel genau will keiner etwas ausrichten müssen. Kannst das ja mal versuchen, macht keinen Spaß.
Code: Alles auswählen
class Gripper(tk.Label):
GRID_SIZE = GRID_X, GRID_Y = 10, 10
def __init__(self, master, toplevel=None, cnf={}, **kwargs):
tk.Label.__init__(self, master, cnf, **kwargs)
self.toplevel = toplevel if toplevel else master
self.bind("<B1-Motion>", self._drag)
def _drag(self, event):
x, y = self.align(event.x_root, event.y_root)
set_position(self.toplevel, x, y)
def align(self, x, y):
return x - (x % self.GRID_X), y - (y % self.GRID_Y)
Für Y habe ich mir nur ein kleines Toplevel gebaut was noch nichts bewirkt das soll nur verdeutlichen wo man ansetzen kann.
Code: Alles auswählen
class Config(tk.Toplevel):
def __init__(self, noticedata, cnf={}, **kwargs):
tk.Toplevel.__init__(self, cnf, **kwargs)
self.noticedata = noticedata
lb = tk.Label(self)
lb.config(text="Dies durch dein Konfigurations-Fenster ersetzen.")
lb.pack()
So Z, wird direkt im Menü gebastelt, ein einfacher Button der das 'Notice'-Text-Widget ein- bzw. ausklappen lässt.
Jetzt bring ich das ganze auf einem Menü-Widget zusammen:
Code: Alles auswählen
class Menu(tk.Frame):
def __init__(self, master, notice, cnf={}, **kwargs):
tk.Frame.__init__(self, master, cnf, **kwargs)
self.notice = notice
self._hide = False
look = {"relief":"flat"}
self.gripper = Gripper(self, master, look, text=u"✥")
self.gripper.pack(expand=True, fill="both")
cmd = partial(Config, notice.data)
self.config = tk.Button(self, look, text="⚒", command=cmd)
self.config.pack(expand=True, fill="both")
self.hide = tk.Button(self, look, text="✗", command=self._switch)
self.hide.pack(expand=True, fill="both")
if notice.data.hide:
self._switch()
Es wird auf dem Menü der Greifer erzeugt und das 'master'-Toplevel-Widget übergeben und ist sofort Einsatzfähig, hier brauche ich nichts mehr zu machen. Als zweites wird die Erzeugung eines Konfigurationsfenster als Kommando dem Button übergeben. Wenn dieser nun gedrückt wird ein neues Fenster erzeugt mit den entsprechenden Daten. Als drittes wird der Button zum ein-/ausklappen erstellt. Dieser erhält ein Funktion '_switch' welche anhand des '_hide'-Attributes entweder das Fenster ein- oder ausklappt.
Code: Alles auswählen
def _switch(self):
self.show_notice() if self._hide else self.hide_notice()
def show_notice(self):
self._hide = False
self.notice.pack()
self.hide.config(text="✗")
def hide_notice(self):
self._hide = True
self.notice.pack_forget()
self.hide.config(text="⇒")
Das sieht doch schonmal gut aus, jetzt möchte ich das noch etwas aufhübschen durch einen netten Scroll-Effekt. Dazu kann man die 'after'-Methode von Tkinter nutzern. Da ein solcher Effekt etwas Zeit braucht und ein paar Information lege ich zunächst vier zusätzliche Variablen für das Menü an. Die Konstanten DELAY und STEPS, welche dafür zuständig sind in welchem Abstand und um wie viel jedes mal verkleinert bzw. vergrößert werden soll. Danach noch die Variable '_width' welche die ursprüngliche Breite darstellt und '_grab', denn wie ich schon sagte braucht eine solche Animation etwas Zeit, also darf ich solange die Animation läuft keine weitern Events zulassen. Nun baue ich die zwei Methoden um und ergänze die Animationen:
Code: Alles auswählen
def fold_up(self, x):
if x >= self.STEPS:
self.after(self.DELAY, self.fold_up, x - self.STEPS)
self.notice.config(width=x)
else:
self.notice.pack_forget()
self._grab = False
def fold_out(self, x):
if x <= self._width:
self.after(self.DELAY, self.fold_out, x + self.STEPS)
self.notice.config(width=x)
else:
self._grab = False
def show_notice(self):
if self._grab:
return
self._grab = True
self._hide = False
self.notice.pack()
self.fold_out(0)
self.hide.config(text="✗")
def hide_notice(self):
if self._grab:
return
self._grab = True
self._hide = True
self._width = self.notice.cget("width")
self.fold_up(self._width)
self.hide.config(text="⇒")
Das war es auch schon (bis auf die Konfiguration) jetzt kann man das ganze z.B. so aufrufen:
Code: Alles auswählen
if __name__ == "__main__":
loremipsum = 2*"""Lorem ipsum dolor sit amet, consetetur sadipscing elitr,
sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat,
sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum.
Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit
amet."""
root = tk.Tk()
root.overrideredirect(True)
close = tk.Button(root, text="Schließen", command=root.destroy)
close.pack(side="right")
notice1 = NoticeData("Lorem ipsum", loremipsum)
notice1.x = 200
notice1.y = 200
notice1.height = 5
notice1.hide = False
nw1 = NoticeWidget(root, notice1)
root.mainloop()
Man bräuchte jetzt noch ein kleines Menü am Rand oder in der Task/Panel/Tool/...-Leiste um Notizen hinzuzufügen, kopieren, ... oder zu löschen.
Das wäre zumindest mein Ansatz. Hier nochmal der gesamte
Quellcode.
