[RESOLVED] Container line

I like to group controls on a form using containers. Typically I use a panel, but sometimes use a combobox. I like to have a fixed line around the container, but I would like to define the color that line should be. I have found nothing in the properties that would allow me to do this. Is there a property that can be defined to set the color of the line, if a fixed line is used?

I don't know of one for the only 'fixed line' control that I am aware of, which is the GroupBox.

However, I often like to divide up controls into groups, as well, and when I want a line, black or some other color, I use a label. This only works for vertical or horizontal lines. If you want any other kind of line, you could use a GraphicsPath object, but that will take more effort. To use a label, you set the backcolor to whatever color you want, set AutoSize to False, then set either the height (horizontal) or width (vertical) to 1, 2, or whatever thickness you want.

The other option would be to draw a rectangle, but that would have to be done in the Paint event handler for it to work right.

That's cool about using a label. I never would have thought of that. Sometimes you have to think out of the box (pun intended).

I didn't come up with it. Back in VB6, there was a Line control. You can still find something like that in the VB PowerPacks supplement, but the supplement is otherwise a pain in the butt, and using the Line control from that is in no way superior to the GraphicsPath, other than the fact that it raises click events (which you can simulate using the GraphicsPath). Since .NET didn't have the Line Control, I went online (possibly here) looking for an alternative.

However, I started into .NET with the old CE, which stood for Compact Edition at the time (it's now used for Community Edition). The CE version worked on mobile devices, which meant PDA devices. The CE version also lacked lots of controls like ListBoxes, so writing for that version meant finding ways to use existing controls to compose what you wanted. For example, a Listbox was a panel with a bunch of labels on it and a vertical scroll bar. As you moved the scrollbar, you changed which item was in each label. These days, there are better controls that do that, such as the FlowLayoutPanel and User Controls, but those didn't exist for the CE version. Doing odd things with labels was just one of the tricks.

Quote:

---

Originally Posted by gwboolean

I like to group controls on a form using containers. Typically I use a panel, but sometimes use a combobox.

---

That doesn't seem to make sense. Did you mean a GroupBox?

It's easy enough to create a border yourself. Here's a control derived from Panel that has a one-pixel border of whatever colour you like:

vb.net Code:

Imports System.ComponentModel
 
Public Class BorderedPanel
    Inherits Panel
 
    Private _borderColor As Color = Color.Black
 
    <Category("Appearance")>
    <Description("The colour of the border")>
    Public Property BorderColor As Color
        Get
            Return _borderColor
        End Get
        Set(value As Color)
            If _borderColor <> value Then
                _borderColor = value
                OnBorderColorChanged(EventArgs.Empty)
            End If
        End Set
    End Property
 
    Public Event BorderColorChanged As EventHandler
 
    Protected Overridable Sub OnBorderColorChanged(e As EventArgs)
        'Repaint the control to update the colour of the border.
        Refresh()
 
        RaiseEvent BorderColorChanged(Me, e)
    End Sub
 
    Protected Overrides Sub OnPaint(e As PaintEventArgs)
        MyBase.OnPaint(e)
 
        Using p As New Pen(BorderColor)
            e.Graphics.DrawRectangle(p, 0, 0, Width - 1, Height - 1)
        End Using
    End Sub
 
End Class

If you add that class to your project and build then you can add an instance from the Toolbox just like any other control. You can also build it into a DLL and add it to the Toolbox for every project.

Obviously that won't have the nice rounded corners that a GroupBox has but you can modify the code in the OnPaint method to draw whatever you like.

Shaggy, based on your historical comments you might even be older than me. That is so sad. But whatever the case, that is an approach I am going to keep in mind.

JM, Yep, I did indeed mean a groupbox. I type so fast that my thoughts usually cannot keep up.

What you provided is pretty cool. However, I am pretty ignorant about the use of classes like this. I guess it is time I learned what the hell is going on and how to do it. So let me see if I understand part of it, at least.

OK, I have created the class, but I have never added a class to a project and build. I have added powerpacks and a few things like that. I would assume it is the same process, but I wouldn't even know where to look for it to add.

I am now able to see the Border Panel class in the toolbox and have added it to the form. In the properties I can see the properties I am after. This is the first time I have done something like this and while it might not be that big a deal for you guys, for me this is very, very cool.

It took me awhile to figure it all out (that is assuming I actually have figured it all out), but I am setting it up and will be checking it out pretty soon. Thanks JM, you nailed by butt to the wall on this one.

Damn, it almost worked!!!! Actually, it does work, but for only the Top and the Left side. The Right side and the bottom do not show the line. So here is what I get in my first attempt using the panel:

Attachment 155489

I did not change the color from the default black, but since the lines are different widths I believe the discrepancy can be easily observed.

It would be my guess that whatever is not quite there would be in this part of the code:

Code:

---

        Using p As New Pen(BorderColor)
            e.Graphics.DrawRectangle(p, 0, 0, Width - 1, Height - 1)
        End Using

---

However, I know nothing about the code in the Using, so I am obviously only guessing. I am going to do some looking through whatever I can find on this, but if someone can explain to me what is going on it would be appreciated.

Even with it not quite right and me not having any idea what to do (yet), this is still cool as hell!

It looks like you have set BorderStyle to something other than None; probably FixedSingle. If you do that then the control will draw its own border first and reduce the usable area of the control by one pixel in all directions. Set BorderStyle back to None and then let the code I provided draw the border for you. Using FixedSingle for the BorderStyle will draw a single-pixel border but can't be any color but black.

You are absolutely correct. It is indeed set to FixedSingle. I set it to None and I do indeed get all for sides (or at least I will when I get the DGV that is sitting in it set to the right height). I am not sure I fully understand all of this (actually I damn sure don't), but I have to say JM, that this is cool as hell.

The code I provided uses one of the fundamental principles of OOP: inheritance. When class B inherits class A, class B automatically has all the functionality of class A by default. You can then add extra functionality and/or depending on how it was implemented, modify existing functionality. That BorderedPanel does both.

Pretty much every class you use in .NET inherits some other class. If you check out the documentation for a class, it will show you the inheritance hierarchy. For instance, the standard Panel control inherits ScrollableControl, which inherits Control, which inherits Component, which inherits MarshalByRefObject, which inherits Object, which is the root of the entire .NET type hierarchy.

So, that BorderedPanel class automatically has all the functionality of the Panel class by default. If you were to use it without adding any more code, it would behave the same way exactly.

It then adds the BorderColor property to enable you set the colour of the border. The property itself just stores a Color value, which is then used elsewhere to draw the border. More recently, VB.NET has supported auto-properties, which allows you to a property with a single line. I chose the old-style, full implementation (backing field, getter and setter) so that I could raise the BorderColorChanged event when the BorderColor property value changes. That's pretty much exactly how properties like Text are implemented to raise events like TextChanged.

The .NET convention for raising SomeEvent is to use a method named OnSomeEvent. If you want to read more about that, follow the Blog link in my signature and check out my post on Custom Events. The OnBorderColorChanged method follows that convention. It raises the BorderColorChanged event and it also forces the control to be repainted, thus redrawing the border in the new colour.

As per the convention I mentioned, the Control class has an OnPaint method to raise the Paint event. All GDI+ drawing on a control should be done on that event. In this case, the OnPaint method is overridden, i.e. a new implementation is provided. The base implementation of OnPaint is called first, which ensures that all existing functionality is executed, including actually raising the event and executing any event handlers. The border is then drawn as a rectangle around the edge of the control.

All this means that, every time the control gets painted on screen, the last thing done will be to draw the border around the edge and over the top of anything else drawn in that area. It also means that the border will be redrawn whenever the BorderColor changes.

That is a really neat feature. However, I do believe I am going to have to put some time into all of that to really see and get real usage from it. But I can already see some of the possibilities.