Anpassen des Menübands in Visio 2010 mithilfe eines Visual Studio 2010-Add-Ins (maschinell übersetzt)

Office 2010
Gg617997.Important(de-de,office.14).gifWichtig:

Dieser Artikel wurde maschinell übersetzt. Bitte beachten Sie den Haftungsausschluss. Die englische Version des Artikels ist als Referenz hier verfügbar: here.

Zusammenfassung:  Sie lernen, wie Sie mithilfe von Microsoft Visual Studio 2010 ein Microsoft Visio 2010-Add-In erstellen können, um die Menübandkomponente der Microsoft Office Fluent-Benutzeroberfläche (UI) programmgesteuert anzupassen.

Gilt für: Microsoft Visio 2010, Microsoft Visual Studio 2010

Veröffentlicht:  Februar 2011

Zur Verfügung gestellt von:  Saul Candib, Microsoft Corporation

Inhalt

Einführung

In dem Artikel Anpassen der 2007 Office Fluent-Multifunktionsleiste für Entwickler (Teil 1 von 3), die Autoren die Multifunktionsleisten-Komponente, der dann ganz neue Microsoft Office Fluent-Benutzeroberfläche eingeführt (UI), wie folgt:

"Entwickler haben die Tools und Programmierstrukturen in früheren Versionen von Office Fluent-Benutzeroberfläche auf kreative Weise erweitern genutzt. Beispielsweise aktiviert das Objektmodell des Befehls Balken Entwickler umfassende Lösungen in ihre benutzerdefinierten Office-Anwendungen zu erstellen. In dieser Tradition fortgesetzt wird, führt ein UI-Erweiterbarkeits-ein innovatives Modell, das Sie verwenden können, um die Benutzerfreundlichkeit verbessern. Verwenden Sie extensible Markup Language (XML) und eine von mehreren konventionellen Programmiersprachen bearbeiten Sie die Komponenten, aus denen der Fluent-Benutzeroberfläche besteht. Da XML nur Text enthält, können Sie Anpassungsdateien in einem beliebigen Texteditor erstellen, die Arbeit mit der Fluent-Benutzeroberfläche vereinfacht. Sie können auch benutzerdefinierte Fluent-Benutzeroberfläche-Dateien mit einem Minimum an Anpassungen wiederverwenden da jede Anwendung dasselbe Programmiermodell verwendet."

In Microsoft Office 2007 enthaltenen Anwendungen, die die Office Fluent-Benutzeroberfläche verwendet Word, Excel, PowerPoint und Outlook. Visio hat auch für das Jahr 2010 die Office Fluent-Benutzeroberfläche und der Multifunktionsleiste erlassen. In diesem Artikel erfahren Sie, wie ein Microsoft Visual Studio 2010 verwaltetem Code Add-in-Projekt (, eine XML-Ressource enthält) und einige zusätzliche Beispielcode aus der Visio-2010-SDK -Codebeispielbibliothek zum Anpassen der Multifunktionsleiste in Visio 2010 verwenden.

Gg617997.note(de-de,office.14).gifHinweis:

Dieser Beispielcode ist in den Artikel aufgenommen, so Sie nicht separat aus dem Visio 2010 SDK downloaden müssen.

Wenn das Projekt wird erstellt und, Microsoft Visio 2010 veröffentlicht, nimmt das Add-in ausgeführt die folgenden Änderungen an der Visio-Benutzeroberfläche:

  • Es fügt eine neue Registerkarte der Multifunktionsleiste, enthält eine benutzerdefinierte Schaltfläche, wenn darauf geklickt wird, führt eine benutzerdefinierte Aktion.

  • Es ändert die Funktion des vorhandenen integrierten Fett und Kopieren -Band-Befehle.

  • Einen neuen Befehl hinzugefügt, der im Kontextmenü alle Shapes.

  • Microsoft Office Backstage-Ansicht, die beim Klicken auf die Registerkarte Datei öffnet hinzugefügt eine neue Registerkarte. Die neue Registerkarte enthält eine benutzerdefinierte Schaltfläche und einen benutzerdefinierten Befehl.

Im Allgemeinen sind die folgenden Schritte zum Anpassen der Benutzeroberfläche erforderlich. Jedes Schritt wird in den entsprechenden Abschnitten dieses Artikels ausführlicher erläutert:

  1. Erstellen Sie ein Visio 2010-add-in-Projekt in Visual Studio 2010.

  2. Ein Multifunktionsleisten-Erweiterbarkeit-Element zum Projekt hinzufügen.

  3. Erstellen einer XML-Ressource.

  4. Fügen Sie eine benutzerdefinierte UI-Datei zum Projekt hinzu.

  5. Aktivieren Sie das Multifunktionsleisten-Erweiterbarkeit-Element.

  6. Erstellen Sie das Projekt, und Visio Add-in veröffentlichen.

  7. Führen Sie das Add-in in Visio, und Testen Sie die neue Multifunktionsleisten-Benutzeroberfläche.

Erstellen eines Visio-2010 Add-In-Projekts in Visual Studio 2010

Visual Studio 2010 bietet Projektvorlagen, die in beiden der am häufigsten verwendeten verwalteten Code-Programmiersprachen von Microsoft basic Add-Ins für die meisten Office 2010-Anwendungen erstellen: Visual Basic und Visual c#.

So erstellen Sie ein Visio 2010-add-in-Projekt in Visual Studio 2010

  1. Zeigen Sie auf der Registerkarte DateiVisual Studio 2010 auf Neu, und klicken Sie dann auf Projekt.

  2. Doppelklicken Sie in der Liste Installierte Vorlagen auf die verwaltete Sprache Ihrer Wahl, Visual Basic oder Visual C#.

  3. Erweitern Sie den Knoten Office , und klicken Sie dann auf 2010.

  4. Klicken Sie auf Visio 2010-Add-In.

  5. Nennen Sie das Projekt RibbonCustomization, geben Sie den Speicherort für das Projekt speichern, und klicken Sie dann auf OK.

Hinzufügen einer Multifunktionsleisten-Erweiterbarkeit-Element zum Projekt

Nachdem Sie erstellt ein einfaches Add-in-Projekt, stellen Sie verschiedene Änderungen und Ergänzungen zum Projekt funktionsfähig zu machen.

Das Projekt eine Multifunktionsleisten-Erweiterbarkeit-Element hinzu

  1. Im Projektmappen-Explorermit der rechten Maustaste des Projektnamen (Menübandanpassung), zeigen Sie auf Hinzufügen, und klicken Sie dann auf Neues Element.

  2. Wählen Sie die Multifunktionsleiste (XML), und klicken Sie dann auf Hinzufügen.

Visual Studio fügt dem Projekt zwei Dateien hinzu:

  • Eine Klassendatei mit dem Namen Ribbon1.cs oder Ribbon1.vb.

  • Eine XML-Datei mit dem Namen Ribbon1.xml.

Die Ribbon.xml-Datei enthält Markup, das angibt, dass eine einfache Benutzeroberfläche angepasst. Die neue Ribbon1.cs oder Ribbon1.vb-Datei enthält eine Reihe von Anweisungen zur Aktivierung des Elements Multifunktionsleiste (XML) und der Ribbon1-Klassendeklaration.

Erstellen einer XML-Ressource

Es ist am einfachsten, die neue XML-Datei zu verwenden, wenn es als Ressource innerhalb der Projektressourcendatei behandelt. Die resultierende Ressourcendatei zugegriffen wird, und darin enthaltenen XML-Markup wird gelesen, von der GetResourceText-Methode der Ribbon1-Klasse.

So erstellen Sie eine XML-Ressource

  1. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste des Projektnamen (Menübandanpassung), und klicken Sie dann auf Eigenschaften.

  2. Klicken Sie auf die Registerkarte Ressourcen.

  3. Ziehen Sie aus dem Projektmappen-ExplorerRibbon1.xml auf der Entwurfsoberfläche Ressourcen .

    Diese Aktion erstellt eine neue, dateibasierte Ressource mit das XML-Inhalt. Von nun an Visual Studio 2010 speichert automatisch Ribbon1.xml als eine Anwendungsressource, und Sie können diese Inhalte mithilfe von Visual Basic oder Visual C#-Sprachfeatures abrufen.

  4. Schließen Sie das Fenster Eigenschaften . Wenn Sie aufgefordert werden, klicken Sie auf Ja , um die Ressourcen zu speichern.

Hinzufügen einer benutzerdefinierten UI-Klasse-Datei zum Projekt

In der Microsoft Visio Codebeispielbibliothek stellt Visio 2010-SDK eine Beispielklasse namens CustomUI (im folgenden Codebeispiel gezeigt), die lädt der benutzerdefinierten Benutzeroberfläche aus der Datei Ribbon1.xml und, optional, ordnet einem Dokument bestimmte Visio auf die Benutzeroberfläche. Das RibbonCustomization-Projekt wird diese Klassendatei hinzugefügt werden.

Das Projekt eine benutzerdefinierte UI-Klassendatei hinzu

  1. Im Projektmappen-Explorermit der rechten Maustaste des Projektnamen, zeigen Sie auf Hinzufügen, und klicken Sie dann auf Klasse.

  2. Nennen Sie die Klasse CustomUI, und klicken Sie dann auf Hinzufügen, klicken Sie im Dialogfeld Neues Element hinzufügen .

  3. Doppelklicken Sie im Projektmappen-Explorerauf die Benutzerdefinierte UI -Datei.

  4. Fügen Sie den folgenden Code in die Datei im Namespace RibbonCustomization, ersetzen die vorhandenen leeren CustomUI-Klassendeklaration.

    
        /// <summary>This class demonstrates how to import custom UI and display it
        /// only for a specific Visio document. The custom UI is shown when the 
        /// document is active, and is not shown in other contexts, such as when 
        /// other documents are active or in other views such as Print Preview.
        /// </summary>
        public class CustomUI {
    
            /// <summary>A reference to the sample class that creates and manages 
            /// the custom UI.</summary>
            private Ribbon1 customRibbon;
    
            /// <summary>This constructor is intentionally left blank.</summary>
            public CustomUI() {
    
                // No initialization is required.
            }
    
            /// <summary>This method loads custom UI from an XML file and 
            /// associates it with the document object passed in.</summary>
            /// <param name="targetDocument">An open document in a running 
            /// Visio application</param>
            public void DemoCustomUIStart(
                Microsoft.Office.Interop.Visio.Document targetDocument)
            {
    
                Microsoft.Office.Interop.Visio.Application visioApplication =
                    targetDocument.Application;
    
                customRibbon = new Ribbon1();
    
                // Passing in null rather than targetDocument would make the custom
                // UI available for all documents.
                visioApplication.RegisterRibbonX(
                    customRibbon,
                    targetDocument,
                    Microsoft.Office.Interop.Visio.VisRibbonXModes.visRXModeDrawing,
                    "RegisterRibbonX example");
            }
    
            /// <summary>This method removes custom UI from a document.</summary>
            /// <param name="targetDocument">An open document in a running 
            /// Visio application that has custom UI associated with it</param>
            public void DemoCustomUIStop(
                Microsoft.Office.Interop.Visio.Document targetDocument)
            {
    
                Microsoft.Office.Interop.Visio.Application visioApplication =
                    targetDocument.Application;
    
                visioApplication.UnregisterRibbonX(customRibbon, targetDocument);
            }
        }
    
    

    
        '// <summary>This class demonstrates how to import custom UI and display it
        '// only for a specific Visio document. The custom UI is shown when the 
        '// document is active, and is not shown in other contexts, such as when 
        '// other documents are active or in other views such as Print Preview.
        '// </summary>
        Public Class CustomUI
    
            '// <summary>A reference to the sample class that creates and manages 
            '// the custom UI.</summary>
            Private customRibbon As Ribbon
    
            '// <summary>This constructor is intentionally left blank.</summary>
            Public Sub New()
    
                ' No initialization is required.
            End Sub
    
            '// <summary>This method loads custom UI from an XML file and 
            '// associates it with the document object passed in.</summary>
            '// <param name="targetDocument">An open document in a running 
            '// Visio application</param>
            Public Sub DemoCustomUIStart( _
                ByVal targetDocument As Global.Microsoft.Office.Interop.Visio.Document)
    
                Dim visioApplication As Global.Microsoft.Office.Interop.Visio.Application = _
                    targetDocument.Application
    
                customRibbon = New Ribbon()
    
                ' Passing in null rather than targetDocument would make the custom
                ' UI available for all documents.
                visioApplication.RegisterRibbonX(customRibbon, _
                    targetDocument, _
                    Global.Microsoft.Office.Interop.Visio.VisRibbonXModes.visRXModeDrawing, _
                    "RegisterRibbonX example")
            End Sub
    
            '// <summary>This method removes custom UI from a document.</summary>
            '// <param name="targetDocument">An open document in a running 
            '// Visio application that has custom UI associated with it</param>
            Public Sub DemoCustomUIStop( _
                ByVal targetDocument As Global.Microsoft.Office.Interop.Visio.Document)
    
                Dim visioApplication As Global.Microsoft.Office.Interop.Visio.Application = _
                    targetDocument.Application
    
                visioApplication.UnregisterRibbonX(customRibbon, _
                    targetDocument)
            End Sub
    
  5. Speichern Sie das Projekt.

Grundlegendes zu den Zweck des CustomUI-Klasse

Die CustomUI-Klasse importiert die benutzerdefinierte Benutzeroberfläche, die in der Datei Ribbon1.xml und die Ribbon1-Klasse in das angegebene Visio-Dokument definiert ist. Es enthält zwei Methoden:

  • DemoCustomUIStart – die benutzerdefinierte Benutzeroberfläche definiert in der Datei Ribbon1.xml und der Band1 -Klasse mit dem Visio-Zieldokument, das, übergeben wird, unter der Voraussetzung, dass dasselbe Dokument wiederum an die integrierte Application.RegisterRibbonX-Methode des Visio-Objektmodells übergeben wird, lädt. Wenn anstelle des Zieldokuments, Sie null für den zweiten Parameter der Methode RegisterRibbonX übergeben, wird die benutzerdefinierte Benutzeroberfläche in alle Visio-Dokumente geladen.

  • DemoCustomUIStop – entfernt die benutzerdefinierte Benutzeroberfläche aus dem Zieldokument durch die integrierte VisioApplication.UnregisterRibbonX-Methode aufrufen.

Aktivieren das Multifunktionsleistenelement (XML)

Um das Multifunktionsleiste (XML) Element zu aktivieren, das Sie zuvor zum Projekt hinzugefügt, müssen Sie die folgenden drei Schritte ausführen (die auch in die auskommentierte TODO-Abschnitt der Datei Ribbon1.cs oder Ribbon1.vb aufgeführt sind):

  1. Fügen Sie die CreateRibbonExtensibilityObject()-Methode, um die ThisAddIn-Klasse.

  2. Erstellen Sie Rückrufmethoden im Bereich Ribbon Callbacks der Ribbon1-Klasse, um Benutzeraktionen zu behandeln.

  3. Weisen Sie Attribute auf die Steuerelementtags in der Datei Ribbon1.xml, um die entsprechenden Rückrufmethoden im Code zu identifizieren.

Hinzufügen der CreateRibbonExtensibilityObject-Methode der ThisAddIn-Klasse

Die erste Schritt erfordert nur einige kopieren und einfügen. Es definiert die CreateRibbonExtensibilityObject-Methode in der ThisAddIn-Klasse. Diese Methode initialisiert eine neue Instanz der Ribbon1-Klasse und gibt diese Instanz der ThisAddIn-Klasse zurück.

Die CreateRibbonExtensibilityObject-Methode der ThisAddIn-Klasse hinzu

  1. Doppelklicken Sie im Projektmappen-Explorerauf die Ribbon1.cs oder Ribbon1.vb -Datei zu öffnen.

  2. Kopieren Sie folgenden Code aus dem auskommentierte TODO-Abschnitt der Datei Band1 in der Klasse ThisAddIn unterhalb der ThisAddIn_Shutdown-Methode.

    protected override Microsoft.Office.Core.IRibbonExtensibility CreateRibbonExtensibilityObject()
        {
            return new Ribbon1();
        }
    

    Protected Overrides Function CreateRibbonExtensibilityObject() As Microsoft.Office.Core.IRibbonExtensibility
        Return New Ribbon1()
    End Function
    
  3. Speichern Sie das Projekt.

Erstellen von Rückrufmethoden zum Behandeln von Benutzeraktionen im Bereich für die Multifunktionsleisten-Rückrufe der Ribbon1-Klasse

Sie können auf Benutzeraktionen, wie z. B. das Klicken auf eine Schaltfläche auf der Multifunktionsleiste durch Erstellen von Rückrufmethoden reagieren. Rückrufmethoden Ereignisse in Windows Forms-Steuerelemente ähneln, jedoch von einem Attribut in der XML-Code des Benutzeroberflächenelements identifiziert werden. Methoden in der Multifunktionsleistenklasse zu schreiben, und ein Steuerelement ruft die Methode mit den gleichen Namen wie der Wert des Attributs.

So erstellen Sie eine Callback-Methode sind zwei Schritte erforderlich:

  1. Weisen Sie Attribute für Steuerelemente in der Datei Ribbon1.xml, die Rückrufmethoden im Code zu identifizieren. Dies wird im nächsten Abschnitt tun werden.

  2. Definieren Sie die Rückrufmethoden in der Ribbon1-Klasse.

Der Codebeispielbibliothek von Visio 2010 SDK enthält Beispielcode, die insbesondere diese Rückrufe in Visio-add-in-Projekt erstellen soll. In der folgende Code gibt beispielsweise die Callback-Methode OnAction der Aktion, die stattfindet, wenn ein Benutzer klickt auf ein Steuerelement in der benutzerdefinierten Benutzeroberfläche, die das OnAction-Attribut in der Datei Ribbon1.xml definiert hat daher Aufrufen der Methode. In diesem Fall wird die angegebene Aktion um ein Meldungsfeld anzuzeigen.

So erstellen Sie Rückrufmethoden Benutzeraktionen im Bereich für die Multifunktionsleisten-Rückrufe der Ribbon1-Klasse behandeln

  1. Klicken Sie auf die Registerkarte für die Ribbon1.cs oder Ribbon1.vb -Klasse.

  2. Erweitern Sie den Ribbon Callbacks-Bereich.

  3. Fügen Sie folgenden Code in dieser Region.

       
            /// <summary>This method is a callback specified in the onLoad attribute 
            /// of the customUI element in the custom UI XML file. It is called by 
            /// Visio when the custom UI is first loaded.</summary>
            /// <param name="ribbonUI">A reference to the object representing the 
            /// custom UI loaded by Visio</param>
            public void OnRibbonLoad(Microsoft.Office.Core.IRibbonUI ribbonUI)
            {
                // Do something with the newly constructed ribbon, such as capture
                // a local reference to it for later use.
                this.ribbon = ribbonUI;
                MessageBox.Show("Capturing local reference to new ribbon.");            
            }
    
            /// <summary>This method is a callback specified in the custom UI XML 
            /// file. It is called by Visio when the associated button defined 
            /// in the XML is clicked.</summary>
            /// <param name="control">The Ribbon UI control that was activated</param>
            public void OnAction(Microsoft.Office.Core.IRibbonControl control)
            {
                System.Windows.Forms.MessageBox.Show("OnAction");
            }
    
            /// <summary>This method is a callback specified in the custom UI XML 
            /// file. It is called by Visio when the associated repurposed ribbon 
            /// control is clicked.</summary>
            /// <param name="control">The Ribbon UI control that was clicked</param>
            /// <param name="cancelDefault">If true, call the built-in command after 
            /// the custom code is complete</param>
            public void CommandOnAction(Microsoft.Office.Core.IRibbonControl control,
                bool cancelDefault) 
            {
                // Take a custom action when the user clicks Copy.
                System.Windows.Forms.MessageBox.Show("CommandOnAction called: User clicked Copy.");
    
                cancelDefault = false;
            }
    
            /// <summary>This is a helper method that reads the content of a
            /// text file resource embedded in the project.</summary>
            /// <param name="resourceName">The name of the resource</param>
            private static string getResourceText(string resourceName) 
            {
                Assembly executingAssembly = Assembly.GetExecutingAssembly();
                Stream resourceStream = executingAssembly.GetManifestResourceStream(
                    resourceName);
                if (resourceStream != null) 
                   {   
                    StreamReader resourceReader = new StreamReader(resourceStream);
                    return resourceReader.ReadToEnd();
                   }
                else 
                   {
                    return null;
                   }
              }
    

    
            '// <summary>This method is a callback specified in the onLoad attribute 
            '// of the customUI element in the custom UI XML file. It is called by 
            '// Visio when the custom UI is first loaded.</summary>
            '// <param name="ribbonUI">A reference to the object representing the 
            '// custom UI loaded by Visio</param>
            Public Sub OnRibbonLoad(ByVal ribbonUI As Global.Microsoft.Office.Core.IRibbonUI)
                ' Do something with the newly constructed Ribbon, such as capture
                ' a local reference to it for later use.
                this.ribbon = ribbonUI
                System.Windows.Forms.MessageBox.Show("Capturing local reference to new ribbon.")
            End Sub
    
            '// <summary>This method is a callback specified in the custom UI XML 
            '// file. It is called by Visio when the associated button defined 
            '// in the XML is clicked.</summary>
            '// <param name="control">The Ribbon UI control that was activated</param>
            Public Sub OnAction(ByVal control As Global.Microsoft.Office.Core.IRibbonControl)
                System.Windows.Forms.MessageBox.Show("OnAction")
            End Sub
    
            '// <summary>This method is a callback specified in the custom UI XML 
            '// file. It is called by Visio when the associated repurposed ribbon 
            '// control is used.</summary>
            '// <param name="control">The Ribbon UI control that was clicked</param>
            '// <param name="cancelDefault">If true, call the built-in command after 
            '// the custom code is complete</param>
            Public Sub CommandOnAction( _
                ByVal control As Global.Microsoft.Office.Core.IRibbonControl, _
                ByVal cancelDefault As Boolean)
    
                ' Take a custom action when the user clicks Copy.
                System.Windows.Forms.MessageBox.Show("CommandOnAction called: User clicked Copy.")
    
                cancelDefault = False
            End Sub
    
            '// <summary>This method is a helper that reads the content of a
            '// text file resource embedded in the project.</summary>
            '// <param name="resourceName">The name of the resource</param>
            Private Shared Function getResourceText(ByVal resourceName As String) As String
                Dim executingAssembly As Assembly = Assembly.GetExecutingAssembly()
                Dim resourceStream As Stream = executingAssembly.GetManifestResourceStream(resourceName)
                If resourceStream IsNot Nothing Then
                    Dim resourceReader As New StreamReader(resourceStream)
                    Return resourceReader.ReadToEnd()
                Else
                    Return Nothing
                End If
            End Function
    
    
  4. Fügen Sie die folgende Direktive am Anfang der Datei Ribbon1.cs oder Ribbon1.vb.

    using System.Windows.Forms;
    

    Imports System.Windows.Forms
    

    Diese Richtlinie ist erforderlich, da einige der Rückrufmethoden System.Windows.Forms.MessageBox.Show-Methode aufrufen.

  5. Speichern Sie das Projekt.

Die Steuerelementtags in der Datei Ribbon1.xml Attribute zuzuweisen.

Die Datei "Ribbon1.xml" definiert die benutzerdefinierte Benutzeroberfläche, einschließlich einer benutzerdefinierten Multifunktionsleisten-Registerkarte, eine benutzerdefinierte Multifunktionsleiste-Gruppe, eine benutzerdefinierte Multifunktionsleisten-Schaltflächen-Steuerelement, ein benutzerdefiniertes Kontextmenü Menu-Steuerelement und ein benutzerdefiniertes Steuerelement im Menü Datei . Es gibt auch Rückrufmethoden, die aufgerufen werden, wenn ein Benutzer die Steuerelemente in der benutzerdefinierten Benutzeroberfläche zugreift. Darüber hinaus ändert die benutzerdefinierte Benutzeroberfläche auf die Aktion der zwei vorhandenen Steuerelemente in die integrierte Benutzeroberfläche: die Schaltfläche " Fett " und die Schaltfläche Kopieren . Das Visio 2010-SDK enthält Beispiel-XML-Markup, das diese Steuerelemente erstellt, wie in der folgenden Prozedur gezeigt.

Die Steuerelementtags in der Datei Ribbon1.xml Attribute zuweisen

  1. Doppelklicken Sie im Projektmappen-Explorerauf die Datei Ribbon1.xml , um ihn zu öffnen.

  2. Wählen Sie das vorhandene XML-Markup in der Datei, und fügen Sie dann das folgende XML-Markup in die Datei überschreiben das vorhandene Markup.

    <?xml version="1.0" encoding="UTF-8"?>
    <!--RibbonXML.xml
    <copyright>Copyright (c) Microsoft Corporation. All rights reserved.
    </copyright>
    <summary>This XML file demonstrates how to define custom UI and its associated 
    callbacks.</summary>
    -->
    <customUI onLoad="OnRibbonLoad" 
        xmlns="http://schemas.microsoft.com/office/2009/07/customui">
    
        <!--This section repurposes built-in commands.-->
        <commands>
            <!--Disables the Bold command-->
            <command idMso="Bold" enabled="false"/>
            <!--Redirects the built-in Copy ribbon button to a custom callback-->
            <command idMso="Copy" onAction="CommandOnAction"/>
        </commands>
    
        <!--This section defines custom ribbon controls.-->
        <ribbon>
            <tabs>
                <tab id="tab1" label="Custom Tab">
                    <group id="group1" label="Custom Group">
                        <button id="button1" size="large" label="Custom Button" 
                            imageMso="AddOnsMenu" onAction="OnAction"/>
                    </group>
                </tab>
            </tabs>
        </ribbon>
        
        <!--This section defines custom Backstage controls.-->
        <backstage>
            <tab id="tab2" label="Custom Tab">
                <firstColumn>
                    <group id="group2" label="Custom Group">
                        <primaryItem>
                            <button id="button2" label="Custom Button" 
                                imageMso="AddOnsMenu" onAction="OnAction"/>
                        </primaryItem>
                    </group>
                </firstColumn>
            </tab>
            <button id="button3" label="Custom Fast Command" imageMso="AddOnsMenu" 
                onAction="OnAction"/>
        </backstage>
    
        <!--This section defines custom context menu controls.-->
        <contextMenus>
            <contextMenu idMso="ContextMenuShape">
                <button id="button4" label="Custom Button" onAction="OnAction"/>
            </contextMenu>
        </contextMenus>
    </customUI>
     
    
    
  3. Speichern Sie das Projekt.

Beim Erstellen des Projekts und Veröffentlichen des Add-Ins in Visio

Nun, da alle Dateien im Projekt abgeschlossen sind, ist die nächste Schritt erstellen Sie das Add-in-Projekt und das Add-in auf Visio veröffentlichen. Veröffentlichen das Add-in können Sie in Visio ohne viel zusätzliche Arbeit verfügbar.

Erstellen Sie das Projekt und das Add-in in Visio veröffentlichen

  1. Klicken Sie im Visual Studio 2010 im Menü Aufbauen auf Projektmappe erstellen.

  2. Klicken Sie im Projektmappen-Explorermit der rechten Maustaste des Projektnamen (Menübandanpassung), und klicken Sie auf Veröffentlichen.

  3. Klicken Sie auf Weiter , um den Standardspeicherort publishing übernehmen.

  4. Klicken Sie auf Fertig stellen.

  5. Speichern Sie das Projekt.

Das Add-in in Visio ausführen und testen die neue Multifunktionsleisten-Benutzeroberfläche

Sie können nun das Add-in im Visio ausführen und testen die neue Multifunktionsleisten-Benutzeroberfläche, die Sie erstellt haben. Die benutzerdefinierte Benutzeroberfläche sollte Abbildungen 1 und 2 entsprechen.



Abbildung 1. Benutzerdefinierte Registerkarte auf der Multifunktionsleiste

Benutzerdefinierte Registerkarte auf dem Menüband

Abbildung 2. Benutzerdefinierte Registerkarte in der Backstage-Ansicht

Benutzerdefinierte Registerkarte in der Backstage-Ansicht

Führen Sie das Add-in in Visio, und testen die neue Multifunktionsleisten-Benutzeroberfläche

  1. Öffnen Sie Visio 2010.

    Wenn der Neu -Abschnitt der Registerkarte Datei öffnet, Visio zeigt den Meldung "Erfassen von lokalen Verweis auf neue Multifunktionsleiste", die Aktion, die Sie in der OnRibbonLoad-Rückrufmethode in der Datei Ribbon1 angegeben.

  2. Klicken Sie auf OK , um das Meldungsfeld zu schließen.

  3. Klicken Sie im Bereich Vorlage wählen unter Vorlagenkategorienauf Allgemein, wählen Sie Standarddiagramm, und klicken Sie dann auf Erstellen , um einen neuen Standard-Netzwerkdiagramm erstellen.

  4. Ziehen Sie ein Shape aus der Schablone der Standardformen auf das Zeichenblatt.

  5. Doppelklicken Sie auf das Shape, und geben Sie den Satz "This is fett formatierter Text."

  6. Markieren Sie den Text, den Sie eingegeben haben, und klicken Sie dann auf die Schaltfläche Fett auf der Multifunktionsleiste.

    Beachten Sie, dass die Schaltfläche " Fett " nicht verfügbar ist und der Text roman bleibt (nicht fett dargestellt). Dies ist das Ergebnis des Markups in der Datei Ribbon1.xml, die den integrierten Befehl Fett deaktiviert.

  7. Wählen Sie das Shape, und klicken Sie auf Kopieren.

    Visio zeigt die Meldung "CommandOnAction aufgerufen: Kopieren geklickt wurde." Wenn Sie anschließend versuchen, einzufügen, geschieht nichts, da die integrierte Aktion der Multifunktionsleiste Schaltfläche Kopieren mit der neuen Aktion ersetzt haben, die Sie im benutzerdefinierten Rückruf angegeben.

  8. Klicken Sie auf die neuen Multifunktionsleisten-Registerkarte mit der Bezeichnung Benutzerdefinierte Registerkarten, und klicken Sie dann auf die Benutzerdefinierte Schaltfläche enthält.

    Visio zeigt die Meldung "Onaction", um anzugeben, dass die Callback-Methode OnAction aufgerufen wurde.

  9. Mit der rechten Maustaste des Shapes, und klicken Sie im Kontextmenü auf Benutzerdefinierte Schaltfläche.

    Wieder einmal Meldung Visio die "Onaction", da das onAction-Attribut des ContextMenuShape-Steuerelements in der Datei Ribbon1.xml auf OnAction festgelegt ist.

  10. Klicken Sie auf die Registerkarte Datei , und klicken Sie dann auf der Benutzerdefinierte Registerkarten.

    Visio zeigt eine benutzerdefinierte Registerkarte in Backstage-Ansicht, die eine benutzerdefinierte Schaltfläche und einen benutzerdefinierten Befehl enthält. Sie können Experimentieren mit diesen Steuerelementen zu überprüfen, ob sie die erwarteten Aktionen ausführen.

Schlussbemerkung

Visio 2010 übernimmt die Multifunktionsleisten-Komponente von der Office Fluent-Benutzeroberfläche, die in Office 2007 eingeführt wurde. Visio 2010-add-in-Lösungen können Sie in Visual Studio 2010, die XML-Markup verwenden, um die Visio-Multifunktionsleiste anpassen, indem Sie an anderer Stelle Hinzufügen von benutzerdefinierten Multifunktionsleisten-Registerkarten und Steuerelemente als auch benutzerdefinierte Schaltflächen und Steuerelemente der Benutzeroberfläche erstellen. Dieser Artikel zeigt, wie mit verwalteten Code aus der Codebeispielbibliothek von Visio 2010 SDK verwenden, um diese Lösungen erstellen und ausführen und Testen Sie diese in Visio.

Weitere Ressourcen

Gg617997.note(de-de,office.14).gifHinweis:

Haftungsausschluss für maschinelle Übersetzungen: Dieser Artikel wurde mithilfe eines Computersystems und ohne jegliche Bearbeitung durch Personen übersetzt. Microsoft bietet solche maschinellen Übersetzungen als Hilfestellung für Benutzer ohne Englischkenntnisse an, damit Sie von den Informationen zu Produkten, Diensten und Technologien von Microsoft profitieren können. Da es sich bei diesem Artikel um eine maschinelle Übersetzung handelt, enthält er möglicherweise Fehler in Bezug auf (Fach-)Terminologie, Syntax und/oder Grammatik.

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2014 Microsoft