• sich Menschen gegenseitig bei Problemen helfen
• gemeinsam Ideen umgesetzt werden
• gemeinsam Wissen verteilt und somit die gemeinsame Community gestärkt wird
• die einzelnen Community-Betreiber zusammen halten um gemeinsam stark zu werden
• einzelne Community-Betreiber sich an Abgemachtes halten um wirklich gemeinsam für die Community da sein zu können
• jeder die Möglichkeit besitzt seine Stärken auszuspielen

public class WindowInformation
{
    private Window _window; 

    public WindowInformation(Window window)
    {
        _window = window;
    }

    public Window Window
    {
        get { return _window; }
    }

    public int WindowHashCode 
    {
        get { return _window.GetHashCode(); }
    }

    public String Title
    {
        get { return _window.Title; }
    }

    public ImageSource Icon
    {
        get { return _window.Icon; }
    }
}

public class WindowInformationCollection : 
    ObservableCollection<WindowInformation>
{
}

public class WindowManager
{
    private static WindowManager _manager;

    private WindowInformationCollection _openWindows = 
        new WindowInformationCollection();

    private WindowManager() { }

    public static WindowManager GetInstance
    {
        get
        {
            if (_manager == null)
                _manager = new WindowManager();
            return _manager;
        }
    }

    public WindowInformationCollection OpenWindows
    {
        get { return _openWindows; }
    }

    public Window GetOpenWindow(int hashCode)
    {
        foreach (WindowInformation wi in _openWindows)
        {
            if (wi.WindowHashCode == hashCode)
            {
                return wi.Window;
            }
        }
        return null;
    }

    public bool RemoveOpenWindow(int hashCode)
    {
        WindowInformation windowToRemove = null;
        foreach (WindowInformation wi in _openWindows)
        {
            if (wi.WindowHashCode == hashCode)
            {
                windowToRemove = wi;
                break;
            }
        }
        if (windowToRemove != null)
        {
            _openWindows.Remove(windowToRemove);
            return true;
        }
        return false;
    }
}

public class WindowInformationHandler
{
    public static readonly DependencyProperty 
        IsHandledProperty =
    DependencyProperty.RegisterAttached("IsHandled", 
        typeof(bool), typeof(WindowInformationHandler),
        new FrameworkPropertyMetadata((bool)false,
            new PropertyChangedCallback(OnIsHandledChanged)));

    private static void OnIsHandledChanged(
        DependencyObject dObj, 
        DependencyPropertyChangedEventArgs e)
    {
        Window openWindow = dObj as Window;
        if (openWindow != null)
        {
            openWindow.Loaded += 
                new RoutedEventHandler(WindowLoaded);
            openWindow.Closed += 
                new EventHandler(WindowClosed);
        }
    }

    public static bool GetIsManaged(DependencyObject dObj)
    {
        return (bool)dObj.GetValue(IsHandledProperty);
    }

    public static void SetIsManaged(
        DependencyObject dObj, 
        bool value)
    {
        dObj.SetValue(IsHandledProperty, value);
    }

    private static void WindowClosed(
        object sender, EventArgs e)
    {
        Window closedWindow = sender as Window;
        if (closedWindow != null)
        {
            WindowManager.GetInstance.RemoveOpenWindow(
                closedWindow.GetHashCode()
                );
            openWindow.Loaded -= 
                new RoutedEventHandler(WindowLoaded);
            openWindow.Closed -= 
                new EventHandler(WindowClosed);
        }
    }

    private static void WindowLoaded(
        object sender, RoutedEventArgs e)
    {
        Window openWindow = sender as Window;
        if (openWindow != null)
        {
            WindowInformation winInfo = 
                new WindowInformation(openWindow);
            WindowManager.GetInstance.OpenWindows.Add(winInfo);
        }
    }
}

local:WindowInformationHandler.IsManaged="true"

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        mnuWindows.ItemsSource = 
            WindowManager.GetInstance.OpenWindows;
    }

    private void NewWindow(object sender, 
        RoutedEventArgs e)
    {
        MainWindow window = new MainWindow();
        window.Title = String.Format("Open Window {0}", 
            Application.Current.Windows.Count);
        window.Show();
    }

    private void ShowWindow(object sender, 
        RoutedEventArgs e)
    {
        MenuItem mi = sender as MenuItem;
        if (mi != null)
        {
            WindowInformation wi = mi.DataContext 
                as WindowInformation;
            if (wi != null)
            {
                wi.Window.Focus();
            }
        }
    }
}

Layout System

• Measure
• Arrange

• Ein Kindelement (UIElement) beginnt den Layoutprozess durch das Erfassen der Basiseigenschaften
• Dann werden die Eigenschaften bezüglich Höhe, Breite, Randstärke ausgewertet
• Ausführung von Panel-spezifischer Logik (siehe Orientation-Eigenschaft des StackPanels)
• Der Inhalt wird ausgerichtet bzw. positioniert, nachdem die Größe etc. aller Kindelemente bemessen wurde.
• Die Liste der Kindelemente wird am Bildschirm ausgegeben

• Hinzufügen eines neuen Kindelementes
• Ausführung der Methode UpdateLayout eines Kindelementes
• Zuweisung von LayoutTransform eines Kindelementes
• Bei Änderung einer Dependency Property mit Auswirkung auf Measure und Arrange (gesetzt über die Metadaten)

Fazit

• Diagramme sollten durchaus nett anzusehen sein. D.h. 80er Jahre Stil ist nicht unbedingt gefragt
• Preise á la Adobe-Produkte möchte ich definitiv nicht ausgeben, ich bin aber bereit den einen oder anderen Euro auszugeben
• Sollte unter Vista lauffähig sein