Windows Forms III - Dynamic Layout

arich — Thu, 05 Feb 2004 19:17:00 GMT

I'm not going to belabor my blog with yet another code explanation. I've converted the dynamic layout example (found here) from C# to C++. It isn't especially interesting, but it is good groundwork for later examples and projects.

Get the code! You can download this dynamic layout example here. As usual, both old and new syntax versions are included. And, as usual, if the old syntax version doesn't seem to compile, please let me know. The comments section on the sample download page has a note about avoiding a compiler warning.

Hello World from Windows Forms, MK II.

arich — Fri, 23 Jan 2004 00:13:00 GMT

Now that we've gotten our feet wet, it's time to try something a bit more complicated. We'll include a TextBox and a Button in this example, and also take a quick look at how we wire up events on actions like button clicks. I'm going to be skipping the explanation for code that we've already seen, and just concentrating on the new stuff. As always, scroll down for the sample download.

public ref class HelloWorldForm : public Form {

private:

Button ^button1;
TextBox ^textBox1;

Our HelloWorldForm now has two private members, button1 and textBox1. The UI elements they represent should be fairly obvious.

public:

HelloWorldForm() {

//allocate the private members

button1 = gcnew Button;

textBox1 = gcnew TextBox;

//Set up the Form

Text = "Hello Windows Forms World";

AutoScaleBaseSize = System::Drawing::Size(5, 13);

ClientSize = System::Drawing::Size(392, 117);

Here's the start of the default constructor, where all the basic setup for this form takes place. We gcnew our two private members, and we start setting up the form. I didn't go into this much last time, but what is happening here may not be totally obvious. Text, AutoScaleBaseSize, and the other members we'll see are members of HelloWorldForm's parent type, System::Windows::Forms::Form. To check out the various members of this type, head here.

Basically, we're setting up the form to have a client area size of 392x117 pixels. This is the default size, which is resizeable (based on whether or not you wish to allow this).

//Set the minimum form size to the client size + the height of the title bar

MinimumSize = System::Drawing::Size(392, (117 + SystemInformation::CaptionHeight));

//Set the default button on the Form

AcceptButton=button1;

It should be plainly obvious what the first line does. The reason we use the CaptionHeight property is that the height of the caption bar (where the program icon, maximize and close buttons, etc. are displayed) can change, depending especially on the font the user has set their default program title to. AcceptButton is the default button on a form that is pressed when the user hits the Enter key. (There's also a CancelButton, which is what is pressed when the user hits the Esc key.)

//Create the button

button1->Location = Point(256, 64);

button1->Size = System::Drawing::Size(120, 40);

button1->TabIndex = 2;

button1->Text = "Click Me!";

Here, we're simply populating our button1 with various useful attributes. The position for Location is based on the upper left-hand corner of the form (which is 0,0). In this case, our button's upper left-hand corner is 256 pixels right and 64 pixels down from that origin.

//Register the event handler

button1->Click += gcnew System::EventHandler(this, &HelloWorldForm::button1_Click);

This is probably the most interesting single line of code in this example. We're probably all aware that Windows is an event-based world. The program sits out there, and waits for user input - whether it be striking a key on the keyboard, or some form of mouse movement. So, we have to be able to wire up function calls to actions the user could perform. We call these actions events. System::Windows::Forms::Button::Click is one such event. (Actually, Click is an event that Button inherits from a common base class, System::Windows::Forms::Control.)

We can wire up a function to handle an event by using the += operator. This allows us to add multiple handlers to a single event (which can be very useful). We pass a this pointer and a pointer to the handler function to the EventHandler constructor, and add that temporary object to the Click event. Now, when the user clicks button1, the function button1_Click will be called! (The definition of this function is below.)

//Create the text box

textBox1->Text = "Hello Windows Forms World";

textBox1->TabIndex = 1;

textBox1->Size = System::Drawing::Size(360, 20);

textBox1->Location = Point(16, 24);

More property set-up, this time for our TextBox. The TabIndex property that you see here (and on button1) represents the order that the controls are focused on, with multiple presses of the Tab key. The focus starts on whatever control has TabIndex 1, and, with subsequent presses of Tab, will cycle through the different controls in order. When the last TabIndex is reached, we loop around to the first again.

//Add the controls to the form

Controls->Add(button1);

Controls->Add(textBox1);

}

Finally, we need to Add our two controls to HelloWorldForm's Controls. Up to this point, the controls have been merely classes that happened to be members of our form. When you hook them up by Adding them, they become visible, clickable objects inside the UI. This is important to remember, if you don't register your control, it simply won't be visible, and you'll be left wondering why.

protected:

void Dispose(bool disposing)

{

try {

MessageBox::Show("Disposed!");

} catch(Exception^ e) {}

Form::Dispose(disposing);

}

I wouldn't have shown you the Dispose function again, except that this time, I'm using MessageBox::Show to pop up a standard Windows dialog while I'm disposing the class, to demonstrate exactly when Dispose gets called. This is bad design, however, as you typically don't want anything in a Dispose function that doesn't need to be there.

private:

void button1_Click(Object^ sender, EventArgs^ evArgs) {

MessageBox::Show(String::Concat("Text is: '", textBox1->Text, "'"));

}

};

Here's button1_Click, the function that is wired up to our button's Click event. It also uses MessageBox::Show to pop up a Windows dialog, with the text of whatever is in our TextBox. We also close out our class here.

int main() {

Application::Run(gcnew HelloWorldForm);

return 0;

}

And, last but not least, our main function. Still not flashy, it does the same thing it did in our first example.

Whew, that was longer. Yes, it was, but it also did a whole lot more, and without too much additional code. Next time, we'll be looking at the power of Windows Forms dynamic layout.

Get the files. You can get the sample here. This contains two files, hwf2.cpp, and hwf2OS.cpp. Hwf2 is the complete code sample above, and hwf2OS.cpp is the Managed Extensions version of it. As always, if something doesn't compile properly, or you have questions, please post a comment.

Hello World from Windows Forms!

arich — Wed, 21 Jan 2004 21:39:00 GMT

It begins... This will be a new series of articles. I'll start with some ports of existing samples (from here), and move into some original material. I want to take a Managed C++ (and specifically a Whidbey C++) approach to Windows Forms, and investigate what exactly we can do with this powerful library. I've created a seperate post category (+RSS) for this special set of samples, in case you want to track this set of articles specially.

On to the first sample, the ever-traditional Hello, World. As always, the link for the sample is at the bottom.

#using <System.Windows.Forms.dll>

#using <System.dll>

#using <System.Drawing.dll>

using namespace System;
using namespace System::Windows::Forms;

We start by #using a few new dll's. System.Windows.Forms.dll contains most of the important forms classes, System.dll includes some important basic types, and System.Drawing.dll contains some additional important types. A few using namespace declarations will help cut down on typing.

public ref class SimpleHelloWorld : public Form {

public:

SimpleHelloWorld(){

Text = "Hello, World.";

}
};

Here, I've declared a new ref class, SimpleHelloWorld, inherited from the type System::Windows::Forms::Form. I override Form's default constructor with one of my own, that sets the Text property to, surprise, “Hello, World.”

int main(){

Application::Run(gcnew SimpleHelloWorld);

}

Here's my main function. I make a call to System::Windows::Forms::Application::Run, and pass it an instance of my SimpleHelloWorld class. The Application::Run function will block until the form passed to it is closed.

That's it? It is undoubtedly simpler than many Windows applications you've seen in the past. No HWNDs, no fancy CoCreateInstances, not even a WinMain! It looks just like a lot of other simple C++ programs you've seen in the past, except this one creates a real window. Yes, it may be a simplistic window with no features, but we're on our way.

Get the files. You can get the files here. This contains two files, hwf.cpp and hwfOS.cpp. Hwf.cpp is the code sample above, in Whidbey C++, and hwfOS.cpp is the Managed Extensions version of it. I don't have an install of VC.NET 2003 handy, so please post a comment if it doesn't compile or work properly.

I Love that New Syntax Smell : Windows Forms

Windows Forms III - Dynamic Layout

Hello World from Windows Forms, MK II.

Hello World from Windows Forms!