An Bildschirmgröße anpassen

[Jaga]

Hi zusammen,

wie kann ich mein Fenster an die Displaygröße anpassen? (damit es auf unterschiedlichen BIldschirmen immer gleich groß ist)

[snafu]

Mit welchem Toolkit erstellst du denn dein Fenster? Nebenbei sei bemerkt, dass man die Standard-Fenstergröße besser dem Window-Manager überlassen sollte, anstatt ihm dazwischen zu "pfuschen".

[Jaga]

Tkinter

[snafu]

Sorry, aber: http://lmgtfy.com/?q=tkinter+get+screen+size

[BlackJack]

@Jaga: Wie snafu schon gesagt hat möchte man so etwas gar nicht machen. Die verwendeten Layout-Manager entscheiden besser als der Programmierer wieviel Platz die jeweiligen Elemente benötigen. Das hängt ja zum Beispiel auch davon ab welche Schriftwart in welcher Grösse der Anwender in seinem System eingestellt hat. Wenn der Layoumanager alleine nicht ausreicht, überlässt man es dem Anwender das Fenster so gross oder klein zu ziehen wie er es gerne hätte. Wenn man ihn dabei unterstützen möchte, schreibt man Code der sich merkt wie gross die durch den Anwender veränderbaren Widgets beim Programmende waren und stellt diese Grösse beim erneuten Start wieder her.

@snafu: Ich glaube diese Google-Anfrage beantwortet die Frage nicht. Da bekomme ich zumindest nur die Information wieviele Pixel der Bildschirm breit und hoch ist, aber nicht wie gross das Display ist.

[snafu]

@BlackJack: Ich hatte die Frage so verstanden, dass sozusagen das Verhältnis zwischen Fenstergröße und Bildschirmgröße erhalten bleiben soll. Ein zehnmal so großer Bildschirm hätte dann ein zehnmal so großes Fenster. Wieso sollte man da denn nicht mit Pixeln als Maß arbeiten wollen? Oder willst du auf etwas anderes hinaus?

EDIT: Achso, du meintest die Größe der tatsächlich für Fenster nutzbaren Arbeitsfläche. Ja, stimmt. Dies wird da nicht beantwortet.

[BlackJack]

@snafu: Mit Pixeln möchte man nicht arbeiten weil heutzutage die Auflösungen, also wieviele Pixel letztlendlich wie viele Millimeter/Zentimeter/… ausmachen, sehr weit gestreut sind. Seit Apple mit den Retina-Displays angefangen hat, kann man zwischen zwei relativ aktuellen Displays locker einen Unterschied vom Faktor 2 haben. Und eine GUI die auf einem „normalen” Display in Pixeln gemessen entworfen wurde ist auf einem hochauflösendem Display in Zentimetern gemessen plötzlich nur noch halb so gross. Der Benutzer wird aber die Schriften im System so gross eingestellt haben, dass er sie lesen kann, was dann aber bedeutet, dass sie sehr wahrscheinlich nicht mehr ordentlich in die Pixelabmessungen der GUI passen.

[Jaga]

Das problem war oder ist immernoch dass auf meinem Bildschirm alles ganz normal dargestellt wird.
Auf den Schul-PCs ist allerdings nur ein Teil des Fensters dargestellt.
Wäre es eine Möglichkeit die Position des Fensters zu verändern?

[BlackJack]

@Jaga: Bist Du denn sicher, dass Du die Layout-Manager von Tk richtig benutzt und da keine Fehler gemacht hast?

[Jaga]

Ich denke schon.

Hier wäre mal meine Oberflächengeschichte:

Code: Alles auswählen

class App():

    def __init__(self, master, ):

        self.master = master
        master.protocol("WM_DELETE_WINDOW", self.ende)
        self.initUI()

    def ende(self):
        self.master.destroy()
        self.master.quit()

    def initUI(self):
        

        
        self.master.title("Funktionsplotter")

           
        
        
        self.label_funktion = Tkinter.Label(self.master, text = "Funktion: f(x)")
        self.label_funktion.grid(row = 0, column = 0)

        self.entry_funktion = Tkinter.Entry(self.master, width = 120)
        self.entry_funktion.grid(row = 0, column = 1)

        self.label_startwert = Tkinter.Label(self.master, text = "Startwert der Funktion:")
        self.label_startwert.grid(row = 2, column = 0)

        self.entry_startwert = Tkinter.Entry(self.master, width = 15)
        self.entry_startwert.grid(row = 2, column = 1)

        self.label_endwert = Tkinter.Label(self.master, text = "Endwert der Funktion:")
        self.label_endwert.grid(row = 3, column = 0)

        self.entry_endwert = Tkinter.Entry(self.master, width = 15)
        self.entry_endwert.grid(row = 3, column = 1)

        self.label_genauigkeit = Tkinter.Label(self.master, text = "Abstand zwischen zu berechnenden Punkten:")
        self.label_genauigkeit.grid(row = 4, column = 0)

        self.entry_genauigkeit = Tkinter.Entry(self.master, width = 15)
        self.entry_genauigkeit.grid(row = 4, column = 1)

        self.plot_button = Tkinter.Button(self.master, text = "Funktion plotten", command = self.plotten)
        self.plot_button.grid(row = 0, column = 4)

        self.hinzufueg_button = Tkinter.Button(self.master, text = "Zum Plot hinzufügen", command = self.hinzufuegen)
        self.hinzufueg_button.grid(row = 3, column = 4)

        self.tangenten_button = Tkinter.Button (self.master, text = "Tangente einzeichnen im Punkt:", command = self.tangente)
        self.tangenten_button.grid(row = 5, column = 4)

        self.entry_tangentenpunkt = Tkinter.Entry(self.master, width = 7)
        self.entry_tangentenpunkt.grid(row = 6, column = 4)

        self.normalen_button = Tkinter.Button (self.master, text = "Normale einzeichnen im Punkt:", command = self.normale)
        self.normalen_button.grid(row = 5, column = 0)

        self.entry_normalenpunkt = Tkinter.Entry(self.master, width = 7)
        self.entry_normalenpunkt.grid(row = 6, column = 0)

        fig = plt.figure()
        self.canvas = FigureCanvasTkAgg(fig, master=self.master)
        self.toolbar = NavigationToolbar2TkAgg(self.canvas, self.master)
        self.canvas.get_tk_widget().grid(row=5, column=1)
        self.toolbar.grid(row=7, column=1)
def main():
     
     root = Tkinter.Tk()
     app = App(root)
     root.mainloop()

if __name__ == '__main__':
    main()
        

[BlackJack]

@Jaga: Ähm, moment, Du erbst von `wx.Frame` und erstellst dann eine Tk-UI‽ Das sieht schon mal falsch aus.

[Jaga]

Sorry den Teil hab ich vergessen rauszulöschen

[Jaga]

ok wie kann ich das Fenster ins linke obere Bildschirmeck parken?

[EyDu]

So

[wuf]

Oder so:

Code: Alles auswählen

WIN_XPOS = 10
WIN_YPOS = 20
root.geometry('+{0}+{1}'.format(WIN_XPOS, WIN_YPOS))

Gruß wuf

[Jaga]

Danke danke hat sich schon erledigt
habs so gelöst:

Code: Alles auswählen

root = Tkinter.Tk()
root.geometry("+%d+%d" % (0,0))
app = App(root)
root.mainloop()

[Sophus]

Hallo Leute,

an dieses Thema dachte ich auch schon. Ich arbeite mit QT-Designer 4. Meine derzeitige Bildschirmauflösung ist 1440x900. In dieser Auflösung wirken die Formen recht "klein". Und wenn ich in dieser Auflösung die Widgets auf die Formen zeichne, könnte man schon das Gefühl bekommen, alles sei an Platz und Stelle. Ich weiß, das es dadurch verschiedene Layouts gibt, die man auch verwenden will. Was ist aber, wenn jemand die Auflösung 800x600 hat? Dann wirkt die erstelle Form beim Start richtig groß. Ich habe auch schon überlegt, das Problem auf dem natürlichen Wege zu umgehen, indem ich in einer recht niedrigen Auflösung die GUI zeichne. Aber was ist, wenn man die GUI, die man in 800x600 erstellt hat, auf einmal in meiner derzeitigen Größe anwendet? Dann sieht die GUI mächtig klein aus, die Widgets wären vermutlich total dicht beieinander gelegt etc.

[BlackJack]

@Sophus: Nur um sicherzugehen: Du verwendest schon Layouts und platzierst die Widgets *nicht* an *absolute* Positionen‽

Man muss die GUI halt auch mal bei einer niedrigen Auflösung testen wenn das dort auch laufen soll. Wobei klein oder gross aussehen eigentlich kein Problem darstellt, denn die Leute stellen ja je nach Auflösung und Displaygrösse die Systemschriften so ein das man sie lesen kann. Problematisch ist eher das auf einem kleineren Display halt nicht so viel Platz ist (wenn man die Beschriftungen noch lesen können will).

[Sophus]

@BlackJack: Ja, ich arbeite mich gerade mit den Layouts durch. Ist etwas Fummelarbeit, aber geht schon. Was genau meinst du mit "absolute Position"? Ich zeichne die Widgets auf die Form, und am Ende drücke ich immer auf "Grid-Layout", und QT-Designer "rückt" die Widgets noch ein wenig, aber alles bleibt dort, wo es sein soll. Ich arbeitet außerdem auch mit den horizontalen und vertikalen Platzhalter (Spaces).

Das von dir geschilderte Problem ist mir auch schon seit VB6 bekannt. Dort muss man alles "per Hand" machen. Diese Resize-Aufgabe nimmt QT-Designer ja schon durch die Layouts ab. Aber die Größe der Formen/Fenster bleiben ja trotzdem bestehen. Wenn ich also in meiner Auflösung (1440x900) ein Fenster in entsprechender Größe ziehe, und der Anwender aber eine wesentlich niedrigere Auflösung hat, könnte die Form bzw. das Fenster seinen Bildschirm vollends füllen. In VB6 konnte ich das Problem in sofern umgehen, weil ich immer noch der gerne mit MDI-Formen (MainForm) arbeite. Ich dann immer die Größe der MDI-Form errechnet, und dementsprechend die Kinder-Formen (MDI-Child) angepasst. Noch unproblematischer ist, wenn man die Formen in der MDI-Form maximiert anziegen lässt, so passen sich die Formen der MDI-Form an. Aber man will ja nicht alles maximiert anzeigen lassen.

Wie gehst du dabei vor, BlackJack?

[BlackJack]

@Sophus: Mit absoluten Positionen meinte ich das platzieren im Designer *ohne* dann ein Layout zu verwenden.

Die Frage ist halt wie klein darf ein Bildschirm werden damit man eine GUI noch sinnvoll benutzen kann. Qt kann auch MDI. Man kann/sollte sich halt überlegen was man alles in eine GUI reinstopft und ob man das nicht sinnvoll aufteilen kann. Also muss immer alles gleichzeitig sichtbar sein. Falls nicht kann man Reiter zum umschalten verwenden, das Toolbox-Widget, MDI mit Dockwidgets, den Benutzer dann entscheiden lassen was er gerne angezeigt haben möchte und wo er die Widgets dann andockt und wie klein oder gross er die jeweils zieht. Vielleicht auch mit sinvollen Vorgaben für bestimmte Aufgaben die nicht alles auf einmal benötigen was das Programm alles anzeigen kann.

Ich persönlich hatte bisher noch nicht das Problem eine GUI zu erstellen die so überladen ist das sie auf 800×600 nicht mehr sinvoll angezeigt werden konnte. Ausserdem habe ich wenn es ”grafisch” werden muss mehr mit Weboberflächen zu tun als mit Desktopanwendungen.