The code to display the dialog goes in the handler for the Pen

Right-click the Width menu item in the Resource View pane for the IDR_SketcherTYPE menu and select Add Event Handler from the pop-up. You can then create a function for the COMMAND message handler corresponding to ID_PEN_WIDTH in the CSketcherDoc class. Now edit this handler and enter the following code:

// Handler for the pen width menu item
void CSketcherDoc::OnPenWidth()
{
   CPenDialog aDlg;                    // Create a local dialog object
   // Display the dialog as modal
   aDlg.DoModal();
}

There are just two statements in the handler at the moment. The first creates a dialog object that is automatically associated with your dialog resource. You then display the dialog by calling the DoModal() function for the aDlg object.

Because the handler creates a CPenDialog object, you must add a #include directive for PenDialog.h to the beginning of SketcherDoc.cpp (after the #include directives for stdafx.h and Sketcher.h); otherwise, you'll get compilation errors when you build the program. After you've done that, you can build Sketcher and try out the dialog. It should appear when you click the pen-width toolbar button. Of course, if the dialog is to do anything, you still have to add the code to support the operation of the controls; to close the dialog, you can use either of the buttons or the close icon in the title bar.

The OK and Cancel buttons (and the close icon on the title bar) already close the dialog. The handlers to deal with the BN_CLICKED event handlers for the OK and Cancel button controls have been implemented for you. However, it's useful to know how the action of closing the dialog is implemented, in case you want to do more before the dialog is finally closed, or if you are working with a modeless dialog.

The CDialog class defines the OnOK() method that is called when you click the default OK button, which has IDOK as its ID. This function closes the dialog and causes the DoModal() method to return the ID of the default OK button, IDOK. The OnCancel() function is called when you click the default Cancel button in the dialog; this closes the dialog, and DoModal() returns the button ID, which is IDCANCEL. You can override either or both of these functions in your dialog class to do what you want. You just need to make sure you call the corresponding base class function at the end of your function implementation. You'll probably remember by now that you can add an override class by clicking the override button in the Properties window for the class.

For example, you could implement an override for the OnOK() function as follows:

void CPenDialog::OnOK()
{
  // Your code for data validation or other actions...

  CDialog::OnOK();                     // Close the dialog
}

In a complicated dialog, you might want to verify that the options selected, or the data that has been entered, is valid. You could put code here to check the state of the dialog and fix up the data, or even to leave the dialog open if there are problems.

Calling the OnOK()function defined in the base class closes the dialog and causes the DoModal() function to return IDOK. Thus, you can use the value returned from DoModal() to detect when the dialog was closed via the OK button.

As I said, you can also override the OnCancel() function in a similar way if you need to do extra cleanup operations before the dialog closes. Be sure to call the base class method at the end of your function implementation.

When you are using a modeless dialog you must implement the OnOK() and OnCancel() function overrides so that they call the inherited DestroyWindow() to terminate the dialog. In this case, you must not call the base class OnOK() or OnCancel() functions, because they do not destroy the dialog window, but merely render it invisible.

Controls in a dialog have what is called a tab sequence. This is the sequence in which the focus shifts from one control to the next when you press the tab key, determined initially by the sequence in which controls are added to the dialog. You can see the tab sequence for the current dialog box by selecting Format

Figure 18.9. FIGURE 18-9

If the tab order you see is different, you have to change it. You really want the edit control to precede the spin button in the tab sequence, so you need to select the controls by clicking them in the order in which you want them to be numbered: OK button; Cancel button; edit control; spin button; and finally the static control. So, the tab order will be as shown in Figure 18-9. Now the edit control is selected as the buddy to the spin button.

A virtual function called DoDataExchange() has been included in the class by the Class Wizard. If you look in the ScaleDialog.cpp file, you'll find that the implementation looks like this:

void CScaleDialog::DoDataExchange(CDataExchange* pDX)
{
   CDialog::DoDataExchange(pDX);
   DDX_Text(pDX, IDC_SCALE, m_Scale);
   DDV_MinMaxInt(pDX, m_Scale, 1, 8);
   DDX_Control(pDX, IDC_SPIN_SCALE, m_Spin);
}

This function is called by the framework to carry out the exchange of data between variables in a dialog and the dialog's controls. This mechanism is called dialog data exchange, usually abbreviated to DDX. This is a powerful mechanism that can provide automatic transfer of information between a dialog and its controls in most circumstances, thus saving you the effort of programming to get the data yourself, as you did with the radio buttons in the pen width dialog.

In the scale dialog, DDX handles data transfers between the edit control and the variable m_Scale in the CScaleDialog class. The variable pDX, passed to the DoDataExchange() function, controls the direction in which data is transferred. After the base class DoDataExchange() function is called, the DDX_Text() function is called. The latter actually moves data between the variable m_Scale and the edit control.

The call to the DDV_MinMaxInt() function verifies that the value transferred is within the limits specified. This mechanism is called dialog data validation, or DDV. The DoDataExchange() function is called automatically before the dialog is displayed to pass the value stored in m_Scale to the edit control. When the dialog is closed with the OK button, it is automatically called again to pass the value in the control back to the variable m_Scale in the dialog object. All this is taken care of for you. You need only to ensure that the right value is stored in m_Scale before the dialog box is displayed, and arrange to collect the result when the dialog box closes.

You'll use the OnInitDialog() function to initialize the dialog, just as you did for the pen width dialog. This time you'll use it to set up the spin control. You'll initialize the m_Scale member a little later when you create the dialog in the handler for a Scale menu item, because it should be set to the value of the scale stored in the view. For now, add an override for the OnInitDialog() function to the CScaleDialog class, using the same mechanism you used for the previous dialog, and add code to initialize the spin control as follows:

BOOL CScaleDialog::OnInitDialog()
{
   CDialog::OnInitDialog();

   // If you have not checked the auto buddy option in
   // the spin control's properties, you can set the buddy control here

   // Set the spin control range
   m_Spin.SetRange(1, 8);

   return TRUE;  // return TRUE unless you set the focus to a control
                 // EXCEPTION: OCX Property Pages should return FALSE
}

There is only one line of code to add. This sets the upper and lower limits for the spin button by calling the SetRange() member of the spin control object. Although you have set the range limits for the edit control, this doesn't affect the spin control directly. If you don't limit the values in the spin control here, you allow the spin control to insert values outside the limits in the edit control, and there will be an error message from the edit control. You can demonstrate this by commenting out the statement that calls SetRange() here and trying out Sketcher without it.

If you want to set the buddy control using code, rather than by setting the value of Auto buddy in the spin button's properties to True, the CSpinButtonCtrl class has a function member to do this. You need to add the statement

mSpin.SetBuddy(GetDlgItem(IDC_SCALE));

at the point indicated by the comments.

You must set up the scrollbars initially for the view in the OnInitialUpdate() member of CSketcherView. Change the previous implementation of the function to the following:

void CSketcherView::OnInitialUpdate()
{
  ResetScrollSizes();                  // Set up the scrollbars
  CScrollView::OnInitialUpdate();
}

All you do is call the ResetScrollSizes() function that you just added to the view. This takes care of everything — well, almost. The CScrollView object needs an initial extent to be set in order for OnPrepareDC() to work properly, so you need to add one statement to the CSketcherView constructor:

CSketcherView::CSketcherView()
: m_FirstPoint(CPoint(0,0))           // Set 1st recorded point to 0,0
, m_SecondPoint(CPoint(0,0))          // Set 2nd recorded point to 0,0
, m_pTempElement(NULL)                // Set temporary element pointer to 0
, m_pSelected(NULL)                   // No element selected initially
, m_MoveMode(FALSE)                   // Set move mode off
, m_CursorPos(CPoint(0,0))            // Initialize as zero
, m_FirstPos(CPoint(0,0))             // Initialize as zero
, m_Scale(1)                          // Set scale to 1:1
{
   SetScrollSizes(MM_TEXT, CSize(0,0));     // Set arbitrary scrollers
}

The additional statement just calls SetScrollSizes() with an arbitrary extent to get the scrollbars initialized before the view is drawn. When the view is drawn for the first time, the ResetScrollSizes() function call in OnInitialUpdate() sets up the scrollbars properly.

Of course, each time the view scale changes, you need to update the scrollbars before the view is redrawn. You can take care of this in the OnViewScale() handler in the CSketcherView class:

void CSketcherView::OnViewScale()
{
  CScaleDialog aDlg;                   // Create a dialog object
  aDlg.m_Scale = m_Scale;              // Pass the view scale to the dialog
  if(aDlg.DoModal() == IDOK)

{
    m_Scale = aDlg.m_Scale;            // Get the new scale
    ResetScrollSizes();                // Adjust scrolling to the new scale
    InvalidateRect(0);                 // Invalidate the whole window
  }
}

With the ResetScrollSizes() function, taking care of the scrollbars isn't complicated. Everything is covered by the one additional line of code.

Now you can build the project and run the application. You'll see that the scrollbars work just as they should. Note that each view maintains its own scale factor, independently of the other views.

You can add radio buttons to a CTaskDialog object using the AddRadioButton() function. Here's how you could add radio buttons to the scaleDlg object that was created in the previous section:

const int SCALE_1(1001), SCALE_2(1002), SCALE_3(1003), SCALE_4(1004);
scaleDlg.AddRadioButton(SCALE_1, _T("View scale 1"));
scaleDlg.AddRadioButton(SCALE_2, _T("View scale 2"));
scaleDlg.AddRadioButton(SCALE_3, _T("View scale 3"));
scaleDlg.AddRadioButton(SCALE_4, _T("View scale 4"));
int result = scaleDlg.DoModal();

The first statement defines four integer constants that you use to identify the radio buttons. The AddRadioButton() function calls add four radio buttons, each identified by the first argument, with the annotation for each radio button specified by the second argument. Executing this fragment, following the statement in the previous section that creates scaleDlg, will display the dialog shown in Figure 18-12.

Figure 18.12. FIGURE 18-12

The first radio button is selected by default. If you wanted to have a different radio button selected by default, you could call the SetDefaultRadioButton() function for the dialog before you display it. For example:

scaleDlg.SetDefaultRadioButton(SCALE_3);

The argument to the function is the ID of the button you want to set as the default selection.

You can remove all the radio buttons from a CTaskDialog object by calling its RemoveAllRadioButtons() function. You would do this if you wanted to add a different set of radio buttons before you re-display the dialog.

You can obtain the ID of the radio button that is selected when the dialog closes by calling the GetSelectedRadioButtonID() function for the dialog object. Here's how you can get output from scaleDlg:

if(scaleDlg.DoModal() == IDOK)
  {
    switch(scaleDlg.GetSelectedRadioButtonID())
    {
    case SCALE_1:
      m_Scale = 1;
      break;
    case SCALE_2:
      m_Scale = 2;
      break;
    case SCALE_3:
      m_Scale = 3;
      break;
    case SCALE_4:
      m_Scale = 4;
      break;
    }
  }

You display the dialog by calling DoModal() for scaleDlg. You want to check the state of the radio buttons in the dialog only when the OK button is used to close the dialog, and the if statement verifies that the return from DoModal() corresponds to the OK button. The GetSelectedRadioButtonID() function returns the ID of the radio button that is selected, so the switch statement sets the value of the m_Scale member, depending on the ID that is returned.

The CTaskDialog class is a convenient and more flexible alternative to the AfxMessageBox() function, especially when you want to get user input in addition to communicating a message. There are also many more functions that the CTaskDialog class defines for manipulating and updating the dialog that I have described here. However, creating a dialog resource using the toolbox provides you with a much wider range of controls that you can use and gives you complete flexibility in how the dialog is laid out. Furthermore, when you do use the CTaskDialog class in an application that you want to run with Windows XP or earlier operating systems, you must call the IsSupported() function to verify that the class is supported before you attempt to use it, and you will need to program for an alternative dialog creation process when it isn't. For these reasons, you will find that most dialogs are best created as a dialog resource or through AfxMessageBox().

To create the panes in the status bar, you call the SetIndicators() function for the status bar object. This function requires two arguments, a const array of indicators of type UINT and the number of elements in the array. Each element in the array is a resource symbol that will be associated with a pane in the status bar, and each resource symbol must have an entry in the resource string table that will be the default text in the pane. There are standard resource symbols, such as ID_INDICATOR_CAPS and ID_INDICATOR_NUM, which are used to identify indicators for the Caps Lock and Num Lock keys respectively, and you can see these in use if you look at the implementation of the OnCreate() function in the CMainFrame class. They also appear in the string table resource.

You can create your own indicator resource symbol by extending the String Table resource in Resource View: click the ⊳ symbol, double-click the String Table entry to display the table, and then press the insert key. If you right-click the new entry in the table and select Properties from the menu, you will be able to change the ID to ID_INDICATOR_SCALE and the caption to View Scale: 1.

You should initialize the m_StatusBar data member just before the visible view window is displayed. So, using the Properties window for the CChildFrame class, you can add a function to the class that will be called in response to the WM_CREATE message that is sent to the application when the window is to be created. Add the following code to the OnCreate() handler:

int CChildFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
  if(CMDIChildWndEx::OnCreate(lpCreateStruct) == -1)
    return −1;

  // Create the status bar
  m_StatusBar.Create(this);
  static UINT indicators[] = {ID_INDICATOR_SCALE};
  m_StatusBar.SetIndicators(indicators, sizeof(indicators)/sizeof(UINT));
  m_StatusBar.SetPaneStyle(0, SBPS_STRETCH);     // Stretch the first pane
  return 0;
}

The generated code isn't bolded. There's a call to the base class version of the OnCreate() function, which takes care of creating the definition of the view window. It's important not to delete this function call; otherwise, the window is not created.

Calling the Create() function for the CMFCStatusBar object creates the status bar. You pass the this pointer for the current CChildFrame object to the Create() function, setting up a connection between the status bar and the window that owns it. The indicators that define the panes in the status bar are typically defined as an array of UINT elements. Here you are interested only in setting up a single pane, so you define indicators as an array that is initialized just with the symbol for your status pane. When you want to add multiple panes to a status bar, you can separate them by including ID_SEPARATOR symbols between your symbols in the indicators array. You call the SetIndicators() function for the status bar object with the address of indicators as the first argument and a count of the number of elements in the array as the second argument. This will create a single pane to the left in the status bar. The call to SetPaneStyle() for the first pane causes this pane to be stretched as necessary, the first argument being the pane index and the second a UINT value specifying the style or styles to be set. Without this, the sizing grip would not remain in the correct position when you resized the window. Only one pane can have the SBPS_STRETCH style. Other styles you can set for a pane are as follows:

You just OR the styles together when you want to set more than one style for a pane.

If you build and run the code now, the status bars appear, but they show only a scale factor of one, grayed out, no matter what scale factor is actually being used — not very useful. This is because there is no mechanism in place for updating the status bar. What you need to do is add code somewhere that changes the text in the status bar pane each time a different scale is chosen. The obvious place to do this is in the CSketcherView class because that's where the current view scale is recorded.

You can update a pane in the status bar by adding an UPDATE_COMMAND_UI handler that is associated with the indicator symbol for the pane. Right-click CSketcherView in Class View, and select Class Wizard from the pop-up. This will display the MFC Class Wizard dialog. As you can see, this enables you to create and edit a whole range of functions in a class and provides an alternative way to access any class member.

If it is not already visible, select the Commands tab in the dialog: this enables you to add command handlers to the class. Select ID_INDICATOR_SCALE in the Object IDs pane; this ID identifies the status bar pane you want to update. Then, select UPDATE_COMMAND_UI in the Messages pane. The dialog should look like Figure 18-13.

Figure 18.13. FIGURE 18-13

Click the Add Handler button to add the command handler to the class. Another dialog will be displayed that gives you the opportunity to change the handler function name to OnUpdateScale, which is a little more concise than the default. You can then click OK to close the dialog, and OK again to close the MFC Class Wizard dialog.

All you need is to complete the definition for the handler that was added, so add the following code to the function in SketcherView.cpp:

void CSketcherView::OnUpdateScale(CCmdUI *pCmdUI)
{
    pCmdUI->Enable();
    CString scaleStr;
    scaleStr.Format(_T(" View Scale : %d"), m_Scale);
    pCmdUI->SetText(scaleStr);
}

The parameter is a pointer to a CCmdUI object that encapsulates the status bar pane as a command target. You create a CString object and call its Format() function to generate the text string to be displayed in the pane. The first argument to Format() is a format control string in which you can embed conversion specifiers for subsequent arguments. The format string with the embedded specifiers is the same as for the C function, printf(). Each of the subsequent arguments is converted according to the corresponding format specifier in the first argument, so there must be one format specifier in the format string for each argument after the first. Here the %d specifier converts the value of m_Scale to a decimal string, and this is incorporated into the format string. Other common specifiers you can use are %f for floating point values and %s for string values. Calling SetText() for the CCmdUI object sets the string you supply as the argument in the status bar pane. Calling Enable() for the CCmdUI object causes the pane text to be displayed normally because the BOOL parameter has a default value of TRUE. An explicit argument of FALSE would make the pane text grayed out.

That's all you need for the status bar. If you build Sketcher again, you should have multiple, scrolled windows, each at different scales, with the scale displayed in the status bar in each view.

Right-click the dialog and select Add Class from the pop-up. Again, you'll be taken to the dialog to create a new class. Give the class an appropriate name, such as the one you used before, CScaleDialog, and select CDialog as the base class. If, when you click Finish, you get a message box saying that ScaleDialog.cpp already exists, you forgot to explicitly delete the .h and .cpp files. Go back and do that now, or rename the files if you want to keep them. Everything should then work as it's supposed to. After you've completed that, all you need to do is add a public control variable called m_Scale to the class, corresponding to the list box ID, IDC_SCALE_LIST. The type should be int and the limits should be 0 and 7. Don't forget to set the Category as Value; otherwise, you won't be able to enter the limits. Because you have created it as a control variable, DDX is implemented for the m_Scale data member, and you will use the variable to store a zero-based index to one of the eight entries in the list box.

You need to initialize the list box in the OnInitDialog() override in the CScaleDialog class, so add an override for this function using the Properties window for the class. Add code to the function as follows:

BOOL CScaleDialog::OnInitDialog()
{
  CDialog::OnInitDialog();

  CListBox* pListBox = static_cast<CListBox*>(GetDlgItem(IDC_SCALE_LIST));
  CString scaleStr;
  for(int i = 1 ; i <= 8 ; ++i)
  {
    scaleStr.Format(_T("Scale %d"), i);
    pListBox->AddString(scaleStr);
  }
  pListBox->SetCurSel(m_Scale);        // Set current scale

  return TRUE;  // return TRUE unless you set the focus to a control
                // EXCEPTION: OCX Property Pages should return FALSE
}

The first line that you have added obtains a pointer to the list box control by calling the GetDlgItem() member of the dialog class. This is inherited from the MFC class, CWnd. It returns a pointer of type CWnd*, so you cast this to type CListBox*, which is a pointer to the MFC class defining a list box.

Using the pointer to the dialog's CListBox object, you then use the AddString() member repeatedly in the for loop to add the lines defining the list of scale factors. Each entry in the list box is formed by a call to the Format() member of the scaleStr object. The statement following the for loop sets the currently selected entry in the list box to correspond to the value of m_Scale. These entries appear in the list box in the order in which you enter them, so that the dialog is displayed as shown in Figure 18-15.

Figure 18.15. FIGURE 18-15

Each entry in the list is associated with a zero-based index value that is automatically stored in the m_Scale member of CScaleDialog through the DDX mechanism. Thus, if you select the third entry in the list, m_Scale is set to 2.

The dialog is displayed by the OnViewScale() handler that you added to CSketcherView in the previous version of Sketcher. You need only to amend this function to deal with the new dialog, using a list box, the code for it is as follows:

void CSketcherView::OnViewScale()
{
  CScaleDialog aDlg;                   // Create a dialog object
  aDlg.m_Scale = m_Scale - 1;          // Pass the view scale to the dialog
  if(aDlg.DoModal() == IDOK)
  {
    m_Scale = 1 + aDlg.m_Scale;        // Get the new scale

    ResetScrollSizes();                // Adjust scrolling to the new scale
    InvalidateRect(0);                 // Invalidate the whole window
  }
}

Because the index value for the entry selected from the list is zero-based, you must decrement the current scale value by one when setting the value in the CScaleDialog object. You also need to add one to the value obtained from the dialog to get the actual scale value to be stored in the view. The code to display this value in the view's status bar is exactly as before. The rest of the code to handle scale factors is already complete and requires no changes. After you've added back the #include directive for ScaleDialog.h, you can build and execute this version of Sketcher to see the list box in action.

You have already used CString objects a couple of times in Sketcher, but there's more to it than you have seen so far. The CString class provides a very convenient and easy-to-use mechanism for handling strings that you can use just about anywhere a string is required. To be more precise, you can use a CString object in place of strings of type const char*, which is the usual type for a character string in native C++, or of type LPCTSTR, which is a type that comes up frequently in Windows API functions.

The CString class provides several overloaded operators, as shown in the following table, that make it easy to process strings.

str1 = str2;
str1 = _T("A normal string");

The variables str1 and str2 in the preceding table are CString objects.

CString objects automatically grow as necessary, such as when you add an additional string to the end of an existing object. For example:

CString str = _T("A fool and your money ");
str += _T("are soon partners.");

The first statement declares and initializes the object str. The second statement appends an additional string to str, so the length of str automatically increases.

The constructor for a CText object needs to initialize the class and base class data members:

// CText constructor
CText::CText(const CString& aString, const CRect& rect, COLORREF aColor)
{
  m_PenWidth = 1;                      // Set the pen width

m_Color = aColor;                    // Set the color for the text
  m_String = aString;                  // Make a copy of the string

  m_EnclosingRect = rect;
  m_EnclosingRect.NormalizeRect();
}

You set the pen width to 1, and store the color and the text string to be displayed. The second parameter is the rectangle in which the text is to be displayed, so this is stored as the enclosing rectangle.

After the element type has been set to TEXT, a text object should be created at the cursor position whenever you click the left mouse button and enter the text you want to display. You therefore need to display the dialog that permits text to be entered in the OnLButtonDown() handler, but only when the element type is TEXT. Add the following code to this handler in the CSketcherView class:

void CSketcherView::OnLButtonDown(UINT nFlags, CPoint point)
{
  CClientDC aDC(this);           // Create a device context
  OnPrepareDC(&aDC);             // Get origin adjusted
  aDC.DPtoLP(&point);            // convert point to Logical
  // In moving mode, so drop the element
  if(m_MoveMode)
  {
    m_MoveMode = false;                      // Kill move mode
    m_pSelected = nullptr;                   // De-select element
    GetDocument()->UpdateAllViews(nullptr);  // Redraw all the views
    return;
  }
  CSketcherDoc* pDoc = GetDocument();// Get a document pointer
  if(pDoc->GetElementType() == TEXT)
  {
    CTextDialog aDlg;
    if(aDlg.DoModal() == IDOK)
    {
      // Exit OK so create a text element
      CSize textExtent = aDC.GetTextExtent(aDlg.m_TextString);
      CRect rect(point, textExtent);      //Create enclosing rectangle
      CText* pTextElement = new CText(
                              aDlg.m_TextString, rect, pDoc->GetElementColor());
      // Add the element to the document
      pDoc->AddElement(pTextElement);
      // Get all views updated
      pDoc->UpdateAllViews(nullptr, 0, pTextElement);
    }
    return;
  }
   m_FirstPoint = point;             // Record the cursor position
   SetCapture();                     // Capture subsequent mouse messages
}

The code to be added is bolded. It creates a CTextDialog object and then opens the dialog using the DoModal() function call. The m_TextString member of aDlg is automatically set to the string entered in the edit box, so you can use this data member to pass the string entered back to the CText constructor if the OK button is used to close the dialog. The color is obtained from the document using the GetElementColor()member that you have used previously.

You also need to determine the rectangle that bounds the text. Because the size of the rectangle for the block of text depends on the font used in a device context, you use the GetTextExtent() function in the CClientDC object, aDC, to initialize the CSize object, textExtent, with the width and height of the text string in logical coordinates. You then use a CRect constructor that creates a rectangle from a point that is the top right corner of the rectangle, and a CSize object that specifies the width and height of the rectangle.

The CText object is created on the heap because the list in the document maintains only pointers to the elements. You add the new element to the document by calling the AddElement() member of CSketcherDoc, with the pointer to the new text element as an argument. Finally, UpdateAllViews() is called with the first argument 0, which specifies that all views are to be updated.

Drawing text in a device context is different from drawing a geometric figure. The implementation of the Draw() function for a CText object is as follows:

void CText::Draw(CDC* pDC, CElement* pElement)
{
  COLORREF Color(m_Color);             // Initialize with element color

  if(this==pElement)
    Color = SELECT_COLOR;              // Set selected color

  // Set the text color and output the text
  pDC->SetTextColor(Color);
  pDC->DrawText(m_String, m_EnclosingRect, DT_CENTER|DT_VCENTER|

DT_SINGLELINE|DT_NOCLIP);
}

You don't need a pen to display text. You just need to specify the text color using the SetTextColor() function member of the CDC object, and then use the DrawText() member to output the text string. This displays the string, specified by the first argument, in the rectangle specified by the second argument, using the default font. The third argument specifies how the text is to be formatted. You specify the third argument as one or more standard formatting constants of type UINT combined together with logical ORs.

Many of these constants correspond to the ones defined for use with the Windows API DrawText() function. The following table lists some of the more common constants:

Because the TextOut() function doesn't use a pen, it isn't affected by setting the drawing mode of the device context. This means that the raster operations (ROP) method that you use to move the elements leaves temporary trails behind when applied to text. Remember that you used the SetROP2() function to specify the way in which the pen would logically combine with the background. By choosing R2_NOTXORPEN as the drawing mode, you could cause a previously drawn element to disappear by redrawing it — it would then revert to the background color and thus become invisible. Fonts aren't drawn with a pen, so it won't work properly with the text elements. You'll see how to fix this problem a little later in this chapter.

The Move() function for a CText object is simple:

void CText::Move(const CSize& size)
{
  m_EnclosingRect += size;            // Move the rectangle
}

All you need to do is alter the enclosing rectangle by the distance specified in the size parameter.

To fix the trails problem when moving a text element, you have to treat it as a special case in the MoveElement() function in the CSketcherView class. Providing an alternative move mechanism for text elements requires that you can discover when the m_pSelected pointer contains the address of a CText object. The typeid operator in native C++ that you met back in Chapter 2 can help with this.

By comparing the expression typeid(*m_pSelected) with typeid(CText), you can determine whether or not m_pSelected is pointing to a CText object. To be able to use the typeid operator in your code, you must change the Enable Run-Time Type Information property value for the project to Yes(/GR). You can open the project's Properties dialog by pressing Alt+F7; you will find the property to change by selecting Configuration Properties

Here's how you can update the MoveElement() function to eliminate the trails when moving text:

void CSketcherView::MoveElement(CClientDC& aDC, CPoint& point)
{
  CSize distance = point - m_CursorPos;   // Get move distance
  m_CursorPos = point;          // Set current point as 1st for next time

  // If there is an element, selected, move it
  if(m_pSelected)
  {
    // If the element is text use this method...
    if (typeid(*m_pSelected) == typeid(CText))
    {
      CRect oldRect=m_pSelected->GetBoundRect(); // Get old bound rect
      aDC.LPtoDP(oldRect);                          // Convert to client coords
      m_pSelected->Move(distance);               // Move the element
      InvalidateRect(&oldRect);                 // Invalidate combined area
      UpdateWindow();                               // Redraw immediately
      m_pSelected->Draw(&aDC,m_pSelected);   // Draw highlighted
      return;
    }
    // ...otherwise, use this method
    aDC.SetROP2(R2_NOTXORPEN);
    m_pSelected->Draw(&aDC,m_pSelected);    // Draw the element to erase it
    m_pSelected->Move(distance);            // Now move the element
    m_pSelected->Draw(&aDC,m_pSelected);    // Draw the moved element
  }
}

When m_pSelected points to a text element, you obtain the bounding rectangle for the old element before moving the element to its new position, and convert the rectangle to client coordinates, because that's what InvalidateRect() expects. After the move, you call InvalidateRect() to redraw the rectangle where the element used to be.

You can see that the code for invalidating the rectangles that you must use for moving the text is a little less elegant than the ROP code that you use for all the other elements. It works, though, as you'll see for yourself if you make this modification, and then build and run the application. Because you use the typeid operator for testing the type, you must add an #include directive for the typeinfo header to SketcherView.cpp. This header provides the definition for the type_info class, and you need this because the typeid operator returns a reference to a const type_info object.

For the program to compile successfully, you need to add a #include directive for TextDialog.h to the SketcherView.cpp file. You should now be able to produce annotated sketches using multiple scaled and scrolled views, such as the ones shown in Figure 18-19.

Figure 18.19. FIGURE 18-19

You can see that the text does not scale along with the shapes. You could scale the text by adjusting the font size in the device context based on the scale. Of course, you would have to adjust the rectangle enclosing the text when you draw it, too.

You'll use radio buttons to allow a pen width to be chosen, and place them within a group box that serves to keep them in a group in which only one radio button can be checked at one time. Drag a GroupBox control from the Containers group in the Toolbox window onto the dialog you have created. Change the value of the Text property for the group box to Select Pen Width and change the value of the (name) property to penWidthGroupBox. Adjust the size of the group box by dragging its border so that it fits nicely within the dialog frame. Drag six RadioButton controls from the Toolbox window to the group box and arrange them in a rectangular configuration as you did in the MFC Sketcher program. You'll notice that alignment guides to help you position the controls display automatically for each RadioButton control after the first. Change the text properties for the radio button controls to Pen Width 1 through Pen Width 6, and the corresponding (name) property values to penWidthButton1 through penWidthButton6. Change the value of the Checked property for penWidthButton1 to true.

Next you can add two buttons to the dialog and change their Text properties to OK and Cancel, and the (name) properties to penWidthOK and penWidthCancel. Return to the dialog's Properties window and set the AcceptButton and CancelButton property values to penWidthOK and penWidthCancel by selecting from the list in the values column. Verify that the DialogResult property values for the buttons are OK and Cancel; this will cause the appropriate DialogResult value to be returned when the dialog is closed by the user clicking one button or the other. You should now have a dialog in the Design window that looks similar to Figure 18-20.

Figure 18.20. FIGURE 18-20

The code for the dialog class is part of the project and is defined in the PenDialog.h header file. However, there are no instances of the PenDialog class anywhere at the moment, so to use the dialog you must create one. You will create a PenDialog object in the Form1 class; add an #include directive for PenDialog.h to Form1.h. Add a new private variable of type PenDialog^ to the Form1 class with the name penDialog and initialize it in the Form1 constructor to gcnew PenDialog().

You need a way to get information about which radio button is checked from the PenDialog object. One way to do this is to add a public property to the class to make the information available. It can be a read-only property, so you need only to implement get() for the property. The code that the Windows Form Designer generates is delimited by a #pragma region and a #pragma endregion directive, and you should not modify this manually or add in your own code. Add the following code to the PenDialog class definition immediately after the #pragma endregion directive:

public: property float PenWidth
{
  float get()
  {
    if(penWidthButton1->Checked)
      return 1.0f;
    if(penWidthButton2->Checked)
      return 2.0f;
    if(penWidthButton3->Checked)
      return 3.0f;
    if(penWidthButton4->Checked)
      return 4.0f;
    if(penWidthButton5->Checked)
      return 5.0f;
    return 6.0f;
  }
}

The System::Drawing::Pen class defines a pen where the pen width is a floating-point value; hence, the PenWidth property is floating-point.

Now that the dialog is complete, and you have a Form1 member that references a dialog object, you need a mechanism to open the dialog. Another toolbar button on the Form1 window is a good choice.

You need a bitmap to display on the new toolbar button. Switch to the Resource View, right-click the Bitmap folder, and click Insert Bitmap. Set the Height and Width property values for the bitmap to 16, the Filename property value to penwidth.bmp, and the ID to IDB_PENWIDTH. You can now create a bitmap of your choosing to represent a line width; I'll use a symbol that looks like a pen drawing a line, as in MFC Sketcher.

In the Design window for Form1.h, add a separator to the toolbar, followed by a new toolbar button. Change the (name) property value to penWidthButton and the ToolTipText property value to Change pen width. Set the image for the new button to penwidth.bmp, and then create a Click event handler for the toolbar button by double-clicking the Click event in its Properties window. You can add the following code to the new event handler to display the pen dialog:

private: System::Void penWidthButton _Click(
                                    System::Object^  sender, System::EventArgs^  e)
{
  if(penDialog->ShowDialog() == System::Windows::Forms::DialogResult::OK)
  {
    // Get the pen width ...
  }
}

Calling ShowDialog() for the PenDialog object displays the dialog. Because it is a modal dialog, it remains visible until a button is clicked to close it. The ShowDialog() function returns a value that is an enumerator from the System::Windows::Forms::DialogResult enumeration. This enumeration defines the following enumerator values:

None, OK, Cancel, Abort, Retry, Ignore, Yes, No

These provide for a variety of buttons being identified to close a dialog, and you can set any of these values from the drop-down list of values for the DialogResult property of a button. You must fully qualify the DialogResult type name here because the Form1 class has an inherited member with the name DialogResult.

You need somewhere to record the current pen width in the Form1 class, so add a private penWidth variable of type float to the class and initialize it to 1.0f in the constructor. You can now replace the comment in the preceding Click event handler with the following:

penWidth = penDialog->PenWidth;

This will set the current pen width to the value returned by the PenWidth property for the dialog.

All that remains to do is to implement creating and drawing elements with a given pen width.

This will involve modifying the constructor in each of the derived element classes. The modifications are essentially the same in each class, so I'll just show how the Line class constructor changes, and you can do the rest.

The changes to the Line class constructor to allow for different pen widths are as follows:

Line(Color color, Point start, Point end, float penWidth)
      {
        pen = gcnew Pen(color, penWidth);
      this->color = color;
      position = start;
      this->end = end - Size(start);
      boundRect = System::Drawing::Rectangle(Math::Min(position.X, end.X),
                                             Math::Min(position.Y, end.Y),
                    Math::Abs(position.X - end.X), Math::Abs(position.Y - end.Y));

boundRect.Inflate(safe_cast<int>(penWidth), safe_cast<int>(penWidth));

      }

The only changes are to add an extra parameter to the Line constructor, to use the Pen constructor that accepts a second argument of type float that specifies the pen width, and to increase the size of the bounding rectangle by the penWidth argument value. Make the same change to the constructors for the other element classes.

Because you have changed the parameter list for the element class constructors, you must change the MouseMove event handler that creates elements:

private: System::Void Form1_MouseMove(System::Object^  sender,
System::Windows::Forms::MouseEventArgs^  e) {
   if(drawing)
  {
    if(tempElement)
      Invalidate(tempElement->Bound);  // The old element region
    switch(elementType)
    {
      case ElementType::LINE:
        tempElement = gcnew Line(color, firstPoint, e->Location, penWidth);
        break;
      case ElementType::RECTANGLE:
        tempElement = gcnew Rectangle(color, firstPoint, e->Location, penWidth);
        break;
      case ElementType::CIRCLE:
        tempElement = gcnew Circle(color, firstPoint, e->Location, penWidth);
        break;
      case ElementType::CURVE:
        if(tempElement)
          safe_cast<Curve^>(tempElement)->Add(e->Location);
        else
          tempElement = gcnew Curve(color, firstPoint, e->Location, penWidth);
        break;
    }
    // Rest of the code as before...
 }

You should now have CLR Sketcher with pen widths fully working, as Figure 18-21 illustrates.

Figure 18.21. FIGURE 18-21

You can add a combo box to the toolbar in the Form1 Design window to provide a way to enter a line style. ComboBox is an option in the list that displays when you click the down arrow for the toolbar item that adds new entries in the Design window. You can customize this option to do what you want.

Set the DropDownStyle property to DropDownList; the effect of this is to only allow values to be selected from the list. A value of DropDown allows any value to be typed in the combo box. Change (name) to something more relevant, such as lineStyleComboBox. You want to add a specific set of items to be displayed in the combo box, and the Items property holds these. Select the Items property, click (Collection) in the value column, and select the ellipsis at the right to open the String Collection Editor dialog. You can then enter strings, as shown in Figure 18-22.

Figure 18.22. FIGURE 18-22

These are the entries that will be displayed in the drop-down for the combo box; they are indexed from 0 to 4.

Because the default size for the combo box is not as wide as you need for the longest string, change the value of the Size property to 150,25. You can also change the FlatStyle property to Standard, so that the combo box will be more visible on the toolbar. You can set the ToolTipText property to Choose line style.

At present the combo box will not show anything when it is first displayed, but you can fix that in the Form1 constructor. Add the following line of code to the constructor after the // TODO comment:

lineStyleComboBox->SelectedIndex = 0;

The SelectedIndex property determines which of the entries in the Items collection is displayed in the combo box, and because the entries in the combo box Items property collection are indexed from 0, this causes the first entry to be displayed initially. That will continue to be the entry displayed until you select a new entry from the combo box, so the combo box will always show the currently selected line width.

You need somewhere to store the current line style, so add a private member, lineStyle, to the Form1 class of type System::Drawing::Drawing2D::DashStyle. This is an enum type used by the Pen class to specify a style for drawing lines. If you add a using directive for the System::Drawing::Drawing2D namespace, you can specify the type for lineStyle as just DashStyle.

The DashStyle enum defines the members Solid, Dash, Dot, DashDot, DashDotDot, and Custom. The meaning for the first five are obvious. The Custom style gives you complete flexibility in specifying a line style as virtually any sequence of line segments and spaces of differing lengths that you want. You specify how the line style is to appear by setting the DashPattern property for the Pen object. You specify the pattern with an array of float values that specify the lengths of the line segments and intervening spaces. Here's an example:

array<float>^ pattern = {5.0f, 3.0f};
pen->DashPattern = pattern;

This specifies a dashed line for the Pen object pen, consisting of segments of length 5.0f separated by spaces of length 3.0f. The pattern you specify is repeated as often as necessary to draw a given line. Obviously, by specifying more elements in the array, you can define patterns as complicated as you like.

You need to know when an entry from the combo box is selected so that you can update the lineStyle member of the Form1 class. An easy way to arrange this is to add a handler for the SelectedIndexChanged event for the ComboBox object; add this handler through the Properties window and implement it like this:

private: System::Void lineStyleComboBox_SelectedIndexChanged(
                            System::Object^  sender, System::EventArgs^ e)
{
  switch(lineStyleComboBox->SelectedIndex)
  {
    case 1:
     lineStyle = DashStyle::Dash;
     break;
    case 2:
     lineStyle = DashStyle::Dot;
     break;
    case 3:
     lineStyle = DashStyle::DashDot;
     break;
    case 4:
     lineStyle = DashStyle::DashDotDot;
     break;
    default:
     lineStyle = DashStyle::Solid;
     break;
  }
}

This just sets the value of lineStyle to one of the DashStyle enum values based on the value of the SelectedIndex property for the combo box object.

To draw elements with different line styles you must add another parameter of type DashStyle to each of the element constructors. First, add the following using directive to Elements.h:

using namespace System::Drawing::Drawing2D;

Here's how you update the Line class constructor to support drawing lines in different styles:

Line(Color color, Point start, Point end, float penWidth, DashStyle style)
    {
      pen = gcnew Pen(color, penWidth);
      pen->DashStyle = style;
      // Rest of the code for the function as before...
    }

There's just one new line of code, which sets the DashStyle property for the pen to the property passed as the last argument to the constructor. Change the other element class constructors in the same way.

The last thing you must do is update the constructor calls in the mouse move event handler in the Form1 class:

private: System::Void Form1_MouseMove(System::Object^  sender,
System::Windows::Forms::MouseEventArgs^  e)
{
  if(drawing)
  {
    if(tempElement)
      Invalidate(tempElement->bound);               // Invalidate old element area
    switch(elementType)
    {
      case ElementType::LINE:
        tempElement = gcnew Line(color, firstPoint, e->Location, penWidth,
                                                                        lineStyle);
        break;
      case ElementType::RECTANGLE:
        tempElement = gcnew Rectangle(color, firstPoint, e->Location, penWidth,
                                                                        lineStyle);
        break;
      case ElementType::CIRCLE:
        tempElement = gcnew Circle(color, firstPoint, e->Location, penWidth,
                                                                        lineStyle);
        break;
      case ElementType::CURVE:
        if(tempElement)
          safe_cast<Curve^>(tempElement)->Add(e->Location);
        else
          tempElement = gcnew Curve(color, firstPoint, e->Location, penWidth,
                                                                        lineStyle);
        break;
    }

   // Rest of the code for the function as before...
}

If you recompile CLR Sketcher and run it again, the combo box will enable you to select a new line style for drawing elements. The line styles don't really work for curves because of the way they are drawn — as a series of very short line segments. With the other elements, the line styles look better if you draw with a pen width greater than the default.

You need to look into several things before you can make CLR Sketcher create and draw text. Let's start with how you draw text. The Graphics class defines a DrawString() function for drawing text. There are several overloaded versions of this function, as described in the following table.

DrawString(
 String^ str,
 Font^ font,
 Brush^ brush,
 PointF point)

DrawString(
 String^ str,
 Font^ font,
 Brush^ brush,
 float X,
 float Y)

DrawString(
 String^ str,
 Font^ font,
 Brush^ brush,
 RectangleF rect)

DrawString(
 String^ str,
 Font^ font,
 Brush^ brush,
 PointF point,
 StringFormat^ format)

DrawString(
 String^ str,
 Font^ font,
 Brush^ brush,
 float X,
 float Y,
 StringFormat^ format)

DrawString(
 String^ str,
 Font^ font,
 Brush^ brush,
 RectangleF rect,
 StringFormat^ format)

Clearly, you need to understand a bit about fonts and brushes in order to use the DrawString() function, so I'll briefly introduce those before returning to how you can create and display Text elements.

You specify the font to be used when you draw a string by a System::Drawing::Font object that defines the typeface, style, and size of the drawn characters. An object of type System::Drawing::FontFamily defines a group of fonts with a given typeface, such as "Arial" or "Times New Roman". The System::Drawing::FontStyle enumeration defines possible font styles, which can be any of the following: Regular, Bold, Italic, Underline, and Strikeout.

You can create a Font object like this:

FontFamily^ family = gcnew FontFamily(L"Arial");
System::Drawing::Font^ font = gcnew System::Drawing::Font(family, 10,
                                            FontStyle::Bold,  GraphicsUnit::Point);

You create the FontFamily object by passing the name of the font to the constructor. The arguments to the Font constructor are the font family, the size of the font, the font style, and an enumerator from the GraphicUnit enumeration that defines the units for the font size.

The possible enumerator values are as follows:

Thus, the previous code fragment defines a 10-point bold Arial font. Note that the Font type name is fully qualified in the fragment because a form object in a Windows Forms application inherits a property with the name Font from the Form base class that identifies the default font for the form. Windows Forms applications support TrueType fonts primarily, so it is best not to choose Open Type fonts. If you attempt to use a font that is not supported, or the font is not installed on your computer, the Microsoft Sans Serif font will be used.

A System::Drawing::Brush object determines the color used to draw a string with a given font; it is also used to specify the color and texture used to fill a shape. You can't create a Brush object directly because Brush is an abstract class. You create brushes using the SolidBrush, the TextureBrush, and the LinearGradientBrush class types derived from Brush. A SolidBrush object is a brush of a single color, a TextureBrush object is a brush that uses an image to fill the interior of a shape, and a LinearGradientBrush is a brush defining a color gradient blend, usually between two colors, but also possibly among several colors. You will use a SolidBrush object to draw text, which you create like this:

SolidBrush^ brush = gcnew SolidBrush(Color::Red);

This creates a solid brush that will draw text in red.

You can store a reference to the current Font object, to be used when CLR Sketcher is creating Text elements, by adding a private variable of type System::Drawing::Font^, and with the name textFont, to the Form1 class. You must use the fully qualified type name to avoid confusion with the inherited property with the name Font. Initialize textFont in the Form1 constructor to Font, which is a form property specifying the default font for the form. Be sure to do this in the body of the constructor following the // TODO: comment; if you attempt to initialize it in the initialization list, the program will fail because Font is not defined at this point.

You can add a toolbar button to allow the user to select a font for entering text, perhaps a button with a bitmap representation of F for font. Give the button a suitable value for the (name) property, such as toolStripFontButton, and add a Click event handler for it.

The Toolbox window has a standard dialog for choosing a font that will display all the fonts available on your system and allow selection of the font style and size. Select the Design window for Form1.h and drag a FontDialog control from the Toolbox window to the form. The Click event handler for the toolStripFontButton can display the font dialog:

private: System::Void toolStripFontButton_Click(
                                   System::Object^  sender, System::EventArgs^  e)
{
  if(fontDialog1->ShowDialog() == System::Windows::Forms::DialogResult::OK)
  {
    textFont = fontDialog1->Font;
  }
}

You display the dialog by calling its ShowDialog() function, as you did for the pen dialog. If the function returns DialogResult::OK, you know the dialog was closed with the OK button. In this case, you retrieve the chosen font from the Font property for the dialog object, and store it in the textFont variable in the Form1 class object. You can try this out if you want. The Font dialog will look like Figure 18-23.

Figure 18.23. FIGURE 18-23

You need a class to represent a Text element, so let's define that next.

The TextElement element type will have Element as a base class like the other element types, so you can call the Draw() function polymorphically. Basic information about the location and color of the text element will be recorded in the members inherited from the base class, but you need to add extra members to store the text and information relating to the font. Here's the initial definition of the class:

public ref class TextElement : Element
  {
    protected:
      String^ text;
      SolidBrush^ brush;
      Font^ font;

public:
      TextElement(Color color, Point p, String^ text, Font^ font)
      {
        this->color = color;
        brush = gcnew SolidBrush(color);
        position = p;
        this->text = text;
        this->font = font;
        int height = font->Height;           // Height of text string
        int width = static_cast<int>(font->Size*text->Length); // Width of string
        boundRect = System::Drawing::Rectangle(position, Size(width, height));
        boundRect.Inflate(2,2);              // Allow for descenders
      }

      virtual void Draw(Graphics^ g) override
      {
        brush->Color = highlighted ? highlightColor : color;
        g->TranslateTransform(safe_cast<float>(position.X),
                              safe_cast<float>(position.Y));
        g->DrawString(text, font, brush, Point(0,0));
        g->ResetTransform();
      }
  };

I chose the TextElement type name, rather than just Text, to avoid confusion with a member of the Form class with the name Text. A TextElement object has members to store the text string, the font, and the brush to be used to draw the text.

Determining the bounding rectangle for a text element introduces a slight complication in that it depends on the point size of the font, and you have to figure out the width and height from the font size. The height is easy because the font object has a Height property that makes the font's line spacing available, which is a good estimate for the height of the text string. The Size property returns the em size of the font (which is the width of the letter M), so you can get a generous estimate of the width of the rectangle the string will occupy by multiplying the em size by the number of characters in the string. I have inflated the rectangle by two because the line spacing doesn't always result in a bounding rectangle that takes account of descenders such as in lowercase ps and qs.

You'll want to enter text from the keyboard when you create a TextElement element, so you need a dialog to manage this. Go to the Solution Explorer window, and add a new form to CLR Sketcher by right-clicking the project name and clicking Add

The next step is to add buttons to close the dialog. Add an OK button and a Cancel button to the text dialog with the DialogResult property values set appropriately. Change the (name) property values to textOKButton and textCancelButton respectively. Set the AcceptButton property value for TextDialog to textOKButton and the CancelButton property value to textCancelButton.

Using a Text Box

A TextBox control allows a single line or multiple lines of text to be entered, so it certainly covers what you want to do here. Add a TextBox to the text dialog by dragging it from the Toolbox window to the dialog in the Design window. By default, a TextBox allows a single line of text to be entered, and you can stick with that here. When you want to allow multiple lines of input, you click the arrow to the right on the TextBox in the Design window, and click the checkbox to enable Multiline. The Text property for the TextBox provides access to the input and makes it available as a String object.

Ideally, you want the text dialog to open with the focus on the box for entering text. Then you can enter the text immediately after the dialog opens, and press enter to close it as if you had selected the OK button. The control that has the focus initially is determined by the tab order of the controls on the dialog, which depends on the value of the TabIndex property for the controls. If you set the TabIndex property for the text box to 0 and the OK and Cancel buttons to 1 and 2 respectively, this will result in the text box having the focus when the dialog initially displays. The tab order also defines the sequence in which the focus changes when you press the tab key. You can display the tab order for the controls in the Design window for the dialog by selecting View

The textBox1 control will store the string you enter, but because this is a private member of the dialog object, it is not accessible directly. You must add a mechanism to retrieve the string from the dialog object. Another problem is that the textBox1 control will retain the text you enter and display it the next time the dialog is opened. You probably don't want this to occur, so you need a way to reset the Text property of textBox1. You can add a public property to the TextDialog class that will deal with both difficulties. Add the following code to the TextDialog class definition, following the #pragma endregion directive:

// Property to access the text in the edit box
    public: property String^ TextString
    {
      String^ get() {return textBox1->Text; }
      void set(String^ text) { textBox1->Text = text; }
    }

The get() function for the TextString property makes the string you enter available, and the set() function enables you to reset it.

It would be nice if the text appeared in the edit box in the current font so that the user could tell whether it's what he or she wants. This will provide an opportunity to cancel the text entry and change to another font. Add the following property to the TextDialog class, following the preceding one:

// Set the edit box font
public: property System::Drawing::Font^ TextFont
{
  void set(System::Drawing::Font^ font) { textBox1->Font = font; }
}

This is a set-only property that you can use to set the font for the edit box object textBox1.

You need an extra data member in the Form1 class to help you create text elements. Add an #include directive for TextDialog.h to Form1.h, then add a textDialog member of type TextDialog^. You can initialize it to gcnew TextDialog() in the initialization list for the Form1 class constructor.

Displaying the Dialog and Creating a Text Element

The process for creating an element that is text is different from the process for geometric elements, so to understand the sequence of events in the code, let's describe the interactive process. Text element mode is in effect when you select the Text menu item or toolbar button. To create an element, you click at the position on the form where you want the top left corner of the text string to be. This will display the text dialog; you type the text you want in the text box, and press Enter to close the dialog. The MouseMove handler is not involved in the process at all. Clicking the mouse to define the position of the element embodies the whole process. This implies that you must display the dialog and create the text element in the MouseDown event handler. Here's the code to do that:

private: System::Void Form1_MouseDown(System::Object^  sender,
System::Windows::Forms::MouseEventArgs^  e) {
  if(e->Button == System::Windows::Forms::MouseButtons::Left)
  {
    firstPoint = e->Location;
    if(mode == Mode::Normal)
    {
      if(elementType == ElementType::TEXT)
      {
        textDialog->TextString = L"";        // Reset the text box string
        textDialog->TextFont = textFont;     // Set the font for the edit box
        if(textDialog->ShowDialog() == System::Windows::Forms::DialogResult::OK)
        {
          tempElement = gcnew TextElement(color, firstPoint,
                                                 textDialog->TextString, textFont);
          sketch += tempElement;
          Invalidate(tempElement->bound);    // The text element region
          tempElement = nullptr;
          Update();
        }
        drawing = false;
      }
      else
      {
        drawing = true;
      }
    }
  }
}

You create text elements only when the elementType member of the form has the value ElementType::TEXT and the mode is Mode::Normal; the second condition is essential to avoid displaying the dialog when you are in move mode. When a text element is being created, the first action is to reset the Text property for the textBox1 control to an empty string by setting it as the value for the TextString property for the dialog. You also set the font for the edit box to the value stored in the textFont member of the form.

You display the dialog by calling ShowDialog() in the if condition expression. If the ShowDialog() function returns DialogResult::OK, you retrieve the string from the dialog, use it to create the TextElement object, and add the object to the sketch. You then invalidate the region occupied by the new element and call Update() to display it. You also reset tempElement to nullptr when you are done with it. Finally, you set drawing to false to prevent the MouseMove handler from attempting to create an element.

Figure 18.24. FIGURE 18-24

If you recompile Sketcher, you should be able to create text elements using a font of your choice. Not only that, but you can move and delete them too. Figure 18-24 shows Sketcher displaying text elements.