Marc Gregoire’s Blog

Microsoft has just released a refreshed version of the Windows Phone Developer Tools CTP. The biggest change is that it is now compatible with the final version of Visual Studio 2010 RTM

The CTP includes the following components:

• Visual Studio 2010 Express for Windows Phone CTP
• Windows Phone Emulator CTP
• Silverlight for Windows Phone CTP
• XNA Game Studio 4.0 CTP

Get it here.

I was technical editor for the book “Ivor Horton’s Beginning Visual C++ 2010“, published by Wiley. According to the author:

I would particularly like to thank my technical editor, Marc Gregoire, for doing such an outstanding job of reviewing the text and checking out all the code fragments and examples in the book. His many constructive comments and suggestions for better ways of presenting the material has undoubtedly made the book a much better tutorial.

Below is a description of what you can expect from the book.

By following author Ivor Horton’s accessible tutorial approach and detailed examples you can quickly become an effective C++ programmer. Thoroughly updated for the 2010 release, this book introduces you to the latest development environment and teached you how to build real-world applications using Visual C++. With this book by your side, you are well on your way to writing applications in both versions of C++ and becoming a successful C++ programmer.

Ivor Horton’s Beginning Visual C++ 2010:

• Teaches the essentials of C++ programming using both of the C++ language technologies supported by Visual C++ 2010.
• Shares techniques for finding errors in C++ programs and explains general debugging principles.
• Discusses the structure and essential elements that are present in every Windows application.
• Demonstrates how to develop native Windows applications using the Microsoft Foundation Classes.
• Guides you through designing and creating substantial Windows applications in both C++ and C++/CLI.
• Features numerous working examples and exercises that help build programming skills.

A few days ago, Microsoft released Visual Studio 2010. Unfortunately, for the time being, this final version is not compatible with the Windows Phone Developer Tools CTP that was released a while ago. According to Charlie Kindel:

“If you install the retail (RTM) release of Visual Studio 2010 on the same machine on which you already have the Windows Phone Developer Tools CTP, you will be unable to build your Windows Phone projects.  Further, while the Windows Phone project type will continue to appear in the File/New dialog, you will not be able to build Windows Phone 7 applications.”

The Windows Phone Developer Tools are being updated and a version that supports the final version of Visual Studio 2010 will be released in a few weeks.

In the meantime, Charlie Kindel recommends the following if you need the retail version of Visual Studio 2010 together with the Windows Phone Developer Tools CTP:

• Install Visual Studio 2010 to a VPC image
• Install Visual Studio 2010  on another machine

Note that installing the Windows Phone Developer Tools CTP to a VPC image is not supported.

Register here to be informed when an updated version of the Windows Phone Developer Tools is released.

Today, Microsoft released Visual Studio 2010 and the .NET Framework 4. A lot of new features are included. One of them is a completely new editor.

“Visual Studio 2010 and .NET Framework 4 have something for every developer. The new editor, now using Windows Presentation Foundation, delivers a more flexible, feature-rich environment that supports concepts such as the use of multiple monitors. This enables a developer to have one monitor with code, another with the user interface designer, and yet another with database structure.”

Visual C++ 2010 also includes a lot of new features, some of them are:

• MSBuild and multi-targeting
• IntelliSense and Browsing (#include auto completion, call hierarchy, red squiggles, find all references, class wizard)
• C++ compiler changes (static_assert, auto keyword, lambda, decltype, rvalue references)
• Ribbon designer
• Deployment changes
• Task dialog support
• Restart manager support

Read the full press release here or watch the keynote.

Later this week, Silverlight 4 will also be released to the web (RTW). At that time, an update for Visual Studio 2010 will also become available that will allow you to develop applications using Silverlight 4.

A friend of mine, Marius Bancila, wrote several blog posts with details about new features in Visual C++ 2010.

He touches the following features:

• MSBuild and multi-targeting
• IntelliSense and Browsing (#include auto completion, call hierarchy, red squiggles, find all references, class wizard)
• C++ compiler changes (static_assert, auto keyword, lambda, decltype, rvalue references)
• Ribbon designer
• Deployment changes
• Task dialog support
• Restart manager support

You can read his posts here. They give you a good idea of new features in VC++ 2010

Now that you know “How To Use the Microsoft WebBrowser Control to Render HTML from Memory” and “How To Navigate to an Anchor in the Microsoft WebBrowser Control when Rendering HTML from Memory“, it’s time to learn how to handle custom URL protocols to tailor the navigation inside the WebBrowser Control to fit your application. The following demonstrates a custom URL protocol called “app”:

<a href="app://some.target">Test</a>

When you would put this link in a normal Internet Explorer window, clicking the link will generate an error because IE does not know how to handle the APP protocol. The name APP is chosen arbitrarily. You can use whatever you want. Handling these custom protocols in your C++ application is actually pretty simple and it doesn’t even involve any real COM coding like in the previous articles. The first thing you need to do is to add a handler for the BeforeNavigate2 handler. Open the resource editor and open your dialog with the WebBrowser control. Right click the WebBrowser control and select “Add Event Handler…”. Select “BeforeNavigate2” as message type, select the appropriate class and click “Add and Edit”. This handler will be called right before the WebBrowser control will navigate to a new page. To handle the custom protocol, implement the handler as follows:

void CMyDlg::BeforeNavigate2Explorer(LPDISPATCH pDisp, VARIANT* URL, VARIANT* Flags,
    VARIANT* TargetFrameName, VARIANT* PostData, VARIANT* Headers, BOOL* Cancel)
{
    const wchar_t* cpszProtocolName = L"app";
    const wchar_t* cpszProtocolSeparator = L"://";

    // We only handle VT_BSTR.
    if (URL->vt != VT_BSTR)
        return;

    // Check the protocol of the URL
    CString str = URL->bstrVal;
    int iPos = str.Find(cpszProtocolSeparator);
    if (iPos == -1)    // Unable to figure out protocol
        return;

    // Extract protocol and check if it's our APP protocol
    CString strProtocol = str.Mid(0, iPos);
    if (strProtocol.CompareNoCase(cpszProtocolName))
        return;    // not our APP protocol

    // It's our APP protocol, so start processing it.
    // Start by preventing Internet Explorer from handling the protocol.
    *Cancel = TRUE;

    // Extract target URL
    CString strTarget = str.Mid(iPos+wcslen(cpszProtocolSeparator));
    strTarget.TrimRight(L"/");

    // Now we are ready to process our protocol.
    // For this demo, I just render a new HTML page with the name
    // of the URL target without the protocol part of the string.
    CString strHTML;
    strHTML.Format(L"My APP protocol processing: \"%s\"", strTarget);
    WriteHTML(strHTML);
}

The flow is pretty straightforward. The URL protocol is extracted; if it’s not our protocol, we let Internet Explorer handle the URL for us. If it is our custom “APP” protocol, we first set Cancel to TRUE which will prevent Internet Explorer from handling this URL protocol. Once that is done, we are completely free to implement the handling of the “APP” protocol however we want. As demonstration I just write a new HTML document from memory which will just mention that we are processing an “APP” protocol URL and that will also display the target part of the URL.

You can quickly test the code with the following piece of HTML rendered from memory:

WriteHTML(L"<html><body>"
    L"<p><a href=\"app://FirstAppProtocolTestLink\">test 1</a></p>"
    L"<p><a href=\"APP://SecondAppProtocolTestLink.Withdots\">test 2</a></p>"
    L"</body></html>");

Run the application, click on the “test 1″ or “test 2″ link and see what happens.

That’s it for handling custom URL protocols in C++

In my previous blog entry titled “How To Use the Microsoft WebBrowser Control to Render HTML from Memory” I described a method how you could use the Microsoft WebBrowser Control to display HTML from memory. One commenter said that it was not possible to navigate to an anchor in the body onload handler. I did some research and it seems all navigation within the rendered page is not working. For example, the following piece of HTML code will not work correctly:

<a href="#n25">Jump to anchor n25</a>
<a name="n25">25</a>

It took me a while to find a workaround, so that’s why I’m posting it now for other people to use. Basically, we cannot use the standard navigation techniques. I tried several possible workaround and the only one that I got working properly is by manually scrolling the window until the requested anchor is visible. It sounds complicated, but it really works pretty nicely. I wrote this little wrapper function to do all the hard work.

void CMyDlg::ScrollToAnchor(const wchar_t* anchor)
{
    IDispatch* pHtmlDoc = m_explorer.get_Document();
    if (!pHtmlDoc)
        return;
    CComPtr<IHTMLDocument2> doc2;
    doc2.Attach((IHTMLDocument2*)pHtmlDoc);
    if (doc2)
    {
        CComPtr<IHTMLElementCollection> anchors;
        HRESULT hr = doc2->get_anchors(&anchors);
        if (SUCCEEDED(hr) && anchors)
        {
            _variant_t index = 0;
            _variant_t str = anchor;
            IDispatch *pdisp;
            hr = anchors->item(str, index, &pdisp);
            if (SUCCEEDED(hr) && pdisp)
            {
                CComPtr<IHTMLElement> el;
                hr = pdisp->QueryInterface(IID_IHTMLElement, (void**)&el);
                if (SUCCEEDED(hr) && el)
                {
                    long yTotal = 0;
                    while (1)
                    {
                        long y;
                        el->get_offsetTop(&y);
                        yTotal += y;
                        CComPtr<IHTMLElement> el2;
                        hr = el->get_offsetParent(&el2);
                        if (SUCCEEDED(hr) && el2)
                            el = el2;
                        else
                            break;
                    }
                    CComPtr<IHTMLWindow2> wnd;
                    hr = doc2->get_parentWindow(&wnd);
                    if (SUCCEEDED(hr) && wnd)
                        wnd->scrollTo(0, yTotal);
                }
            }
        }
    }
}

What it does is it gets a pointer to the document. Then gets a list of all the anchors in the document and get the anchor with the given name out of that list. Once we have the target element, we calculate the offset from the top of the document. This is done in a while loop, because the target anchor could be inside another element like a div or a table. After calculating the offset, we get a pointer to the HTML window and call the scrollTo function to make it scroll to the anchor position.

Now the only thing you need to do is to render your HTML using the method in my previous blog entry and then call this new ScrollToAnchor function with the name of the anchor to which you want to scroll.

It seems Microsoft listened to all the complains about the long name for the new Windows phone. The Microsoft Windows Phone twitter page just had the following message:

“Tis the season for Series finales. We’ve got one too – dropping the ‘Series’ and keeping the ‘Windows Phone 7.’ Done.”

Excellent, “Windows Phone 7″ sounds much better without the strange “Series” behind it

I got the confirmation email from Microsoft that my MVP (Most Valuable Professional) award for Visual C++ is extended for 2010

See my MVP profile.