Notizdeskv 0.1 ist da!

[jtschoch]

Hi
Habe ein Python Prog. geschrieben genaueres seht ihr hier

[gkuhl]

Erstmal kommt dort "Seite nicht gefunden" und dann kann man da eine "setup.exe" laden. Hier wird sich wohl kaum jemand finden, der so wahnsinnig ist und die Datei ausführt. Nebenbei läuft das mir unter Linux sowieso nicht.

Bewertung: ungenügend

Grüße
Gerrit

PS: Hab heute meine fiesen Tag.

[jtschoch]

besser - ist für Windows

[nomnom]

Das ist auch das falsche Unterforum dafür.

Off-topic: Der Link in deiner Signatur funktioniert sowieso nur für Leute in deinem LAN.

[Xynon1]

ich finde es selbt unter Windows grausam
man kann es nicht auf dem Desktop positionieren und schließen
geht auch nur über den Taskmanger und um das zu konfigurieren muss man auch noch ein zeites Programm öffnen
man könnte ja auch einfach einen kleinen Button hinmachen der dann die Kofiguration öffnet

[Xynon1]

ach und wegen der ganze Symbole hinten auf dem dekstop sehe ich natürlich nix
man kann ja nicht einstellen das die Notizen einen hintergrund haben

[numerix]

Wenn jtschoch die Posting-Frequenz und die Qualität seiner Postings so aufrechterhält, sollte man vielleicht ein Extra-Unterforum für ihn einrichten, bei dem die Beiträge nicht in "Beiträge der letzten 24 Stunden" erscheinen. Dann kann man sich wieder stärker auf die Threads konzentrieren, die man lesen möchte ...

[lunar]

@Xynon1: Hast Du das Programm wirklich ausgeführt?! Ziemlich gewagt angesichts dessen, was der OP so in seinen bisherigen Beiträgen gezeigt hat …

@numerix: +1

[Xynon1]

@lunar
Ja, in VitualBox mit einem WindowsXP - ich habe mir extra voher nochmal eine Kopie gezogen.

@numerix
+1

[jtschoch]

1. Habt ihr dem Button übersehen da steht Beenden drauf (siehe Bild auf der Webseite)
2. das ist Version 0.1 ich bin dabei das zu verbessern

also schreibt mir was ich verbessern soll!

[jtschoch]

Gefällt euch wenigstens der Editor dazu?

[Xynon1]

ähem ich rede von der notiz
keiner will seine Notizen oben in der mitte des bildschirmes habe und weder positionieren noch ausblenden können

sie dir mal an wie das mit den Icons auf dem desktop bei KDE gemacht wird

[jtschoch]

Und wie?

[EyDu]

Du könntest dir einfach Kubuntu runterladen.

[deets]

Bitte! Dann installiert er Linux, kommt nicht klar, und wir haben den Support-Salat...

[EyDu]

Ach, bis das WLAN läuft braucht er eine Woche

[Xynon1]

@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.

[jtschoch]

Ich habe auch Linux,
aber da kann ich keine Instalationsdatei erstellen

[jtschoch]

Danke werde mal sehen wie ich das ganze mit den anderen Funktionen einbinte

[numerix]

... 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.

Ich frage mich, wo du diese Hoffnung her nimmst. Ich kann mich an kein Posting von ihm erinnern (zugegeben, ich habe sie nicht alle gelesen - das ertrage ich einfach nicht), das auch nur einen kleinen Anlass zur Hoffnung gab, dass sich an seinem Verhalten hier im Forum irgendetwas ändern wird.

Deine Mühen in Ehren, aber ich fürchte, damit erreicht man eher das Gegenteil. Er erlebt doch gerade immer wieder, dass er mit seiner Art des Auftretens hier "Erfolg" hat (subjektiv aus seiner Sicht zumindest): Er wirft ein paar Wortfetzen hin, gelegentlich mit einem größeren Haufen schaurigem Quelltext angereichert, und kann sich fast sicher sein, dass sich andere die Mühe machen, herauszufinden, was er gemeint haben könnte und ihm lauter leckere Häppchen servieren, die er dann als Versatzstücke in sein Menü integriert, dass dadurch allerdings auch nicht genießbarer wird.

Naja, mir kann's ja egal sein. Ich muss einfach noch etwas konsequenter im Nichtlesen bestimmter Beiträge werden.
Aber wenigstens da habe ich die Hoffnung, dass sich da etwas zum Positiven entwickelt.