Ein echtes Highlight…
Das Highlighting das in diesem Artikel realisiert werden soll, hebt unser UserControl bei Mausberührung und Fokuserhalt hervor:

Um dies zu realisieren werden im folgenden zunächst die Mouse-Events behandelt.

Mouse-Events
Unser Usercontrol hat bereits Mouse-Events, die es von der Klasse ContainerControl geerbt hat. Diese beziehen sich jedoch nur auf die Fläche des Controls, die nicht durch untergeordnete Controls belegt ist. In unserem Beispiel erhalten wir kein MouseMove-Event, wenn sich die Maus über den farbigen Panels befindet. Um dieses Verhalten zu erreichen, müssen von allen untergeordneten Controls die gewünschten Events eingesammelt und auf unser Control übertragen werden. Dies geschieht, in dem im Eventhandler die zugehörige Funktion (gleicher Name wie Event, nur mit „On“) aufgerufen wird:

Public panel1_MouseMove(Object sender, EventArgs e){
    OnMouseMove(e);
}

Sonderfall MouseLeave und MouseEnter
Nicht ganz unproblematisch sind hierbei jedoch die MouseLeave und MouseEnter Events. Dadurch dass sich die untergeordneten Controls innerhalb unseres UserControls befinden, führt eine Mausbewegung von z.B. dem Panel ausgehend hin zu unbelegtem Bereich im Control zu einer Folge von MouseLeave- und MouseEnter-Events, obwohl die Maus nie unser UserControl verlassen hat.

Focus-Behandlung
Auch bei der Behandlung der Focus-Events kann es zu unerwünschten Effekten kommen. Ein nicht ganz einfacher Fall ist z.B. wenn das Contrrol untergeordnete Controls besitzt, die selbst einen Focus erhalten können, wie z.B. Textboxen. Erhält diese den Focus, so verliert das UserControl selbst den Fokus, obwohl sich dieser ja noch innerhalb des Controls befindet (nur eben auf einem untergeordneten Control). Um dieses Problem zu vermeiden, sollte für alle untergeordneten UserControls die Eigenschaft „enabled“ auf false gesetzt werden, wenn diese keine Interaktion mit dem User durchführen müssen.

Praktisches Beispiel
An Hand von dem schon in den vorherigen Artikeln vorgestelltem UserControl soll nun die vorgestellte Problematik veranschaulicht werden. Damit man auch was sieht, wird dazu zunächst eine Eigenschaft „Highlighted“ zugefügt, die die Schrift auf „Fett“ stellt. Zusätzlich erhält die Property ein Browsable-Attribut mit dem Parameter false, so dass die Property nicht im Visual Studio Designer angezeigt wird.

bool highlight = false;
 
[Browsable(false)]
public bool Highlight
{
    get { return highlight; }
    set {
        highlight = value;
        this.Font = new Font(this.Font,highlight?FontStyle.Bold:FontStyle.Regular);
    }
}

Diese Eigenschaft soll nun automatisch gesetzt werden, wenn die Maus über unser UserControl bewegt wird oder wenn das Control den Fokus erhält. Dazu werden zunächst im Designer die Events MouseEnter, MouseLeave, Enter und Leave aboniert und wie folgt implementiert:

void RegisterEvents(Control parent)
{
    foreach (Control child in parent.Controls)
    {
        child.Click += new System.EventHandler(child_Click);
        child.MouseMove += new MouseEventHandler(child_MouseMove);
        child.MouseEnter += new EventHandler(child_MouseEnter);
        child.MouseLeave += new EventHandler(child_MouseLeave);
        RegisterEvents(child);
    }
}
 
void child_MouseLeave(object sender, EventArgs e)
{
    OnMouseLeave(e);
}
 
void child_MouseEnter(object sender, EventArgs e)
{
    OnMouseEnter(e);
}
 
void child_MouseMove(object sender, MouseEventArgs e)
{
    OnMouseMove(e);
}
 
void child_Click(object sender, System.EventArgs e)
{
    OnClick(e);
}

Beim Ausführen des Codes wird deutlich, dass die Events nur auf die Hintergrundfläche des Controls reagieren. Bewegt man die Maus in den Grenzbereich zum farbigen Rechteck, kommt es sogar zu einem sehr unschönen Flimmern.

MouseEnter und MouseLeave: Auf richtige Verschaltung kommt es an
Wie schon erwähnt wird für die MouseEnter und MouseLeave Events eine Sonderbehandlung benötigt. Diese wird durch ein Überschreiben der OnMouseEnter und OnMouseLeave Methoden realisiert. In diesen muss eine Zustandsvariable eingeführt und die Mausposition muss ausgewertet werden. In der Zustandsvariablen wird gespeichert, ob sich die Maus bereits innerhalb des Controls befindet. In diesem Fall wird kein neuer MouseEnter-Event ausgelöst. Beim MouseLeave wird die Mausposition überprüft. Nur wenn sich die Maus tatsächlich außerhalb des Controls befindet, wird der MouseLeave Event ausgeführt:

// This flag indicates if the mouse was inside the control
bool inside = false;
 
protected override void OnMouseEnter(EventArgs e)
{
    // Check if mouse was already in control. 
    if (!inside)
    {
        inside = true;
        base.OnMouseEnter(e);
    }
}
 
protected override void OnMouseLeave(EventArgs e)
{
    // Check mouse coordinates
    Point mouseCoordinates = this.Parent.PointToClient(MousePosition);
 
    // Call base method only if mouse really left control
    if (!this.Bounds.Contains(mouseCoordinates))
    {
        inside = false;
        base.OnMouseLeave(e);
    }
}

Zu guter Letzt
Mit dem dritten Teil endet mein Workshop über Usercontrols zunächst. Das heißt aber nicht, dass ich nicht noch mehr coole Ideen und Tricks zum Thema UserControls habe. Die verrate ich aber nur, wenn ich auch mal nen Kommentar zu meinen Workshops bekomme . Also haut in die Tasten und schreibt was Ihr denkt oder zu was Ihr gerne noch mehr lesen würdet.

So, und wie immer gibt es an dieser Stelle das komplette Projekt zum Download:

Visual Studio Pojekt “UserControlworkShopPart2″

MS Visual Studio 2008
MS Visual Studio ist defacto die Standard-Entwicklungsumgebung zur Realisierung von Windows Anwendungen.
Ich benutze das Visual Studio schon seit der Version 2003 und bin sehr zufrieden mit den Möglichkeiten, die einem geboten werden. Ich habe viel Java programmiert und mich dadurch sehr schnell in C# zurecht gefunden. Die Unterstützung durch die Visual Studio IDE ist sehr umfassend und z.B. der Designer für Windows Anwendungen ermöglicht es einem, ansprechende Oberflächen zusammen zu klicken und einfache Datenbankanbindungen zu realisieren. Mehr zu Fakten und zur Geschichte des Visual Studios kann z.B. bei Wikipedia nach gelesen werden: Microsoft Visual Studio
Seit geraumer Zeit bietet Microsoft auch kostenlose Varianten des Visual Studios an, die “Express”-Editionen. Für alle, die nur Windows Anwendungen oder Webanwendungen realisieren wollen genügt diese völlig. Mit dieser Version dürfen sogar kommerzielle Projekte realisert werden. Die Professional Variante bietet darüber hinaus einen größeren Funktionsumfang und ermöglicht es beispielsweise auch, Anwendungen für Windows Mobile Geräte zu schreiben.
Wer das Visual Studio also noch nicht kennt, sollte sich einfach mal die Expressversion herunterladen und ausprobieren:
Microsoft Visual Studio 2008 Express Editions

MS SQL Server / MS SQL Server Management Studio
Der MS SQL Server ist eine relationale Datenbank die sich - Hersteller-bedingt - optimal in die Microsoft Windows Landschaft integriert. Mehr zum MS SQL Server kann z.B. direkt bei Microsoft oder auch bei Wikipedia nachgelesen werden.
Das Microsoft SQL Server Management Studio wird zusammen mit dem MS SQL Server ausgeliefert. Es ist das Zentrale Werkzeug zur Verwaltung des SQL Servers und zur Entwicklung und zum Test von Sql-Abfragen (Queries). Man kann es von der MS SQL-Server Installations-DVD aus auf dem Entwicklungsrechner installieren. Die älteren Versionen (bsp. 2003) basierten auf die Windows MMC. Ab Version 2005 basiert das SQL Server Management Studio auf die Umgebung des Visual Studios.
Auch vom SQL Server und vom SQL Server Management Studio kann eine Express Version bezogen werden:
Downloaddetails: Microsoft SQL Server Management Studio Express
Downloaddetails: Microsoft SQL Server Management Studio Express

Red Gate .Net Reflector
Jeder der Programme auf Basis des Microsoft .Net Frameworks realisiert sollte sich bewußt sein, dass sein Programm-Code in CLI-Code übersetzt wird, was neben vielen Vorteilen auch wieder den Nachteil hat, dass der Code sehr leicht decompiliert werden kann. Wie einfach das geht, kann jeder mit dem Tool “.Net Reflector” ausprobieren, das kostenlos von Red Gate bezogen werden kann. Dieses Tool ist einer der mächtigsten Decompiler für .Net Dieses Tool stellt damit ein absolutes Must-Have für .Net Entwickler dar, wobei natürlich beachtet werden muß, dass das Decompileren vieler Programme in deren Nutzungsbedingungen ausgenommen ist. Diese Einschränkung ist jedoch nicht uneingeschränkt gültig, wie z.B. hier bei Wikipedia erläutert wird. Bleibt also nur die Schlussfolgerung zu ziehen, dass wer seinen Quellcode wirkungsvoll schützen möchte auf Obfuscator wie z.B. den im Visual Studio enthaltenen “Dotfuscator Community Edition” zurückgreifen sollte.

Der Click-Event
Damit sich unsere Schaltfläche aus Teil 1 des Workshops auch tatsächlich als Schaltfläche verhält, wird eine sinnvolle Implementierung des Click-Events benötigt. Wie jedes Control besitzt die Klasse UserControl bereits einen ClickEvent. Dieser wird jedoch nur ausgelöst, wenn auch tatsächlich auf das UserControl geklickt wird. Wird stattdessen z.B. auf das Label in dem UserControl geklickt, wird der Click-Event nicht ausgelöst.

Folglich müssen wir von allen Untergeordneten Controls den ClickEvent abonieren und mit diesem ein Click Auslösen, was ein Eventsammler für uns erledigt.

Eventsammler
Über eine rekursive Methode wird der Click-Event aller untergeordneten Controls aboniert:

public SomeButton() {
    InitializeComponent();
    RegisterEvents(this);
}
 
void RegisterEvents(Control parent) {
    foreach (Control child in parent.Controls) {
        child.Click += new System.EventHandler(child_Click);
        RegisterEvents(child);
    }
}

Abfeuern des ClickEvents
Nun bleibt die Frage, wie wir selbst den Click Event unseres Controls auslösen können. Der erste Ansatz, den Event mit “override” zu überschreiben schlägt fehl, da der Event nicht als “virtual” definiert ist. Nun könnte man versucht sein, den Event einfach auszublenden und den neuen Event wie folgt zu definieren:

public new event EventHandler Click;

Hiervon sei aber dringend abzuraten!!! Wird unsere Componente nämlich als Componente betrachtet und auf sie der Click Event registriert (z.B. so wie wir es in der Methode “RegisterEvents” gemacht haben ), so wird nicht der neue, sondern der Event der Basisklasse abonniert. Also gilt: NEVER DO THAT!

Stattdessen ist auf die Methode base.OnClick(EventArgs e) zurück zugreifen. Diese Methode löst den Click-Event aus:

void child_Click(object sender, System.EventArgs e) {
    base.OnClick(e);
}

Click als Standard
Ein kleines Detail fehlt dem Click-Event noch; damit dieser standardmäßig angelegt wird, wenn im Designer auf unser Control ein Doppelclick ausgeführt wird, müssen wir unere Class UserControl mit dem Attribut [DefaultEvent(”Click”)] versehen.

Schon hat sich unser Control in einen funktionierenden Button verwandelt. Wobei die Button-Funktionalität noch nicht volständig gegeben ist. Unser Button reagiert nicht auf Tastatureingabe.

Tastatureingabe
Um auf Tastatureingabe zu reagieren, ist es nicht nötig, von allen untergeordneten Controls das KeyDown-Event zu abonieren, da ein KeyDown nur von einem Control ausgelöst werden kann, dass den EingabeFocus hat. Folglich reicht es, für unser UserControll selbst den KeyDown-Event zu abonieren. Dies kann z.B. über die Design-Ansicht gemacht werden (Properties-Fenster auf Events umschalten und dort ein Doppelklick auf KeyDown) oder natürlich auch als Code im Konstruktor der Klasse.

In der KeyDown-Eventmethode wird nun einfach überprüft, ob der Benutzer Space oder Enter gedrückt hat und entsprechend ein Click-event ausgelöst:

private void SomeButton_KeyDown(object sender, KeyEventArgs e) {
    if (e.KeyCode == Keys.Space || e.KeyCode == Keys.Enter) {
        base.OnClick(e);
    }
}

Nun können Per Tab-Taste die Buttons ausgewählt und mit Space oder Enter bestätigt werden. Der einzige Hacken ist nur, dass der Benutzer nicht erkennen kann, welcher Button gerade den Focus hat. Dieses Problem wird in Teil 3 dieses Workshops angesprochen.

Mnemonics
Der Begriff Mnemonic bedeutet “Gedächtnisstütze” vom griechischen mnēmoniká “Gedächtnis”. Im Context Windows Applikation steht er für die Sortcuts, die bei Betätigung der ALT-Taste in Form eines unterstrichenen Buchstabens angezeigt werden. Dieser Buchstabe wird vom Entwickler festgelegt, in dem ihm ein & vorangestellt wird. Das & erscheint nicht auf dem Button. (Soll dagegen Tatsächlich ein & auf dem Button stehen, so müssen zwei & angegeben werden.)

Wenn wir nun wollen, dass unser UserControl auf ein Mnemonic reagiert, reicht es aber leider nicht, in die Text-Property ein & einzufügen. Der nachfolgende Buchstabe wird zwar unterstrichen, sobald man die ALT-Taste drückt, ein Click wird jedoch nicht ausgelöst.
Der Trick besteht nun darin, dass die Methode “ProcessMnemonic” überschrieben werden muss. Diese Methode wird aufgerufen, wenn der Benutzer eine mögliche Tastenkombination gedrückt hat. Der statischen methode Control.isMnemotic() wird der Wert der Text-Property unseres Controls übergeben und es wird ausgewertet, ob diese Tatsächlich der Mnemonic dieses Controls war. Bei positiver Rückgabe ein Click ausgelöst.

Implementiert wird dies wie folgt:

protected override bool ProcessMnemonic(char charCode) {
    if (Control.IsMnemonic(charCode, this.Text)) {
        base.OnClick(new EventArgs());
        return (true);
    } else {
        return base.ProcessMnemonic(charCode);
    }
}

Zu guter Letzt
Hier endet nun auch der zweite Teil des UserControl-Workshops. Im dritten Teil werde ich noch tiefer auf Events eingehen, insbesondere werde ich die MouseEnter, MouseLeave und die Focus Events behandeln, so dass sich unser Control noch intuitiver verhält.

Wie immer gibt es an dieser Stelle das komplette Projekt zum Download:

Visual Studio Pojekt “UserControlworkShopPart2″

Was sind UserControls?
UserControls können mit dem Visual Studio sehr bequem aus bestehenden Controls zusammen gestellt werden. Das resultierende UserControl kann genauso wie ein bestehendes Control im Visual Studio verwendet werden. Durch Properties wird das Control dabei bequem parametrierbar.
In dem folgenden Beispiel wird eine Schaltfläche mit individuellem Design realisiert:

Ein UserControl anlegen…
… ist nicht wirklich schwer. Als erstes wird ein Projekt im Visual Studio benötigt. Im einfachsten Fall ist dies eine Windows-Anwendung die (CamelCase lässt grüßen) z.B. „UserControlWorkshopPart1“ heißen könnte.

Folgende Schritte sind nun nötig:

1. Dem Projekt wird ein neues UserControl „SomeButton“ zugefügt.
2. Die Hintergrundfarbe wird auf weiß gesetzt und ein Panel und ein Label werden hinzugefügt.
3. Das Panel bekommt einen roten Hintergrund und für die Schattierungen werden zwei weitere Panels mit einem etwas dunkleren Rot zugefügt.
4. Die neuen Panels werden im ersten Panel angedockt: das eine unten, das andere rechts. Das Panel rechts bekommt die Breite 2 und das Panel unten die Höhe 2.
5. Das erste Panel bekommt die Größe 20×20 und wird ganz an den linken Rand gesetzt.
6. Das Label bekommt den Text „Some Text“

Anschließend wird das Projekt einmal kompiliert.

Ready To Go: das UserControl einsetzten
Bisher haben wir das UserControl ja nur in der Design-Sicht verwendet. Nach dem Kompilieren unseres Projektes steht es uns in der Toolbar zur Verfügung und wartet nur darauf, auf ein Formular gezogen zu werden:

Wie bei jedem normalen Control können nun über den Designer bequem z.B. Größe oder die Schriftart ändern, was sich interessanterweise auch auf die untergeordneten Controls und somit auch unser Label sofort durchschlägt. Im Folgenden wird gezeigt, wie neue Eigenschaften deklariert werden können, wodurch das Control noch flexibler wird.

Das Control über Properties parametrieren
Als einfaches Beispiel soll zunächst die Farbe des Rechtecks einstellbar sein. Dazu wird in der Code-Ansicht des UserControls die Property „BoxColor“ definiert, in deren Set-Methode einfach die BackColor-Eigenschaft des ersten Panels durchgereicht wird. Um das ganze noch spannender zu machen, erhalten das zweite und das dritte Panel zugleich eine leicht dunklere Variante der ausgewählten Farbe:

using System.Drawing;
using System.Windows.Forms;
 
namespace UserControlWorkshopPart1 {
    public partial class SomeButton : UserControl {
        public SomeButton() {
            InitializeComponent();
        }
 
        byte makeDarker(byte input) {
            return ((byte)(input*0.7));
        }
 
        public Color BoxColor {
            get {
                return (panel1.BackColor);
            }
            set {
                panel1.BackColor = value;
                Color darkerColor = Color.FromArgb(makeDarker(value.R), makeDarker(value.G), makeDarker(value.B));
                panel3.BackColor = darkerColor;
                panel2.BackColor = darkerColor;
            }
        }
    }
}

Nach dem erneuten kompilieren können wir nun über den Designer bequem etwas Farbe in unser Form bringen:

Nicht ganz ohne: die Text-Property
Jetzt fehlt nur noch eine Möglichkeit, den Text des Controls zu ändern.
Analog zum vorherigen Beispiel liegt folgender Code nahe:

public string Text {
    get {
        return (label1.Text);
    }
    set {
        label1.Text = value;
    }
}

Beim kompilieren erhalten wir nun die Warnung „’UserControlWorkshopPart1.SomeButton.Text’ hides inherited member ‘System.Windows.Forms.UserControl.Text’. To make the current member override that implementation, add the override keyword…”

Die Meldung besagt, dass UserControl bereits eine Property Text besitzt. Da diese jedoch auf das Label umgeleitet werden soll, deklarieren wir die Property mit dem override-Schlüsselwort:

public override string Text {
    get {
        return (label1.Text);
    }
    set {
        label1.Text = value;
    }
}

Nach einem erneuten Kompilieren ist die Warnung weg. Jedoch erscheint die Property Text nicht in dem Properties-Fenster. Die Erklärung hierfür ist, dass die Text-Property eines UserControls per Default im Designer ausgeblendet wurde. Dies muss über Member-Attribute wieder rückgängig gemacht werden. Folgende 3 Attribute sollten gesetzt werden:

Browsable(true):
Hierdurch erscheint die Property im Designer

DesignerSerializationVisibility(DesignerSerializationVisibility.Visible):
Ist dieses Attribut nicht gesetzt, vergisst der Designer den eingestellten Wert beim schließen des Formulares sofort wieder.

Localizable(true):
Durch dieses Attribut wird es möglich, die Text-Property für verschiedene Sprachen zu lokalisieren.

Mit diesen drei Attributen sieht die Text-Property nun wiefolgt aus:

[DesignerSerializationVisibility(DesignerSerializationVisibility.Visible)]
[Browsable(true)]
[Localizable(true)]
public override string Text {
    get {
        return (label1.Text);
    }
    set {
        label1.Text = value;
    }
}

Zum kompilieren wird noch eine zusätzliche Using-Anweisung benötigt:

using System.ComponentModel;

Zu guter Letzt
Das war auch schon der erste Teil des UserControl-Workshops. Im zweiten Teil werde ich näher auf Events eingehen, insbesondere den Click Event, damit sich unser Control auch wie ein ordentlicher Button verhält.

Wie immer gibt es an dieser Stelle das komplette Projekt zum Download:

Visual Studio Pojekt “UserControlworkShopPart1″

Die richtige Einstellung…
Die Einstellung, nach der ich lange gesucht habe und die mir auch Google nicht verraten konnte ist die Folgende:
Im Menü “Tools” => “Options” auswählen. Im Options-Dialog nun “Enviroment” => “Keyboard” auswählen und “Apply the following additional keyboard mapping scheme” auf “Visual C#” stellen. Schon ist die Welt wieder in Ordnung

Noch ein Tip
Wo wir schon mal hier sind, gleich noch ein Tipp, wo man hinschauen sollte: “Enviroment” => “International Settings”. Steht hier eine andere Sprache, als die in der man das Visual Studio installiert hat oder sogar “Same as Microsoft Windows” kann dies zu fast schon babylonischer Sprachverwirrung führen (Passiert z.B. wenn man auf einem deutschen WinXP ein englisches Visual Studio 2005 und anschließend ein deutsches SQL Server Management Studio installiert…). Also, hier immer die tatsächlich installierte Sprache einstellen…

Die Idee
Die Klasse “ErrorProviderButtonDisabler” erweitert die Klasse “ErrorProvider” und kann folglich auch genauso verwendet werden. Zusätzlich hat sie noch die Eigenschaft “DefaultButton”. Dieser Eigenschaft wird der OK-Button des Dialoges zugewiesen. Sobald nun ein Fehler im ErrorProvider anliegt, wird der OK-Button disabled, so dass der Benutzer den Dialog nicht mit OK verlassen kann. Liegen keine Fehler an, sind folglich alle Felder korrekt gefüllt und der OK-Button wird wieder freigegeben. Natürlich kann der Benutzer den Dialog jederzeit über Cancel verlassen, auch wenn eine ungültige Eingabe vorliegt.

Der Code
Die Realisierung ist sehr einfach, weswegen ich sie hier an einem Stück aufliste:

using System;
using System.Windows.Forms;
using System.Collections;
using System.Drawing;
 
namespace BookInventoriser {
    /// <summary>
    /// Behaves like a normal ErrorProvider but in addition controls a Button, which will only be enabled if no Error occures.
    /// </summary>
    [ToolboxBitmap(typeof(ErrorProvider))]
    public class ErrorProviderButtonDisabler: ErrorProvider {
        private Button acceptButton;
 
        public Button AcceptButton {
            get { return acceptButton; }
            set { acceptButton = value; }
        }
 
        private Hashtable errors = new Hashtable();
 
        public new void SetError(Control control, string value){
            base.SetError(control, value);
            if (value != "") {
                errors[control] = value;
            } else {
                try {
                    errors.Remove(control);
                } catch { }
            }
 
            if(AcceptButton!=null){
                if (errors.Count > 0) {
                    AcceptButton.Enabled = false;
                } else {
                    AcceptButton.Enabled = true;
                }
            }
        }
    }
}

Die Idee
Mein Ziel war es, eine Komponente zu realisieren, die sich im Visual Studio genauso wie ein Tooltip benutzen läßt. Im Gegensatz zum Tooltip sollte die Komponente aber keinen Text direkt anzeigen, sondern über einen Event die Hilfetexte bereit stellen. So kann der Text an einer beliebigen Stelle ausgegeben werden, z.B. in einer Textbox oder in der Statusleiste.

Das Interface IExtenderProvider
Die Klasse Tooltip erweitert andere Controls um eine Eigenschaft “ToolTip”, über die sich der ToolTip -Text festlegen läßt. Genauso soll sich auch der HelpExtender verhalten. Dies geschieht über das Interface “IExtenderProvider”. Die Eigenschaft, die bereitgestellt werden soll, wird durch das Attribut “ProvideProperty” angegeben. Damit ergibt sich für den HelpExtender folgende Deklaration:

[ProvideProperty("HelpText", typeof(Control)), ToolboxItemFilter("System.Windows.Forms")]
public class HelpExtender : Component, IExtenderProvider {
  ...
}

Die Eigenschaft HelpText
Für die Eigenschaft HelpText muß nun noch eine Set und eine Get Methode geschrieben werden. In der Set-Methode wird zum einen der Helptext in der Hash-Table “helpTexts” gespeichert und zum anderen werden die Events MouseEnter, MouseLeave, GotFocus und LostFocus registriert. Hierdurch wird der HelpExtender beanachrichtigt, wenn der Benutzer mit der Maus über eins der verwalteten Controls geht oder dieses den Focus erhält:

public void SetHelpText(Control control, string caption) {
  if (caption != "") {
    helpTexts[control] = caption;
    control.MouseEnter += new EventHandler(control_MouseEnter);
    control.MouseLeave += new EventHandler(control_MouseLeave);
    control.GotFocus += new EventHandler(control_GotFocus);
    control.LostFocus += new EventHandler(control_LostFocus);
  } else {
    helpTexts[control] = null;
    control.MouseEnter -= new EventHandler(control_MouseEnter);
    control.MouseLeave -= new EventHandler(control_MouseLeave);
    control.GotFocus -= new EventHandler(control_GotFocus);
    control.LostFocus -= new EventHandler(control_LostFocus);
  }
}

Die Get-Methode sucht zu dem übergebenen Control den passenden Text:

[DefaultValue(""), Editor("System.ComponentModel.Design.MultilineStringEditor, System.Design, Version=2.0.0.0", typeof(UITypeEditor)), Localizable(true)]
public string GetHelpText(Control control) {
  if (control == null) {
    return string.Empty;
  }
  if (helpTexts[control] != null) {
    return ((string)helpTexts[control]);
  }
  return "";
}

Event-Verarbeitung
Nun wird noch ein Event samt passender Argumente und EventHandler benötigt, der über einen Hilfetext benachrichtig:

public delegate void HelpTextEventHandler(object sender, HelpTextEventArgs args);
 
public class HelpTextEventArgs : EventArgs {
  string helpText;
  public string HelpText {
    get {
      return (helpText);
    }
  }
 
  public HelpTextEventArgs(string helpText) {
    this.helpText = helpText;
  }
}
 
public event HelpTextEventHandler HelpTextAvailable;

In der Eventbehandlung wird nun der HelpTextAvailable Event über die Methoden “provideHelpText” und “ClearHelpText” ausgelöst:

private void provideHelpText(Control control) {
  string text = (string)helpTexts[control];
  if (text == null) text = "";
  if (HelpTextAvailable != null) {
    HelpTextAvailable(this, new HelpTextEventArgs(text));
  }
}
 
private void clearHelpText() {
  if (HelpTextAvailable != null) {
    HelpTextAvailable(this, new HelpTextEventArgs(""));
  }
}
 
void control_GotFocus(object sender, EventArgs e) {
  provideHelpText((Control)sender);
}
 
void control_MouseLeave(object sender, EventArgs e) {
  clearHelpText();
}
 
void control_MouseEnter(object sender, EventArgs e) {
  provideHelpText((Control)sender);
}
 
void control_LostFocus(object sender, EventArgs e) {
  clearHelpText();
}

Das Ergebnis
Mit der so entstandenen Komponente lassen sich auf einfache und komfortable Weise Hilfetexte für Oberflächen realisieren. Auch die Lokalisierung stellt kein Problem dar. Zur Benutzung muß die Komponente einfach nur auf das gewünschte Form gezogen werden und die Hilfe-Texte müssen definiert werden. Durch einen Doppelklick auf den HelpExtender gelangt man zu dem Event, der ausgelöst wird, wenn ein Hilfetext bereit steht. Durch eine einfache Anweisung kann dieser z.B. auf ein StatusLabel übertragen werden:

private void helpExtender1_HelpTextAvailable(object sender, HelpTextEventArgs args) {
  this.toolStripStatusLabelHelp.Text = args.HelpText;
}

Hier noch einmal ein Screenshot aus dem Beispielprojekt sowie der komplette Sourcecode zum Download:

Das Projekt steht hier zum Download bereit:

Beispielprojekt “HelpExtender”

Die dtv_channel.txt-Datei

Die Liste der Sender wird in einer Datei mit dem Namen dtv_channel.txt gespeichert, die sich in dem Pfad /usr/local/etc/dvdplayer befindet. Leider trügt die Endung txt, es handelt sich um eine Binärdatei.

Der einfachste Weg, die Datei zu erhalten, ist sie auf den Samba-Bereich der Platte zu kopieren. Dazu muss zunächst eine Telnet-Verbindung zu dem Gerät hergestellt werden.  Dies geht entweder mit dem Befehl “Telnet <IP-Adresse>” oder komfortabel über das Tool Putty, das ich nur empfehlen kann. Als Login ist ”root” einzugeben, das Passwort lautet “MeLE”.

Mit dem folgenden Befehl wird die Datei kopiert:

cp /usr/local/etc/dvdplayer/dtv_channel.txt /var/hdd/volumes/HDD1/

Die Datei kann nun von Windows aus zugegriffen und bearbeitet werden. Da es sich aber leider eben nicht um eine echte Text-Datei handelt, gestaltet sich das Bearbeiten zunächst als schwierig.

Die Datei ist wie folgt aufgebaut:

• Header: 4 Byte, je nach Firmware z.B. 0xFF000004 oder 0xFF000005
• Anzahl der Sender: 4 Byte Integer
• Sender: 544 Byte (576 Byte in der neusten Firmware)
• CRC32: 4 Byte

Die Sender selbst sind wiederum so aufgebaut:

• Index des Senders: 4 Byte
• Länge des Titels: 4 Byte
• Der Titel (Nullterminiert): X Byte
• Sonstige Daten (noch keine Details bekannt)

Das Umsortieren und Löschen ist nun trivial. Für das Umbenennen muss der Name als nullterminierter String geschrieben werden (UTF-8) sowie die Länge korrekt eingetragen werden.

Anschließend muss der CRC32 neu berechnet werden. Hierbei ist zu beachten, dass die Bit-Reihenfolge vom höchstwertigsten zu niederwertigsten erfolgt und der Startcode 0xFFFFFFFF lautet. Details zum CRC32 finden sich bei Wikipedia.

Das Programm “DTV Channel Manager”

Hier nun das Programm zur Bearbeitung der DTV-Channels:

Über diesen Dialog wird die Datei geöffnet:

Der Download des DTV Channel Managers befindet sich am Ende dieses Artikels.

Speichern und aktivieren der aktualisierten Senderliste

Die neue Datei muss nun wieder auf das Gerät geschrieben werden.  Hierzu kann z. B. die Datei auf der Samba-Partition geschrieben werden und mit dem folgenden Befehl zurück kopiert werden:

cp /var/hdd/volumes/HDD1/dtv_channel.txt /usr/local/etc/dvdplayer/

Damit die Box die Datei übernimmt, muss die Anwendung “DVDPlayer” neu gestartet werden. Dies kann entweder durch einen kompletten Neustart der Box oder durch den folgenden Befehl im Telnet erfolgen:

kill $(pidof DvdPlayer)

Noch mehr Komfort: schreiben der Datei über Web

Da es natürlich sehr umständlich ist, die Datei immer hin- und herzukopieren, habe ich auf der Box ein Webserver gestartet und zwei cgi-Scripte geschrieben, um auf die Datei zu zugreifen. Diese Dateien habe ich in der Samba-Partition in dem Ordner www/cgi-bin abgelegt und mit chmod 755 die Rechte für die Datei eingestellt. Natürlich können die Dateien auch in anderen Partitionen abgelegt werden.
Um auf der Box ein Webinterface zu starten, habe ich die Datei /etc/inetd.conf in das Verzeichnis /usr/local/etc kopiert und wie auf dem Screenshot zu sehen ist angepasst.

Um den inetd-Dämonen nun mit der Konfigurationsdatei als Parameter beim starten des Gerätes auszuführen, wird in die Datei /usr/local/rcS folgende Zeile angefügt:

inetd /usr/local/etc/inetd.conf

Wird nun die Datei dtv_channel.cgi aufgerufen, so gibt sie einfach den Inhalt der Datei /usr/local/etc/dvdplayer/dtv_channel.txt zurück. Somit kann die Senderliste von dem Gerät gelesen werden. Um nun eine geänderte Senderliste an das Gerät zu schicken, muss auf die URL einfach ein POST angewendet werden. Die übermittelten Daten werden dann direkt auf das Gerät in die /usr/local/etc/dvdplayer/dtv_channel.txt geschrieben.
Die zweite Datei heißt restart.cgi und übernimmt den Neustart der DVDPlayer-Anwendung. Sie führt einfach den oben beschriebenen Kill-Befehl aus.

Sind diese beiden CGI-Scripte installiert, so kann die Senderliste mit dem DTV-Channel-Manager auch direkt bearbeitet werden.

Downloads

» DTV Channel Manager (UPDATE v1.2)

» CGI-Scripte

Ausblick

Das Gerät bietet noch eine Menge weitere spannende Optionen. Insbesondere das Webinterface ist ausbaufähig. Anregungen (z.B. als Kommentar) werden gerne angenommen. Mehr dazu werde ich in kommenden Artikeln veröffentlichen.

UPDATE

Die Header der dtv_channel.txt scheinen nicht bei allen Firmware-Versionen gleich zu sein. Auch die Länge der Channel-Entries ist in der neusten Firmware 576 statt 544 byte. In der neuen Version (1.1, Download s. oben) des DTV Channel Managers wird die Länge nun dynamisch berechnet, somit müßte diese auch mit der neuen Firmware funktionieren.

Der aktuelle Funktionsumfang des Book Inventorisers

• Erfassung von Büchern anhand der ISBN
• Unterstützung von Barcodescannern
• Nachschlagen der Buchdetails im Internet
• Verwaltung der Standorte
• Export der Bücherliste in CSV
• Mehrsprachigkeit: Deutsch/Englisch
• Installation per Click-Once ohne das Adminrechte benötigt werden

Für den Anfang stelle ich hier zunächst das Setup zur Verfügung. Das gesamte Projekt kommt nach und nach, bevor ich es veröffentliche möchte ich an der einen oder anderen Stelle noch ein wenig Feinschliff vornehmen und einzelne sehr interessante Aspekte herausarbeiten.

Das Programm kann lizenzfrei benutzt werden. Für die Funktion und Verfügbarkeit besteht jedoch seitens der Sternico keine Garantie.

Installations-URL:
» Book Inventoriser

Lokale Tabellen finden

Sämtliche Tabellen sind in Access über das Objekt TabelDefs zugreifbar. Über eine einfache Foreach-Schleife können diese durchlaufen werden:

  Dim td As TableDef
  For Each td In CurrentDb.TableDefs
    ...
  Next

Handelt es sich bei der Tabelle um eine verknüpfte Tabelle, so ist die String-Eigenschaft Connect der zugehörigen Tabellendefinition gesetzt. Folglich können verknüpfte Tabellen daran erkannt werden, dass Connect nicht leer ist. Beim Durchlaufen fällt zudem auf, dass es Tabellen gibt, die ~ im Namen beinhalten. Diese sind Access-Interne Tabellen und werden von uns einfach ignoriert. Durch die folgende Schleife sammeln wir alle verlinkten Tabellen in einer Collection:

  Dim locals As New Collection
 
  ' Verlinkte Tabellen suchen
  Dim td As TableDef
  For Each td In CurrentDb.TableDefs
    If Not td.Connect = "" Then
      If InStr(td.Name, "~") = 0 Then
        locals.Add td.Name
      End If
    End If
  Next

Eine verknüpfte Tabelle in eine lokale Tabelle umwandeln

Um die verknüpfte Tabelle TabelleA samt Daten in eine lokale Tabelle TabelleB zu kopieren, verwenden wir den folgenden SQL-Befehl:

  SELECT [TabelleA].* INTO [TabelleB] FROM [TabelleA];

Da wir die verknüpfte Tabelle ja durch die Lokale ersetzen wollen, müssen wir die verknüpfte Tabelle zuerst mit einem neuen Namen kopieren, dann die verknüpfte Tabelle löschen und schließlich der neuen Tabelle wieder den ursprünglichen Namen geben. Dies geschieht mit den folgenden 3 Zeilen:

    DoCmd.RunSQL ("SELECT [" & Table & "].* INTO [local_" & Table & "] FROM [" & Table & "];")
    DoCmd.DeleteObject acTable, Table
    DoCmd.Rename Table, acTable, "local_" & Table

Die Funktion makeTablesLocal

Die beschriebenen Schritte werden nun in einer Funktion zusammengefaßt, die z.B. über die Direkteingabe aufgerufen werden kann:

Function makeTablesLocal()
 
  DoCmd.SetWarnings False
  Dim locals As New Collection
 
  ' Verlinkte Tabellen suchen
  Dim td As TableDef
  For Each td In CurrentDb.TableDefs
    If Not td.Connect = "" Then
      If InStr(td.Name, "~") = 0 Then
        locals.Add td.Name
      End If
    End If
  Next
 
  ' Tabellen umwandeln
  For Each Table In locals
    Debug.Print "Kopiere " & Table & "..."
    DoCmd.RunSQL ("SELECT [" & Table & "].* INTO [local_" & Table & "] FROM [" & Table & "];")
    DoCmd.DeleteObject acTable, Table
    DoCmd.Rename Table, acTable, "local_" & Table
  Next
End Function

Und wie immer gibt es hier noch den gesamten Code zum Download:

Modul TableTools