PRISM – materiały do nauki.

13/06/2012 ~ Jarosław Stadnicki ~ 11 Comments

Jestem zafascynowany framworkiem PRISM, czytam, oglądam i piszę jakieś przykładowe aplikacje z wykorzystaniem tej biblioteki. Prism ułatwia tworzenia modularnych i dynamicznych systemów, dostarcza mechanizm do rozwiązywania zależności (Unity Container), umożliwia dynamiczną zmianę zachowania aplikacji poprzez wczytywanie dodatkowych modułów z katalogu lub aktualizację pliku konfiguracyjnego aplikacji – to tylko część z błyszczących bajerów.
Prism wspiera Silverlight, WPF czy Windows Phone 7 oraz mocno promuje wzorzec MVVM. Aby skorzystać z Prism wystarczy zaciągnąć paczkę z codeplex.com, rozpakować oraz dodać referencje do projektu.

Polecam dwa źródła do nauki: dla posiadających dostęp do płatnych szkoleń na Pluralsight taki oto kurs – Introduction to PRISM . Jeśli nie masz dostępu, nie masz się czym martwić na Channel9 jest inny równie dobry, oraz dwu i pół godzinny film akcji, gdzie autor tworzy prostą aplikację do odbierania i wysyłania poczty elektronicznej – Prism & Silverlight. Pierwszy z materiałów jest oparty na WPF, drugi to aplikacja webowa pisana w Silverlight.

Moje proste działania można obserwować na bitbucket.org pod adresem:
https://bitbucket.org/jstadnicki/prismcapture oraz link do repozytorium git https://jstadnicki@bitbucket.org/jstadnicki/prismcapture.git

WPF pasek postępu na ikonie aplikacji, dodatkowe guziki w podlądzie apliacji – TaskbarItemInfo w natarciu.

20/12/2011 ~ Jarosław Stadnicki ~ 2 Comments

Nauka WPF idzie całkiem dobrze, a to oznacza kolejną porcję informacji. Dzisiaj trochę o ficzerze z Windows7 (które jest w Viście), a nie wiem czy będzie nadal aktualny w nowej wersji Windows, która pewnie ukaże niebawem.
Opowiem trochę o pasku postępu, który można wyświetlać na ikonie aplikacji, która jest na systemowym pasku zadań, oraz o tym jak dodać kilka (maksymalnie 7 widocznych) guzików do podglądu aplikacji. Przez podgląd rozumiem, najechanie myszą na ikonę działającej aplikacji,
znajdującą się na pasku zadań, ale bez klikania na niej. Spowoduje to
wyświetlenie się małego okienka z podglądem naszej aplikacji.
Media Player Classic to ma, Zune to ma, Windows Media Player to, więc dlaczego i ja miałbym z tego nie skorzystać.

Podgląd aplikacji, z wyświetlonym podpisem dla pierwszego guzika.

Obie funkcjonalności (pasek postępu oraz dodatkowe guziki) opierają się na TaskbarItemInfo, który jest częścią wyświetlanego okna. Jak prawie wszystko w WPF, można to zdefiniować w XAML oraz code-behind. Wszyscy pamiętamy o tym, że samodzielne definiowane właściwości dla TaskbarItemInfo w code-behind zaczynamy od zaalokowania pamięci na ten obiekt, ponieważ początkowo TaskbarItemInfo jest NULLem. Ja o tym pamiętam po pierwszym uruchomienia programu.
Tak deklaruje się w XAML dodatkowe guziki, które mają być widoczne w podglądzie okna.

<Window.TaskbarItemInfo>
    <TaskbarItemInfo>
      <TaskbarItemInfo.ThumbButtonInfos>
        <ThumbButtonInfo x:Name=”ReverseThumb” ImageSource=”imagesrev.png” Description=”Reverse progress”
                         Click=”ReverseThumbClick” />
        <ThumbButtonInfo x:Name=”PauseThumb” ImageSource=”imagespause.png” Description=”Pause progress”
                         Click=”PauseThumbClick” IsEnabled=”False” />
        <ThumbButtonInfo x:Name=”RunThumb” ImageSource=”imagesplay.png” Description=”Run progress”
                         Click=”RunThumbClick” />
        <ThumbButtonInfo x:Name=”ForwardThumb” ImageSource=”imagesffd.png” Description=”Forward progress”
                         Click=”ForwardThumbClick” IsEnabled=”False” />
      </TaskbarItemInfo.ThumbButtonInfos>
    </TaskbarItemInfo>
  </Window.TaskbarItemInfo>

Nie ma w tym nic trudnego, ani skomplikowanego. Jenocześnie można wyświetlić nie więcej niż siedem, jeśli na liście będzie ich więcej, to tylko pierwszych siedem widocznych będzie wyświetlonych. Dynamiczne zachowanie się guzików, można osiągnąć poprzez zmianę wartości Visibility na Collapsed, ukrywając jedne, a odkrywając inne.
W przykładnie postanowiłem obsłużyć zdarzenie Click i wtedy wykonać odpowiedni kod. Do TaskbarItemInfo można również przypiąć wpf’owy Command.
ThumbButtonInfo ma pewną przypadłość, lub nie potrafiłem znaleźć tej informacji, otóż w C# nie można (nie wiem jak?) odwołać się do właściwości Name, przez co musiałem obsługę zdarzeń rozdzielić na pojedyncze metody. Funkcjonalność na której mi zależało, to uruchomienie paska postępu, pauza postępu, oraz zmiana kierunku postępu (np. na symulowanie rollback instalacji).

Oprócz tego, na kolorowym oknie aplikacji (to różowe GUI powstało w ramach praktyki WPF i ćwiczeń z layoutu) widać 5 pseudo guzików, które umożliwiają ustawienie właściwości paska postępu, wyświetlanego na ikonie aplikacji.
Stan postępu można sygnalizować na cztery (pięć) sposob:

Zielony (TaskbarItemProgressState.Normal), wszystko w porządeczku
Niezdecydowany (TaskbarItemProgressState.Indeterminate), gdy
programista nie jest pewien ile czasu zajmie operacja, może wyświetlić
pasek informujący o tym, że operacja jest w trakcie wykonywania i
będzie gotowa gdy będzie gotowa (tak samo jak Diablo III). W tym
przypadku aktualizowanie paska postępu nie wpływa w żaden sposób na
sposób wyświetlania postępu)
Zółty (TaskbarItemProgressState.Paused) – brak postępu, pauza. Nie mniej jednak nic nie powstrzymuje aplikacji przed zwiększaniem wartości postępu,
Czerwony (TaskbarItemProgressState.Error) – pojawił się błąd, nadal można aktualizować pasek.
Brak paska postępu (TaskbarItemProgressState.None)

Powtórzę się: w każdym przypadku wartość postępu może wzrastać czy maleć (cofać się).
Poszczególne stany można zmieniać w trakcie działania aplikacji, nie trzeba zerować czy resetować postępu. Oczywiście wszyscy pamiętamy, że kontrolki modyfikować wolno tylko w głównym wątku, TaskbarItemInfo nie jest wyjątkiem. Wartości przyjmowane przez pasek postępu mieszcząc się od 0.0 do 1.0 (double).
Wątek który symuluje postęp paska:

new Action(
() =>
{
    this.TaskbarItemInfo.ProgressValue = progressValue;
    progressValue += progress;
    if (progressValue > 1.0)
    {
        progressValue = 0.0;
    }
    else if (progressValue < 0.0)
    {
        progressValue = 1.0;
    }
})

Tyle – cała filozofia. Przyznam szczerze, że tą funkcjonalność wcześniej, to myślałem że będzie więcej zabawy, jednak WPF kolejny raz mnie pozytywnie zaskakuje.
W świątecznej promocji dopiszę jeszcze na krótko, że dodatkowo na ikonie można dorysować jeszcze mniejszą ikonkę tzw. Overlay. Miniaturka pojawia się i znika płynnie, natomiast jeśli jest już widoczna i zostanie zmieniona na inną, to zmiana ta jest natychmiastowa.

<Window.TaskbarItemInfo>
    <TaskbarItemInfo Overlay=”imagesthree.png”>
</Window.TaskbarItemInfo>

Znowu prosto – WPF nas rozpieszcza 🙂

Wszelkie uwagi i krytykę jak zwykle chętnie przyjmę w komentarzach.

WPF – rotacja, transformacja i przechylanie

13/11/2011 ~ Jarosław Stadnicki ~ 2 Comments

W ramach uczestnictwa w kursie WPF czytam ksiązkę “WPF 4 Unleashed” i przygotowuje jakieś przykłady sprawdzające co tam pan autor pisze w tej książce. Jeden z początkowych rozdziałów (tak, dopiero rozpoczynam kurs i książkę) poświęcony jest tematyce transformacji kontrolek, w związku z tym napisałem prosty przykład ukazyjący omawiane tranformacje. W zasadzie testuje tylko trzy z pięciu, ponieważ przesunięcie obiektów nie jest zbyt widowiskowe, a wykorzystanie macierzy nie jest na moją głowę. Zostają tylko obracanie, skalowanie i przechylanie.
Do implementacji wykorzystałem trzy wątki, a jak wszyscy wiemy .NET nie lubi, jak ktoś dobiera się do kontrolek z innego wątku niż głównego. Wykorzystany został tutaj obiekt Dispatcher z WPF, który ułatwia sprawę. Najbardziej denerwującą rzeczą okazał się brak możliwości skorzystania z wyrażeń lambda do implementacji ciała metody zajmującej się aktualizacją kontrolek. Trzeba było skorzystać z delegatów. Na stackoverflow widziałem przykład z rzutowaniem lambdy na Action. Po krótkiej i przegranej walce z przykładem, postanowiłem że zostanę przy delegatach.

Przykład jest na tyle prosty, że nie pokuszę się o wrzucanie go na jakiś serwer, zostanie pokazany światu tu i tylko tu.
Na początek UI (bez szału):

<Window x:Class=”wpfTransformations.MainWindow”
        xmlns=”http://schemas.microsoft.com/winfx/2006/xaml/presentation”
        xmlns:x=”http://schemas.microsoft.com/winfx/2006/xaml”
        Title=”MainWindow” Height=”466″ Width=”1000″>
    <Grid>
        <!– Rotating –>
        <Button x:Name=”r_00_00″ Content=”0,0″ Height=”23″ HorizontalAlignment=”Left” Margin=”69,64,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0,0″>
            <Button.RenderTransform >
                <RotateTransform Angle=”33″ x:Name=”RotateTransform”/>
            </Button.RenderTransform>
        </Button>
 
        <Button x:Name=”r_10_00″ Content=”1,0″ Height=”23″ HorizontalAlignment=”Left” Margin=”255,64,0,0″
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”1,0″>
            <Button.RenderTransform>
                <RotateTransform Angle=”33″/>
            </Button.RenderTransform>
        </Button>
 
        <Button x:Name=”r_10_10″ Content=”1,1″ Height=”23″ HorizontalAlignment=”Left” Margin=”447,64,0,0″
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”1,1″>
            <Button.RenderTransform>
                <RotateTransform Angle=”33″/>
            </Button.RenderTransform>
        </Button>
 
        <Button x:Name=”r_00_10″ Content=”0,1″ Height=”23″ HorizontalAlignment=”Left” Margin=”631,64,0,0″
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0,1″>
            <Button.RenderTransform>
                <RotateTransform Angle=”33″/>
            </Button.RenderTransform>
        </Button>
 
        <Button x:Name=”r_05_05″ Content=”0.5,0.5″ Height=”23″ HorizontalAlignment=”Left” Margin=”803,64,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0.5,0.5″>
            <Button.RenderTransform>
                <RotateTransform Angle=”33″/>
            </Button.RenderTransform>
        </Button>
        <!– Scaling –>
          <Button x:Name=”s_00_00″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”69,179,0,0″
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0,0″>
            <Button.RenderTransform>
                <ScaleTransform ScaleX=”.6″ ScaleY=”-.6″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”s_00_10″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”255,179,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0,1″>
            <Button.RenderTransform>
                <ScaleTransform ScaleX=”.6″ ScaleY=”-.6″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”s_10_10″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”447,179,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”1,1″>
            <Button.RenderTransform>
                <ScaleTransform ScaleX=”.6″ ScaleY=”-.6″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”s_10_00″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”631,179,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”1,0″>
            <Button.RenderTransform>
                <ScaleTransform ScaleX=”.6″ ScaleY=”-.6″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”s_05_05″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”803,179,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0.5,0.5″>
            <Button.RenderTransform>
                <ScaleTransform ScaleX=”.6″ ScaleY=”-.6″ />
            </Button.RenderTransform>
        </Button>
        <!– Skewing –>
          <Button x:Name=”sk_00_00″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”69,315,0,0″
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0,0″>
            <Button.RenderTransform>
                <SkewTransform AngleX=”33″ AngleY=”3″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”sk_10_00″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”255,315,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”1,0″>
            <Button.RenderTransform>
                <SkewTransform AngleX=”33″ AngleY=”3″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”sk_10_10″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”447,315,0,0″
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”1,1″>
            <Button.RenderTransform>
                <SkewTransform AngleX=”33″ AngleY=”3″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”sk_00_10″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”631,315,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0,1″>
            <Button.RenderTransform>
                <SkewTransform AngleX=”33″ AngleY=”3″ />
            </Button.RenderTransform>
        </Button>
        <Button x:Name=”sk_05_05″ Content=”Button” Height=”23″ HorizontalAlignment=”Left” Margin=”803,315,0,0″ 
                VerticalAlignment=”Top” Width=”75″ RenderTransformOrigin=”0.5,0.5″>
            <Button.RenderTransform>
                <SkewTransform AngleX=”33″ AngleY=”3″ />
            </Button.RenderTransform>
        </Button>
    </Grid>
</Window>

Tak wygląda code-behind i trzy wątki odpowiedzialne, za aktualizację kontrolek (też bez szału):

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
 
namespace wpfTransformations
{
using System.Threading;
 
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
    // delegates to handle UI controls update from background threads
    public delegate void SetAngleD(float f, Button b);
    public delegate void SetScaleD(float sx, float sy, Button b);
    public delegate void SetSkewD(float ax, float ay, Button b);
 
    // helper methods to update the controls    
    public void SetAngle(float f, Button b)
    {
        RotateTransform r = new RotateTransform(f);
        b.RenderTransform = r;
    }
 
    public void SetScale(float sx, float sy, Button b)
    {
        ScaleTransform st = new ScaleTransform(sx, sy);
        b.RenderTransform = st;
    }
 
    public void SetSkew(float ax, float ay, Button b)
    {
        SkewTransform sk = new SkewTransform(ax, ay);
        b.RenderTransform = sk;
    }
 
    public MainWindow()
    {
        InitializeComponent();
 
        // This one will take care of rotation of the elements
        Thread tRotatingThread = new Thread(
            () =>
            {
                float angle = 33.0f;
                while (true)
                {
                    SetAngleD d = new SetAngleD(this.SetAngle);
                    r_00_00.Dispatcher.Invoke(d, new object[] { angle, r_00_00 });
                    r_00_10.Dispatcher.Invoke(d, new object[] { angle, r_00_10 });
                    r_10_10.Dispatcher.Invoke(d, new object[] { angle, r_10_10 });
                    r_10_00.Dispatcher.Invoke(d, new object[] { angle, r_10_00 });
                    r_05_05.Dispatcher.Invoke(d, new object[] { angle, r_05_05 });
 
                    angle += 1.0f;
                    if (angle > 360.0f)
                    {
                        angle = 0.0f;
                    }
 
                    Thread.Sleep(10);
                }
            });
        tRotatingThread.IsBackground = true;
 
        // This one will play with scaling properties of controls
        Thread tScalingThread = new Thread(
            () =>
            {
                float sxm = 0.019f;
                float sym = -0.011f;
 
                float sx = 0.6f;
                float sy = -0.6f;
 
                while (true)
                {
                    SetScaleD d = new SetScaleD(this.SetScale);
                    s_00_00.Dispatcher.Invoke(d, new object[] { sx, sy, s_00_00 });
                    s_10_00.Dispatcher.Invoke(d, new object[] { sx, sy, s_10_00 });
                    s_10_10.Dispatcher.Invoke(d, new object[] { sx, sy, s_10_10 });
                    s_00_10.Dispatcher.Invoke(d, new object[] { sx, sy, s_00_10 });
                    s_05_05.Dispatcher.Invoke(d, new object[] { sx, sy, s_05_05 });
 
                    if (Math.Abs(sx) > 2.1f)
                    {
                        sxm *= -1.0f;
                    }
 
                    if (Math.Abs(sy) > 2.1f)
                    {
                        sym *= -1.0f;
                    }
 
                    sx += sxm;
                    sy += sym;
                    Thread.Sleep(30);
                }
            });
 
        tScalingThread.IsBackground = true;
 
 
        // This one will skew them grrrrr
        Thread tSkewingThread = new Thread(
            () =>
            {
                float ax = 33.0f;
                float ay = 3.0f;
 
                while (true)
                {
                    SetSkewD d = new SetSkewD(this.SetSkew);
                    sk_00_00.Dispatcher.Invoke(d, new object[] { ax, ay, sk_00_00 });
                    sk_10_00.Dispatcher.Invoke(d, new object[] { ax, ay, sk_10_00 });
                    sk_10_10.Dispatcher.Invoke(d, new object[] { ax, ay, sk_10_10 });
                    sk_00_10.Dispatcher.Invoke(d, new object[] { ax, ay, sk_00_10 });
                    sk_05_05.Dispatcher.Invoke(d, new object[] { ax, ay, sk_05_05 });
 
                    ax += 1.0f;
                    if (ax > 90.0f)
                    {
                        ax = 0.0f;
                    }
 
                    ay += 1.0f;
                    if (ay > 60.0f)
                    {
                        ay = 0.0f;
                    }
 
                    Thread.Sleep(30);
                }
            });
 
        tSkewingThread.IsBackground = true;
 
 
        // Because everyone of them is set as background thread
        // They should end nicely at the end of application
        tRotatingThread.Start();
        tScalingThread.Start();
        tSkewingThread.Start();
    }
 
}
}

Na koniec aplikacji w akcji (odrobina szału jest):

Pierwszy rząd guzików jest obracany, kolejny skalowany, a ostatni przechylany. Chyba lepiej to wygląda gdy działa, po wklejeniu do msvc powinien śmigać bez zająknięcia.
To tyle. Do zapamiętania: Dispatcher nie przyjmie lamby i nie walcz z tym, od razu korzystaj z delegatów. Chyba, że wiesz o co chodzi z tym Action() i wiesz jak z tego skorzystać (wiesz? – napisz w komentarzu), albo masz inne rozwiązanie. Podobno w 4.5 można z każdego wątku aktualizować UI, jeszcze nie sprawdziłem.

ps. Rozpieszczam was tym zawijaniem wierszy.

Jak rysować w C#

18/02/2011 ~ Jarosław Stadnicki ~ Leave a comment

Uczę się i uczę, sprawdzam wiedzę i sprawdzam i wyszło, że z rysowaniem sobie nie do końca poradziłem. Aby to poprawić chciałem coś napisać/narysować, od słowa (kluczowego) do słowa i zacząłem pisać prostego painta. W sumie nic skomplikowanego, a cieszy. Wyciosałem coś co może pretendować do miany prostego rysownika.

Można sobie wybrać kilka prostych opcji do rysowania plus kilka kolorów, nic fikuśnego. Później mnie trochę poniosło i dodałem opcje cofania edycji i zmiany rozmiaru okna do rysowania, co okazało się banalnie proste.
W zasadzie wszystko co powinna robić aplikacja to posiadanie listy kształtów i kolorów które trzeba narysować gdzieś na ekranie.
Potem pomyślałem o tym, że skoro ktoś spędzi przy mojej aplikacji tyle godzin rysując jakieś cuda, szkoda aby jego praca poszła na marne. Można więc zapisywać i odczytywać obrazek, ponad to można go nawet (wow!) wyeksportować do .png tak aby inne mniej zaawansowane programy mogły go odczytać. Mój paint nie zniży się do tego poziomu i działa tylko z własnym formatem pliku (zserializowana lista obiektów). Tak zamierzam wprowadzić nowy standard.

W między czasie przeczytałem krótki art o wzorcu odwiedzający (Visitor), jako że pasował trochę do koncepcji aplikacji, postanowiłem zrobić mały refactor, aby z niego skorzystać. Wzorzec działa całkiem sprytnie, ale wiadomo że nic nie przychodzi za darmo. Prosta zmiana z enum na odwiedzającego, spowodowała lawinę zmian, którą musiałem wprowadzić do aplikacji, aby przystosować do nowej logiki. Jeszcze jedno spostrzeżenie, ten wzorzec szybko zwiększa ilość klas w projekcie.
Od razu przychodzą rozważania nad oczywistą oczywistością – nic na siłę. Jeżeli rozwiązanie z którego korzystam jest zupełnie wystarczające, nie powoduje problemów, etc to nie widzę najmniejszej potrzeby zmiany. Może poza ciekawością lub celami czysto szkoleniowymi. Tak właśnie było w moim przypadku.

Przy okazji poćwiczyłem także XAML i UI, naprawdę sporą część aplikacji robi się właśnie w designerze – to dobre jest. Pisanie GUI całkowicie w kodzie, a potem zabawa w przesuwanie tego po ekranie, powiększanie i obsługa OnSize(…), OnMove(…), szkoda na to czasu, tym bardziej że można to wyklikać, dzięki czemu prawdopodobieństwo popełnienia błędu jest dużo mniejsze.

Jeżeli ktoś będzie ciekawy jak prosto napisać Painta w C# lub chciałby zobaczyć jak ja to zrobiłem. Lub chciałbym zobaczyć jak skorzystałem ze wzorca odwiedzający, lub chciałbym zobaczyć kod lub po prostu jest znudzony lub zbiera kod lub … To właśnie wtedy powinien skorzystać z tego linka xp-dev i zaciągnąć odpowiednie źródła.

Pytania, odpowiedz i drwiny w komentarzach (jak zawsze)

ps.
Poly nie dziala
ps2
Już weekend!

Pomoc w WPF

28/12/2010 ~ Jarosław Stadnicki ~ Leave a comment

Jak już się napisze aplikację, to czasem trzeba pomóc użytkownikowi odnaleźć się w gąszczu guzików, opcji, ustawień i innych zmiennych. Czas zagubiona dusza naciśnie F1 w nadziei na uzyskanie odrobiny więcej informacji na temat magicznego pola DevCtrlNo które przyjmuję tylko cyfry. Na przykład co ma tam wpisać i czy nie zepsuje się po wpisaniu złych wartości. Żeby tego dokonać, trzeba zaimplementować jakąś pomóc dla usera, np. poprzez F1. Można to zrobić także na inne sposoby, tooltip, dołączyć, html, czy inaczej. Ja góglując znalazłem taki jeden, który mi odpowiada i chce się tym sposobem podzielić.

Przykładowy kod jak zwykle na xp-dev. Tak jak poprzednio nie jest to mój wkład w wiedzę dotyczącą WPF, a jedynie opracowanie posta. Oryginalny wpis znaleźć można tutaj, a dodatkowe fikuśne bajery tutaj. Drugi link zawiera ciekawe artykuły dotyczące WPF – polecam przejrzenie.

Co trzeba zrobić by pięknie obsługiwać helpa?
– Nowy projekt
– Prze(pisz|kopiuj) klasę HelpProvider
– Dodaj brakujące namespace w xaml okna
– Rozszerz kontrolki o helpa
– Przejrzyj kod klasy, aby wyklikać ciekawsze efekty helpa niż tylko messagebox.

Oczywiście taki kod wspiera różne wersje językowe, ale o tym już pisałem wcześniej.

To tyle. Dla mnie taki help jest na wypasie, a dla was?