<\/p>\n
Softwareprojekte sind das A und O von Access-Entwicklern und somit auch für Sie. Es sei denn, Sie schnuppern rein zufällig hier herein – und selbst dann können Sie mit der hier vorgestellten Lösung vielleicht etwas anfangen. Diese soll nämlich helfen, ein Softwareprojekt in seine Meilensteine, Iterationen, Kundenstories und Tätigkeiten aufzuteilen und deren Abarbeitung zu organisieren.<\/b><\/p>\n
Ein Softwareprojekt lässt sich in den seltensten Fällen und selbst unter Access nicht auf einer Karteikarte darstellen – und wenn doch, brauchen Sie sicher keine Datenbankanwendung, um ein solches Projekt zu verwalten. Sobald eine Anwendung jedoch aus einigen Tabellen, Abfragen, Formularen, Berichten und dem notwendigen VBA-Code besteht, kann es nicht schaden, das Projekt vernünftig zu planen und auch die Fortschritte festzuhalten. Gerade wenn Sie ein Projekt für einen Kunden entwickeln, werden Sie keine ungenauen Prognosen bezüglich des zeitlichen und finanziellen Aufwands machen und den Kunden bei Abweichungen enttäuschen wollen.<\/p>\n
Es ist daher immer sinnvoll, ein Projekt in der Entwurfsphase so genau wie möglich zu skizzieren, was am einfachsten geht, wenn Sie die Anforderungen genau kennen. Deren Erfassung soll nicht Thema dieses Beitrags sein, sondern lediglich deren Umwandlung in eine Form, die Sie mit der hier vorgestellten Lösung verwalten können. Zugrunde liegen sollten die Informationen jedoch in der folgenden Aufgliederung:<\/p>\n
Die Aufteilung, wie Sie sie hier vorfinden, lehnt sich an das Buch Softwareentwicklung von Kopf bis Fuß <\/b>an (O€Reilly, ISBN 978-3-89721-862-8). Es vermittelt Wissen zum Thema Softwareentwicklung auf witzige Weise, ohne sich auf spezielle Entwicklungsumgebungen festzulegen. Wenn Sie mehr zur Planung von Softwareprojekten erfahren möchten, schauen Sie beim nächsten Besuch Ihrer Lieblingsbuchhandlung einfach einmal hinein, es lohnt sich wirklich.<\/p>\n
Die vorliegende Lösung können Sie natürlich auch ohne die Lektüre dieses Buchs einsetzen. Sie besteht im Wesentlichen aus einem Formular mit einem TreeView<\/b>-Steuerelement, mit dem Sie die oben genannten Elemente einer Softwareentwicklung verwalten können. Das oberste Element ist dabei das Projekt selbst. Darunter finden Sie, hierarchisch untereinander angeordnet, die Meilensteine, Iterationen, Kundenstories und Aufgaben.<\/p>\n
Über Kontextmenüeinträge stellt das TreeView<\/b>-Steuerelement Funktionen zum Anlegen untergeordneter Elemente und zum Löschen der Elemente selbst bereit. In einem Bereich rechts des TreeView-Steuerelements finden Sie Informationen zum jeweils aktivierten Eintrag.<\/p>\n
Damit sich auch der oben angesprochene Motivationseffekt einstellt, gibt es für die Aufgaben auch einen Kontextmenüeintrag, mit dem sich eine Aufgabe als „in Arbeit“ und als „erledigt“ abhaken lässt. Beides führt zur Anzeige eines veränderten Symbols des jeweiligen Eintrags. Sind alle Aufgaben einer Kundenstory erledigt, erhält auch diese ein entsprechendes Symbol.<\/p>\n
Aber die Lösung soll nicht nur beim Erledigen der Aufgaben selbst helfen, sondern auch bei der Planung des Aufwands und somit bei der Kalkulation. In Anlehnung an oben erwähntes Buch können Sie auf zwei Ebenen den geplanten Aufwand eintragen: auf der Kundenstory-Ebene und auf Aufgaben-Ebene.<\/p>\n
Zu Beginn eines Projekts werden Sie sich noch keine Gedanken über die einzelnen Aufgaben machen, die zur Implementierung der für eine Kundenstory nötigen Funktionen führen, sondern zunächst grob abschätzen, wieviel Aufwand die Umsetzung der Kundenstory selbst erfordert. Die Summe dieser Aufwände ergibt eine Grobkalkulation des Projekts, auf deren Basis die grundsätzliche Entscheidung über die Durchführung erfolgen kann. Später werden Sie die einzelnen Aufgaben definieren und deren Aufwand abschätzen. Meilensteine, Iterationen und Kundenstories sollen dann jeweils die Kalkulation auf Basis der groben Abschätzung der Kundenstories und zusätzlich die verfeinerte, auf den Aufgaben basierende Berechnung liefern.<\/p>\n
Als Letztes sollen die Entwickler noch den tatsächlichen Aufwand für die Durchführung einer Aufgabe eintragen, um eine Nachkalkulation zu ermöglichen.<\/p>\n
Zusätzliche Kundenstories und Aufgaben<\/p>\n
Natürlich kann und wird es passieren, dass Kundenstories hinzukommen, wegfallen oder sich ändern und dadurch Aufgaben neu organisiert werden müssen. Die Projektverwaltung soll dazu eine Funktion enthalten, mit der Sie die Planungsphase für das Projekt für beendet erklären können. Neu hinzugefügte Elemente werden dann speziell gekennzeichnet, gelöschte Elemente ebenfalls – nur können diese auch noch ausgeblendet werden.<\/p>\n
Dies dient vor allem dazu, dass der Entwickler dem Kunden erklären kann, warum das Projekt plötzlich zeitintensiver und teurer wird als geplant.<\/p>\n
Mehrbenutzerfähigkeit<\/b><\/p>\n
Bei großen Softwareprojekten sind meist mehrere Softwareentwickler involviert. Aber Access ist nicht gerade für die Entwicklung mit mehreren Personen optimiert und die Erfahrung zeigt, dass die meisten Projekte von Einzelkämpfern durchgeführt werden. Wir verzichten daher zunächst auf die Einrichtung einer zusätzlichen Tabelle zum Speichern mehrerer Benutzer und auf Funktionen zum Zuteilen von Aufgaben an diese Benutzer.<\/p>\n
Datenmodell<\/b><\/p>\n
Das Datenmodell besteht aus einigen hierarchisch verschachtelten Tabellen (siehe Bild 1). Die oberste Tabelle in der Hierarchie heißt tblProjekte<\/b>. Sie enthält neben dem Primärschlüsselfeld lediglich ein Feld zum Speichern des Projektnamens sowie ein Feld namens PlanungAbgeschlossenAm<\/b>. Nach diesem Zeitpunkt hinzugefügte Elemente sollen zur besseren Nachvollziehbarkeit von änderungen, die während des Projekts erfolgen, entsprechend gekennzeichnet werden.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Das Datenmodell der Softwareprojektverwaltung<\/span><\/b><\/p>\n Die Tabelle tblMeilensteine <\/b>ist über das Feld ProjektID <\/b>mit dem Primärschlüsselfeld der Projekte-Tabelle verknüpft und enthält eine Bezeichnung und das Datum des Meilensteins.<\/p>\n Die Tabelle tblIterationen <\/b>ist genauso aufgebaut, aber mit der Tabelle tblMeilensteine <\/b>verknüpft. Gleiches gilt für die Tabelle tblKundenstories<\/b>, die über das Fremdschlüsselfeld IterationID <\/b>mit der Tabelle tblIterationen <\/b>verknüpft ist.<\/p>\n Interessant wird es bei der Tabelle tblAufgaben<\/b>, die wiederum mit tblKundenstories <\/b>verknüpft ist. Sie enthält ebenfalls die beiden Felder Titel <\/b>und Beschreibung <\/b>sowie Felder namens GeschaetzterAufwand <\/b>und TatsaechlicherAufwand<\/b>, die eine Angabe des Aufwands in Stunden erwarten (eine exakte Erfassung der einzelnen Zeiten, zu denen sich der Entwickler mit der Aufgabe beschäftigt, ist hier zunächst nicht geplant).<\/p>\n Das Feld FertiggestelltAm <\/b>erhält das Datum, an dem der Entwickler diese Aufgabe erledigt hat – damit das Symbol des entsprechenden TreeView-Elements auch ein nettes „Erledigt“-Häkchen bekommt und der Entwickler sich frohen Mutes der nächsten Aufgabe zuwenden kann. Damit der Entwickler einen Überblick über den Fortschritt gewinnen kann, gibt es noch ein Feld namens ProzentFertiggestellt<\/b>, das Werte von 0 % bis 100 % in Zehnerschritten annimmt.<\/p>\n Alle Tabellen erhalten ein Feld namens ReihenfolgeID<\/b>, das zur Sortierung der Datensätze im TreeView-Steuerelement und darüber zum Festlegen der Priorität genutzt werden kann. Außerdem erhalten alle Tabellen die Felder AngelegtAm <\/b>und GeloeschtAm<\/b>.<\/p>\n Alle Tabellen besitzen außerdem Felder, die für die Anzeige im TreeView-Steuerelement nötig sind. Das Feld Image <\/b>gibt den Namen einer Bilddatei an, die zum Zeitpunkt der Anzeige in einem entsprechenden ImageList-Steuerelement vorliegen muss – dazu weiter unten mehr. Außerdem gibt es je ein Feld namens Expanded<\/b>, das angibt, ob das zum Datensatz gehörende TreeView-Element seine Unterelemente anzeigen oder verbergen soll.<\/p>\n Formular zur Verwaltung der Softwareprojekte<\/b><\/p>\n Das Formular soll frmSoftwareprojektverwaltung <\/b>heißen und fürs Erste lediglich drei Steuerelemente enthalten:<\/p>\n Ordnen Sie die Steuerelemente wie in Bild 2 und passen Sie Größe und Ausrichtung großzügig an. Das ImageList<\/b>-Steuerelement ist später unsichtbar und kann an beliebiger Stelle platziert werden. Access 2007-Benutzer nutzen die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker<\/b>, damit sich die Steuerelemente automatisch mit dem Formular vergrößern.<\/p>\n Bild 2: Steuerelemente der Softwareprojektverwaltung<\/span><\/b><\/p>\n Mit dem TreeView-Steuerelement fügen Sie dem VBA-Projekt der Anwendung einen Verweis auf die Bibliothek Microsoft Windows Common Controls 6.0<\/b> hinzu; zusätzlich benötigen Sie einen Verweis auf die Bibliothek Microsoft Office x.0 Object Library<\/b>, die das CommandBars<\/b>-Objektmodell für die Programmierung von Kontextmenüs liefert.<\/p>\n TreeView-Konfigurator<\/b><\/p>\n Unter uns gesagt würde die Beschreibung der Ausstattung des TreeViews inklusive Füllung und Funktionen, wie Drag and Drop sowie der restlichen Elemente des gewünschten Formulars und die Synchronisierung zwischen TreeView und Formular, den Rahmen dieses Beitrags bei Weitem sprengen.<\/p>\n Zum Glück stellen wir im Beitrag TreeView-Konfigurator <\/b>(s. Shortlink 667) ein Tool vor, mit dem das Programmieren des TreeViews viel einfacher vonstatten geht – Sie brauchen hier beispielsweise nicht selbst das Füllen des TreeViews, das Anzeigen von Kontextmenüs oder Drag and Drop zu implementieren.<\/p>\n Alles, was Sie tun müssen, ist das Importieren der im oben erwähnten Beitrag genannten Access-Objekte, welche die Funktionalität und die Benutzeroberfläche für das einfache Füllen des TreeViews mitbringen.<\/p>\n TreeView mit Leben füllen<\/b><\/p>\n Fügen Sie dem Formular eine Prozedur für das Ereignis Beim Laden <\/b>hinzu. Diese dient als Ausgangspunkt für das Initialisieren und Füllen des TreeView-Steuerelements.<\/p>\n Erweitern Sie die Prozedur wie folgt und deklarieren Sie außerdem die modulweit gültige Variable objTreeViewHandler<\/b>:<\/p>\n Im Gegensatz zur Vorgehensweise bei der direkten Programmierung des TreeView-Steuerelements brauchen Sie hier noch nicht einmal eine Objektvariable für dieses Element anzulegen.<\/p>\n Die erste Anweisung weist der Objektvariablen objTreeView <\/b>einen Verweis auf das entsprechende Steuerelement des Formulars zu, die beiden Folgenden initialisieren und füllen das TreeView-Steuerelement. Das Initialisieren ersetzt die Einstellungen, die Sie normalerweise im Eigenschaften<\/b>-Dialog des TreeView-Steuerelements vornehmen würden. Dies hat rein praktische Gründe: Sie brauchen nicht lange in den Eigenschaften herumzuspielen, sondern können einfach die Routine InitTreeView <\/b>in die Zielanwendung kopieren und sie anpassen. Sollten die Eigenschaften des TreeView-Steuerelements nicht Ihren Vorstellungen entsprechen, können Sie diese später über die Eigenschaften der Klasse clsTreeViewHandler <\/b>anpassen.<\/p>\n <\/p>\n Unterformular für die Projektübersicht<\/b><\/p>\n Damit das Formular im aktuellen Zustand überhaupt funktioniert, brauchen Sie erstens ein Unterformular namens sfmProjekte<\/b>, dem Sie die Tabelle tblProjekte <\/b>als Datenherkunft zuweisen und dessen Detailbereich Sie mit den beiden Feldern ID <\/b>und Projekt <\/b>der Datenherkunft füllen (siehe Bild 3). Stellen Sie außerdem die Eigenschaft Standardansicht <\/b>auf Datenblatt <\/b>ein.<\/p>\n Die zweite Aktion, die notwendig ist, damit Sie das Formular überhaupt ohne Fehler öffnen können, ist das Anlegen eines TreeViews im TreeView-Konfigurator, den Sie dazu erstmalig öffnen – und zwar in Form des Formulars frmTreeViewConf<\/b>. Dort klicken Sie auf TreeView neu anlegen <\/b>und geben im nun erscheinenden Dialog die Bezeichnung Softwareprojektverwaltung <\/b>ein (siehe Bild 4).<\/p>\n Bild 3: Das Unterformular sfmProjekte in der Entwurfsansicht<\/span><\/b><\/p>\n Bild 4: Anlegen des neuen TreeViews im TreeView-Konfigurator<\/span><\/b><\/p>\n Links unter dem Kombinationsfeld mit dem Namen des neuen TreeViews finden Sie eine ID<\/b> (zum Beispiel 3<\/b>), die Sie nun in die folgende Zeile der oben bereits vorgestellten Prozedur Form_Load <\/b>eintragen:<\/p>\n Öffnen Sie nun das neue Formular frmSoftwareprojektverwaltung<\/b>, sollte Access eine Meldung mit dem Text Die Konfiguration enthält noch keine Tabellen zum Füllen des TreeView-Steuerelements <\/b>anzeigen, nach deren Bestätigung das Formular mit leerem TreeView-Steuerelement erscheint.<\/p>\n Tabellen in den Baum<\/b><\/p>\n Nun beginnen wir mit dem Füllen des Baums. Der erste Schritt ist einfach: Sie legen eine Dummy-Tabelle namens tblRoot<\/b> an, die wie in Bild 5 aufgebaut ist.<\/p>\n Bild 5: Die Dummy-Tabelle liefert das Root-Element für das TreeView-Steuerelement.<\/span><\/b><\/p>\n Dann öffnen Sie erneut den TreeView-Konfigurator und fügen der Konfiguration mit einem Klick auf die Schaltfläche Neue Tabelle <\/b>eine neue Tabelle hinzu. Füllen Sie die folgenden Felder aus:<\/p>\n Klicken Sie auf Tabelle speichern<\/b>, damit sich die Anzeige der Liste der im TreeView enthaltenen Tabellen im oberen Bereich des TreeView-Konfigurators aktualisiert, und schließen Sie diesen. Wenn Sie nun das Formular frmSoftwareprojektverwaltung <\/b>öffnen, erscheint bereits der erste Knoten des TreeViews.<\/p>\n Kontextmenü hinzufügen<\/b><\/p>\n Bevor wir weitere Elemente einbauen, fügen wir nun zunächst ein Kontextmenü zum Root-Element hinzu, mit dem wir ein erstes Projekt in der Datenbank anlegen können.<\/p>\n Öffnen Sie erneut den TreeView-Konfigurator, wählen Sie die Tabelle tblRoot <\/b>aus und fügen Sie im unteren Bereich einen Eintrag mit den folgenden Werten hinzu:<\/p>\n Wenn Sie das Formular frmSoftwareprojektverwaltung <\/b>nun erneut öffnen und mit der rechten Maustaste auf den Eintrag Projekte <\/b>klicken, erscheint das Kontextmenü aus Bild 6. Wie füllen wir dieses nun mit Leben Nun, zunächst einmal brauchen Sie ein kleines Formular, mit dem Sie die Kerndaten des neuen Projekts anlegen können. Dieses sieht ganz einfach wie in Bild 7 aus, heißt frmProjektNeu <\/b>und enthält verhältnismäßig wenig Code. Den Beginn macht die Prozedur Form_Open<\/b>, die das Formular gleich beim Öffnen auslöst:<\/p>\n Bild 6: Ein Kontextmenüeintrag, zunächst noch ohne Wirkung<\/span><\/b><\/p>\n Bild 7: Formular zum Anlegen von Projekten<\/span><\/b><\/p>\n Sie weist dem Fremdschlüsselfeld RootID <\/b>der Tabelle tblProjekte <\/b>den Wert als Standardwert hinzu, der mit dem Öffnungsargument an das Formular übergeben wurde – dazu später mehr.<\/p>\n Die Schaltfläche Abbrechen <\/b>sorgt schlicht für das Schließen des Formulars:<\/p>\n Die OK<\/b>-Schaltfläche hingegen blendet das Formular aus, damit die aufrufende Routine es auswerten kann:<\/p>\n Kontextmenü mit Funktion versehen<\/b><\/p>\n Jetzt müssen Sie dem Kontextmenü nur noch beibringen, das Formular zu öffnen. Dazu nutzen Sie eine Ereignisprozedur der Klasse clsTreeViewConf<\/b>, die Sie über die Auswahl von objTreeViewConf <\/b>und ShortcutMenuClick <\/b>in den beiden Kombinationsfeldern des VBA-Fensters mit dem Klassenmodul des Formulars frmSoftwareprojektverwaltung <\/b>anlegen.<\/p>\n Die Prozedur füllen Sie wie in Listing 1. Die Ereignisprozedur liefert über ihre Parameter jede Menge Informationen woher der Aufruf kommt. strParameter <\/b>liefet den Wert Add<\/b>, den Sie im TreeView-Konfigurator für das Root-Element eingetragen haben. Die übrigen offerieren den Namen der Tabelle, aus welcher das Element stammt, sowie den Primärschlüsselnamen und -wert des entsprechenden Datensatzes. Die Select Case<\/b>-Bedingung prüft den Inhalt von strThisTable <\/b>und verzweigt an die entsprechende Stelle, wobei hier zunächst noch per Code die untergeordnete Tabelle, also tblProjekte<\/b>, und das zum Anlegen eines neuen Datensatzes nötige Formular festgelegt werden.<\/p>\n Listing 1: Aufrufen eines Formulars per Kontextmenü<\/p>\n Dieses heißt natürlich frmProjektNeu <\/b>und wird mit den Argumenten gefüttert, die dazu führen, dass es einen neuen, leeren Datensatz anlegt, aber den Standardwert des Fremdschlüsselfelds RootID <\/b>bereits mit dem Primärschlüsselwert des Datensatzes hinter dem aufrufenden TreeView-Element bestückt.<\/p>\n Nach dem Ausfüllen und Schließen prüft die Routine, die während der Anzeige des Formulars angehalten wurde, ob das Formular noch offen ist – ein Indiz dafür, dass der Benutzer es nicht über die Abbrechen<\/b>-Schaltfläche geschlossen, sondern lediglich über die OK<\/b>-Schaltfläche unsichtbar geschaltet hat.<\/p>\n Fertig – der neue Datensatz muss nur noch im TreeView erscheinen, was eigentlich durch diese Zeile geschehen sollte, welche die Methode NewChildNode <\/b>mit dem Namen der Quelltabelle und dem Wert des Primärschlüsselfelds aufruft:<\/p>\n Es geschieht aber nichts – und auch das Schließen und erneute Öffnen des Formulars frmSoftwareprojektverwaltung <\/b>schafft keine Besserung. Der Grund ist einfach: Die Tabelle tblProjekte <\/b>ist noch nicht im TreeView-Konfigurator definiert, was wir nun nachholen.<\/p>\n Öffnen Sie also den TreeView-Konfigurator, klicken Sie auf Neue Tabelle <\/b>und legen Sie ihre Eigenschaften wie in Bild 8 fest. Im Unterschied zur zuvor festgelegten Tabelle tblRoot <\/b>definieren Sie hier auch ParentTable <\/b>und FKIDField<\/b>, was der übergeordneten Tabelle, also tblRoot<\/b>, und dem Fremdschlüsselfeld der Tabelle tblProjekte <\/b>für die Verknüpfung mit tblRoot <\/b>entspricht.<\/p>\n Bild 8: Eigenschaften der Tabelle tblProjekte für das TreeView<\/span><\/b><\/p>\n Beim nächsten Öffnen zeigt das Formular frmSoftwareprojektverwaltung <\/b>nun auch die neuen Projekt-Knoten an (die Stellen, an denen normalerweise Images erscheinen sollten, bleiben noch leer – darum kümmern wir uns später).<\/p>\n Beachten Sie, welche Aufgaben die Klasse clsTreeViewConf<\/b> alle übernommen hat:<\/p>\n Daten zum TreeView-Element im Unterformular anzeigen<\/p>\n Wenn Sie auf den neuen Projektknoten klicken, würden Sie wohl gern auch die Details zu diesem Projekt im Unterformular neben dem TreeView-Steuerelement sehen. Dort tut sich allerdings noch nichts. Zum Glück liefert die Klasse clsTreeViewConf <\/b>auch hierfür eine Ereignisprozedur. Diese legen Sie im Klassenmodul des Formulars frmSoftwareprojektverwaltung <\/b>wie in Bild 9 an. Das Ereignis liefert einen Verweis auf das angeklickte Element, die dahinterstehende Tabelle, den Namen des Primärschlüsselfeldes sowie dessen Wert. Im Falle des Root-Elements soll einfach nur das Übersichtsformular angezeigt werden, das auch bereits beim Öffnen des Formulars eingeblendet wird. Mehr als den Namen der zugrunde liegenden Tabelle braucht der entsprechende Case<\/b>-Zweig nicht, um das Formular sfmProjekte <\/b>als Unterformular festzulegen.<\/p>\n Bild 9: Dieses Ereignis wird beim Anklicken eines TreeView-Elements ausgelöst.<\/span><\/b><\/p>\n Beim Projekte-Unterformular sieht das anders aus: Dieses soll keine Übersicht aller Projekte, sondern nur die Daten eines speziellen Projekts anzeigen – nämlich jenes, auf das der Benutzer soeben geklickt hat. Dazu filtern die folgenden beiden Anweisungen noch die Datenherkunft des Formulars. Die Zeile<\/p>\n setzt aus dem Inhalt der Variablen strPKID <\/b>und lngPKID <\/b>ein Filterkriterium wie das folgende zusammen:<\/p>\n Unterformular für Projekte erstellen<\/b><\/p>\n Natürlich können wir kein Projekt in einem Unterformular abbilden, das es noch nicht gibt. Also bauen wir schnell eines zusammen, das die Tabelle tblProjekte <\/b>als Datenherkunft besitzt und im Entwurf wie in Bild 10 aussieht. Sie sehen hier nicht ausschließlich Felder, die in der Tabelle tblProjekte<\/b> enthalten sind, sondern auch einige ungebundene Textfelder. Diese sollen die in den weiter unten in der Hierarchie befindlichen Aufgaben enthaltenen Informationen, wie den geplanten Aufwand, den tatsächlichen Aufwand, den aktuellen Fortschritt und das Fertigstellungsdatum für das komplette Projekt, zusammenrechnen. Diese Informationen werden über eine Abfrage ermittelt, die im Ereignis Beim Anzeigen <\/b>ausgewertet wird – mehr dazu später. Das Formular heißt übrigens sfmProjekt <\/b>(man achte auf den Singular im Vergleich zum weiter oben verwendeten Formular sfmProjekte<\/b>).<\/p>\n Bild 10: Das Formular sfmProjekt in der Entwurfsansicht<\/span><\/b><\/p>\n Schließen und öffnen Sie das Formular frmSoftwareprojektverwaltung<\/b>, um sich von der Funktion des Mausklicks auf ein Projekt-Element und der anschließenden Anzeige des entsprechenden Unterformulars zu überzeugen.<\/p>\n Projekte löschen<\/b><\/p>\n Zum Löschen von Projekten brauchen wir einen weiteren Kontextmenüeintrag, den Sie im TreeView-Konfigurator für die Tabelle tblProjekte <\/b>mit den Werten Projekt löschen <\/b>für das Feld ContextmenuCaption <\/b>und Delete <\/b>für das Feld ContextmenuParameter <\/b>anlegen. Warum für die Tabelle tblProjekte <\/b>und nicht für tblRoot<\/b> Anders ginge es nicht: Der Eintrag soll ja in Zusammenhang mit dem jeweiligen Projekt-Element erscheinen, allein damit Sie dessen Daten (Tabellenname, Primärschlüsselfeld, Primärschlüsselwert) in der entsprechenden Ereignisprozedur verarbeiten können.<\/p>\n Die Ereignisprozedur ist die aus Listing 1. Sie brauchen dort nur einen neuen Case<\/b>-Zweig einzubauen. Dieser sieht so aus:<\/p>\n Die Routine fragt einfach nach, ob das Element gelöscht werden soll, und führt dies gegebenenfalls durch einen einfachen Aufruf der Methode DeleteCurrentNode <\/b>durch. Weitere Parameter braucht die Routine hier nicht, weil das aktuelle Element intern alle nötigen Informationen liefert. Was macht diese Routine nun<\/p>\n Top Down<\/b><\/p>\n Auf die gleiche Weise, wie die Tabelle tblProjekte, <\/b>binden Sie von oben nach unten auch die weiteren Tabellen tblMeilensteine<\/b>, tblIterationen<\/b>, tblKundenstories <\/b>und tblAufgaben <\/b>in den TreeView-Konfigurator ein. Dazu müssen Sie jeweils die folgenden Schritte durchführen:<\/p>\n Bottom Up<\/b><\/p>\n In der umgekehrten Richtung gehen wir nun vor, was die Behandlung der für die einzelnen Aufgaben des Projekts eingetragenen Informationen wie geschätzter Aufwand, tatsächlicher Aufwand, Fertigstellungsdatum und Fortschritt angeht.<\/p>\n Wir beginnen mit dem Unterformular sfmAufgabe<\/b>, das im Entwurf wie in Bild 11 aussieht. Wichtig sind hier die Steuerelemente zum Eingeben der oben erwähnten Eigenschaften.<\/p>\n Bild 11: Entwurf des Formulars frmAufgaben<\/span><\/b><\/p>\n Dies hier ist nämlich das einzige Formular, das diese Daten in elementarer Form enthält, das heißt, dass jede Information genau dem aktuellen Datensatz zugeordnet ist. <\/p>\n Gehen wir weiter zum Unterformular sfmKundenstories<\/b>, das die übergeordneten Elemente anzeigen soll (siehe Bild 12).<\/p>\n Bild 12: Das Unterformular sfmKundenstory aggregiert Daten der untergeordneten Aufgaben.<\/span><\/b><\/p>\n Es enthält einige ungebundene Felder, die auf Basis von Informationen aus der Abfrage qryKundenstoryDetails <\/b>gefüllt werden sollen.<\/p>\n Die Abfrage basiert allein auf der Tabelle tblAufgaben<\/b>, ist nach dem Feld KundenstoryID <\/b>gruppiert und besitzt folgende Felder (die Abbildung der Entwurfsansicht ist an dieser Stelle aus Platzgründen nicht möglich):<\/p>\n Diese Abfrage wird beim Anzeigen eines Datensatzes im Unterformular sfmKundenstory <\/b>mit der Ereignisprozedur aus Listing 2 ausgewertet. <\/p>\n Listing 2: Füllen eines Unterformulars mit aggregierten Daten zu den untergeordneten Aufgaben<\/p>\n Dabei werden drei Felder direkt mit den Werten der entsprechenden Abfragefelder gefüllt, das vierte wird nur dann mit dem Fertigstellungstermin der zuletzt fertiggestellten Aufgabe gefüllt, wenn alle Aufgaben zu dieser Kundenstory erledigt sind.<\/p>\n Es gibt noch drei weitere Abfragen, die ähnlich wie Abfrage qryKundenstoryDetail <\/b>aufgebaut sind: qryIterationDetails<\/b>, qryMeilensteinDetails <\/b>und qryProjektDetails<\/b>.<\/p>\n Der einzige Unterschied ist, dass die Aggregierung der gesuchten Informationen jeweils für übergeordnete Tabellen erfolgt und dementsprechend mit jeder Ebene eine Tabelle zur Abfrage hinzukommt – genau so, dass jeweils alle Tabellen enthalten sind, die sich in der Hierarchie unterhalb der im Formular anzuzeigenden Tabelle befinden. qryProjektDetail <\/b>beispielsweise liefert die Daten für das Unterformular sfmProjekt<\/b> und sieht wie in Bild 13 aus.<\/p>\n Bild 13: Diese Abfrage aggregiert Aufgaben-Daten für das komplette Projekt.<\/span><\/b><\/p>\n Images einfügen<\/p>\n Ein wenig nackt sieht ein solches TreeView-Steuerelement ohne jegliches Icon schon aus, also fügen wir welche hinzu, genau genommen zur Tabelle tblImages<\/b>. Dort speichern Sie die Bilddatei, die einen transparenten <\/span>oder weißen Hintergrund liefern sollte, mit der Funktion SaveFileToOLEField <\/b>aus dem Modul mdlOLE <\/b>in der Zieltabelle, hier tblImages <\/b>(für den reibungslosen Betrieb mit dem TreeView-Konfigurator muss diese Tabelle nicht so heißen – aber Sie müssen eine Abfrage namens qryImages <\/b>mit den drei Feldern ID<\/b>, ImageName <\/b>und ImageObject <\/b>auf diese oder eine andere Tabelle mappen, welche ein entsprechendes OLE-Feld enthält). Der Aufruf dieser Funktion lautet beispielsweise wie folgt, wobei c:\\application.png <\/b>die zu speichernde Datei, tblImages <\/b>die Zieltabelle, ImageObject <\/b>das Zielfeld, ID <\/b>das Primärschlüsselfeld und 123 <\/b>der Primärschlüssel für einen bestehenden Datensatz in dieser Tabelle ist:<\/p>\n Haben Sie auf diese Weise einige Bilder in der Tabelle tblImages <\/b>gespeichert, müssen Sie dem TreeView-Konfigurator mitteilen, welche Bilder für welches Element verwendet werden sollen.<\/p>\n Dies geschieht auf zwei Ebenen:<\/p>\n Beim Aufbauen des TreeViews verwendet der TreeView-Konfigurator primär die mit den Datensätzen angegebenen Images und greift erst beim Fehlen eines entsprechenden Feldes oder des Feldinhalts auf die standardmäßig für Datensätze der entsprechenden Tabelle festgelegten Images zu (ist nirgends ein Image angegeben, wird einfach keines angezeigt).<\/p>\n Komfortlösung<\/b><\/p>\n Dank TreeView-Konfigurator können Sie bei der Arbeit mit der Softwareprojektverwaltung nicht nur die gewünschten Elemente anlegen, löschen, deren Eigenschaften bearbeiten und die aggregierten Daten in höheren Hierarchieebenen betrachten, sondern noch mehr:<\/p>\n Notizen<\/b><\/p>\n Die Beispieldatenbank enthält auch noch die Möglichkeit, Notizen zu jedem der Elemente hinzuzufügen. Die Notizen stammen aus der Tabelle tblNotizen<\/b>.<\/p>\n Sie ahnen es bereits: Wenn Sie Daten aus einer einzigen Tabelle zu Elementen aus allen Ebenen hinzufügen möchten, müssen Sie auch mehr als einen Eintrag im TreeView-Konfigurator vornehmen.<\/p>\n Sie müssen für jede Tabelle, für deren Elemente Sie Notizen anlegen und über das TreeView verwalten möchten, einen neuen Eintrag anlegen, der die entsprechende Tabelle als ParentTable <\/b>enthält. Dementsprechend sieht auch die Handhabung des Formulars zum Anlegen neuer Notizen etwas anders aus – mehr erfahren Sie, wenn Sie sich die Beispieldatenbank ansehen.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die Softwareprojektverwaltung sieht zwar in erster Linie wie eine Beispielanwendung für den TreeView-Konfigurator aus, aber sie sollte – gegebenenfalls mit Anpassungen – auch in der Praxis einsetzbar sein. Bislang enthält sie im Prinzip nur ein Formular mit vielen Hilfsformularen, aber die Erweiterung durch Berichte mit Auswertungen oder mit weiteren Formularen steht Ihnen offen.<\/p>\n Geplant war für diese Version der Softwareprojektverwaltung eigentlich noch die Möglichkeit, über die Images der einzelnen TreeView-Elemente Informationen über den Fortschritt und die Einhaltung der geschätzten Aufwände zu liefern – beispielsweise, indem man die bestehenden Images um kleine Icons wie Ausrufezeichen, OK<\/b>-Zeichen et cetera unten links und unten rechts erweitert.<\/p>\n Leider wäre die Programmierung eines solchen Features etwas aufwändiger geworden und wir wollten die Vereinfachungen bei der Gestaltung des TreeViews durch den TreeView-Konfigurator nicht durch erhöhten Aufwand für andere Features wieder zunichte machen.<\/p>\n Wenn Sie konkrete Ideen zum Ausbau oder Einsatz der Softwareprojektverwaltung haben, teilen Sie uns diese doch einfach unter info@access-im-unternehmen.de <\/b>mit – wir informieren Sie im Gegenzug über Neuerungen beim TreeView-Konfigurator.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Softwareprojektverwaltung.mdb<\/p>\n Softwareprojektverwaltung.accdb<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic002_opt.jpeg\")
<\/p>\nPrivate WithEvents objTreeViewHandler As µ\r\nclsTreeViewHandler\r\nPrivate Sub Form_Load()\r\n Set objTreeViewHandler = New clsTreeViewHandler\r\n With objTreeViewHandler\r\n Set .TreeViewInst = Me.ctlTreeView.Object\r\n Set .ImageListInst = Me.ctlImageList.Object\r\n .InitTreeView (3)\r\n .LineStyle = tvwTreeLines\r\n .FillTree\r\n End With\r\n Me.sfm.SourceObject = \"sfmProjekte€\r\n End Sub<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic004_opt.jpeg\")
<\/p>\n.InitTreeView (3)<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic005_opt.jpeg\")
<\/p>\n\n
\n
![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic006_opt.jpeg\")
<\/p>\n![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic007_opt.jpeg\")
<\/p>\nPrivate Sub Form_Open(Cancel As Integer)\r\n Me!RootID.DefaultValue = Me.OpenArgs\r\n End Sub<\/pre>\n
Private Sub cmdCancel_Click()\r\n DoCmd.Close acForm, Me.Name\r\n End Sub<\/pre>\n
Private Sub cmdOK_Click()\r\n Me.Visible = False\r\n End Sub<\/pre>\n
Private Sub objTreeViewHandler_ShortcutMenuClick(strParameter As String, strThisTable As String, _\r\n strPKID As String, lngPKIDValue As Long)\r\n Dim strAddForm As String\r\n Dim strChildTable As String\r\n Select Case strParameter\r\n Case \"Add\"\r\n Select Case strThisTable\r\n Case \"tblRoot\"\r\n strAddForm = \"frmProjektNeu\"\r\n strChildTable = \"tblProjekte\"\r\n End Select\r\n DoCmd.OpenForm strAddForm, WindowMode:=acDialog, DataMode:=acFormAdd, _\r\n OpenArgs:=objTreeViewHandler.PKIDValue\r\n If IstFormularGeoeffnet(strAddForm) Then\r\n lngPKIDValue = Forms(strAddForm)(strPKID)\r\n DoCmd.Close acForm, strAddForm\r\n objTreeViewHandler.NewChildNode strChildTable, lngPKIDValue\r\n End If\r\n End Select\r\n End Sub<\/pre>\n
objTreeViewHandler.NewChildNode µ\r\nstrChildTable, lngPKIDValue<\/pre>\n
![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic008_opt.jpeg\")
<\/p>\n\n
![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic009_opt.jpeg\")
<\/p>\n.Form.Filter = strPKID & \" = \" & lngPKID<\/pre>\n
ID = 12<\/pre>\n
![\"pic010.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic010_opt.jpeg\")
<\/p>\nCase \"Delete\"\r\nIf MsgBox(\"Möchten Sie das Element µ\r\nwirklich löschen\", vbYesNo + µ\r\nvbExclamation, \"Element löschen\") µ\r\n= vbYes Then\r\nobjTreeViewHandler.DeleteCurrentNode\r\nEnd If<\/pre>\n
\n
\n
![\"pic011.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic011_opt.jpeg\")
<\/p>\n![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic012_opt.jpeg\")
<\/p>\n\n
Private Sub Form_Current()\r\n Dim rst As DAO.Recordset\r\n Set rst = dbs.OpenRecordset(\"SELECT * FROM qryKundenstoryDetails WHERE KundenstoryID = \" _\r\n & Me.ID, dbOpenDynaset)\r\n If Not rst.EOF Then\r\n With rst\r\n Me.txtGeschaetzterAufwand = !SummeGeschaetzterAufwand\r\n Me.txtTatsaechlicherAufwand = !SummeTatsaechlicherAufwand\r\n Me.txtProzentErledigt = !ProzentFertiggestelltKundenstory\r\n If !CountID = !CountFertiggestelltAm Then\r\n Me.txtFertiggestelltAm = !MaxFertiggestelltAm\r\n End If\r\n End With\r\n Else\r\n With rst\r\n Me.txtGeschaetzterAufwand = 0\r\n Me.txtTatsaechlicherAufwand = 0\r\n Me.txtProzentErledigt = 0\r\n Me.txtFertiggestelltAm = \"\"\r\n End With\r\n End If\r\n End Sub<\/pre>\n
![\"pic013.png\"](\"..\/fileadmin\/_temp_\/2009_03\/Projektverwaltung-web-images\/pic013_opt.jpeg\")
<\/p>\nSaveFileToOLEField \"c:\\application.png\", \"tblImages\", \"ImageObject\", True, \"ID\", 123<\/pre>\n
\n
\n
Downloads zu diesem Beitrag<\/h3>\n