c#: transparent label control

After you change the text value you would need to invalidate the control to force a re-paint.

A better approach might be to use something like this:

public class TransparentLabel : Label {
        /// <summary>
        /// Creates a new <see cref="TransparentLabel"/> instance.
        /// </summary>
        public TransparentLabel() {
        }
 
        /// <summary>
        /// Gets the creation parameters.
        /// </summary>
        protected override CreateParams CreateParams {
            get {
                CreateParams cp = base.CreateParams;
                cp.ExStyle |= 0x20;
                return cp;
            }
        }
 
        /// <summary>
        /// Paints the background.
        /// </summary>
        /// <param name="e">E.</param>
        protected override void OnPaintBackground(PaintEventArgs e) {
            // do nothing
        }
 
    }

                                              

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:

mac-will: it looks like you just removed the constructor and the OnPaint method. When I commented those out, nothing happens.

Hi BlearyEye;

To your question, "When I assign or change the value in the text property for the control, it does no show up on the design window", this may happen if the label is on top of another control and its z-order is not set to be the first. You can select the label control and right click on it. Then from the context menu select "Bring to Front".

To your question, "Similarly, when I change the value in the program, it does not show up", This may also be happening for the above reason but also that the system has not yet updated the UI. The simplest way to solve this issue is when you change the Text property of the label do it in a function as shown in the snippet this way you can force an update.

        private void ChangeLableText(string changeTo)
        {
            transparentLabel1.Text = changeTo;
            this.Invalidate(true);
        }

Fernando

I suspect the problem is at design time, when the property value is set via the properties editor. An invalidate would probably need to put in the property setter.

This doesn't directly answer the question - but I'm using VS2008 on Vista and I can quite succesfully set the background color of a label to Transparent and its working fine for me. When you say transparency is not supported - what do you mean? All the controls I've needed to have with a transparent background so far have worked fine.

You know ... that was my first impression. I quickly dismissed it, thinking I was being dumb. Was too lazy to test it. :)

No, I also change the parent class!!!

public class TransparentLabel : Label

NOT

public class TransparentLabel : Control

Which probably aquires the built-in "invalidation" when the Text property is set, regardless of how it's set, right?

mc-will: sorry, I missed that.

OK, I made the change and am closer since it now updates the text. However, there are some new issues.

1. The background that gets painted dynamically is wrong. There are several graphics on the form and it looks like the background chosen is part of another graphic that's a fair distance away from the label.

2. The previous text in the label is still there; it doesn't get erased when the new text is added.

3. In the designer, and until the first assignment in the program, the label shows up with a white background.

These are re-painting issues.  Because the label is not painting it's background you need to have what ever is behind it invalidate the label retangle so that it repaints the background you want.

You could maybe do something cleaver in the OnPaintBackground override like:

this.Parent.Invalidate(this.myRectangle)

Todd:  Yes I believe the Label control would have all the invalidation built in.

hmmm ... invaidating the parent means that the transparentlabel control will be called continuously (invaliate -> call transparentlabel -> invalidate). I guess I'll ned to add a switch..

Add this to the class and it should do it for you.

protected void InvalidateEx()
         {
  
            if (Parent == null)
                 return;
 
            Rectangle rc = new Rectangle(this.Location, this.Size);
 
            Parent.Invalidate(rc, true);
         }
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

Hi BlearyEye;

Try this, leave your TransparentLabel class as originally posted that inherits from Control.  When you add the TransparentLabel control to the form add its TextChanged event handler. Then in the event handler do the invalidate, like so:

        private void transparentLabel1_TextChanged(object sender, EventArgs e)
        {
            this.Invalidate(true);
        }

Fernando

(sorry for the delay ... been travelling)

mac-will:

I added the method but it seems to have no effect. See complete class below.

public class TransparentLabel : Label {
        public TransparentLabel() {
        }
        protected override CreateParams CreateParams {
            get {
                CreateParams cp = base.CreateParams;
                cp.ExStyle |= 0x20;
                return cp;
            }
        }
        protected override void OnPaintBackground(PaintEventArgs e) {
            // do nothing
        }
 
        // added by suggestion of mac-will
        protected void InvalidateEx() {
 
            if (Parent == null)
                return;
 
            Rectangle rc = new Rectangle(this.Location, this.Size);
 
            Parent.Invalidate(rc, true);
        }
    }
                                              

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:

FernandoSoto:

The control is called ClipLength. I added the following to the form code as you suggested

        private void ClipLength_TextChanged(object sender, EventArgs e) {
            this.Invalidate(true);
        }

I used the control as originally posted. This seemed to have no effect. I put a breakpoint on the code and it appears that the TextChanged method is never called. I'm changing the text from program code, not from user interaction.

ya, it doesn't seem to work with the label control.
You can try this class and see if it does the trick for you:

class TransparentLabel : Control
    {
 
        public TransparentLabel(Control parent)
         {
             this.Parent = parent;
         }
 
        protected void InvalidateEx()
        {
 
            if (Parent == null)
                return;
 
            Rectangle rc = new Rectangle(this.Location, this.Size);
 
            Parent.Invalidate(rc, true);
        }
 
         protected override CreateParams CreateParams
         {
             get
             {
                 CreateParams cp = base.CreateParams;
                 cp.ExStyle |= 0x0000020;
                 return cp;
             }
         }
 
         protected override void OnPaintBackground(PaintEventArgs e)
         {
             // do nothing
         }
 
         protected override void OnPaint(PaintEventArgs e)
         {
             using (SolidBrush brush = new SolidBrush(base.ForeColor))
             {
                 e.Graphics.DrawString(base.Text, base.Font, brush, -1, 0);
             }
         }
 
 
    }

                                              

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:
39:
40:
41:
42:
43:
44:

I see what you did: changed the constructor to make the parent explicit.

It seems to be working now (yay), but I had to add the following:

   To InitializeComponent:
        this.ClipLength.TextChanged += new System.EventHandler(ClipLength_TextChanged);

    To the form class:
        private void ClipLength_TextChanged(object sender, EventArgs e) {
            this.Invalidate(true);
        }

Otherwise, nothing happened.

I tried using this.ClipLength.Invalidate(true), but it did not erase the current contents of ClipLength; new text overwrote the old stuff. Apparently I'm invalidating the entire form, which seems inefficient.

The TransparentLabel control code includes a method InvalidateEx(). I added a breakpoint to the method and apparently it's never being called. I changed it to the attached snippet, but when I use this.ClipLength.Invalidate(true), the overwriting still happens.

        protected new void Invalidate()
        {
 
            if (Parent == null)
                return;
 
            Rectangle rc = new Rectangle(this.Location, this.Size);
 
            Parent.Invalidate(rc, true);
        }
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

This last version seems to work. The key points are:
- specify the control explicitly
- clear the background part when text changed

below is a somewhat cleaned-up version of the control.

    public class TransparentLabel : Control {
        //
        // Constructor specifies parent control. 
        // This is what will be refreshed when label text is changed
        //
        public TransparentLabel(Control parent) {
            this.Parent = parent;
        }
        //
        // When text value changes, invalidate corresponding area of parent
        //
        public override String Text {
            get {
                return base.Text;
            }
            set {
                if (value != base.Text) {
                    base.Text = value;
                    if (this.Parent == null)
                        return;
                    Rectangle rc = new Rectangle(this.Location, this.Size);
                    this.Parent.Invalidate(rc, true);
                    this.Parent.Update();
                }
            }
        }
        protected override CreateParams CreateParams {
            get {
                CreateParams cp = base.CreateParams;
                cp.ExStyle |= 0x0000020;
                return cp;
            }
        }
        protected override void OnPaintBackground(PaintEventArgs e) {
            // do nothing
        }
        protected override void OnPaint(PaintEventArgs e) {
            using (SolidBrush brush = new SolidBrush(base.ForeColor)) {
                e.Graphics.DrawString(base.Text, base.Font, brush, -1, 0);
            }
        }
    }
                                              

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:
39:
40:
41:
42: