Rubrik: Verschiedenes | VB-Versionen: VB6 | 15.01.08 |
Aufgabenliste als dockendes AddIn für Visual Basic 6.0 In diesem Workshop möchte der Autor zeigen, wie man ein AddIn für VB 6.0 erstellt, das - ähnlich wie in VB 2005 - eine Aufgabenliste bietet, die Kommentare, Aufgaben und Fehler anzeigt. | ||
Autor: Dipl.-Ing.(FH) Marcus Jacob | Bewertung: | Views: 15.763 |
Inhaltsverzeichnis
- Übersicht
- Dockendes Addin
- Ereignisbehandlung
- Hinzufügen eines Icons vor den Menüeintrag
- Das Benutzerinterface
- Füllen der Aufgabenliste
- Springen zum Code
- Zusammenfassung
1. Übersicht
Programme lassen sich sehr schnell mit Visual Basic entwickeln. Mit Visual Basic werden dabei schon einige Tools ausgeliefert, welche das Programmieren erleichtern. So. z.B. der "Resource Editor" oder den „ActiveX-Schnitstellenassistenten“.
Irgendwann wird man aber feststellen, dass bei der täglichen Arbeit mit VB doch so einige Tools fehlen, welche das Schreiben eines Programmes erleichtern könnten. Solche Tools, AddIns genannt, lassen sich in VB einbinden. Leider hat es Microsoft irgendwie versäumt, genauer auf diese Möglichkeit des Erweiterns von VB durch AddIns einzugehen und so findet man in der MSDN sehr wenige Beispiele und Informationen dazu. Auch im Internet gestaltet sich die Suche nach Informationen recht schwierig. Insbesondere Informationen zum VBIDE-Objekt und dessen Klassen, die ja die Grundlage für ein AddIn bilden. Einziger Ausweg bleibt hier wohl nur der "Objekt Browser" und das Ausprobieren der einzelnen Klassen und deren Funktionen.
In diesem Workshop möchte ich zeigen, wie man ein AddIn erstellt, das uns eine Aufgabenliste ähnlich wie in VB2005 auch für die Visual Basic 6 IDE bietet. Hiermit soll es möglich sein Kommentare, Aufgaben und Fehler im Code des Programmes als Kommentare zu vermerken und in der Aufgabenliste anzuzeigen.
Visual Basic liefert uns glücklicherweise ein fast fertiges AddIn-Template, das „nur“ noch entsprechend angepasst werden muss. Hierzu erstellen wir ein neues Projekt und wählen aus der Projektliste den Projekttyp "AddIn" aus. Nun wird das AddIn-Template geladen und im Projektexplorer wird ein neues Projekt "MeinAddIn" angezeigt. Der Vorteil diese Templates ist, dass man sich nicht um die Verweise kümmern muss und es schon fertigen Code für ein AddIn enthält. Die wichtigsten Verweise sind die "Microsoft Office x.x Object Library" für das Erstellen von Menüeinträgen und die "Microsoft Visual Basic 6.0 Extensibility" für den Zugriff auf die VB-IDE sowie der Verweis "Microsoft Add-In Designer". Dieser Verweis bildet das eigentliche Interface zwischen Visual Basic und einem AddIn.
2. Dockendes Addin
Das soeben angelegte AddIn-Projekt besteht aus einer Form (frmAddIn) und einem Designer-Modul (Connect). Die wichtigste Komponente ist das Modul "Connect". Hier wird der Menüeintrag in Visual Basic für das AddIn erstellt und die Verbindung zur Entwicklungsumgebung hergestellt.
Da wir hier ein dockendes AddIn entwickeln möchten, muss das Template noch entsprechend angepasst werden:
Die Entwicklungsumgebung behandelt ein dockendes AddIn so, als wäre es ein eigenes Fenster in der Entwicklungsumgebung. Dies bedeutet, das AddIn kann, wie die anderen Fenster von Visual Basic, an jeder beliebigen Stelle in der Entwicklungsumgebung an andere Fenster andocken. Ein dockendes AddIn hat zu einem "normalen" AddIn zwei Unterschiede: Anstelle einer Form wird in einem dockenden AddIn-Projekt ein Benutzerdokument eingesetzt. Das heißt, die Form muss aus dem Projekt entfernt werden und ein Benutzerdokument muss dem Projekt hinzugefügt werden. Der zweite Unterschied ist, dass das Benutzerdokument in ein Fenster der Entwicklungsumgebung umgewandelt wird. Dieses Umwandeln geschieht im Connect-Modul durch die Funktion "CreateToolWindow" des Window-Objektes und zwar beim Laden des AddIn. Dazu muss der Code im Connect-Modul etwas abgeändert werden. Hier der abgeänderte Code:
Private Sub AddinInstance_OnConnection( _ ByVal Application As Object, _ ByVal ConnectMode As AddInDesignerObjects.ext_ConnectMode, _ ByVal AddInInst As Object, _ custom() As Variant) ' Hinzufügen des AddIns zur VB-IDE On Error GoTo error_handler ' Speichern der VB-Instance Set VBInstance = Application ' VBBuildEvents instanzieren nur in VB6 !!! Set nEvents2 = VBInstance.Events Set VBModeEvents = nEvents2.VBBuildEvents ' Eintrag im Menü erzeugen Set mcbMenuCommandBar = AddToAddInCommandBar("Aufgabenliste") ' Übergeben des Ereignisses an die Behandlungsroutine. Set Me.MenuHandler = VBInstance.Events.CommandBarEvents(mcbMenuCommandBar) If GetSetting(App.Title, "Settings", "Aufgabenliste", "0") = "0" Then ' freie GUID ermitteln, wenn noch keine vorhanden DockingAddInGUID = GUIDGen SaveSetting App.Title, "Settings", "Aufgabenliste", DockingAddInGUID Else ' GUID laden DockingAddInGUID = GetSetting(App.Title, "Settings", "Aufgabenliste", "0") End If ' Hier wird das Userdokument in ein Fenster umgewandelt Set mWindow = VBInstance.Windows.CreateToolWindow(AddInInst, _ "jsdTaskList.dobAddIn", "Aufgabenliste", DockingAddInGUID, mdobAddIn) If ConnectMode = ext_cm_AfterStartup Then If GetSetting(App.Title, "Settings", "DisplayOnConnect", "0") = "1" Then ' Anzeigen der Form nach Connect Me.Show End If End If Exit Sub error_handler: MsgBox Err.Description End Sub
Jedes AddIn benötigt eine GUID. Diese wird in der Registry eingetragen. Im Modul "Connect" im Sub "AddinInstance_OnConnection" prüfen wir ob unser AddIn bereits eine GUID besitzt:
If GetSetting(App.Title, "Settings", "Aufgabenliste", "0") = "0" Then ' freie GUID ermitteln, wenn noch keine vorhanden DockingAddInGUID = GUIDGen SaveSetting App.Title, "Settings", "Aufgabenliste", DockingAddInGUID Else ' GUID laden DockingAddInGUID = GetSetting(App.Title, "Settings", "Aufgabenliste", "0") End If
Ist noch keine GUID vorhanden, so wird eine neue GUID erzeugt. Dies geschieht mittels der Function "GUIDGen" im Modul "modMain". Hierzu ist es notwendig die API zu bemühen. Dazu deklarieren wir zuerst den GUID-Typ und die notwendigen API-Calls:
Private Type GUID Data1 As Long Data2 As Long Data3 As Long Data4(8) As Byte End Type Private Declare Function CoCreateGuid Lib "ole32.dll" ( _ pguid As GUID) As Long Private Declare Function StringFromGUID2 Lib "ole32.dll" ( _ rguid As Any, _ ByVal lpstrClsId As Long, _ ByVal cbMax As Long) As Long
Die Generierung der GUID übernimmt die Function "GUIDGen", welche uns die neue GUID als String zurückliefert:
Public Function GUIDGen() As String ' Erzeugen einer GUID Dim uGUID As GUID Dim sGUID As String Dim tGUID As String Dim bGUID() As Byte Dim lLen As Long Dim RetVal As Long lLen = 40 bGUID = String(lLen, 0) CoCreateGuid uGUID RetVal = StringFromGUID2(uGUID, VarPtr(bGUID(0)), lLen) sGUID = bGUID If (Asc(Mid$(sGUID, RetVal, 1)) = 0) Then RetVal = RetVal - 1 End If GUIDGen = Left$(sGUID, RetVal) End Function
Somit haben wir ein funktionsfähiges dockendes AddIn.
3. Ereignisbehandlung
Die Entwicklungsumgebung bietet die Möglichkeit, auf Ereignisse zu reagieren. Dafür werden durch die Entwicklungsumgebung diverse Events bereitgestellt, welche nur noch ausgewertet werden müssen. An dieser Stelle interessieren uns nur die Events für die Zustandsänderung der Entwicklungsumgebung in Bezug auf "RunModus" und "DesignModus". Schließlich wollen wir vermeiden, dass unser AddIn im "RunModus" der Entwicklungsumgebung benutzt werden könnte. Dies würde unweigerlich zu Fehlern führen.
Bevor wir aber mit diesen Events arbeiten können, müssen wir diese in unserem AddIn deklarieren. Dazu erweitern wir den Code im Modul "Connect", im Deklarationsabschnitt, um folgende Zeilen:
' Implementierung der Events2 Schnittstelle ' nur in VB6 !!! Dim nEvents2 As Events2 ... ' Ereignisbehandlungsroutine für den Status der ' Entwicklungsumgebung (RunModus, DesignModus) ' nur in VB6 !!! Public WithEvents VBModeEvents As VBBuildEvents
Im Code des Benutzerdokumentes muss nun eine öffentliche Variable für den Zustand der Entwicklungsumgebung eingefügt werden:
' 0=RunMode, 1=BreakMode, 2=DesignMode Public IDEMode As Integer
Anschließend fügen wir im Modul „Connect“ folgende Eventhandler ein:
Private Sub VBModeEvents_EnterDesignMode() ' Ereignis nach Wechsel in Design-Modus mdobAddIn.IDEMode = vbext_vm_Design End Sub
Private Sub VBModeEvents_EnterRunMode() ' Ereignis nach Wechsel in Ausführen-Modus mdobAddIn.IDEMode = vbext_vm_Run End Sub
Diese Eventhandler setzen je nach Zustand die zuvor deklarierte Variable im Benutzerdokument. Nun sind wir also in der Lage den Zustand der Entwicklungsumgebung auszuwerten.
4. Hinzufügen eines Icons vor den Menüeintrag
Schaut man sich die Einträge im Menü "Add-Ins" mal genauer an, so stellt man fest, dass bei den meisten AddIns ein Icon vor der Beschriftung angezeigt wird. Beim AddIn-Template wurde die Möglichkeit des Anzeigens eines Icon vor der Beschriftung schlichtweg vergessen. Damit auch wir ein Icon vor die Beschriftung bekommen wird der Code im Modul "Connect" durch zwei Zeilen erweitert und eine Ressourcendatei erstellt. Mit dem Ressourceneditor erstellen wir eine Ressourcendatei mit einem 16x16 Pixel Picture und fügen diese Ressourcendatei unserem Projekt hinzu. Danach erweitert man im Modul "Connect" die Funktion "AddToAddInCommandBar" um zwei Zeilen Code. Unter den Zeilen
' Hinzufügen zum Menü Set cbMenuCommandBar = cbMenu.Controls.Add(1) cbMenuCommandBar.Caption = sCaption
fügen wir folgendes hinzu:
' Hinzufügen Icon zu Menü Clipboard.SetData LoadResPicture(101, 0) cbMenuCommandBar.PasteFace
Nun wird auch bei unserem AddIn ein Icon vor der Beschriftung angezeigt.
5. Das Benutzerinterface
Für das Benutzerinterface orientieren wir uns an der Aufgabenliste aus Visual Basic 2005.
Auf dem Benutzerdokument platzieren wir eine Combobox für die Auswahl der anzuzeigenden Information. Der Eigenschaft List fügen wir folgende Einträge hinzu:
- "Aufgaben"
- "Kommentare"
- "Fehler"
Weiterhin platzieren wir hier ein FlexGrid für die dann anzuzeigenden Kommentarzeilen. Das FlexGrid ist mit folgenden Eigenschaften zu versehen:
Damit unser FlexGrid sich automatisch an die Größe des Fensters anpasst müssen noch einige Anpassungen im Benutzerdokument durchgeführt werden. Die Größenanpassung übernimmt der Code im Sub "UserDocument_Resize":
Private Sub UserDocument_Resize() ' Anpassen der Controls VW = UserDocument.ViewportWidth VH = UserDocument.ViewportHeight ' Begrenzung bis zu welcher AddIn-Größe die Controls ' mit angepasst werden sollen If VW < 235 Then VW = 235 If VH < 95 Then VH = 95 ' Controls anpassen flxToDo.Move 5, 30, VW - 10, VH - 30 End Sub
Da wir im FlexGrid eingestellt haben, dass die horizontale und die vertikale Scrollbar zulässig sind, wollen wir diese auch bei der Größenänderung des Benutzerdokumentes berücksichtigen. Die Spalte für die Einträge der Kommentarzeilen soll sich automatisch anpassen. Hierzu bedienen wir uns der API. Zuerst müssen einige Konstanten und eine API-Funktion deklariert werden:
Private Declare Function GetSystemMetrics Lib "user32" ( _ ByVal nIndex As Long) As Long ' Breite in Pixel für Pfeilsymbol bei horizontaler Scrollbar Private Const SM_CXHSCROLL = 21 ' Höhe in Pixel der horizontalen Scrollbar Private Const SM_CYHSCROLL = 3 ' Breite in Pixel der vertikalen Scrollbar Private Const SM_CXVSCROLL = 2 ' Höhe in Pixel für Pfeilsymbol bei vertikaler Scrollbar Private Const SM_CYVSCROLL = 20
Mit der API-Funktion "GetSystemMetrics" ermitteln wir die Breite der Scrollbars damit diese von der Gesamtbreite der letzten Spalte abgezogen werden kann. Dies geschieht im Sub "SetTodoColumnWidth":
Private Sub SetTodoColumnWidth() ' Ermitteln Spaltenbreite für Beschreibungs-Spalte Dim UsableWidth As Long With flxToDo UsableWidth = (.Width * Screen.TwipsPerPixelX) - _ (GetSystemMetrics(SM_CXVSCROLL) * Screen.TwipsPerPixelX) - 4100 .ColWidth(3) = UsableWidth End With End Sub
Wichtig ist hierbei zu beachten, dass die Größenangaben hier in Pixel vorliegen! Es ist also eine Umwandlung mittels der Funktion "TwipsPerPixelX" des Screen-Objekts notwendig.
Nun fügen Sie noch eine Toolbar für das Schließen und Aktualisieren der Aufgabenliste und ein Imagelist-Control für die Bilder der Toolbar hinzu.
Beim Betätigen der Toolbar-Buttons reagieren wir mit folgendem Sub:
Private Sub tbMain_ButtonClick(ByVal Button As MSComctlLib.Button) ' Toolbar Select Case Button.Key Case "Close" Connect.Hide Case "Refresh" Call FillGrid End Select End Sub
Beim Klick auf den Schliessen-Button schließen wir unser AddIn. Beim Klick auf den Refresh-Button wird unser FlexGrid neu gefüllt. Wie, das verrate ich Ihnen im nächsten Abschnitt.
In der Entwurfsphase zeigt sich dann folgendes Bild:
6. Füllen der Aufgabenliste
Unser AddIn soll in der Lage sein Kommentarzeilen anzuzeigen, welche mit folgenden Tags beginnen:
´ TODO: | für Aufgaben |
´ CMT: | für Kommentare |
´ BUG: | für Fehler |
Diese Tags können natürlich jederzeit durch Sie verändert bzw. geändert oder erweitert werden. Die Auswahl des entsprechenden Tags erfolgt durch die Combobox auf dem Benutzerdokument und wird im Sub "FillGrid" ausgewertet.
' Prüfen der Auswahl Select Case cbAuswahl.Text Case "Aufgaben" sTag = "TODO:" sGridHeader = "<Projekt|<Komponente|<Prozedur|<ToDo" Case "Kommentare" sTag = "CMT:" sGridHeader = "<Projekt|<Komponente|<Prozedur|<Kommentar" Case "Fehler" sTag = "BUG:" sGridHeader = "<Projekt|<Komponente|<Prozedur|<Fehler" End Select
Für das Auslesen der Kommentarzeilen benötigen wir nun den Zugriff auf die geöffneten Objekte und die entsprechenden Code-Module. Hierbei greifen wir auf das VBE-Objekt zurück und iterieren durch alle geladenen Projekte und deren Module im Sub "FillGrid". Hierbei beschränken wir uns für den Quellcode auf folgende Komponenten: Standardmodul, Form, MDI-Form, Klassenmodul, UserControl und ActivXDesigner.
' Iteration durch alle geladenen Projekte For Each VBProj In VBInstance.VBProjects For Each VBMod In VBProj.VBComponents If VBMod.Type = vbext_ct_VBForm Or _ VBMod.Type = vbext_ct_VBMDIForm Or _ VBMod.Type = vbext_ct_StdModule Or _ VBMod.Type = vbext_ct_UserControl Or _ VBMod.Type = vbext_ct_ActiveXDesigner Or _ VBMod.Type = vbext_ct_ClassModule Then lNoCodeLines = VBMod.CodeModule.CountOfLines lNoDeclLines = VBMod.CodeModule.CountOfDeclarationLines lStartLine = 1 lEndLine = -1 lStartCol = 1 lEndCol = -1 ' Suchen des Tags Do Until Not VBMod.CodeModule.Find("'" & sTag, lStartLine, _ lStartCol, lEndLine, lEndCol, False, False, True) sCodeLine = Trim(VBMod.CodeModule.Lines(lStartLine, 1)) sUCCodeline = UCase(sCodeLine) lPos = InStr(1, sUCCodeline, sTag, vbTextCompare) If lPos <> 0 Then If lStartLine <= lNoDeclLines Then sProcName = "Deklarationen" Else lProcType = vbext_pk_Proc sProcName = VBMod.CodeModule.ProcOfLine(lStartLine, lProcType) If lProcType <> vbext_pk_Proc Then Select Case lProcType Case vbext_pk_Get sProcName = sProcName & "(Prop. Get)" Case vbext_pk_Set sProcName = sProcName & "(Prop. Set)" Case vbext_pk_Let sProcName = sProcName & "(Prop. Let)" End Select End If End If ' Hinzufügen Tag zum Flexgrid flxToDo.AddItem VBProj.Name & vbTab & VBMod.Name & vbTab & _ sProcName & vbTab & Trim(Mid(sCodeLine, lPos + Len(sTag))) lNoOfItems = lNoOfItems + 1 flxToDo.RowData(flxToDo.Rows - 1) = lStartLine End If lStartLine = lStartLine + 1 lStartCol = 1 lEndLine = -1 lEndCol = -1 Loop End If Next Next
Wir durchsuchen alle Code-Module und fügen die Informationen über Projekt, Modul und Prozedur sowie die Zeilennummer im Codemodul dem FlexGrid hinzu.
Anschließend formatieren wir unser FlexGrid und „Mergen“ bei gefundenen Kommentarzeilen die Spalten von Projekt, Modul und Prozedur. Dies führt zu einer Darstellung wie man sie aus Pivot-Tabellen kennt und erlaubt uns, auch innerhalb einer Prozedur mehrere Kommentarzeilen mit gleichem Tag zu nutzen und diese übersichtlich darzustellen:
' Formatierung des Flexgrids With flxToDo If lNoOfItems <> 0 Then .RemoveItem 1 .MergeCells = flexMergeRestrictColumns .MergeCol(0) = True .MergeCol(1) = True .MergeCol(2) = True Else Const sNOITEMS = " keine Einträge verfügbar - " .TextMatrix(1, 0) = sNOITEMS .TextMatrix(1, 1) = sNOITEMS .TextMatrix(1, 2) = sNOITEMS .TextMatrix(1, 3) = sNOITEMS .MergeCells = flexMergeRestrictRows .MergeRow(1) = True .RowData(1) = ROWDATAEMPTYLINE End If .Refresh .Redraw = True End With
Nun wird unser FlexGrid mit den entsprechenden Kommentarzeilen aus dem Quellcode gefüllt. Es bietet sich folgendes Erscheinungsbild:
7. Springen zum Code
Nun sind wir in der Lage die definierten Kommentarzeilen in unserem AddIn anzuzeigen. Doch damit nicht genug: Es soll ermöglicht werden, dass man bei einem Klick auf die entsprechende Zeile im AddIn sofort zum Quellcode im Designer der Entwicklungsumgebung gelangt. Die Vorarbeit haben wir bereits im Sub "FillGrid" geleistet. Durch die Übergabe der Zeilennummer an die Eigenschaft "RowData" des Flexgrids wissen wir zu jeder Kommentarzeile die Zeilennummer im Code. Uns sind das Projekt und das Modul bekannt und somit haben wir alle Informationen zusammen welche wir benötigen.
Beim Doppelklick auf eine Zeile führen wir folgenden Code aus:
Private Sub flxToDo_DblClick() ' Springen zur aktuellen Codezeile Call GotoTaggedLine End Sub
Die Hauptarbeit wird im Sub GotoTaggedLine ausgeführt. Zuerst stellen wir sicher, dass die Entwicklungsumgebung sich im "DesignModus" befindet. Anschließend prüfen wir, ob unser AddIn auch Zeilen enthält, die zu einer Kommentarzeile verzweigen könnte. Dies stellen wir wie folgt sicher:
If IDEMode = vbext_vm_Design Then If flxToDo.Row > 1 Or (flxToDo.Row = 1 And _ flxToDo.RowData(1) <> ROWDATAEMPTYLINE) Then …
Danach prüfen wir der Reihe nach, ob das Projekt, das Modul und die Kommentarzeile noch vorhanden sind:
' Prüfung Projekt Set oPrj = VBInstance.VBProjects(sPrjName) If oPrj Is Nothing Then sMsg = "Das Projekt " & sPrjName & " ist nicht in der IDE geladen!" & _ vbCrLf & "Wollen Sie die Aufgabenliste aktualisieren ?" If MsgBox(sMsg, vbYesNo + vbExclamation, "Aufgabenliste") = vbYes Then Call FillGrid Else Exit Sub End If Else ' Prüfung Komponente Set oMod = oPrj.VBComponents(sModName) If oMod Is Nothing Then sMsg = "Das Modul " & sModName & " ist im Projekt" & vbCrLf & _ sPrjName & " nicht vorhanden !" & vbCrLf & _ "Wollen Sie die Aufgabenliste aktualisieren ?" + vbCrLf If MsgBox(sMsg, vbYesNo + vbExclamation, "Aufgabenliste") = vbYes Then Call FillGrid Else Set oPrj = Nothing Exit Sub End If Else ' Lesen der Codezeile sCode = oMod.CodeModule.Lines(lCodeLine, 1) sCodeUC = UCase(Trim(sCode)) lPos = InStr(1, sCodeUC, sTag, vbTextCompare) If lPos = 0 Then sMsg = "Die gewählte Zeile enthält kein gültiges Flag!" & vbCrLf & _ "Wollen Sie die Aufgabenliste aktualisieren ?" If MsgBox(sMsg, vbYesNo + vbExclamation, "Aufgabenliste") = vbYes Then Call FillGrid Else Set oPrj = Nothing Set oMod = Nothing Exit Sub End If Else ' Prüfen/Vergleich Inhalt If Trim(sText) <> Trim(Mid(Trim(sCode), lPos + Len(sTag))) Then sMsg = "Der Inhalt des Flags stimmt nicht mit " & vbCrLf & _ "der Aufgabenliste überein!" & vbCrLf & _ "Wollen Sie die Aufgabenliste aktualisieren ?" If MsgBox(sMsg, vbYesNo + vbExclamation, "Aufgabenliste") = vbYes Then Call FillGrid Else Set oPrj = Nothing Set oMod = Nothing Exit Sub End If Else ' Anzeigen der Codezeile oMod.Activate With oMod.CodeModule.CodePane .Show .TopLine = lCodeLine Call .SetSelection(lCodeLine, 1, lCodeLine, 255) End With End If End If End If End If Else Exit Sub End If
Sofern noch alles in der Entwicklungsumgebung vorhanden ist, aktivieren wir das CodeModul und selektieren die übergebene Kommentarzeile.
' Anzeigen der Codezeile oMod.Activate With oMod.CodeModule.CodePane .Show .TopLine = lCodeLine Call .SetSelection(lCodeLine, 1, lCodeLine, 255) End With
Fällt eine der Prüfungen negativ aus, so wird der Benutzer gefragt, ob die Aufgabenliste aktualisiert werden soll. Sofern er dies bejaht, wird die Aufgabenliste automatisch neu gefüllt.
8. Zusammenfassung
Mit dem hier programmierten AddInn ist es uns nun möglich unsere Aufgaben, Kommentare und Fehlerbeschreibungen im Quellcode zu vermerken und übersichtlich in der Entwicklungsumgebung anzuzeigen bzw. an diese Position im Quellcode zu verzweigen. Gerade wenn mehrere Entwickler beteiligt sind, sind alle Informationen im aktuellen Quellcode verfügbar und es muss keine externe Datei geführt werden.
Der im Beispielprojekt vorhandene Quellcode ist hinreichend kommentiert und erklärt auch die letzten "Geheimnisse", welche hier nicht ausführlich beschrieben wurden.
Weiterführende Informationen für die Programmierung von AddInns hat Frank Schüler in einem sehr empfehlenswerten Tutorial zusammengestellt. Dieses ist erhältlich unter: http://www.activevb.de/tutorials/tut_addin/addin.html
Viel Spaß bei der Nutzung der Aufgabenliste unter Visual Basic 6.
Download Aufgaben-AddIn
Vollständiger Source-Code zu dem in diesem Workshop besprochenen AddIn:
jsdTaskListAddin.zip (37 KB)