Numéro de téléphone : 434014314
Windows (2019, dernière version) | Linux Ubuntu (20.04, dernière version) | Mac (11-dernier) | |
---|---|---|---|
Qt5.12 | |||
Qt5.13 | |||
Qt5.14 | |||
Qt5.15 | |||
Qt6.0 | |||
Qt6.1 | |||
Qt6.2 | |||
Qt6.3 | |||
Qt6.4 | |||
Qt6.5 | |||
Qt6.6 |
Il s'agit d'un Ribbon control
sous framework Qt
, qui propose une interface similaire à celle des logiciels Microsoft Office. SARibbon
convient aux logiciels volumineux, aux logiciels industriels et aux interfaces utilisateur logicielles complexes. SARibbon
est conçu en référence au style de dénomination de l'interface MFC Ribbon, et le style d'interface de SARibbon
fait référence à l'interface Ribbon des logiciels de la série Microsoft Office et du logiciel WPS, et combine les avantages des deux. SARibbon
est un widget de ruban qui peut définir une variété de styles de thème, et il peut définir rapidement le style de thème souhaité via qss. Afin de faciliter le développement de logiciels volumineux, SARibbon
encapsule certains contrôles fonctionnels couramment utilisés, tels que les widgets de couleur.
Thème win7 : Thème office2013 : Thème office2016 : Thème office2021 : thème sombre :
Protocole MIT, bienvenue à tous pour l'utiliser et donner des commentaires
gîte - https://gitee.com/czyt1988/SARibbon
github - https://github.com/czyt1988/SARibbon
SARibbon
fournit à la fois les méthodes de construction qmake et cmake, et fournit un fichier fusionné SARibbon.h
et SARibbon.cpp
pour une intégration statique dans un seul projet.
SARibbon
prend en charge la bibliothèque tierce QWindowKit. En même temps, il prend également en charge des solutions simples sans cadre. Si vous avez besoin d'une prise en charge native des fenêtres pour le système d'exploitation, comme le découpage des bords après Windows 7 et la maximisation de l'effet de survol des boutons dans Windows 11, il est recommandé d'activer la bibliothèque QWindowKit, la bibliothèque QWindowKit peut mieux résoudre le problème du mouvement multi-écran.
Si vous souhaitez vous appuyer sur la bibliothèque QWindowKit, vous devez d'abord compiler la bibliothèque QWindowKit, QWindowKit comme sous-modules du projet SARibbon, si le paramètre '-- recursive' n'est pas inclus dans le 'git clone', la commande 'submodules update' doit être exécuté :
git submodule update --init --recursive
Pour le processus de construction détaillé, reportez-vous au document : Construction de SARibbon
SARibbon fournit une fusion des fichiers SARibbon.h
et SARibbon.cpp
, il vous suffit d'importer ces deux fichiers dans votre propre projet, et en même temps d'importer des fichiers de ressources et des fichiers de bibliothèques tierces à utiliser, pas besoin de compiler dans des bibliothèques dynamiques ou des bibliothèques statiques, vous pouvez vous référer à l'exemple StaticExample (situé dans src/example/StaticExample
), l'intégration statique sera utilisée pour SARibbon.h
, SARibbon.cpp
, SARibbon.pri
, SARibbonBar/resource.qrc
et SARibbonBar/3rdparty
, SARibbonBar/resource
deux dossiers :
Votre répertoire de projet ressemblera à ceci :
|-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
Pour compiler avec qmake, vous pouvez suivre les étapes ci-dessous :
SARibbon.h
, SARibbon.cpp
, SARibbon.pri
dans le répertoire de votre projetSARibbonBar
dans le répertoire de votre projetsrc/SARibbonBar/resource.qrc
dans le code source dans le dossier SARibbonBar
de votre répertoire de projetresource
sous src/SARibbonBar
dans le dossier SARibbonBar
dans le répertoire de votre projetSARibbon.pri
dans le fichier pro de votre projet, par exemple include($$PWD/SARibbon.pri)
Si vous utilisez cmake, reportez-vous à la méthode d'écriture cmake de l'exemple StaticExample (situé dans src/example/StaticExample
)
Une fois la compilation terminée, importez SARibbon comme suit :
Si vous utilisez qmake, vous pouvez simplement copier les fichiers suivants dans votre projet dans une structure de répertoires une fois la compilation terminée
Créez d'abord un dossier tiers dans votre projet, puis copiez l'intégralité du dossier SARibbon. Il existe déjà plusieurs fichiers pri dans SARibbon qui peuvent facilement vous permettre d'importer le projet dans votre propre répertoire, et le fichier ./importSARibbonBarLib.pri
est utilisé pour importer la bibliothèque SARibbon
Après avoir terminé le processus d'appel, vous pouvez ajouter la déclaration suivante au fichier de profil de votre projet Qt
include( $$ PWD/3rdparty/SARibbon/importSARibbonBarLib.pri)
Le processus de compilation de qmake générera le dossier bin_qtx.x_xx sous SARibbon, et les fichiers de bibliothèque et les fichiers dll se trouvent dans ce dossier, et importSARibbonBarLib.pri
référencera automatiquement les bibliothèques dans ce dossier.
À ce stade, le répertoire de votre projet ressemble à ceci :
|-[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]
Il est recommandé d'utiliser cette bibliothèque après l'exécution de install
.
Méthode d'introduction de cmake :
find_package (SARibbonBar REQUIRED)
...
target_link_libraries ({your_target_name} PUBLIC SARibbonBar::SARibbonBar)
Si find_package
ne trouve pas SARibbonBar
, vous devez informer votre projet cmake de l'emplacement d'installation de SARibbon
.
set(SARibbonBar_DIR "[your SARibbonBar installation root directory]/lib/cmake")
Si lors de la compilation, l'option SARIBBON_INSTALL_IN_CURRENT_DIR
est définie sur ON
(par défaut), un dossier bin_qt{Qt version}_{MSVC/GNU}_x{32/64}
sera généré sous le répertoire racine du projet SARibbon comme répertoire d'installation. Il s'agit de s'aligner sur qmake et de faciliter l'installation de plusieurs versions différentes de Qt et de compilateurs sur un seul système d'exploitation. Sinon, sous Windows, il sera installé par défaut dans le dossier C:Program FilesSARibbonBar
.
Pour référence sur l'introduction de SARibbon via cmake, voir src/example/MainWindowExample/CMakeLists.txt
.
Pour plus de détails, reportez-vous à la documentation : SARibbon Building
Le ruban est une combinaison de la barre de menus et de la barre d'outils, et affiché via un contrôle onglet, le ruban ne peut pas être simplement remplacé par Tab + barre d'outils, impliquant beaucoup de détails, SARibbon
fait référence au style de dénomination de l'interface du ruban MFC dans la conception , la page à onglet s'appelle Category
, et il y a plusieurs pannel
sous chaque Category
, en dessous desquels gère le bouton d'outil, pannel
est un peu comme la Toolbar
traditionnelle, avec une hiérarchie comme le montre l'image ci-dessous, et ces noms font référence au Classe d'interface de ruban MFC
Certains noms communs sont expliqués ci-dessous
Category , représentant ce qu'une étiquette présente, correspondant à SARibbonCategory
.
Catégorie de contexte , il s'agit d'une catégorie spéciale. Il ne s'affiche pas normalement. Vous devez juger s'il doit être affiché en fonction du contexte. Le moyen le plus courant est qu'après avoir inséré une image dans Word, une étiquette relative à la modification de l'image apparaît. Si aucune image n’est sélectionnée, l’étiquette disparaîtra. Il s'agit de la catégorie de contexte, correspondant à SARibbonContextCategory
.
Pannel , Il s'agit d'une collection de menus, comme une barre d'outils, correspondant à SARibbonPannel
Bouton d'application , c'est le bouton le plus à gauche de la barre d'onglets (le mot est le bouton de fichier correspondant). Ce bouton déclenchera des pages ou menus spéciaux, correspondant à SARibbonApplicationButton
, qui peuvent être masqués.
Quick Access Bar , une barre d'outils simple en haut pour placer des actions courantes correspondant à SARibbonQuickAccessBar
.
Gallery Control , c’est le contrôle le plus accrocheur du ruban. Il affiche les fonctions avec des images intuitives, et même certains rendus sont réalisés en temps réel selon le contexte. Un exemple typique est la sélection de style dans le mot bureau. correspondant à SARibbonGallery
.
La disposition de SARibbonBar est illustrée dans la figure ci-dessous
Remarque : Différents schémas de disposition affectent l'emplacement de la
Category
etQuick Access Bar
Pour utiliser SARibbon dans MainWindow, vous devez remplacer QMainWindow
par SARibbonMainWindow
, ce qui modifie la façon dont QMainWindow
restitue la barre de menus.
Notez que si vous utilisez un fichier UI, vous devez supprimer le menu du fichier UI, sinon cela pourrait provoquer des exceptions.
L'exemple de code est le suivant :
# include " SARibbonMainWindow.h "
class MainWindow : public SARibbonMainWindow
{
Q_OBJECT
public:
MainWindow (QWidget* par = nullptr );
...
}
SARibbonMainWindow
prend également en charge le rendu en mode normal avec le constructeur suivant :
SARibbonMainWindow (QWidget *parent = nullptr , bool useRibbon = true );
Si le deuxième paramètre est défini sur false, il utilisera le mode normal de la barre d'outils du menu, cette interface est réservée à certains projets qui doivent pouvoir basculer entre les scènes du ruban et de la barre d'outils du menu classique, l'état du ruban et l'état classique ne prennent pas en charge la commutation à chaud. , si vous devez changer, vous pouvez définir un fichier de configuration ou un registre, passer false au deuxième paramètre au redémarrage de l'application pour accéder au mode barre d'outils du menu classique
SARibbonBar
peut être utilisé sur QWidget
ou QDialog
, voir l'exemple: src/example/WidgetWithRibbon
Tout ce que vous avez à faire est d'utiliser SARibbonBar
comme widget normal
Tout d'abord, déclarez le pointeur de SARibbonBar
dans le fichier d'en-tête
private:
Ui::Widget* ui;
SARibbonBar* mRibbonBar { nullptr };
Créez un SARibbonBar
dans le constructeur du Widget, il y a une disposition QVBoxLayout
dans le fichier ui du widget, placez le SARibbonBar
tout en haut, et en même temps, depuis le mode QWidget, il n'y a pas besoin d'afficher le titre, vous pouvez appeler la méthode SARibbonBar::setTitleVisible
pour masquer le titre. applicationbutton peut également être annulé dans QWidget via SARibbonBar::setApplicationButton
si ce n'est pas nécessaire, et enfin puisque le thème de SARibbonBar est défini dans la méthode SARibbonMainWindow
, le thème peut être défini dans QWidget via la fonction globale sa_set_ribbon_ theme
# 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 );
}
Voici à quoi cela ressemble :
L'ordre de création d'un ruban est de créer une catégorie, puis un panneau et enfin un bouton outil (action)
Utilisez SARibbonBar::addCategoryPage
pour ajouter une catégorie à SARibbonBar, SARibbonCategory::addPannel
pour ajouter une catégorie et SARibbonPannel::addAction
pour ajouter une action au Pannel.
Le code suivant montre un exemple d'ajout d'une action :
// 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);
L'opération ci-dessus ajoute un bouton et l'effet est illustré dans la figure suivante :
Vous pouvez également directement sortir de SARibbonCategory
et l'ajouter au panneau, et le code suivant ressemblera à celui ci-dessus :
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);
Différents styles de mise en page peuvent être combinés via addLargeAction
, addMediumAction
, addSmallAction
. Pour plus de détails, voir :
./src/example/MainWindowExample/mainwindow.cpp
La catégorie de contexte fait référence à l'étiquette/au groupe d'étiquettes qui n'apparaît que dans des circonstances particulières. Par exemple, lorsque Office Word sélectionne une image, la catégorie contextuelle d'édition d'image apparaîtra, comme le montre la figure suivante :
La classe correspondant à la catégorie de contexte dans SARibbon est SARibbonContextCategory
La catégorie de contexte est généralement créée lors de l'initialisation du programme. Il est généralement masqué et affiché lorsqu'il doit être affiché. La catégorie de contexte est créée comme suit :
Étant donné que la catégorie de contexte doit être invoquée lorsqu'elle est utilisée, c'est un bon choix de la sauvegarder avec une variable membre. Bien sûr, vous pouvez également parcourir la recherche ( SARibbonBar::contextCategoryList
peut énumérer tous SARibbonContextCategory
).
fichier d'en-tête :
SARibbonContextCategory* m_contextCategory;
fichier cpp :
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
......
Le SARibbonCategory
créé par SARibbonContextCategory
est géré par SARibbonContextCategory
. Ce n'est que lorsque SARibbonContextCategory
est affiché que le SARibbonCategory
géré est affiché
Remarque : SARibbonContextCategory
n'est pas un widget.
Pour afficher un contexte, utilisez
SARibbonBar::showContextCategory
/ SARibbonBar::hideContextCategory
:
void MainWindow::onShowContextCategory ( bool on)
{
if (on) {
this -> ribbonBar ()-> showContextCategory (m_contextCategory);
} else {
this -> ribbonBar ()-> hideContextCategory (m_contextCategory);
}
}
**Remarque : ** si vous souhaitez supprimer contextCategory
, vous devez appeler SARibbonBar::destroyContextCategory
au lieu de supprimer directement. Après avoir appelé SARibbonBar::destroyContextCategory
, vous n'avez pas besoin de supprimer le pointeur de ContextCategory.
Différents contextCategory ont un style différent. Pour plus de détails, voir : [Style SARibbon](#SARibbon style) et [Afficher la comparaison sous différents styles](#Afficher la comparaison sous différents styles).
Il y a un bouton spécial et évident appelé ApplicationButton
dans le coin supérieur gauche de l'interface du ruban. Ce bouton est généralement utilisé pour appeler des menus. SARibbonBar crée ApplicationButton
par défaut pendant la construction. Son texte peut être défini des manières suivantes :
SARibbonBar* ribbon = ribbonBar();
ribbon-> applicationButton ()->setText(( " File " ));
L'applicationButton par défaut hérite de SARibbonApplicationButton
et SARibbonApplicationButton
hérite de QPushButton
, vous pouvez donc effectuer toutes les opérations sur QPushButton
. Bien sûr, si vous souhaitez définir votre propre bouton comme applicationButton, vous pouvez simplement appeler la fonction SARibbonBar::setApplicationButton
.
QuickAccessBar est la barre d'outils rapide dans le coin supérieur gauche et rightButtonGroup est la barre d'outils rapide dans le coin supérieur droit. En mode bureau, il est divisé en côtés gauche et droit. En mode WPS, les côtés gauche et droit seront combinés et placés à droite.
Dans SARibbon
:
SARibbonQuickAccessBar
.SARibbonQuickAccessBar
. Lors de l'initialisation, SARibbonBar
créera QuickAccessBar et RightButtonGroup par défaut. Ses pointeurs peuvent être obtenus via SARibbonBar::quickAccessBar
et SARibbonBar::rightButtonGroup
. Les exemples sont les suivants :
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
prend en charge la commutation entre quatre styles de ruban. Ici, le style de ruban de office
et WPS
est référencé. Le changement de style en ligne peut être réalisé via void SARibbonBar::setRibbonStyle(RibbonStyle v)
.
Le mode office
est le mode ruban le plus courant, l' tab
et la barre de titre occupent plus d'espace, le mode ruban conçu par WPS
a été amélioré, il réduit la hauteur du ruban, l'étiquette et la barre de titre sont assemblées, de manière à réduire la hauteur d'une barre de titre, utiliser efficacement l'espace vertical et, en même temps, la disposition des boutons du panneau passe d'un maximum de 3 à 2, compressant davantage l'espace vertical
Comparaison de capture d'écran entre l'interface Word d'Office et l'interface Word de WPS
Sous l'écran normal, le style WPS réduira la hauteur verticale d'au moins 30 pixels par rapport au style Office, ce qui équivaut à économiser près de 3 % de l'espace vertical par rapport à l'écran 1920*1080.
Dans SARibbon, celui avec la barre de titre s'appelle Loose, et les éléments de la mise en page lâche sont disposés comme indiqué ci-dessous :
Cette mise en page est cohérente avec la mise en page par défaut d'Office
Dans SARibbon, la mise en page avec une barre de titre et un onglet est appelée mise en page compacte, et les éléments de la mise en page compacte sont disposés comme suit :
SARibbonBar fournit une fonction setRibbonStyle
qui définit le style de mise en page actuel, et l'énumération SARibbonBar::RibbonStyle
définit quatre schémas de mise en page :
SARibbonBar::RibbonStyleLooseThreeRow
lâche avec trois rangées (la version v0.x est SARibbonBar::OfficeStyle
) SARibbonBar::RibbonStyleLooseTwoRow
lâche avec deux rangées (la version v0.x est SARibbonBar::OfficeStyleTwoRow
) SARibbonBar::RibbonStyleCompactThreeRow
Compact à trois rangées (la version v0.x est SARibbonBar::WpsLiteStyle
) SARibbonBar::RibbonStyleCompactTwoRow
Compact avec deux lignes (la version v0.x est SARibbonBar::WpsLiteStyleTwoRow
) La fonction SARibbonBar::setEnableWordWrap
vous permet de contrôler si le texte du SARibbonBar s'enroule ou non, la hauteur du SARibbonBar
est fixe et si le texte s'enroule ou non affectera la taille de l'affichage de l'icône, donc si vous voulez que l'icône pour paraître plus grand, vous pouvez définir le texte pour qu'il ne soit pas renvoyé à la ligne
Dans le style de mise en page SARibbonBar::RibbonStyleCompactTwoRow
, le texte sans retour à la ligne s'affiche comme suit :
SARibbonBar::RibbonStyleCompactTwoRow
est un système à 2 versions ( SARibbonBar::setEnableWordWrap(false)
)
Lorsque le texte SARibbonBar est défini sur sans retour à la ligne, l'espace d'affichage de l'icône devient plus grand
SARibbonPannel
propose trois méthodes pour ajouter une action :
addLargeAction
addMediumAction
addSmallAction
Dans le panneau standard, une action (bouton) a trois modes de présentation. En prenant Office Word comme exemple, les trois dispositions du panneau correspondent en fait au nombre de lignes occupées :
SARibbonPannelItem::RowProportion
est utilisé pour représenter le nombre de lignes que chaque formulaire occupe dans le panneau. Il est couramment utilisé dans la disposition des panneaux. Cette énumération est définie comme suit :
/* *
* @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.
};
Chaque action gérée dans SARibbonPannel
aura une propriété privée ( SARibbonPannelItem::RowProportion
). Cette propriété détermine la disposition de cette action dans le panneau.
SARibbonPannel
Le mode trois lignes est la disposition traditionnelle du panneau, comme le montre la figure suivante :
En mode 3 lignes, il existe trois types d'espaces réservés : grand, moyen et petit.
Le panneau en mode 3 lignes affichera le titre du panneau dans la zone Titre du panneau, et il y a une autre zone OptionAction. Cette zone est utilisée pour ajouter un déclencheur spécial à cette action. Si OptionAction n’est pas défini, cette zone est masquée.
Le mode deux lignes est la méthode de mise en page améliorée WPS, comme le montre la figure suivante :
En mode 2 lignes, les espaces réservés moyens et petits (SARibbonPannelItem::RowProportion) sont les mêmes et aucune distinction n'est faite.
En mode 2 lignes, le panneau n'affiche pas le titre.
La personnalisation du ruban est une fonctionnalité du ruban. En référence à l'interface personnalisée d'Office et de WPS, les utilisateurs peuvent définir de nombreux contenus pour leur propre ruban, ou même définir une interface complètement différente de celle d'origine.
Ce qui suit est l’interface personnalisée d’Office.
SARibbon fait référence à l'interface d'Office et de WPS et encapsule la classe SARibbonCustomize**
facile à utiliser, comprenant les cinq classes suivantes :
SARibbonCustomizeDialog
SARibbonCustomizeWidget
SARibbonCustomizeData
SARibbonActionsManager
SARibbonActionsManagerModel
Les utilisateurs réels ne peuvent utiliser que SARibbonActionsManager
et SARibbonCustomizeDialog
/ SARibbonCustomizeWidget
, et les autres utilisateurs ne les utiliseront pas normalement.
SARibbonActionsManager
est utilisé pour gérer QAction
, ajouter la QAction
que vous souhaitez personnaliser à SARibbonActionsManager
pour la gestion et classer QAction
afin qu'elles puissent être affichées dans SARibbonCustomizeDialog
/ SARibbonCustomizeWidget
.
SARibbonCustomizeDialog
/ SARibbonCustomizeWidget
est une fenêtre d'affichage spécifique. Le SARibbonCustomizeDialog
encapsule le SARibbonCustomizeWidget
sous forme de boîte de dialogue. Si vous souhaitez l'intégrer dans la boîte de dialogue de configuration comme Office, vous pouvez utiliser le SARibbonCustomizeWidget
. L'effet de SARibbonCustomizeDialog
est illustré dans la figure suivante :
Voici comment ajouter des fonctionnalités personnalisées.
Tout d’abord, définissez SARibbonActionsManager
comme variable membre de MainWindow
.
// Define member variables in the MainWindow.h.
SARibbonActionsManager* m_ribbonActionMgr; // /< Manage all actions
Lors de l'initialisation de MainWindow
, un grand nombre de QAction
doivent être créées. L'objet parent de QAction
est désigné comme MainWindow
. De plus, une disposition du ruban sera générée, telle que l'ajout d'une catégorie, l'ajout d'un panneau et d'autres opérations. Une fois les opérations ci-dessus terminées, ajoutez les étapes suivantes pour laisser automatiquement SARibbonActionsManager
gérer tous QAction
.
// Initialization of MainWindow and generation of QAction.
// Generate ribbon layout.
m_ribbonActionMgr = new SARibbonActionsManager(mainWinowPtr);
m_ribbonActionMgr-> autoRegisteActions (mainWinowPtr);
La fonction clé autoRegisteActions
de SARibbonActionsManager
peut parcourir tous les sous-objets sous SARibbonMainWindow
, rechercher et enregistrer une action et parcourir tous SARibbonCategory
. Les actions sous SARibbonCategory
sont classées selon le nom du titre SARibbonCategory
. Cette fonction enregistre également les actions sous SARibbonMainWindow
, mais pas dans aucune catégorie, en tant que balises 'NotInRibbonCategoryTag'. Le nom par défaut est 'pas dans le ruban'.
Pour appeler SARibbonCustomizeDialog comme suit :
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
}
Avant que la MainWindow ne soit générée, le contenu personnalisé doit être chargé. Par conséquent, l’instruction suivante doit être ajoutée au constructeur :
// Constructor of MainWindow
sa_apply_customize_from_xml_file ( " customization.xml " , this , m_ribbonActionMgr);
sa_apply_customize_from_xml_file
est la fonction fournie dans SARibbonCustomizeWidget.h
. Le contenu personnalisé du fichier de configuration est directement appliqué dans la MainWindow.
De cette façon, le logiciel sera chargé selon le fichier de configuration à chaque démarrage.
github - https://github.com/czyt1988/data-workbench
gîte - https://gitee.com/czyt1988/data-workbench
Le code spécifique de génération du ruban peut être vu :
https://github.com/czyt1988/data-workbench/blob/master/src/APP/DAAppRibbonArea.cpp
Il existe deux manières de se préparer au problème de l’affichage sur écran haute DPI :
Qt::AA_EnableHighDpiScaling
pour QApplication
dans la fonction principaleCet attribut permet à l'application de détecter automatiquement la densité de pixels de l'affichage pour obtenir une mise à l'échelle automatique, par exemple :
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
dans la fonction principale : QApplication::setHighDpiScaleFactorRoundingPolicy
Qt5.6 fournit Qt::AA_EnableHighDpiScaling
, mais il ne peut pas résoudre complètement le problème des écrans haute résolution. Qt5.14 a fourni un paramètre de stratégie de mise à l'échelle d'écran à haute résolution appelé QApplication::setHighDpiScaleFactorRoundingPolicy
, qui doit également être défini dans la fonction principale, par exemple :
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);
......
}
Les gens disent souvent qu'après avoir utilisé SARibbonBar, les touches de raccourci des pages à onglet inactives ne répondent pas et que seules les touches de raccourci des pages à onglet activées répondent. S'il est en mode barre d'outils traditionnel, la touche de raccourci restera en vigueur car la barre d'outils où se trouve l'action est toujours au premier plan. Cependant, s'il s'agit de SARibbonBar, la touche de raccourci dans le panneau d'action sera masquée et ne prendra pas effet une fois masquée. Si vous souhaitez que la touche de raccourci prenne effet, que le panneau soit masqué ou non, définissez la touche de raccourci. La propriété shortContext 'de Qt::ApplicationShortcut
n'est pas non plus valide. Dans ce cas, vous pouvez créer manuellement la touche de raccourci à l'endroit où vous avez créé la catégorie.
exemple:
ribbon build
...
QShortcut* shortCut = new QShortcut(QKeySequence(QLatin1String( " Ctrl+S " )), this );
connect (shortCut, &QShortcut::activated, this , [ actSave ]() {
actSave-> trigger ();
});