Archiv

Archiv für März, 2009

Registry-Zugriffe bei Windows 64Bit für 32Bit Anwendungen

29. März 2009 Keine Kommentare

Windows 64 Bit setzt sich in Zeiten fallender RAM-Preise immer mehr durch, als Vista64. Bei dem Zugriff auf die Registry stolpert man dabei aber über ungeahnte Probleme.

32Bit Programme legen Ihre Einträge nämlich nicht in der normalen Registry ab, sondern im Unterschlüssel Wow6432Node (wird von Windows umgeleitet):

Auszug aus der Registry unter Vista64

Was bedeutet das für eigene Programme:
Möchte man von einem 64-Bit Programm aus auf Einstellungen eines 32-Bit Programms zugreifen, ist der Unterschlüssel Wow6432Node zu öffnen. Will man von einem 32-Bit Programm Einstellungen eines 64-Bit Programms auslesen, so steht man vor einem Problem. Will man auf die 64-Bit Schlüssel zugreifen, so muss man die Registry mit speziellen Parametern öffnen. Für Delphi findet man eine Lösung in Delphi-PRAXIS. Für .NET ist die Sache erstaunlicherweise komplizierter.
kick it on dotnet-kicks.de

Zwischenablage zwischen PCs synchronisieren

13. März 2009 Keine Kommentare

Wer immer wieder auf 2 Computern gleichzeitig arbeitet, vermisst evtl. auch die einfache Übertragung der Zwischenablage zwischen diesen PCs. Ich habe dafür das Tool Ditto clipboard manager entdeckt, was meiner Meinung nach eine ideale Möglichkeit bietet, die Zwischenablage aufzubohren.

Ditto kann unter SourceForge direkt herunter geladen werden. Es handelt sich dabei um ein Archiv, welches ich direkt in meine Eigenen Dateien entpackt habe, da eine Datenbank im Programmverzeichnis von Ditto schreibbar sein muss. Nach dem Start erscheint das Tool im Tray und kann in den Eigenschaften auch auf Deutsch umgestellt werden.

Zur Grundfunktion: Ditto überwacht nach dem Start automatisch die Zwischenablage und sichert diese auch automatisch in einer Datenbank (letzte 500 Einträge, letzte 5 Tage). Systemweit wird der Hotkey Strg + ö registriert. Man kann also etwas in die Zwischenablage nehmen, irgendwo hin wechseln, Strg + ö drücken und beispielsweise den vorletzten Eintrag einfügen.

Standardmäßig werden nur einige Text-Typen überwacht, dieses kann man aber in den Einstellungen von Ditto unter Unterstützte Typen einstellen. Sinnvoll ist dazu, wenn ein zu überwachender Inhalt bereits in der Zwischenablage ist, dann ist der Typ direkt wählbar:

Formate der Zwischenablage

Interessant wird es auf der Konfigurationsseite Freunde:

Konfiguration Freunde

Soll der betreffende PC Zwischenablage-Inhalte empfangen können, so muss die Option Empfang von Ausschnitten deaktivieren entfernt werden! Dann muss im unteren Abschnitt der PC, an den Zwischenablagen-Inhalt einzeln oder permanent übertragen werden, konfiguriert werden:

Hinzufügen eines Freund-PCs

Fertig: Ist alles korrekt eingestellt, überträgt ein PC seine aufgefangenen Inhalt der Zwischenablage automatisch an eine weitere Instanz von Ditto im Netzwerk. Das ganze macht das Übertragen von Komponenten im Designer fast zum Kinderspiel…

KategorienToolbox Tags: ,

Datumsfelder in Word

Auf ein interessantes Problem machte mich ein Kunde aufmerksam. Wenn man in ein Word-Dokument ein Datums-Feld einfügt, so wird normalerweise der Feldtyp DATE verwendet. Das ist kein Problem, wenn das Dokument quasi sofort verwendet bzw. gedruckt oder in ein PDF umgewandelt wird.

Möchte man aber im Nachhinein alte Worddokumente archivieren und darum in PDF umwandeln, steht man vor dem Problem, dass Word beim Öffnen des Dokuments das Datum auf den aktuellen Tag hin aktualisiert. Eine Abhilfe lässt sich schaffen, wenn man alle DATE-Felder durch SAVEDATE oder CREATEDATE-Felder austauscht.

In WordToPDF Pro habe ich darum Parameter eingeführt, womit WordToPDF Pro diese Ersetzungen durchführt:

-datereplace:create
-datereplace:save
-datereplace:print

Da das gleich Problem auch bei TIME-Felder auftritt (diese können ebenfalls auf Datumausgabe hin formatiert werden), wurde das selbe Konzept auch noch mit timereplace eingeführt.

KategorienWordToPDF Tags: , ,

Master Detail mit List<>

Möchte man Listen (System.Collection.Generic.List<>) an Comboboxen mittels einer Master-Detail-Beziehung anbinden, so bietet sich die hier dargestellte Vorgehensweise an.

Code der Listen:

    public class Detail
    {
        public String Caption { get; set; }
        public int Id { get; set; }
 
        public Detail(string caption)
        {
            Caption = caption;
        }
    }
 
    public class DetailList: List<Detail>
    {
        public String DetailListCaption { get; set; }
 
        public DetailList(string masterCaption)
        {
            DetailListCaption = masterCaption;
        }
    }
 
    public class Master: List<DetailList>
    { }

Zur Anwendung wird die Liste bespielhaft befüllt:

    private Master master = new Master();
...
    master.Add(new DetailList("Cap Master 1"));
    master.Add(new DetailList("Cap Master 2"));
 
    master[0].Add(new Detail("Cap Detail 1.1"));
    master[0].Add(new Detail("Cap Detail 1.2"));
    master[1].Add(new Detail("Cap Detail 2.1"));
    master[1].Add(new Detail("Cap Detail 2.2"));

Nun werden noch zwei BindingSource-Komponenten erzeugt und initialisiert:

    masterBindingSource = new BindingSource {DataSource = typeof (Master)};
    comboBox1.DataSource = masterBindingSource;
    comboBox1.DisplayMember = "DetailListCaption";
 
    detailBindingSource = new BindingSource {DataSource = typeof (DetailList)};
    comboBox2.DataSource = detailBindingSource;
    comboBox2.DisplayMember = "Caption";
 
    masterBindingSource.CurrentChanged += masterBindingSource_CurrentChanged;
...
    private void masterBindingSource_CurrentChanged(object sender, EventArgs e)
    {
        detailBindingSource.DataSource = masterBindingSource.Current;
    }

Wichtig ist dann nur noch die Initialisierung der Datasource mit einem konkreten Wert:

    masterBindingSource.DataSource = master;
KategorienMicrosoft .NET Tags: ,

Runden in Microsoft .NET

Es gibt in Microsoft .NET alle gebräuchlichen Möglichkeiten, Zahlen zu runden:

using System;
 
namespace RoundTest
{
    class Program
    {
        static void TestOutput(double value)
        {
            Console.WriteLine();
            Console.Write(value);
            Console.Write("\t Truncate: " + Convert.ToInt32(Math.Truncate(value)));
            Console.Write("\t Ceiling : " + Convert.ToInt32(Math.Ceiling(value)));
            Console.Write("\t RoundAFZ: " + Convert.ToInt32(Math.Round(value, MidpointRounding.AwayFromZero)));
            Console.Write("\t RoundToE: " + Convert.ToInt32(Math.Round(value, MidpointRounding.ToEven)));
        }
 
        static void Main(string[] args)
        {
            TestOutput(10.0);
            // ...
            TestOutput(-10.51);
            Console.ReadLine();
        }
    }
}

Hier ist die Ergebnisausgabe davon zu finden:

10       Truncate: 10    Ceiling : 10    RoundAFZ: 10    RoundToE: 10
10,49    Truncate: 10    Ceiling : 11    RoundAFZ: 10    RoundToE: 10
10,5     Truncate: 10    Ceiling : 11    RoundAFZ: 11    RoundToE: 10
10,51    Truncate: 10    Ceiling : 11    RoundAFZ: 11    RoundToE: 11
 
-10      Truncate: -10   Ceiling : -10   RoundAFZ: -10   RoundToE: -10
-10,49   Truncate: -10   Ceiling : -10   RoundAFZ: -10   RoundToE: -10
-10,5    Truncate: -10   Ceiling : -10   RoundAFZ: -11   RoundToE: -10
-10,51   Truncate: -10   Ceiling : -10   RoundAFZ: -11   RoundToE: -11

kick it on dotnet-kicks.de

KategorienMicrosoft .NET Tags: ,