SARibbon
v2.2.6
中文文档点击这里,QQ群:434014314
| Windows (2019, aktuell) | Linux Ubuntu (20.04, aktuell) | Mac (11-neueste Version) | |
|---|---|---|---|
| Qt5.12 | |||
| Qt5.13 | |||
| Qt5.14 | |||
| Qt5.15 | |||
| Qt6.0 | |||
| Qt6.1 | |||
| Qt6.2 | |||
| Qt6.3 | |||
| Qt6.4 | |||
| Qt6.5 | |||
| Qt6.6 |
Dabei handelt es sich um ein Ribbon control im Qt -Framework, das eine ähnliche Schnittstelle wie die Microsoft Office-Software bietet. SARibbon eignet sich für große Software, Industriesoftware und komplexe Software-Benutzeroberflächen. SARibbon basiert auf dem Namensstil der MFC-Ribbon-Schnittstelle. Der Schnittstellenstil von SARibbon bezieht sich auf die Ribbon-Schnittstelle der Software der Microsoft Office-Serie und der WPS-Software und kombiniert die Vorteile beider. SARibbon ist ein Multifunktionsleisten-Widget, das eine Vielzahl von Themenstilen definieren kann und über qss schnell den gewünschten Themenstil definieren kann. Um die Entwicklung großer Software zu erleichtern, kapselt SARibbon einige häufig verwendete Funktionssteuerelemente, wie z. B. Farb-Widgets
Win7-Thema: 
Office2013-Thema: 
Thema office2016: 
Thema office2021: 
dunkles Thema: 
MIT-Protokoll, jeder kann es verwenden und Kommentare abgeben
Ferienhaus – https://gitee.com/czyt1988/SARibbon
Github – https://github.com/czyt1988/SARibbon
SARibbon bietet sowohl qmake- als auch cmake-Build-Methoden und stellt eine zusammengeführte SARibbon.h und SARibbon.cpp Datei für die statische Einbettung in ein einzelnes Projekt bereit
SARibbonunterstützt die Drittanbieter-Bibliothek QWindowKit. Gleichzeitig werden auch einfache rahmenlose Lösungen unterstützt. Wenn Sie native Fensterunterstützung für das Betriebssystem benötigen, z. B. Kantenbeschnitt nach Windows 7 und Maximierung des Hovering-Effekts von Schaltflächen in Windows 11, wird empfohlen, die QWindowKit-Bibliothek zu aktivieren. Die QWindowKit-Bibliothek kann das Problem der Bewegung mehrerer Bildschirme besser lösen
Wenn Sie sich auf die QWindowKit-Bibliothek verlassen möchten, müssen Sie zuerst die QWindowKit-Bibliothek und QWindowKit als Submodule des SARibbon-Projekts kompilieren. Wenn der Parameter „--recursive“ nicht im „git clone“ enthalten ist, verwenden Sie den Befehl „submodules update“. muss ausgeführt werden:
git submodule update --init --recursiveDen detaillierten Build-Prozess finden Sie im Dokument: Building SARibbon
SARibbon stellt SARibbon.h Datei und SARibbon.cpp -Datei zusammen. Sie müssen nur diese beiden Dateien in Ihr eigenes Projekt importieren und gleichzeitig Ressourcendateien und Bibliotheksdateien von Drittanbietern zur Verwendung importieren, ohne dass eine Kompilierung in dynamische Bibliotheken erforderlich ist oder statische Bibliotheken, Sie können auf das StaticExample-Beispiel verweisen (befindet sich in src/example/StaticExample ). Die statische Einbettung wird für SARibbon.h verwendet. SARibbon.cpp , SARibbon.pri , SARibbonBar/resource.qrc und SARibbonBar/3rdparty , SARibbonBar/resource zwei Ordner:
Ihr Projektverzeichnis sieht folgendermaßen aus:
|-you-project-dir
| |-you-project.pro
| |-SARibbon.h
| |-SARibbon.cpp
| |-SARibbon.pri
| |-SARibbonBar
| |-resource.qrc
| |-resource(Directly copy the resource under SARibbonBar in its entirety)
| |-resource files
Um mit qmake zu kompilieren, können Sie die folgenden Schritte ausführen:
SARibbon.h , SARibbon.cpp , SARibbon.pri in Ihr ProjektverzeichnisSARibbonBar -Ordner in Ihrem Projektverzeichnissrc/SARibbonBar/resource.qrc im Quellcode in den Ordner SARibbonBar in Ihrem Projektverzeichnisresource unter src/SARibbonBar in den Ordner SARibbonBar in Ihrem ProjektverzeichnisSARibbon.pri in die Profildatei Ihres Projekts, z. B. include($$PWD/SARibbon.pri) Wenn Sie cmake verwenden, lesen Sie die cmake-Schreibmethode des StaticExample-Beispiels (befindet sich in src/example/StaticExample ).
Nachdem die Kompilierung abgeschlossen ist, importieren Sie SARibbon wie folgt:
Wenn Sie qmake verwenden, können Sie nach Abschluss der Kompilierung einfach die folgenden Dateien in einer Verzeichnisstruktur in Ihr Projekt kopieren
Erstellen Sie zunächst einen Ordner eines Drittanbieters in Ihrem Projekt und kopieren Sie dann den gesamten SARibbon-Ordner. In SARibbon befinden sich bereits mehrere Pri-Dateien, mit denen Sie das Projekt problemlos in Ihr eigenes Verzeichnis importieren können. Die Datei ./importSARibbonBarLib.pri wird verwendet Importieren Sie die SARibbon-Bibliothek
Nach Abschluss des Einspruchsverfahrens können Sie die folgende Erklärung zu Ihrer Qt-Projektprofildatei hinzufügen
include( $$ PWD/3rdparty/SARibbon/importSARibbonBarLib.pri) Der Kompilierungsprozess von qmake generiert den Ordner bin_qtx.x_xx unter SARibbon, und die Bibliotheksdateien und DLL-Dateien befinden sich in diesem Ordner, und importSARibbonBarLib.pri verweist automatisch auf die Bibliotheken in diesem Ordner
Zu diesem Zeitpunkt sieht Ihr Projektverzeichnis so aus:
|-[you-project-dir]
| |-you-project.pro
| |-[3rdparty]
| |-[SARibbon](Copy SARibbon in its entirety)
| |-importSARibbonBarLib.pri
| |-SARibbonBar.pri
| |-common.pri
| |-[bin_qtx.x.x_{MSVC/GNU}_x{32/64}]
| |-[src]
| | |-[SARibbonBar]
Es wird empfohlen, diese Bibliothek nach der Ausführung von install zu verwenden.
Methode zur Einführung von cmake:
find_package (SARibbonBar REQUIRED)
...
target_link_libraries ({your_target_name} PUBLIC SARibbonBar::SARibbonBar) Wenn find_package SARibbonBar nicht finden kann, müssen Sie Ihrem cmake-Projekt den Installationsort von SARibbon mitteilen.
set(SARibbonBar_DIR "[your SARibbonBar installation root directory]/lib/cmake")
Wenn während der Kompilierung die Option SARIBBON_INSTALL_IN_CURRENT_DIR auf ON (Standard) gesetzt ist, wird im Stammverzeichnis des SARibbon-Projekts ein Ordner bin_qt{Qt version}_{MSVC/GNU}_x{32/64} als Installationsverzeichnis generiert. Dies dient der Anpassung an qmake und erleichtert die Installation mehrerer verschiedener Versionen von Qt und Compilern auf einem einzigen Betriebssystem. Andernfalls wird es unter Windows standardmäßig im Ordner C:Program FilesSARibbonBar installiert.
Eine Referenz zur Einführung von SARibbon über cmake finden Sie src/example/MainWindowExample/CMakeLists.txt .
Einzelheiten finden Sie in der Dokumentation: SARibbon Building
Ribbon ist eine Kombination aus Menüleiste und Symbolleiste und wird über ein Tab-Steuerelement angezeigt. Ribbon kann nicht einfach durch Tab+Toolbar ersetzt werden, was viele Details erfordert. SARibbon bezieht sich auf den Benennungsstil der MFC-Ribbon-Schnittstelle im Design , die Registerkartenseite heißt Category , und unter jeder Category gibt es mehrere pannel , unter denen die Tool-Schaltfläche verwaltet wird. pannel ähnelt ein wenig der traditionellen Toolbar , mit einer Hierarchie wie im Bild unten gezeigt, und diese Namen verweisen darauf die MFC-Ribbon-Schnittstellenklasse
Nachfolgend werden einige gebräuchliche Substantive erläutert
Category , stellt dar, was ein Etikett präsentiert, entsprechend SARibbonCategory .
Kontextkategorie , dies ist eine spezielle Kategorie. Es wird nicht normal angezeigt. Sie müssen anhand des Kontexts beurteilen, ob es angezeigt werden soll. Die gebräuchlichste Methode besteht darin, dass nach dem Einfügen eines Bildes in Word eine Beschriftung zur Bildänderung angezeigt wird. Wenn kein Bild ausgewählt ist, verschwindet die Beschriftung. Dies ist die Kontextkategorie, SARibbonContextCategory entspricht.
Pannel , Dies ist eine Sammlung von Menüs, wie eine Symbolleiste, entsprechend SARibbonPannel
Anwendungsschaltfläche : Dies ist die Schaltfläche ganz links in der Registerkartenleiste (Wort ist die entsprechende Dateischaltfläche). Diese Schaltfläche löst einige spezielle Seiten oder Menüs aus, SARibbonApplicationButton entsprechen und ausgeblendet werden können.
Schnellzugriffsleiste , eine einfache Symbolleiste oben zum Platzieren allgemeiner Aktionen, die SARibbonQuickAccessBar entsprechen.
Galerie-Steuerung , dies ist die auffälligste Steuerung der Multifunktionsleiste. Es zeigt die Funktionen mit intuitiven Bildern an und einige Renderings erfolgen sogar je nach Kontext in Echtzeit. Ein typisches Beispiel ist die Stilauswahl im Office-Wort. entsprechend SARibbonGallery .
Das Layout von SARibbonBar ist in der folgenden Abbildung dargestellt
Hinweis: Unterschiedliche Layoutschemata wirken sich auf die Platzierung der
CategoryundQuick Access Baraus
Um SARibbon in MainWindow zu verwenden, müssen Sie QMainWindow durch SARibbonMainWindow ersetzen, wodurch sich die Art und Weise ändert, wie QMainWindow die Menüleiste rendert
Beachten Sie, dass Sie bei Verwendung einer UI-Datei das Menü der UI-Datei löschen sollten, da es sonst zu Ausnahmen kommen kann
Der Beispielcode lautet wie folgt:
# include " SARibbonMainWindow.h "
class MainWindow : public SARibbonMainWindow
{
Q_OBJECT
public:
MainWindow (QWidget* par = nullptr );
...
} SARibbonMainWindow unterstützt auch das Rendern im Normalmodus mit dem folgenden Konstruktor:
SARibbonMainWindow (QWidget *parent = nullptr , bool useRibbon = true );Wenn der zweite Parameter auf „false“ gesetzt ist, wird der normale Menü-Symbolleistenmodus verwendet. Diese Schnittstelle ist für einige Projekte reserviert, die zwischen Multifunktionsleisten- und klassischen Menü-Symbolleistenszenen wechseln müssen. Der Multifunktionsleistenstatus und der klassische Status unterstützen kein Hot-Switching Wenn Sie wechseln müssen, können Sie eine Konfigurationsdatei oder Registrierung festlegen und beim Neustart der Anwendung false an den zweiten Parameter übergeben, um in den klassischen Menüsymbolleistenmodus zu gelangen
SARibbonBar kann auf QWidget oder QDialog verwendet werden, siehe Beispiel: src/example/WidgetWithRibbon
Sie müssen SARibbonBar lediglich als normales Widget verwenden
Deklarieren Sie zunächst den Zeiger von SARibbonBar in der Header-Datei
private:
Ui::Widget* ui;
SARibbonBar* mRibbonBar { nullptr }; Erstellen Sie eine SARibbonBar im Konstruktor des Widgets, es gibt ein QVBoxLayout -Layout in der UI-Datei des Widgets, platzieren Sie die SARibbonBar ganz oben und gleichzeitig ist es aufgrund des QWidget-Modus nicht erforderlich, den Titel anzuzeigen, den Sie aufrufen können die SARibbonBar::setTitleVisible -Methode, um den Titel auszublenden. applicationbutton kann in QWidget auch über SARibbonBar::setApplicationButton abgebrochen werden, wenn dies nicht erforderlich ist, und schließlich kann das Thema in QWidget über die globale Funktion sa_set_ribbon_ theme festgelegt werden, da das Thema von SARibbonBar in der Methode SARibbonMainWindow festgelegt ist
# include " SARibbonBar.h "
# include " SARibbonCategory.h "
# include " SARibbonPannel.h "
# include " SARibbonMainWindow.h "
Widget::Widget (QWidget* parent) : QWidget(parent), ui( new Ui::Widget)
{
// Note: There is a QVBoxLayout layout in the ui file
ui-> setupUi ( this );
// Create SARibbonBar
mRibbonBar = new SARibbonBar ( this );
// there is no need to display the title anymore on QWidget
mRibbonBar -> setTitleVisible ( false );
// it is better to use compact mode directly on QWidget
mRibbonBar -> setRibbonStyle (SARibbonBar::RibbonStyleCompactThreeRow);
// cancel applicationbutton
mRibbonBar -> setApplicationButton ( nullptr );
// Set the theme, although SARibbonMainWindow is not used here,
// but the theme of the Ribbon is defined in SARibbonMainWindow, so SARibbonMainWindow.h should be introduced
sa_set_ribbon_theme ( mRibbonBar , SARibbonMainWindow::RibbonThemeOffice2013);
// QWidgets sets a QVBoxLayout and puts the window in the second layout of the QVBoxLayout,
// and the first layout is given to SARibbonBar, so that SARibbonBar will be on top
ui-> verticalLayout -> insertWidget ( 0 , mRibbonBar );
buildRibbon ( mRibbonBar );
}So sieht es aus:
Die Reihenfolge beim Erstellen eines Menübands besteht darin, eine Kategorie, dann ein Pannel und schließlich eine Werkzeugschaltfläche (Aktion) zu erstellen.
Verwenden Sie SARibbonBar::addCategoryPage um eine Kategorie zu SARibbonBar hinzuzufügen, SARibbonCategory::addPannel um eine Kategorie hinzuzufügen, und SARibbonPannel::addAction um eine Aktion zu Pannel hinzuzufügen
Der folgende Code zeigt ein Beispiel für das Hinzufügen einer Aktion:
// Add main tab - The main tab is added through the addcategorypage factory function.
SARibbonCategory* categoryMain = ribbon-> addCategoryPage (tr( " Main " ));
// Using the addpannel function to create saribponpannel. The effect is the same as that of new saribponpannel, and then call SARibbonCategory:: addpannel.
SARibbonPannel* pannel1 = categoryMain-> addPannel (( " Panel 1 " ));
QAction* actSave = new QAction( this );
actSave-> setText ( " save " );
actSave-> setIcon (QIcon( " :/icon/icon/save.svg " ));
actSave-> setObjectName ( " actSave " );
actSave-> setShortcut (QKeySequence(QLatin1String( " Ctrl+S " )));
pannel1-> addLargeAction (actSave);Durch den obigen Vorgang wird eine Schaltfläche hinzugefügt. Der Effekt ist in der folgenden Abbildung dargestellt:
Sie können „new“ auch direkt aus SARibbonCategory heraus zum Pannel hinzufügen. Der folgende Code sieht dann genauso aus wie der oben:
SARibbonCategory* categoryMain = new SARibbonCategory(tr( " Main " ));
ribbon-> addCategoryPage (categoryMain);
SARibbonPannel* pannel1 = new SARibbonPannel( " Panel 1 " );
categoryMain-> addPannel (pannel1);
QAction* actSave = new QAction( this );
...
pannel1-> addLargeAction (actSave); Verschiedene Layoutstile können über addLargeAction , addMediumAction und addSmallAction kombiniert werden. Einzelheiten finden Sie unter:
./src/example/MainWindowExample/mainwindow.cpp
Die sogenannte Kontextkategorie bezieht sich auf das Label/die Labelgruppe, die nur unter besonderen Umständen erscheint. Wenn Office Word beispielsweise ein Bild auswählt, wird die Kontextkategorie der Bildbearbeitung angezeigt, wie in der folgenden Abbildung dargestellt:
Die Klasse, die der Kontextkategorie in SARibbon entspricht, ist SARibbonContextCategory
Die Kontextkategorie wird normalerweise bei der Initialisierung des Programms erstellt. Es wird normalerweise ausgeblendet und angezeigt, wenn es angezeigt werden muss. Die Kontextkategorie wird wie folgt erstellt:
Da die Kontextkategorie bei Verwendung aufgerufen werden muss, empfiehlt es sich, sie mit einer Mitgliedsvariablen zu speichern. Natürlich können Sie die Suche auch durchlaufen ( SARibbonBar::contextCategoryList kann alle SARibbonContextCategory auflisten).
Header-Datei:
SARibbonContextCategory* m_contextCategory;cpp-Datei:
SARibbonBar* ribbon = ribbonBar();
// Create a contextCategory with random colors
m_contextCategory = ribbon-> addContextCategory (tr( " context " ), QColor());
SARibbonCategory* contextCategoryPage1 = m_contextCategory-> addCategoryPage (tr( " Page1 " ));
// Operate on contextCategoryPage1
......
SARibbonCategory* contextCategoryPage2 = m_contextCategory-> addCategoryPage (tr( " Page2 " ));
// Operate on contextCategoryPage2
...... Die von SARibbonContextCategory erstellte SARibbonCategory wird von SARibbonContextCategory verwaltet. Nur wenn SARibbonContextCategory angezeigt wird, wird die verwaltete SARibbonCategory angezeigt
Hinweis: SARibbonContextCategory ist kein Widget.
Um einen Kontext anzuzeigen, verwenden Sie
SARibbonBar::showContextCategory / SARibbonBar::hideContextCategory :
void MainWindow::onShowContextCategory ( bool on)
{
if (on) {
this -> ribbonBar ()-> showContextCategory (m_contextCategory);
} else {
this -> ribbonBar ()-> hideContextCategory (m_contextCategory);
}
} **Hinweis: ** Wenn Sie contextCategory löschen möchten, müssen Sie SARibbonBar::destroyContextCategory aufrufen, anstatt direkt zu löschen. Nach dem Aufruf von SARibbonBar::destroyContextCategory müssen Sie den Zeiger von ContextCategory nicht löschen.
Unterschiedliche Kontextkategorien haben unterschiedliche Stile. Einzelheiten finden Sie unter: [SARibbon-Stil](#SARibbon-Stil) und [Vergleich unter verschiedenen Stilen anzeigen](#Vergleich unter verschiedenen Stilen anzeigen).
In der oberen linken Ecke der Multifunktionsleistenoberfläche befindet sich eine spezielle und offensichtliche Schaltfläche namens ApplicationButton . Diese Taste wird im Allgemeinen zum Aufrufen von Menüs verwendet. SARibbonBar erstellt während der Erstellung standardmäßig ApplicationButton . Der Text kann auf folgende Weise festgelegt werden:
SARibbonBar* ribbon = ribbonBar();
ribbon-> applicationButton ()->setText(( " File " )); Der standardmäßige applicationButton erbt von SARibbonApplicationButton und SARibbonApplicationButton erbt von QPushButton , sodass Sie alle Vorgänge für QPushButton ausführen können. Wenn Sie Ihren eigenen Button als applicationButton festlegen möchten, können Sie natürlich einfach die Funktion SARibbonBar::setApplicationButton aufrufen.
QuickAccessBar ist die Schnellsymbolleiste in der oberen linken Ecke und rightButtonGroup ist die Schnellsymbolleiste in der oberen rechten Ecke. Im Büromodus ist es in eine linke und eine rechte Seite unterteilt. Im WPS-Modus werden die linke und rechte Seite kombiniert und auf der rechten Seite platziert.
In SARibbon :
SARibbonQuickAccessBar -Klasse.SARibbonQuickAccessBar -Klasse. Während der Initialisierung erstellt SARibbonBar standardmäßig QuickAccessBar und RightButtonGroup. Seine Zeiger können über SARibbonBar::quickAccessBar und SARibbonBar::rightButtonGroup abgerufen werden. Beispiele sind wie folgt:
QAction* MainWindow::createAction ( const QString& text, const QString& iconurl, const QString& objName)
{
QAction* act = new QAction ( this );
act-> setText (text);
act-> setIcon ( QIcon (iconurl));
act-> setObjectName (objName);
return act;
}
void MainWindow::initQuickAccessBar (){
SARibbonBar* ribbon = ribbonBar ();
SARibbonQuickAccessBar* quickAccessBar = ribbon-> quickAccessBar ();
quickAccessBar-> addAction ( createAction ( " save " , " :/icon/icon/save.svg " , " save-quickbar " ));
quickAccessBar-> addSeparator ();
quickAccessBar-> addAction ( createAction ( " undo " , " :/icon/icon/undo.svg " ), " undo " );
quickAccessBar-> addAction ( createAction ( " redo " , " :/icon/icon/redo.svg " ), " redo " );
quickAccessBar-> addSeparator ();
}
void MainWindow::initRightButtonGroup (){
SARibbonBar* ribbon = ribbonBar ();
SARibbonButtonGroupWidget* rightBar = ribbon-> rightButtonGroup ();
QAction* actionHelp = createAction ( " help " , " :/icon/icon/help.svg " , " help " );
connect (actionHelp, &QAction::triggered, this , &MainWindow::onActionHelpTriggered);
rightBar-> addAction (actionHelp);
} SARibbon unterstützt das Wechseln zwischen vier Multifunktionsleistenstilen. Hierbei wird auf den Ribbon-Stil von office und WPS verwiesen. Der Online-Stilwechsel kann durch void SARibbonBar::setRibbonStyle(RibbonStyle v) realisiert werden.
Der office Modus ist der gebräuchlichste Multifunktionsleistenmodus. Die tab und die Titelleiste nehmen mehr Platz ein. Der von WPS entwickelte Multifunktionsleistenmodus wurde verbessert Reduzieren Sie die Höhe einer Titelleiste, nutzen Sie den vertikalen Raum effektiv und ändern Sie gleichzeitig das Tastenlayout des Panels von maximal 3 auf 2, wodurch der vertikale Raum weiter komprimiert wird
Screenshot-Vergleich zwischen der Word-Schnittstelle von Office und der Word-Schnittstelle von WPS
Unter dem normalen Bildschirm reduziert der WPS-Stil die vertikale Höhe um mindestens 30 Pixel im Vergleich zum Office-Stil, was einer Einsparung von fast 3 % des vertikalen Platzes im Vergleich zum 1920*1080-Bildschirm entspricht.
In SARibbon heißt die Titelleiste Loose, und die Elemente des Loose-Layouts sind wie unten gezeigt angeordnet:
Dieses Layout stimmt mit dem Standardlayout von Office überein
In SARibbon wird das Layout mit Titelleiste und Registerkarte als kompaktes Layout bezeichnet, und die Elemente des kompakten Layouts sind wie folgt angeordnet:
SARibbonBar stellt eine setRibbonStyle -Funktion bereit, die den aktuellen Layoutstil definiert, und die Aufzählung von SARibbonBar::RibbonStyle definiert vier Layoutschemata:
SARibbonBar::RibbonStyleLooseThreeRow Loose With Three Row (Die v0.x-Version ist SARibbonBar::OfficeStyle ) 
SARibbonBar::RibbonStyleLooseTwoRow Lose mit zwei Zeilen (Die v0.x-Version ist SARibbonBar::OfficeStyleTwoRow ) 
SARibbonBar::RibbonStyleCompactThreeRow Kompakt mit drei Zeilen (Die v0.x-Version ist SARibbonBar::WpsLiteStyle ) 
SARibbonBar::RibbonStyleCompactTwoRow Kompakt mit zwei Zeilen (Die v0.x-Version ist SARibbonBar::WpsLiteStyleTwoRow ) 
Mit der Funktion SARibbonBar::setEnableWordWrap können Sie steuern, ob der Text der SARibbonBar umgebrochen wird oder nicht, die Höhe der SARibbonBar ist festgelegt und ob der Text umgebrochen wird oder nicht, wirkt sich auf die Größe der Symbolanzeige aus, also wenn Sie das Symbol möchten Um größer zu wirken, können Sie den Text so einstellen, dass er nicht umbrochen wird
Im SARibbonBar::RibbonStyleCompactTwoRow -Layoutstil wird der Text ohne Umbruch wie folgt angezeigt:
SARibbonBar::RibbonStyleCompactTwoRow eine 2-Punkte-Kombination SARibbonBar::setEnableWordWrap(false) ).
Wenn der SARibbonBar-Text auf „Nicht umbrechen“ eingestellt ist, wird der Anzeigebereich des Symbols größer
SARibbonPannel bietet drei Methoden zum Hinzufügen von Aktionen:
addLargeActionaddMediumActionaddSmallActionIm Standard-Panel verfügt eine Aktion (Schaltfläche) über drei Layouts. Am Beispiel von Office Word entsprechen die drei Layouts des Pannels tatsächlich der Anzahl der belegten Zeilen:
SARibbonPannelItem::RowProportion wird verwendet, um die Anzahl der Zeilen darzustellen, die jedes Formular im Pannel einnimmt. Es wird häufig im Panel-Layout verwendet. Diese Aufzählung ist wie folgt definiert:
/* *
* @brief defines the proportion of rows. The ribbon has three proportions: large, media and small.
*/
enum RowProportion {
None // /< to define the proportion, it will be judged according to expandingDirections. If Qt::Vertical is available, it is equal to Large, otherwise it is Small
, Large // /< Large proportion, the height of a widget will fill the whole pannel.
, Medium // /< Medium proportion will only work when @ref SARibbonPannel::pannelLayoutMode is @ref SARibbonPannel::ThreeRowMode, and will occupy two of the three rows if both of them in the same column are Medium.
, Small // /< Small proportion, in the line of SARibbonPannel, Medium will become Small if it does not meet the conditions, but will not become Large.
}; Jede in SARibbonPannel verwaltete Aktion verfügt über eine private Eigenschaft ( SARibbonPannelItem::RowProportion ). Diese Eigenschaft bestimmt das Layout dieser Aktion im Panel.
SARibbonPannel Layoutmodus Der Drei-Zeilen-Modus ist das traditionelle Panel-Layout, wie in der folgenden Abbildung dargestellt:
Im 3-Zeilen-Modus gibt es drei Arten von Platzhaltern: groß, mittel und klein
Das Pannel im 3-Zeilen-Modus zeigt den Titel des Pannels im Pannel-Titelbereich an, und es gibt einen weiteren OptionAction-Bereich. Dieser Bereich wird verwendet, um dieser Aktion einen speziellen Auslöser hinzuzufügen. Wenn OptionAction nicht gesetzt ist, wird dieser Bereich ausgeblendet.
Der zweizeilige Modus ist die WPS-verbesserte Layoutmethode, wie in der folgenden Abbildung dargestellt:
Im 2-Zeilen-Modus sind die mittleren und kleinen Platzhalter (SARibbonPannelItem::RowProportion) gleich und es wird kein Unterschied gemacht.
Im 2-Zeilen-Modus zeigt das Pannel den Titel nicht an.
Die Anpassung des Menübands ist eine Funktion des Menübands. Mithilfe der benutzerdefinierten Benutzeroberfläche von Office und WPS können Benutzer viele Inhalte für ihr eigenes Menüband definieren oder sogar eine Benutzeroberfläche definieren, die sich völlig von der ursprünglichen unterscheidet.
Das Folgende ist die benutzerdefinierte Benutzeroberfläche von Office.
SARibbon bezieht sich auf die Schnittstelle von Office und WPS und kapselt die benutzerfreundliche Klasse SARibbonCustomize** , einschließlich der folgenden fünf Klassen:
SARibbonCustomizeDialogSARibbonCustomizeWidgetSARibbonCustomizeDataSARibbonActionsManagerSARibbonActionsManagerModel
Tatsächliche Benutzer können nur SARibbonActionsManager und SARibbonCustomizeDialog / SARibbonCustomizeWidget verwenden, andere Benutzer werden sie nicht normal verwenden.
SARibbonActionsManager wird verwendet, um QAction zu verwalten, die QAction , die angepasst werden soll, zu SARibbonActionsManager zur Verwaltung hinzuzufügen und QAction zu klassifizieren, damit sie in SARibbonCustomizeDialog / SARibbonCustomizeWidget angezeigt werden können.
SARibbonCustomizeDialog / SARibbonCustomizeWidget ist ein spezifisches Anzeigefenster. Der SARibbonCustomizeDialog kapselt den SARibbonCustomizeWidget als Dialogfeld. Wenn Sie es wie Office in das Konfigurationsdialogfeld integrieren möchten, können Sie das SARibbonCustomizeWidget verwenden. Die Auswirkung von SARibbonCustomizeDialog ist in der folgenden Abbildung dargestellt:
So fügen Sie benutzerdefinierte Funktionen hinzu.
Definieren Sie zunächst SARibbonActionsManager als Mitgliedsvariable von MainWindow .
// Define member variables in the MainWindow.h.
SARibbonActionsManager* m_ribbonActionMgr; // /< Manage all actions Während der Initialisierung von MainWindow muss eine große Anzahl von QAction erstellt werden. Das übergeordnete Objekt von QAction wird als MainWindow bezeichnet. Darüber hinaus wird ein Ribbon-Layout generiert, z. B. das Hinzufügen einer Kategorie, das Hinzufügen eines Panels und andere Vorgänge. Fügen Sie nach Abschluss der oben genannten Vorgänge die folgenden Schritte hinzu, damit SARibbonActionsManager automatisch alle QAction verwalten kann.
// Initialization of MainWindow and generation of QAction.
// Generate ribbon layout.
m_ribbonActionMgr = new SARibbonActionsManager(mainWinowPtr);
m_ribbonActionMgr-> autoRegisteActions (mainWinowPtr); Die Schlüsselfunktion autoRegisteActions von SARibbonActionsManager kann alle Unterobjekte unter SARibbonMainWindow durchlaufen, Aktionen suchen und registrieren und alle SARibbonCategory durchlaufen. Die Aktionen unter SARibbonCategory werden nach dem Titelnamen von SARibbonCategory klassifiziert. Diese Funktion registriert auch die Aktionen unter SARibbonMainWindow , jedoch nicht unter einer Kategorie, als „NotInRibbonCategoryTag“-Tags. Der Standardname ist „nicht im Menüband“.
So rufen Sie SARibbonCustomizeDialog wie folgt auf:
QString cfgpath = " customization.xml " ;
SARibbonCustomizeDialog dlg ( this , this );
dlg.setupActionsManager(m_ribbonActionMgr);
dlg.fromXml(cfgpath); // This step is called to load the existing custom steps, which can be added based on the original custom steps when saving.
if (QDialog::Accepted == dlg.exec()) {
dlg. applys (); // Apply custom steps
dlg. toXml (cfgpath); // Save custom steps to a file
}Bevor das MainWindow generiert wird, muss der angepasste Inhalt geladen werden. Daher sollte dem Konstruktor die folgende Anweisung hinzugefügt werden:
// Constructor of MainWindow
sa_apply_customize_from_xml_file ( " customization.xml " , this , m_ribbonActionMgr); sa_apply_customize_from_xml_file ist die in SARibbonCustomizeWidget.h bereitgestellte Funktion. Die angepassten Inhalte in der Konfigurationsdatei werden direkt im MainWindow angewendet.
Auf diese Weise wird die Software bei jedem Start entsprechend der Konfigurationsdatei geladen.
Github – https://github.com/czyt1988/data-workbench
Gitee – https://gitee.com/czyt1988/data-workbench
Der spezifische Code zur Generierung des Menübands ist zu sehen:
https://github.com/czyt1988/data-workbench/blob/master/src/APP/DAAppRibbonArea.cpp
Es gibt zwei Möglichkeiten, sich auf das Thema High-DPI-Bildschirmdarstellung vorzubereiten:
Qt::AA_EnableHighDpiScaling für QApplication in der Hauptfunktion festDieses Attribut ermöglicht es der Anwendung, die Pixeldichte der Anzeige automatisch zu erkennen, um eine automatische Skalierung zu erreichen, wie zum Beispiel:
int main ( int argc, char * argv[])
{
# if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
QApplication::setAttribute (Qt::AA_EnableHighDpiScaling);
QApplication::setAttribute (Qt::AA_UseHighDpiPixmaps);
# endif
QApplication a (argc, argv);
......
}QApplication in der Hauptfunktion fest: QApplication::setHighDpiScaleFactorRoundingPolicy Qt5.6 bietet Qt::AA_EnableHighDpiScaling , kann das Problem von Bildschirmen mit hoher DPI jedoch nicht vollständig lösen. Qt5.14 hat eine Richtlinieneinstellung für die Bildschirmskalierung mit hoher Auflösung namens QApplication::setHighDpiScaleFactorRoundingPolicy bereitgestellt, die auch in der Hauptfunktion festgelegt werden muss, zum Beispiel:
int main ( int argc, char * argv[])
{
# if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
QApplication::setAttribute (Qt::AA_EnableHighDpiScaling);
QApplication::setAttribute (Qt::AA_UseHighDpiPixmaps);
# endif
# if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
QApplication::setHighDpiScaleFactorRoundingPolicy (Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
# endif
QApplication a (argc, argv);
......
} Es wird häufig die Rückmeldung gegeben, dass nach der Verwendung von SARibbonBar die Tastenkombinationen inaktiver Registerkarten nicht reagieren und nur die Tastenkombinationen aktivierter Registerkarten reagieren. Im herkömmlichen Symbolleistenmodus bleibt die Tastenkombination wirksam, da die Symbolleiste, in der sich die Aktion befindet, immer im Vordergrund steht. Wenn es sich jedoch um SARibbonBar handelt, wird die Tastenkombination im Aktionsbereich ausgeblendet und nach dem Ausblenden nicht wirksam. Wenn Sie möchten, dass die Tastenkombination unabhängig davon wirksam wird, ob Pannel ausgeblendet ist oder nicht, legen Sie die Tastenkombination fest. Die Eigenschaft „shortcutContext“ von Qt::ApplicationShortcut ist ebenfalls ungültig. In diesem Fall können Sie die Tastenkombination manuell an der Stelle erstellen, an der Sie die Kategorie erstellt haben
Beispiel:
ribbon build
...
QShortcut* shortCut = new QShortcut(QKeySequence(QLatin1String( " Ctrl+S " )), this );
connect (shortCut, &QShortcut::activated, this , [ actSave ]() {
actSave-> trigger ();
});
