QToolBox erscheint nicht im Hauptfenster - Pyside

[machupicchu]

Hi, ich arbeite mich zur Zeit in Pyside ein und habe folgendes Problem. Habe mit dem Qt - Designer meine GUI erstellt und finde die Codierung iwie unschön, so, dass ich eigenes Fenster geproggt habe. Möchte jetzt Teile von Qt Creator erstellten Codes in mein Code übernehmen,d.h. ich möchte den QToolBox auf meinem Fenster haben. Hatte folgende Methode geschrieben:

Code: Alles auswählen

 def toolB(self):
        self.toolBox = QToolBox()
        self.toolBox.setGeometry(QRect(30, 70, 500, 561))
        sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.toolBox.sizePolicy().hasHeightForWidth())
        self.toolBox.setSizePolicy(sizePolicy)
        self.toolBox.setObjectName("toolBox")
        self.smarter = QWidget()
        self.smarter.setGeometry(QRect(0, 0, 1091, 459))
        self.smarter.setObjectName("People")
        self.tabWidget = QTabWidget(self.smarter)
        self.tabWidget.setGeometry(QRect(0, 0, 1081, 451))

Diesen Methode "def toolB" habe ich unten in meinem Code hinzugefügt und versucht im Konstruktor aufzurufen. Aber siehe leider nichts auf meinem Main-Fenster.
Wäre echt dankbar, wenn mir einer helfen würde. Danke

Code: Alles auswählen

from PySide.QtGui import QApplication, QWidget, QToolBox

from PySide.QtGui import *
from PySide.QtCore import *

class SampleWindow(QWidget):
    """ Our main window class
    """
    # Constructor function
    def __init__(self):

        QWidget.__init__(self)
        self.setWindowTitle("Sample Window")
        self.setGeometry(300, 300, 200, 150)
        self.setMinimumHeight(100)
        self.setMinimumWidth(250)
        self.setMaximumHeight(200)
        self.setMaximumWidth(800)
        self.toolBox = QToolBox(QWidget)
        self.toolBox.setGeometry(QRect(10, 20, 381, 138))
        self.toolBox.setObjectName("toolBox")
        self.page = QWidget()
        self.page.setGeometry(QRect(0, 0, 381, 76))
        self.page.setObjectName("page")
        self.toolBox.addItem(self.page, "")
        self.toolB()               #<-------------------------------------------------------------------------------------------Hier

  

    def toolB(self):              #<-------------------------------------------------------------------------------------------Hier
        self.toolBox = QToolBox()
        self.toolBox.setGeometry(QRect(30, 70, 500, 561))
        sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.toolBox.sizePolicy().hasHeightForWidth())
        self.toolBox.setSizePolicy(sizePolicy)
        self.toolBox.setObjectName("toolBox")
        self.smart = QWidget()
        self.smart.setGeometry(QRect(0, 0, 1091, 459))
        self.smart.setObjectName("People")
        self.tabWidget = QTabWidget(self.smart)
        self.tabWidget.setGeometry(QRect(0, 0, 1081, 451))      

if __name__ == '__main__':
    # Exception Handling
    try:
        myApp = QApplication(sys.argv)
        myWindow = SampleWindow()
        myWindow.show()
        time.sleep(3)
        myWindow.resize(300, 300)
        myWindow.setWindowTitle("Sample Window Resized")
        myWindow.repaint()
        myApp.exec_()
        sys.exit(0)
    except NameError:
        print("Name Error:", sys.exc_info()[1])
    except SystemExit:
        print("Closing Window...")

    except Exception:
        print (sys.exc_info()[1])

[Madmartigan]

Hi, ich arbeite mich zur Zeit in Pyside ein und habe folgendes Problem. Habe mit dem Qt - Designer meine GUI erstellt und finde die Codierung iwie unschön, so, dass ich eigenes Fenster geproggt habe. Möchte jetzt Teile von Qt Creator erstellten Codes in mein Code übernehmen,d.h. ich möchte den QToolBox auf meinem Fenster haben. Hatte folgende Methode geschrieben:

Code: Alles auswählen

def toolB(self):
    self.toolBox = QToolBox()

QToolBox(parent=None) ... du hast der Toolbox kein Parent zugewiesen. Daher wird sie auch nicht auf dem MainWindow angezeigt.

Code: Alles auswählen

def toolB(self):
    self.toolBox = QToolBox(QWidget)
    self.toolBox.setGeometry(QRect(30, 70, 500, 561))

Das macht demnach auch keinen Sinn, da parent eine Instanz sein muss, QWidget ist aber der Klassenname, das funktioniert so nicht.
setGeometry(...) ist keine gute Idee, dafür sollte man Layouts verwenden.

Code: Alles auswählen

time.sleep(3)

Wozu machst du das? Der User wartet ungern unnötige drei Sekunden.

Hinweis: Du hälst dich nicht an den Code Styleguide, für bessere Lesbarkeit und sauberen Code orientiere dich an PEP8.

[machupicchu]

Hi,

ich habe mal mein Code jetzt geändert.
Habe eine Instanz "widg" für QWidget erzeugt und das in QToolBox(widg) hinzugefügt.
Leider funzt nicht. QToolBox wird von QWidget abgeleitet. Habe jetzt meine Instanz "widg" und diese muss jetzt auf meine SampleWindow instanz "myWindow".

Habe ich das iwie falsch verstanden oder was mache ich da falsch.

Code: Alles auswählen

import sys
import time
from PySide.QtGui import QApplication, QWidget, QToolBox
from PySide.QtGui import *
from PySide.QtCore import *

class SampleWindow(QWidget):
    """ Our main window class
    """
    # Constructor function
    def __init__(self):

        QWidget.__init__(self)
        self.setWindowTitle("Sample Window")
        self.setGeometry(300, 300, 200, 150)
        self.setMaximumHeight(700)
        self.setMaximumWidth(800)


if __name__ == '__main__':
 
        myApp = QApplication(sys.argv)
        widg = QWidget()                    <------------------------------------------------------------Hier
        myWindow = SampleWindow()
        toolBox = QToolBox(widg)         <----------------------------------------------------------- Hier
        toolBox.setGeometry(QRect(10, 20, 381, 138))
        myWindow.show()
        myWindow.resize(600, 600)
        myWindow.setWindowTitle("Sample Window Resized")
        myWindow.repaint()
        myApp.exec_()
        sys.exit(0)

[BlackJack]

@machupicchu: Na grundsätzlich ist das immer noch der gleiche Fehler. Jetzt hat Dein (sehr komisch benanntes) `widg` kein `parent` und wird deshalb nirgends dargestellt. Du musst damit schon explizit sagen welchem Containerwidget ein Widget zugeordnet werden soll. Qt wird da nicht einfach so raten was Du wohl gerne haben würdest. Und Du solltest Layouts verwenden. Die sinnfreien `my*`-Präfixe könnte man auch weglassen.

[machupicchu]

Hi blackjack, any sugestions?

[Madmartigan]

Hi blackjack, any sugestions?

Die Frage verstehe ich nicht, er hat dir doch gesagt, was das Problem ist.

Du hast zwar ein Widget erstellt, aber leider wieder ohne Parent. Das heißt, dieses Widget "besitzt" jetzt zwar deine Toolbox, es selbst wird aber aufgrund des genannten Problems nicht angezeigt.

Code: Alles auswählen

myWindow = SampleWindow()
toolbox = QToolBox(myWindow)

Das wäre valide.

Code: Alles auswählen

myWindow = SampleWindow()
widg = QWidget(myWindow)
toolbox = QToolBox(widg)

Auch das ist valide, wenn gleich widg hier unnötig ist.

Das Präfix my ist wirklich unschön, die Bezeichner der Variablen folgen nicht dem Python StyleGuide (es müsste in dem Fall heißen: my_window).
setGeometry(...) lässt sich durch die Verwendung von Layouts vermeiden (siehe den Link in meinem ersten Post). Aufwändigere UIs willst du einfach nicht hardcodieren, überlass das Sizing dem Layout Manager von Qt.

Code: Alles auswählen

myWindow.repaint()

Warum? Beim showEvent und resizeEvent wird das Widget sowieso neu gezeichnet. Explizites Neuzeichnen sollte man vermeiden. Wenn du die UI refreshen musst/willst, nutze update(). Das Scheduling für das Zeichnen wird dir abgenommen, es gibt hier keinen Grund, das manuell zu machen.

[machupicchu]

Verstehe schon! Mir war nicht bewusst, dass man zum Beispiel einer ToolBox ein Widget zuordnen muss, damit er mir überhaupt was anzeigt.
Habe es jetzt folgendermaßen nach langem herumprobieren umgesetzt. Habe zwei Tabs in meine ToolBox eingebunden. Wollte jetzt innerhalb meiner ToolBox weitere ToolBoxes einbauen, aber vertical. Ist dies überhaupt möglich?

Code: Alles auswählen

import sys
from PySide.QtGui import *
from PySide.QtCore import *

class Window(QWidget):
    """ Our main window class
    """
    # Constructor function
    def __init__(self):
        QWidget.__init__(self) 
        self.layout = QVBoxLayout()
        self.menuLayout = QHBoxLayout()
        self.setMinimumWidth(800)
        self.setMinimumHeight(800)
        self.setLayout(self.layout)
        


        
    def tabWidget(self):
        self.toolBox = QToolBox()
        self.tab = QTabWidget()
        self.label = QLabel()
        self.label2 = QLabel()
      
        self.toolBox.addItem(self.tab, "toolbox")
        self.tab.addTab(self.label, 'Tab')
        self.tab.addTab(self.label2, 'Tab2')
        
        self.menuLayout.addWidget(self.toolBox)
        self.layout.addLayout(self.menuLayout)
       

    
if __name__ == '__main__':
 
        app = QApplication(sys.argv)
        window = Window()
        window.tabWidget()
        window.show()
        app.exec_()
        sys.exit(0)

[Madmartigan]

Wollte jetzt innerhalb meiner ToolBox weitere ToolBoxes einbauen, aber vertical.

Eine QToolBox ist doch vertikal, ich weiß nicht was du hier genau meinst. Manchmal hilft eine kleine 2-Minuten Skizze, um anderen zu erläutern, was man erreichen möchte.

Leider wird der Code aber nicht besser!
Du hast nach wie vor bei der Instantiierung deiner Objekte kein parent angegeben. Der Verwendung von Layouts sei es hier gedankt, dass die Widgets dann trotzdem da landen, wo du sie haben willst. Saubere Objekterzeugung ist das leider dennoch nicht.

Ein Hinweis zu den Layouts:

Code: Alles auswählen

def __init__(self):
    QWidget.__init__(self)
    self.layout = QVBoxLayout()
    self.menuLayout = QHBoxLayout()
    self.setLayout(self.layout)

Das ist zu kompliziert, das Layout für das Fenster kannst du einfacher setzen:

Code: Alles auswählen

def __init__(self):
    QWidget.__init__(self)
    self.setLayout(QVBoxLayout())
    self.menuLayout = QHBoxLayout()

Danach greifst du einfach auf self.layout() zu. Was uns gleich zur nächsten unglücklichen Stelle im Code führt:

Code: Alles auswählen

    self.layout.addLayout(self.menuLayout)

Ich würde dringend davon abraten, das in dieser Art und Weise, einem property ähnlich, zu verwenden. Sprich das Layout, wie oben erwähnt, direkt an:

Code: Alles auswählen

    self.layout().addLayout(self.menuLayout)

Btw, Sternchen-Importe sollte man vermeiden, explizit das importieren, was auch wirklich benötigt wird. So schließt man Namensprobleme (beinahe) aus!

Ich hoffe, das hilft dir weiter.

[machupicchu]

Ich habe da jetzt so einige instanzen. Weiß aber leider nicht was ich da als parent angeben muss. QWidget ist mein parent, aber verstehe nicht was und wieso???

Ich habe auf der oberen Zeile meinen "toolbox". Diese sind horizontal, so wie der text auch. Wollte darin noch eine toolbox einbinden. Man kann sich das so wie ein virtuelles buch vorstellen. Skizze mache ich dann noch fertig.

[machupicchu]

Wie versprochen hier die Skizze. So soll es vorerst aussehen.

https://dl.dropboxusercontent.com/u/701 ... sideQt.jpg

[Madmartigan]

Ja, jetzt verstehe ich, was du machen möchtest. Für mein Verständnis sind diese neuen Toolboxes da zwar horizontal, aber du meinst sicher die Tabs der Toolbox. Die wären jetzt vertikal.

Leider erlaubt dir QToolBox diese Verwendung nicht. Wenn du in die Klassen-Referenz von QToolBox schaust, liest du bereits an erster Stelle:
The QToolBox class provides a column of tabbed widget items.

Dieses Widget ist also ausschließlich für die mitgelieferte Orientierung ausgelegt. Wenn du mehr Erfahrung im Umgang mit Qt gesammelt hast, kannst du dir aber ohne Probleme ein eigenes Widget schreiben, das die von dir gewünschte Funktionalität anbietet.

Alternativ schau dir mal QStackedWidget an, vielleicht erfüllt es seinen Zweck für dein Vorhaben.

[machupicchu]

Ja, für meine Zwecke reicht das auch erstmal aus.
Könntest Du mir mal bitte erklären wie Du das mit der Ableitung vom Parent meinst. Habe nämlich jetzt das Problem, dass mit QWidget keine Menüs einbinden kann. Mit der Klasse QMainWindow geht es schon, aber dann gehen mir die Widgets verloren. QMainWindow ist ja die Subclass von QWidget, da dürfte es doch eigentlich kein Problem sein, dass er die Methode

Code: Alles auswählen

 menubar()

findet. Kann auch zum Beispiel

Code: Alles auswählen

setCentralWidget()

nicht nutzen.


Hatte versucht mit einer zweiten Klasse zu arbeiten und von QMainWindow abgeleitet, z.B.

Code: Alles auswählen

import sys
from PySide import QtGui

class Example(QtGui.QMainWindow):
    
    def __init__(self):
        super(Example, self).__init__()
        
        self.initUI()
        
    def initUI(self):               

        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')

Weiß jetzt an der Stelle nicht wie ich das mit der Klasse Window verknüpften kann.


Alternativ hatte ich wie oben beschrieben die "menubar()" Methode in "Window(QWidget)" implementiert, dass ja ohne die Klasse QMainWindow ja nicht funktioniert. Da könnte mir die Ableitungen evtl. helfen?????

Code: Alles auswählen

import sys
from PySide.QtGui import *
from PySide.QtCore import *
 
class Window(QWidget):
    """ Our main window class
   """
    # Constructor function
    def __init__(self):
        QWidget.__init__(self)
        self.layout = QVBoxLayout()
        self.menuLayout = QHBoxLayout()
        self.menueL = QHBoxLayout()       <------------------------------------------------Hier
        self.setMinimumWidth(800)
        self.setMinimumHeight(800)
        self.setLayout(self.layout)

     def menue(self)                                      <-------------------------------------------------------Hier
        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')
        self.menueL.addWidget(fileMenu)
        self.layout.addLayout(self.menueL)



        

    def tabWidget(self):
        self.menue()                           <--------------------------------------------------Hier
        self.toolBox = QToolBox()
        self.tab = QTabWidget()
        self.label = QLabel()
        self.label2 = QLabel()
     
        self.toolBox.addItem(self.tab, "toolbox")
        self.tab.addTab(self.label, 'Tab')
        self.tab.addTab(self.label2, 'Tab2')
       
        self.menuLayout.addWidget(self.toolBox)
        self.layout.addLayout(self.menuLayout)
       
 
   
if __name__ == '__main__':
 
        app = QApplication(sys.argv)
        window = Window()
        window.tabWidget()
        window.show()
        app.exec_()
        sys.exit(0)

[Madmartigan]

Verstehe schon! ...

Offensichtlich tust du das nicht, sonst wäre die Frage nach der korrekten Instantiierung doch längst geklärt!

Du deklarierst das Folgende als dein Hauptfenster (zumindest sagt das dein Kommentar):

Code: Alles auswählen

class Window(QWidget):
    """ Our main window class
    """

Selbstverständlich kannst du da nicht auf menuBar() und setCentralWidget() zugreifen, da die Basisklasse QWidget diese nicht besitzt. Dein Hauptfenster muss also bereits von QMainWindow erben. Dazu brauchst du keine separate Klasse.


Ich halte es nicht wirklich für sinnvoll, hier weitergehende Fragen zu beantworten, solange du nicht die bisherigen Hinweise und Tipps beachtest.
Dein Code beinhaltet nach wie vor die gleichen Probleme und unkonventionellen Bezeichner! Wenn das bisschen Code schon so unstrukturiert ist, wie lange willst du dieses Chaos fortführen?

Ehrlich, ich meine das wirklich nicht böse oder abwertend, denn aller Anfang ist schwer und GUI-Programmierung wird nicht selten schnell komplexer als es dir lieb ist. Daher ist es wichtig, bereits am Anfang "sauber" zu arbeiten.

[machupicchu]

............. sonst wäre die Frage nach der korrekten Instantiierung doch längst geklärt!

Dein Hauptfenster muss also bereits von QMainWindow erben. Dazu brauchst du keine separate Klasse.

Kannst Du nicht einfach mal kurz erklären was Du meinst und ein Beispiel dazu geben. Dann hätten wir das doch geklärt.



So, habe jetzt Deine vorrigen Tipps befolgt.

Code: Alles auswählen

import sys
from PySide.QtGui import QHBoxLayout, QVBoxLayout, QIcon, QLabel, QWidget, QToolBox, QTabWidget, QTextEdit, QMainWindow, QPixmap, QAction, QApplication
from PySide.QtCore import *
 
class Window(QWidget):

    # Constructor 
    def __init__(self):
        QWidget.__init__(self)
        self.setLayout(QVBoxLayout())
        self.menuLayout = QHBoxLayout()
        self.setMinimumWidth(800)
        self.setMinimumHeight(800)

       
    def tabWidget(self):
        self.toolBox = QToolBox()
        self.tab = QTabWidget()
        self.label = QLabel()
        self.label_2 = QLabel()
     
        self.toolBox.addItem(self.tab, "toolbox")
        self.tab.addTab(self.label, 'Tab')
        self.tab.addTab(self.label_2, 'Tab2')
       
        self.menuLayout.addWidget(self.toolBox)
        self.layout().addLayout(self.menuLayout)
       
 
   
if __name__ == '__main__':
 
        app = QApplication(sys.argv)
        window = Window()
        window.tabWidget()
        window.show()
        app.exec_()
        sys.exit(0)

[Madmartigan]

Schau an, das sieht schon etwas besser aus. Du nutzt aber immer noch Sternchenimporte wie hier:

Code: Alles auswählen

from PySide.QtCore import *

Das ist ungut, warum habe ich bereits erklärt. Sicherer ist, du importierst immer explizit. Beispiel:

Code: Alles auswählen

from PySide.QtCore import QSize, Qt, Signal

Namenskonventionen:

Code: Alles auswählen

self.menuLayout = QHBoxLayout()

Gemäß PEP8 Code StyleGuide:

Code: Alles auswählen

self.menu_layout = QHBoxLayout()

Das gleiche gilt natürlich für:

Code: Alles auswählen

self.toolBox = QToolBox()

PEP8:

self.tool_box = QToolBox()

Wobei der Name eben diskutiert werden kann. Bezeichner sollten immer aussagekräftig sein.

Hier ein Beispiel für das, was du machen willst.

Code: Alles auswählen

import sys
from PySide.QtGui import (QApplication, QMainWindow, QWidget, QToolBox,
                          QTabWidget, QLabel, QAction)
 
class Window(QMainWindow):

    def __init__(self):

        QMainWindow.__init__(self)

        self.create_ui()
        self.connect_ui()

        self.resize(800, 600)

    def create_ui(self):
        # Beispiel fuer das Hauptmenue
        self.file_menu = self.menuBar().addMenu('File')
        self.about_menu = self.menuBar().addMenu('About')

        # Beispiel fuer eine QAction
        self.act_exit = QAction('Exit', self.file_menu)
        self.file_menu.addAction(self.act_exit)

        # Instantiierung der ToolBox
        self.tool_box = QToolBox(self)

        # Instantiierung des TabWidgets
        self.tab_widget = QTabWidget(self)

        # Befuellung der ToolBox
        self.tool_box.addItem(self.tab_widget, 'First toolbox item')
        self.tool_box.addItem(QLabel('I am a label'), 'Second toolbox item')

        # Zuweisung der ToolBox zum TabWidget
        self.tab_widget.addTab(QLabel('Hello first tab'), 'Tab')
        self.tab_widget.addTab(QLabel('Hello second tab'), 'Tab 2')

        # Setzen der ToolBox als <centralWidget>
        self.setCentralWidget(self.tool_box)

    def connect_ui(self):
        self.act_exit.triggered.connect(self.close)


if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())

Die deutschen Kommentare sind jetzt für dich zur Erklärung drin, in der Regel dokumentiert man aber, wie bereits erwähnt, in englischer Sprache.
Ich hoffe, das ist hilfreich.

[machupicchu]

Super aller besten Dank!
Das hilft mir schon wesentlich weiter.
Habe jetzt gesehen, dass Du keinen Layer verwendet hast.
Mit "self" referenzierst Du auf die abgeleitete Klasse QMainWindow, d.h. meine Widgets, z.B. QToolBar etc sind in der QMainWindow Klasse enthalten. Habe ich das richtig verstanden?

[Madmartigan]

Das ist so nicht ganz richtig.
Mit self verweise ich auf die Instanz der Klasse Window, somit sind die Widgets Instanzvariablen und haben self als Parent.

Es gibt einen Unterschied zwischen einer reinen Instanzvariable und der Notwendigkeit, dass visuelle Komponenten zusätzlich auch ein Parent Objekt haben müssen.

Code: Alles auswählen

self.button_exit = QPushButton("Exit")

legt zwar einen Button an, da Parent aber fehlt, bleibt er unsichtbar
Erst die Zuweisung des Parent Objekts:

Code: Alles auswählen

self.button_exit.setParent(self)

ermöglicht es, den Button anzuzeigen.

Und das machst du bereits bei der Instantiierung, wenn du schreibst:

Code: Alles auswählen

self.button_exit = QPushButton("Exit", self)

[machupicchu]

Danke! Aber ich brauche nochmal Deine Hilfe.

Was ich aber jetzt noch wissen möchte ist, wie bekomme ich das alles auf einen Layer. Du hattest mir geraten mit Layer zu arbeiten, aber hast es selber nicht genutzt.


Wollte ganz weit oben ein Bild(z.B. Logo) reinsetzen und das werde ich denke ich mit einem Layer umsetzen können. Ich nehme einfach mal Dein Code zur Hilfe, um es besser zu begreifen.
Wollte jetzt das Menu, Toolbox auf Layer QVBoxLayout untereinander setzen.

Code: Alles auswählen

  import sys
from PySide.QtGui import (QApplication, QMainWindow, QWidget, QToolBox,
                          QTabWidget, QLabel, QAction, QVBoxLayout, QHBoxLayout)
 
class Window(QMainWindow):
 
    def __init__(self):
 
        QMainWindow.__init__(self)
 
        self.create_ui()
        self.connect_ui()
 
        self.resize(800, 600)
 
    def create_ui(self):
        #Erstelle Layer
        self.entire_layer = QVBoxLayout(self) <------------------self.setLayout(QVBoxLayout) hat über direkten Zugriff layout(). nicht funktioniert
        self.menu_layout = QHBoxLayout()
        self.entire_layer.addLayout(self.menu_layout)            <--------------------------------------------------Hier
        
    

    
        # Beispiel fuer das Hauptmenue
        self.file_menu = self.menuBar().addMenu('File')
        self.about_menu = self.menuBar().addMenu('About')
        self.menu_layout.addWidget(self.file_menu) <--------------------------------------------------------------Hier
       
        # Beispiel fuer eine QAction
        self.act_exit = QAction('Exit', self.file_menu)
        self.file_menu.addAction(self.act_exit)
 
        # Instantiierung der ToolBox
        self.tool_box = QToolBox(self)
 
        # Instantiierung des TabWidgets
        self.tab_widget = QTabWidget(self)
 
        # Befuellung der ToolBox
        self.tool_box.addItem(self.tab_widget, 'First toolbox item')
        self.tool_box.addItem(QLabel('I am a label'), 'Second toolbox item')
 
        # Zuweisung der ToolBox zum TabWidget
        self.tab_widget.addTab(QLabel('Hello first tab'), 'Tab')
        self.tab_widget.addTab(QLabel('Hello second tab'), 'Tab 2')
 
        # Setzen der ToolBox als <centralWidget>
        self.setCentralWidget(self.tool_box)
 
    def connect_ui(self):
        self.act_exit.triggered.connect(self.close)
 
 
if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())

[Madmartigan]

Nicht Layer, sondern Layout

Ich habe hier kein neues Layout erzeugt, weil QMainWindow bereits ein Layout hat. Wenn du ein beliebiges, skalierbares Widget als centralWidget angibst, wird es automatisch auf den zur Verfügung stehenden Platz auf dem QMainWindow gestreckt/gestaucht.

In meinem Beispiel hatte ich die QToolBox als centralWidget gesetzt. Statt dessen kannst du einfach auch ein QWidget als Platzhalter verwenden.

Die Abfolge wäre wie folgt:
Erzeugung eines QWidget (mit Namen base_widget)
Setzen des Layouts von base_widget (QVBoxLayout)
Setzen von base_widget als centralWidget der QMainForm
Hinzufügen deines Bildes (ich gehe davon aus, dass du dazu ein QLabel benutzt!?) zum Layout von base_widget
Hinzufügen der QToolBox zum Layout von base_widget

Und schon ist base_widget somit das centralWidget, welches ein eigenes, vertikales Layout besitzt, in welchem dann das Bild und die ToolBox "liegen".
Soweit also der Ablauf. Die Umsetzung sollte nach dem vorangegangenen Beispiel und den vielen Tipps nun kein Problem sein, oder?

Btw, das Menü von QMainWindow musst du nicht extra in ein Layout packen, da das Fenster bereits dreigeteilt ist: Menubar, StatusBar und centralWidget (also der Platz dazwischen). Egal was du auf dem centralWidget treibst, Menubar und Statusbar bleiben davon unberührt. Du kannst beide natürlich auch löschen, wenn du sie nicht brauchst/willst.

[machupicchu]

Hi, ja hatte das jetzt eigentlich mit einer zweiten Klasse umgesetzt. Würde auch gerne wissen wie es ohne die zweite Klasse ableitet von QWidget geht. Bin ja auch erst seit fast einer Woche mit Pyside dabei.

Hatte jetzt Deine Schritte befolgt, aber wie immer kriege ich es selbstständig nicht hin

Code: Alles auswählen

        self.logo = QIcon('logo.png')                                                 <-------------------Logo Icon und Label label_Logo
        self.label_Logo = QLabel(self)
        self.pixmap1 = self.logo.pixmap(200, 200)
        self.base_widget = QWidget()                                               <-------------------QWidget instanz
        self.base_widget.setLayout(QVBoxLayout)                               <-------------------Layout setten
        self.base_widget.layout().addWidget(self.label_Logo)                <----------------- label_Logo auf Layout
        self.base_widget.layout().addWidget(self.tool_box)                   <------------------toolbox auf Layout
        
        # Setzen der ToolBox als <centralWidget>
        self.setCentralWidget(self.base_widget)                                    <----------------base_widget mit CentralWidget setzen

Code: Alles auswählen

import sys
from PySide.QtGui import (QApplication, QMainWindow, QWidget, QToolBox,
                          QTabWidget, QLabel, QAction, QVBoxLayout, QIcon)
 
class Window(QMainWindow):
 
    def __init__(self):
 
        QMainWindow.__init__(self)
 
        self.create_ui()
        self.connect_ui()
 
        self.resize(800, 600)
 
    def create_ui(self):
        # Beispiel fuer das Hauptmenue
        self.file_menu = self.menuBar().addMenu('File')
        self.about_menu = self.menuBar().addMenu('About')
 
        # Beispiel fuer eine QAction
        self.act_exit = QAction('Exit', self.file_menu)
        self.file_menu.addAction(self.act_exit)
 
        # Instantiierung der ToolBox
        self.tool_box = QToolBox(self)
 
        # Instantiierung des TabWidgets
        self.tab_widget = QTabWidget(self)
 
        # Befuellung der ToolBox
        self.tool_box.addItem(self.tab_widget, 'First toolbox item')
        self.tool_box.addItem(QLabel('I am a label'), 'Second toolbox item')
 
        # Zuweisung der ToolBox zum TabWidget
        self.tab_widget.addTab(QLabel('Hello first tab'), 'Tab')
        self.tab_widget.addTab(QLabel('Hello second tab'), 'Tab 2')
        
          self.logo = QIcon('logo.png')                                                 <-------------------Logo Icon und Label label_Logo
        self.label_Logo = QLabel(self)
        self.pixmap1 = self.logo.pixmap(200, 200)
        self.base_widget = QWidget()                                               <-------------------QWidget instanz
        self.base_widget.setLayout(QVBoxLayout)                               <-------------------Layout setten
        self.base_widget.layout().addWidget(self.label_Logo)                <----------------- label_Logo auf Layout
        self.base_widget.layout().addWidget(self.tool_box)                   <------------------toolbox auf Layout
        
        # Setzen der ToolBox als <centralWidget>
        self.setCentralWidget(self.base_widget) 
 
    def connect_ui(self):
        self.act_exit.triggered.connect(self.close)
 
 
if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = Window()
    window.show()
    sys.exit(app.exec_())