Discussion :

[TheBlackReverand]

Bonjour,

Je viens de trouver une source très interessante realiser en C#2.0 qui explique l'utilisation de "IExtenderProvider" afin d'ajouter des propriétèes a divers elements.

Dans mon cas il s'agit d'ajouter une propriétèe de type texte qui permet, si une TextBox est vide d'y afficher un message en grisè.

Le problème est le suivant:
dans une de ses methodes il utilise "control.Invalidate()" qui n'existe pas dans la version 3.5....

PS: il utilise OnPaint(je sais pas si sa peut etre utile)

voici la methode d'origine

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
public void SetEmptyText(Control control, string text)
{
    if (control == null)
        throw new NullReferenceException();
 
    if (!controls.ContainsKey(control))
        controls.Add(control, new CEmptyText(text, control, this));
    else
        ((CEmptyText)controls[control]).EmptyText = text;
 
    control.Invalidate();
}

[smyley]

"control.Invalidate()" qui n'existe pas dans la version 3.5....

Tu es certain de ce que tu affirmes ?

[TheBlackReverand]

desoler j'avou avoir oublier de precisè un point

pour moi le passage au framework 3.5 implique la migration vers WPF

ainsi j'utilise System.Windows.Controls au lieu de System.Windows.Forms

le problème ici est donc que je doit utilise System.Windows.Controls.Control.Invalidate() qui cette fois n'existe pas....


par la meme occasion je doit recuperer le Handle du control qui lui ausi n'est pas accessible....


merci pour votre aide

[Guulh]

Dans mon cas il s'agit d'ajouter une propriétèe de type texte qui permet, si une TextBox est vide d'y afficher un message en grisè.

En winforms, ça se fait très bien en faisant appel à la fonction de Win32 correspondante (j'avais chopé ça sur Codeproject :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
private const int EM_SETCUEBANNER = 0x1501;
 
[DllImport("user32.dll", CharSet = CharSet.Auto)]
private static extern Int32 SendMessage(IntPtr hWnd, int msg, int wParam, [MarshalAs(UnmanagedType.LPWStr)] string lParam);
 
public static void SetCue(Control control, string cue)
{
	SendMessage(control.Handle, EM_SETCUEBANNER, 0, cue);
}

Par contre WPF fonctionne complètement différemment des winforms, donc je doute fort que ton bout de code soit directement exploitable. WPF n'est pas un wrapper de win32, donc pas de handle...

[smyley]

Pour refresher un contrôle WPF on peux faire comme ceci :

Code c# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
   private static Action EmptyDelegate = delegate() { };
 
 
   public static void Refresh(this UIElement uiElement)
   {
      uiElement.Dispatcher.Invoke(DispatcherPriority.Render, EmptyDelegate);
   }

Mais comme dit plus haut, en WPF il n'y a pas de Handle, les contrôles sont entièrement gérés par le framework.
Mais du coup, le passage en WPF ne devrais pas être qu'une simple adaptation d'un code WinForms : les concepts des deux technologies ne sont pas les mêmes.
Pour faire ce que tu veux j'aurai plus vu un TextBox auquel on aurai appliqué un DataTemplate ou un ControlTemplate. Il suffirait juste de mettre à jour l'affichage du texte au changement de la propriété Content ou Text.

[ikeas]

je voulais juste préciser quelque chose, le invalidate dans le c#2 indique a windows que le control doit être redessiné, ce qui génére un événement WM_PAINT en général ....

[TheBlackReverand]

ok donc je peut resoudre le problème du Invoke() en forcant le control a etre redessiner, sa doit pouvoir se fair...

pour le handle l'utiliter était d'intercepter les messages envoyer au control pour effectuer nos propres traitement...

je vais reflechir sur les Template mais ici l'integration était on ne peut plus aprèciable, on ajouter un control invisible(il s'afficher a la maniere des DataSet) qui ajouter une propriétè "TextVide" a chaque TextBox. se controle offret egalement le choix de la police et couleur d'ecriture directement dans le designer

[smyley]

pour le handle l'utiliter était d'intercepter les messages envoyer au control pour effectuer nos propres traitement...

ça tombe mal, les messages ça n'existe pas en WPF.
Il reste la méthode également de rendre tout ça plus propre avec des vrais évènements ou des triggers par exemple pour faire réagir l'interface.

[tomlev]

Dans mon cas il s'agit d'ajouter une propriétèe de type texte qui permet, si une TextBox est vide d'y afficher un message en grisè.

il y a déjà un contrôle qui fait ça dans le WPF Bag-o-tricks de Kevin Moore

Sinon, une autre approche, plus dans l'esprit WPF, serait d'utiliser une propriété Attachée...

[ikeas]

si tu veux rafraichir le visuel tu peux peut etre essayer le invalidate visual
sinon si tu veux mettre un text gris (en dessous) quand la valeur de text est vide il y'a une solution simple
c'est de modifier le template de la text box pour avoir un texblock sous la text box
tu bindera le textde la textbox sur une propriete attache qui evenrra dans le textbloxk un text particulier quand le text ext null ou vide
bien sur la propriete attache (dans le call back de la definition c'est le meilleurs moyen)

un peut comme ca

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
 
    #region Text
        //----------------------------------------------------------------------------------------------------
        [Localizability(LocalizationCategory.Text)]
        public string Text
        {
            get { return (string)base.GetValue(TextProperty); }
            set { base.SetValue(TextProperty, value); }
        }
        //----------------------------------------------------------------------------------------------------
        public static readonly DependencyProperty TextProperty =
            DependencyProperty.Register(
                "Text", typeof(string), typeof(SASCurrentLevel),
            //new PropertyMetadata(false));
                new FrameworkPropertyMetadata(string.Empty,
                    FrameworkPropertyMetadataOptions.AffectsRender | FrameworkPropertyMetadataOptions.AffectsMeasure,
                    new PropertyChangedCallback(OnTextChanged),
                    new CoerceValueCallback(CoerceText)
                )
            );
        //----------------------------------------------------------------------------------------------------
        private static void OnTextChanged(DependencyObject element, DependencyPropertyChangedEventArgs args)
        {
            element.CoerceValue(TextProperty);
        }
        //----------------------------------------------------------------------------------------------------
        private static object CoerceText(DependencyObject element, object value)
        {
            SASCurrentLevel block = (SASCurrentLevel)element;
string s = "";
            if (value == null || s == "") 
value = string.Empty;
else
s = (string)value;
            block.MonTextBlock.Text = (s.equal(string.empty) ?  "entrez un text" ? "");
            return value;
        }

dans ton cas tu pourrais te passer du CoerceValueCallback
j'ai fait ca vite fait

[TheBlackReverand]

au vu des difference entre WPF et WinForms(principalement le handle et l'interception de message) j'ai abandonner l'adaptation de la source et me analyse maintenant la methode utiliser dans WPF Bag-o-tricks dont le resultat est....

merci pour votre temps =>