This is the new keyboard layout I’ve ever heard of since QWERTY. I thought QWERTY is the most usable keyboard. But on reading about this keyboard layout, it’s promising. Reducing your typing effort

The Dvorak keyboard is patented in 1936 by Dr.August Dvorak and his brother in William Dealey. The proponents of the keyboard says, the keyboard layout only requires small amount of movements to reduce the typing effort compared to standard QWERTY keyboard. Also it purported to reduce the repetitive strain injuries. Even though it was offered with major operating systems includes Windows, Linux and MacOS etc in addition to QWERTY keyboard, it failed to become popular

Some of the advantages on using Dvorak Keyboard are

QWERTY Keyboard is for Typewriters – QWERTY keyboard was born in order to solve the mechanical problems found in the initial typewriter layout. It’s good for type writers but not for typist.

Speed Boost - Dvorak layout contains 70% of most used keys in the home row (in qwerty keyboard, the row contains asdf keys). 22% on the top row and 8% in the bottom row. In QWERTY, only 32% of keystrokes are on the home row. Which means most of the time, typists’ fingers are either reaching up for the top row (52%) or down for the bottom row (16%). So not only does QWERTY do nothing for typists, it actually hinders them. It further improves the speed by containing the vowels on the left side of the home row and most used consonants on right. Alternating between either fingers are faster.

Less mistakes – Homerow is where typists make less mistakes. As mentioned before, 70% of the most used keys are in homerow which helps you to reduce the typing errors. But this is not the case for QWERTY. Most of the time, we will have to move away from homerow.

Better health – In Dvorak layout, typists finger travels 1.5 km per day while on QWERTY it’s 30 km per day. These extra miles are more error prone and stress on fingers.

Easy to switch from QWERTY – Studies have proved, Dvorak is easy to switch from QWERTY typist. There are lot of helpful games to learn about Dvorak typing.

Despite of these advantages, Dvorak can’t become popular. Simple people don’t want to change. Just think, do you want to join the prestigious club of Dvorak, which includes Matt Mullenweg of WordPress, Bram Cohen., inventor of BitTorent and finally Barbara Blackburn, Worlds fastest typist.

Further reading –

Dvorak Simplified Keyboard – Wikipedia

7 Reasons to Switch to Dvorak Keyboard – Work Awesome

Have Keyboard will program – Coding horror

Image Originally Taken from Wikipedia, under Wiki Common License.

Finally Direct2D rendering is here with Firefox 4 nightly build.

Prerequisites

• Windows 7/Vista with latest service pack
• You should have DirectX 9/10 enabled Graphics card

1. Download Firefox nightly build

2. Take configuration page by navigating to about:config from address bar

3. Change mozilla.widget.render-mode value to 6 (default is –1)

4. Change gfx.font_rendering.directwrite.enabled to true (Just double click. default value is false)

We can’t ensure it’s drawing using Direct2D because some plugins may force the browser to draw using GDI. If possible disable/remove the plugins

Now how to test it?

Check the following tests. Probably these test should execute so smoothly if hardware accelerated.

http://ie.microsoft.com/testdrive/Performance/PsychedelicBrowsing/

http://people.mozilla.com/~vladimir/demos/photos.svg

Bas Schouten has published the performance gain of Direct2D over conventional GDI interface.

Image Courtesy Bas Schouten

I was quickly going through the String class (C#). I found Split and Trim is really handy methods of String class for text processing.

Trim

Usually if we call the trim function, it removes the leading and trailing spaces. Here also same, String class provides Trim function for removing leading and trailing spaces. If we need to remove only leading spaces TrimStartand to remove trailing spaces, you can use TrimEndfunction. But Trim method is overloaded to accept a character array, which can trim any of the characters specified in the array appears in the beginning or end of the string. Similarly you can use this function with TrimStart or TrimEnd function. See the sample snippet below

String strHw = "* *_Hello World_* *";
char[] trim = { '*', ' ', '_'};
str  = strHw.Trim( trim );
Console.WriteLine("After Trimming:- " + str);

Split

Split method provides painless way for tokenize the string with the given delimiters. No loops or anything required. Just call the Split function and pass the delimiters to spot the end of each tokens. The function will return a string array. This function is really handy especially for things to do like CSV (Comma Seperated values) parsing. The overloaded Split functions gives more control over the return of array( e.g. to return emptry string element or not, maximum string elements to be returned etc). Please check the documentation See the Sample below

String str = "Quick,Brown,Fox,Jumps Over The,Lazy Dog";
Console.WriteLine("String:-" + str + "Split to");

char[] delim = {',', ' '};
String[] csvArray = str.Split(delim);

foreach (String s in csvArray)
{
       Console.WriteLine(s);
}

For a wordpress blog, MYSQL database is it’s heart. We can restore the wordpress installation, themes plugins or anything easily but once the database is corrupted, it’s not easy to go well with your blog.

I had faced the server crash many times and also due to some problems at server side, my DB was filled with spams and lot of other unnecessary categories and tags. What you can do is to restore the website to previous state. If you’re a heavy blogger, it’s better to keep the backup everyday or otherwise at least once in a week.

Now I’m talking about the backing up the wordpress blog DB easily. Almost all hosting providers are having phpAdmin enabled through webpage to control the database but this is not really easy.

Previously MySQL tool was available in MYSQL website but I was suprised once I format my machine and tried to download the same application again. MySQL provides a better tool called MySQL Workbench for controlling your database. It’s not only a backup tool, but it has other features like server administration, scripting console etc.

Just download MySQL Workbench from MySQL Website and specify your connection strings (servername, username and password) in the “New Server Instance” option.

Finally do your backup through Manage Import/Export. Sorry I could not find any option to automate the backup. Share if you find any options

I like readable fonts, slightly big in size. But I’m quite bored with the standard fonts we’re seeing for ages like Arial, Verdana, Georgia etc. Recently I tried of another simple experiment with my blog by enabling open webfonts created by Google. I like the font collection provided from Google. In Windows, I like Segoe UI and Calibri which is the most readable fonts bundled with Windows. In the apple world, I personally like Helvetica but the problem is, these wont run across platforms. I agree most of the visitors in my website are Windows users but I still like to have a unique look for my website across browsers and platforms. Also in the old version of Windows, Calibri and Segoe UI is not available by default. Also the purpose of this post is to letting someone know, there some simple beautiful things are happening around to try with.

Google webfonts are available through Google Fonts API which helps you to add web fonts to any webpage. Google fonts are high in quality, extremely easy to use and it works with most of the browsers in any platforms. There are two methods to use Google open fonts in your website, the first one is very basic usage of CSS and second version called WebFont Loader which is giving advanced usage of fonts and give far more flexibilty using JavaScript.

Here I’m covering only the basic usage of enabling Google fonts in the website.

1. Add the sytlesheet link request to the required font.

With a wordpress blog, I prefer you’re adding this in header.php file.

<link rel="stylesheet" type="text/css" href="http://fonts.googleapis.com/css?family=Font+Name">

2. Select the CSS elements which need to apply the fonts with

CSS selector {
  font-family: 'Font Name', serif;
}

Or inline stle with div tag

<div style="font-family: 'Font Name', serif;">Your text</div>

A Simple Example

Here’s the way I updated my blog font

Added link code in Modified Header.php

<link  href="//fonts.googleapis.com/css?family=Nobile:regular,italic,bold,bolditalic" rel="stylesheet" type="text/css" >

Modified the stylesheet.css and select the body with the Nobile font I selected

body {
  font-family: 'Nobile', serif;
  font-size: 14px;
  font-style: normal;
  font-weight: 400;
  text-shadow: none;
  text-decoration: none;
  text-transform: none;
  letter-spacing: 0em;
  word-spacing: 0em;
    line-height: 1.4em;
}

How to easily generate the Google Font API stylesheet code?

You can simply generate Google Font API CSS style sheet using Google font preview page. The modified parts will simply highlight in Yellow color and you’ve perfect control over vertical and horizontal spacing decoration etc. I prefer you to use this page to generate flawless CSS code.

Few hours ago, @twitter has officially released their brand new tweet button for content publishers to share their content through twitter. @TweetMeme has Retweet button integration with a number of blogging platform which was also used previously in this website. Now codereflect.com is integrated with brand new tweet button to share the content.

Twitter supports 3 different kind of buttons so far which contains a tweet button and also a retweet count linked to a twitter search page, which can display the reteweets on this same URL.

The steps for creating the reteweet button is quite easy. With simple 3 steps your retweet button will be ready.

Head to http://twitter.com/tweetbutton

Choose your button type

The biggest advantage of twitter share option is, you can add a set of twitter account suggest to follow.

You’re done.

Now You’ve created a typical button for your website. But now let’s see how to integrate this to wordpress. The default tweet button can’t work with the dynamic post contents in the blog. But it has options to specify the felids to control all parameters associated with the tweet button and share window eventually appears on clicking it.

Head to Developer page to get more information about tweet button http://dev.twitter.com/pages/tweet_button

Here I’m talking about the javascript version of the tweet button. The parameters which can be passed to script are listed below

In addition to the default button HTML code generated, we may have to add some more parameters to enable it in wordpress hosted blog

Modify Index.php from Appearance->Editor option

Copy the generated HTML code between the iteration to display the post. The screenshot is attached above. You may have to add data-url and data-text parameter to enable tweet button specfically for each post in the blog post. You can simply call the php call to get the title and and link the URL

Modify the Singlepost.php from Apperance->Editor Menu

This is also done in the same fashion for PHP.

Finally the share window appear as follows. 

I’m not covered all the parameters listed for the tweet option. Please check the documentation it’s simple as it’s. There may be a better way for doing these things. I’m not an expert web programmer. Please share if you’ve any comments. Hope you enjoy this

Most of the Visual Studio Developers are familiar with Visual Assist X developer tool. It has really nifty features for improving the productivity. It may not be too detailed refactoring facilities or so flexible features as other tools provides like DevExpress but as a whole all we like this tool. But only one problem, it’s a paid software.

Visual Studio IDE is consistently getting improved over the versions but still some of the feature are missing like Symbol Search, file search within the IDE until Visual Studio 2010. It’s really important while managing large projects. The best thing in the Visual Studio 2010, is the extensibility SDK. It’s far more flexible and prominent comparing to it’s predecessors.

Microsoft has created a really helpful site to host the useful tools for Visual Studio created by developers across the world. Even Microsoft has created some really cool tools for Visual Studio which is freely available in Visual Studio Gallery.

Productivity tools are one of best extensions available. It contains a bunch of features to improve your Visual Studio 2010 experience. You can download it from Visual Studio Gallery. The features can be simply enabled and disabled through Tools->Option menu.

Let’s have a quick look into the features. Each options are described well in their home page itself. Let’s skim through the features anyway. This contains only the features I handpicked from the whole features available. You can see the entire features the home page itself. The descriptions and screenshots are given same as the extension’s homepage.

Solution Navigator  (More Info)

This is one of the best feature.

• Expand code files to navigate to its classes, expand classes to navigate to their members, and so on (C# and VB only)
• Search your solution, all the way down to class members
• Filter your solution or projects to see just opened files, unsaved files, and so on
• View related information about classes and members (such as references or callers/callees for C#)
• Preview images by hovering over them, or preview rich information by hovering over code item

Solution Navigator also provides interactive tooltips in C# and VB code (replacing the default “quick info” tooltips) that give you the same kind of data, but right at your fingertips.  In addition to getting the tooltips on hover, you can:

• Press Ctrl+1 to open a relevant tooltip at the current cursor location
• Press Ctrl+2 to quickly navigate to any class/member in the current source file

Ctrl + Click Go To Definition
This extension gives the editor a web browser by adding clickable hyperlinks to symbols in your code as you hold down the Ctrl key.

Align Assignments
This extension is useful for making your code a little more readable by aligning the assignments when you type Ctrl+Alt+] such that it takes this:

And turns it into this:

Please note: This may conflict with your formatting settings. E.g. in C# you will need to disable: Tools->Options->Text Editor->C#->Formatting->Spacing->"Ignore spaces in declaration statements"

Triple Click
It’s never been easier to select a line of code from the mouse by simple triple-clicking anywhere on the line.

Highlight Current Line
As the resolution of monitors increases, it’s becoming more difficult to find the caret in the code editor.  The highlight current line extension makes it easy to find the caret by highlighting the line that the caret is on in the editor.  You can even configure the default colour by changing the setting for “Current Line (Extension)” and “Current Line Inactive (Extension)” in Tools Options Fonts & Colors.

HTML Copy (More Info)
This extension provides support for the HTML Clipboard format when cutting or copying code from the editor.  This means that you’ll no longer have to go fix up the formatting of your code when you paste it into a TFS bug form or any other HTML based control.

Colorized Parameter Help
This extension improves consistency with the editor by applying syntax highlighting to the contents of the Parameter Help window for C# &VB.
Please note: Syntax highlighting colors can be customized using the display items prefixed with “Signature Help” in the “Fonts and Colors” menu.

Tab Well UI
This extension allows you to completely customize the behavior of your document tabs from the Productivity Power Tools Options: See More Info

Auto Brace Completion
Automatic Brace Completion improves the productivity of writing code by automatically inserting the closing code construct when the opening construct is typed for VB & C#.  More specifically, this extension:

• Supports the following constructs: (), {}, [], <>, “”, and ‘’. 
• Allows you to press <TAB> to navigate past the next enclosing brace
• Allows you to automatically complete a statement in C# by inserting the closing semi-colon and moving you to the next line with SHIFT + ENTER

Most of the native Windows Programmers are familiar with GDI, the graphics API provided under Windows. GDI is widely used in windows applications. Later, Microsoft had introduced class-based, better services through GDI+ under Windows. Both Native programmers and Managed developers are making use of GDI/GDI+ classes and APIs.

But GDI was too old and was introduced with the initial versions of the Windows and over the time the capabilities of graphics hardware has grown and so does the demand for creating Visually Rich UI. With Windows 7, Microsoft has introduced a totally revamped 2D graphics subsystem called Direct2D based on their prominent Direct3D platform to create high quality 2D rendering. If you know or not, Windows Aero system is already taking advantage of graphics hardware since Windows Vista. This is supposed to replace the GDI APIs in the coming years. Direct2D is not only available under Windows 7 but Microsoft has made it available in Window Vista with the latest service pack upgrade.

The major advantages of the Direct2D APIs are it’s hardware accelerated and provides high quality 2D rendering. It enables the user to create visually rich applications by paying less effort, when comparing to conventional APIs .

GDI uses Pixel graphics but Direct2D can supports vector graphics as well, in which mathematical formulas are used to draw the lines and curves. Vector graphics provides high quality rendering independent of resolution of the device, while the pixelated graphics has dependency with resolution which may results in choppy graphics.

Most of the GDI APIs are not using anti-aliasing and transparency. Ofcrouse there are functions to do so but always there’s programming cost for taking advantage of these features. Also if we apply transparency and anti-aliasing, the computations are done using CPU. Direct2D can take advantage of graphics hardware and delegate the computationally intensive tasks to GPU.

Direct2D built on top of Direct3D components. The layered architecture is described below

You can see the underlying layers are Direct3D which make use of DXGI(DirectX Graphics Infrastructure), which manages the low level graphics related tasks that are independent of DirectX graphics runtime. DXGI provides common framework for graphics components. Simultaneously a high performance software rasterizer is available when the hardware acceleration is not possible. Another advantage of Direct2D API is, it’s using lightweight COM. It’s almost like simple C++ class. No BSTRS, COM Variants, Interfaces, Apartments etc.

Let’s start analyzing a simple Direct2D Program

There are 3 main components inevitable for enabling D2D rendering your application.

• A rendering Window and its handle (HWND)
• ID2D1Factory object to create the Direct2D resources
• ID2D1HwndRenderTarget object to draw the scene on the window.

The below example provides steps for enabling Direct2D Rendering in your MFC Application. It’s hard to describe the parameters of all APIs. Please refer them in MSDN.

Create your Window

Here I’m taking a dialog based application for rendering. The functions and messages may change if you’re using any other type of applications like SDI or MDI. No need to reinvent the wheel, allow the wizard to create your main dialog.

Prepare your Rendering Engine

Let’s delegate all the rendering tasks to another class instead of managing everything in the dialog class. I call this class as Direct2DHandler.

The Direct2DHandler declaration goes like below and it exposes the following functions.

#pragma once
#include <d2d1.h>
#include <d2d1helper.h>

class Direct2DHandler
{
public:
	Direct2DHandler( HWND hWnd ); // ctor
	~Direct2DHandler(void); // dtor
	HRESULT Initialize(); // Initialize the rendering
	HRESULT OnRender(); // Called from OnPaint function
	void OnResize(UINT width, UINT height);

private:
	HRESULT CreateDeviceResources(); // Create resources for drawing
	void DiscardDeviceResources(); // Release resources for drawing

private:

	HWND					m_hWnd;
	ID2D1Factory*			m_pDirect2dFactory;
	ID2D1HwndRenderTarget*	m_pRenderTarget;
	ID2D1SolidColorBrush*	m_pLightSlateGrayBrush;
	ID2D1LinearGradientBrush* m_pLinearGradientBrush;
};

The constructor

does nothing other than calling CoInitialize() function and initialize the member variables( mostly to NULL).

The Initialize function

creates the Direct2D factor object, which similar the HDC (context variable) in GDI.

HRESULT Direct2DHandler::Initialize()
{
    HRESULT hr = S_OK;

    // Create a Direct2D factory.
    hr = D2D1CreateFactory(D2D1_FACTORY_TYPE_SINGLE_THREADED, &m_pDirect2dFactory);

    return hr;
}

OnResize

function handles the rendering area for the render target. We will be using whole window area in this example.

void Direct2DHandler::OnResize(UINT width, UINT height)
{
    if (m_pRenderTarget)
    {
        // Note: This method can fail, but it's okay to ignore the
        // error here, because the error will be returned again
        // the next time EndDraw is called.
        m_pRenderTarget->Resize(D2D1::SizeU(width, height));
    }
}

OnRender

function does the following

1. Create the device resource for drawing (if not created)
2. Render the scene to the Window
3. Release the resources if error occurred

If you’re experienced 3D programming probably you might be knowing about the role of matrix and how the affects the rendering object. The matrix can be used for representing the objects coordinates system. We can apply rotation, translation (movement) etc (collectively called transformation). on a matrix and this can be used for specifying how object must be rendered. Here we’re using D2D1::Matrix3x2F::Identity() helper function which creates an identity matrix(object will be rendered at origin without any transformation)

m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());

We can clear the rendering area with a default color (as the dialog background filled with some default color according to Window’s theme. Here I selected white color

m_pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));

The important thing is, whatever you draw for the scene must be done between BeginDraw() and EndDraw() APIs. The other part of this code is simply straight forward and you can easily grasp it. See the source below.

HRESULT Direct2DHandler::OnRender()
{
	HRESULT hr = S_OK;

	hr = CreateDeviceResources();

	if (SUCCEEDED(hr))
	{
		m_pRenderTarget->BeginDraw();
		m_pRenderTarget->SetTransform(D2D1::Matrix3x2F::Identity());
		m_pRenderTarget->Clear(D2D1::ColorF(D2D1::ColorF::White));
		D2D1_SIZE_F rtSize = m_pRenderTarget->GetSize();
		// Draw a grid background.
		int width = static_cast<int>(rtSize.width);
		int height = static_cast<int>(rtSize.height);

		// Draw two rectangles.
		D2D1_RECT_F rectangle1 = D2D1::RectF(
			rtSize.width/2 - 50.0f,
			rtSize.height/2 - 50.0f,
			rtSize.width/2 + 50.0f,
			rtSize.height/2 + 50.0f
			);

		D2D1_RECT_F rectangle2 = D2D1::RectF(
			rtSize.width/2 - 100.0f,
			rtSize.height/2 - 100.0f,
			rtSize.width/2 + 100.0f,
			rtSize.height/2 + 100.0f
			);

		// Draw the outline of a rectangle.
		m_pRenderTarget->FillRectangle(&rectangle2, m_pLinearGradientBrush);

		// Draw a filled rectangle.
		m_pRenderTarget->FillRectangle(&rectangle1, m_pLightSlateGrayBrush);

		hr = m_pRenderTarget->EndDraw();

	}
	if (hr == D2DERR_RECREATE_TARGET)
	{
		hr = S_OK;
		DiscardDeviceResources();
	}
	return hr;
}

CreateDeviceResources

is slightly a lengthy function to initialize the required resources for rendering, like we create pens, brushes, bitmaps etc. Here mainly I’m creating a light colored solid brush and linear gradient brush to render as depicted in above picture. The comments are inlined and please read it along with the code. It will be interesting to learn about gradient brushes. If you’ve created a gradient brush in photoshop things will be far more easy. We can put stop spots to controls the end of gradients also line can be used for representing flow and angle for the gradient. Simple isn’t it? Like we create a normal gradient. See the code below.

HRESULT Direct2DHandler::CreateDeviceResources()
{
    HRESULT hr = S_OK;

    if (!m_pRenderTarget)
    {
        RECT rc;
        GetClientRect(m_hWnd, &rc);

        D2D1_SIZE_U size = D2D1::SizeU(
            rc.right - rc.left,
            rc.bottom - rc.top
            );

        // Create a Direct2D render target.
        hr = m_pDirect2dFactory->CreateHwndRenderTarget(
            D2D1::RenderTargetProperties(),
            D2D1::HwndRenderTargetProperties(m_hWnd, size),
            &m_pRenderTarget
            );

        if (SUCCEEDED(hr))
        {
            // Create a gray brush.
            hr = m_pRenderTarget->CreateSolidColorBrush(
                D2D1::ColorF(D2D1::ColorF::LightSlateGray),
                &m_pLightSlateGrayBrush
                );
        }

		// Create an array of gradient stops to put in the gradient stop
		// collection that will be used in the gradient brush.
		ID2D1GradientStopCollection *pGradientStops = NULL;

		D2D1_GRADIENT_STOP gradientStops[2];
		gradientStops[0].color = D2D1::ColorF(D2D1::ColorF::Maroon, 1);
		gradientStops[0].position = 0.0f;
		gradientStops[1].color = D2D1::ColorF(D2D1::ColorF::Red, 1);
		gradientStops[1].position = 1.0f;
		// Create the ID2D1GradientStopCollection from a previously
		// declared array of D2D1_GRADIENT_STOP structs.
		hr = m_pRenderTarget->CreateGradientStopCollection(
			gradientStops,
			2,
			D2D1_GAMMA_2_2,
			D2D1_EXTEND_MODE_CLAMP,
			&pGradientStops
			);
		// The line that determines the direction of the gradient starts at
		// the upper-left corner of the square and ends at the lower-right corner.

		if (SUCCEEDED(hr))
		{
			hr = m_pRenderTarget->CreateLinearGradientBrush(
				D2D1::LinearGradientBrushProperties(
				D2D1::Point2F(0, 0),
				D2D1::Point2F(300, 300)),
				pGradientStops,
				&m_pLinearGradientBrush
				);
		}

    }

    return hr;
}

DiscardDeviceResources

Just releases the allocated resouces. It simply uses helper macro SafeRelease described below the code.

void Direct2DHandler::DiscardDeviceResources()
{
    SafeRelease(&m_pRenderTarget);
    SafeRelease(&m_pLightSlateGrayBrush);
    SafeRelease(&m_pLinearGradientBrush);
}

template<class Interface>
inline void SafeRelease(
    Interface **ppInterfaceToRelease
    )
{
    if (*ppInterfaceToRelease != NULL)
    {
        (*ppInterfaceToRelease)->Release();

        (*ppInterfaceToRelease) = NULL;
    }
}

Initializing Rendering in Dialog class

In the

OnInitDialog function,

allocate memory for the Direct2DHandler class and Initialize it. You can call this from OnCreate function as well but ensure that there’s a valid Window handle is there.

m_pRender = new Direct2DHandler( m_hWnd );
m_pRender->Initialize();

Disable Default Background Drawing

Disable the default OnErasBkgrnd function because it may cause flickering while drawing. Also we’re occupying full client area in the dialog and the background is clearing is OnRender function itself.

BOOL CDirect2DDemoDlg::OnEraseBkgnd(CDC* pDC)
{
    return FALSE;//CDialogEx::OnEraseBkgnd(pDC);
}

OnSize (WM_SIZE)

function handles the Window size events. It will resize render target according to the Window Size.

void CDirect2DDemoDlg::OnSize(UINT nType, int cx, int cy)
{
    CDialogEx::OnSize(nType, cx, cy);
    if( m_pRender )
        m_pRender->OnResize( cx, cy );
}

OnPaint function

calls OnRender function of Direct2DHandler to draw the scene.

void CDirect2DDemoDlg::OnPaint()
{
    if (IsIconic())
    {
        // code for handling when window is minimized. Check original CPP file attached.
    }
    else
    {
        // CDialogEx::OnPaint(); no need to call this.
        if( m_pRender )
            m_pRender->OnRender();
    }
}

Linking

The Application must link to d2d1.lib through project settings or using #pragma comment( lib, “d2d1.lib” ) in the source file

d2d1helper

d2d1helper.h contains some useful functions to help the drawing. See the header for more details.

OK that’s the basics of creating Direct2D rendering for your Windows Application. Go ahead with the attached source code.

The project file is in Visual Studio 2010 format, but basically you only need to have Direct2DHandler class. You can also use other prior version of Visual Studio with Windows 7/Vista SDK.

Note: Take whole responsibility of downloading and executing the code shared here. Don’t sue me. It was virus free, malware free when I uploaded.

Download Demo Source code

Are you really bored of the default appearance of Visual Studio? Even it’s quite different from Normal Windows (XP) Menus and toolbars, yea I’m sure it’s really nice if we can customize the colors based on our mood.

Here’s a free tool to play around with Visual Studio 2010. You can edit the theme for Visual Studio with Visual Studio Color Theme Editor. It comes up with some default flavors of themes but we can also customize or download pre-created themes from any website. You can see a bunch of extensions, tools, themes etc. at Visual Studio Gallery.

Also studiostyles.info contains 100’s of themes to satisfy your moods. The Visual Studio 2010 extensibility library contains lot of gems to make everything in your way. Not only themes, the whole Visual Studio and it’s contents can be taken in your hand using Visual Studio 2010 SDK. It’s much more flexible and innovative than it’s predecessors. You can get a bit more detailed scoop here. Anyways have a nice time with colors

Bonus: How many of you guys are fascinated with keyboard shortcuts? I usually use mouse only if I can’t operate something with keyobard. Have you ever wished, if we could hide the unusable menubar? Matthew Johnson has written a nice extension to hide the menubar from Visual Studio 2010 IDE. On hitting, alt key will enable the menubar again. You can directly press the Alt+ Any (valid) key (e.g. Alt+F, Alt+T etc.)

In the last installment, we’ve seen using the basic version of task dialog. But usually when we see the task dialogs in Windows Vista or 7, it’s more detailed and can have flashy icons etc. Let’s see how to take more control over the task dialogs.

TaskDialogIndirect function can be used to have more options with task dialogs. TASKDIALOGCONFIG structure is used along with TaskDialogIndirect API.

As you’re seeing above the task dialog contains different type of controls, icons and capable of displaying more information to the user. It can have lengthy big buttons, radio buttons, checkbox, footer area, progressbar, custom icon, displaying predefined buttons like OK, Cancel, Yes, No etc. even we can have control over the buttons in the titlebar( minimize, maximize button etc)

The following code describes creating a task dialog with more flexible options. User can specify the callback functions which can be used to control the behavior if the controls and contents in the task bar. Filling the TASKDIALOGCONFIG structure is simple and straight forward as we’re seeing the code. The detailed option can be obtained from MSDN page.

HRESULT CALLBACK CTaskDialogSampleDlg::TaskDialogCallbackProc(
  __in  HWND hwnd,
  __in  UINT uNotification,
  __in  WPARAM wParam,
  __in  LPARAM lParam,
  __in  LONG_PTR dwRefData
)
{
	if( TDN_CREATED == uNotification )
	{
		::SendMessage( hwnd, TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE, IDOK, TRUE );
		::SendMessage( hwnd, TDM_SET_PROGRESS_BAR_RANGE, 0, 100 );
	}
	else if( TDN_HYPERLINK_CLICKED == uNotification )
	{
		ShellExecute( 0, L"open", (LPCTSTR) lParam, 0, 0, SW_SHOW );
	}
	else if( TDN_TIMER == uNotification )
	{
		static int i = 0;
		::SendMessage( hwnd, TDM_SET_PROGRESS_BAR_POS, i++,0 );
	}

	return 0;
}

void CTaskDialogSampleDlg::OnBnClickedButton1()
{
	int nButtonPressed                  = 0;
	TASKDIALOGCONFIG config             = {0};
	const TASKDIALOG_BUTTON buttons[]   = {
		{ IDOK, L"Elevate Privilege" },
		{ IDCANCEL, L"Run with user privilege" }
	};

	const TASKDIALOG_BUTTON radiobuttons[] = {
		{ IDCANCEL, L"Test Radio" }};
	config.cbSize                       = sizeof(config);
	config.hInstance                    = AfxGetApp()->m_hInstance;
	config.dwCommonButtons              = TDCBF_OK_BUTTON | TDCBF_CANCEL_BUTTON;
	config.pszMainIcon                  = TD_SHIELD_ICON;
	config.pszMainInstruction           = L"Main Instruction";
	config.pszContent                   = L"This is the content.";
	config.pszVerificationText          = L"Conifirm license agreement";
	config.pButtons                     = buttons;
	config.cButtons                     = ARRAYSIZE(buttons);
	config.pRadioButtons				= radiobuttons;
	config.cRadioButtons				= ARRAYSIZE( radiobuttons );
	config.dwFlags						= TDF_SHOW_PROGRESS_BAR |
		TDF_EXPAND_FOOTER_AREA | TDF_ENABLE_HYPERLINKS | TDF_CAN_BE_MINIMIZED
		| TDF_USE_COMMAND_LINKS | TDF_CALLBACK_TIMER;
	config.pszExpandedInformation		= _T( "<a href=\"http://codereflect.com/\" >Codereflect.com</a>" );
	config.pfCallback = TaskDialogCallbackProc;
	BOOL bVerification = FALSE;
	TaskDialogIndirect(&config, &nButtonPressed, NULL, &bVerification);

	switch (nButtonPressed)
	{
	case IDOK:
		break; // the user pressed button 0 (change password).
	case IDCANCEL:
		break; // user canceled the dialog
	default:
		break; // should never happen
	}
}

The callback function is also easy to manage. There are predefined set of events for each type of control and we can simply make use of these controls by sending various messages to update its state and values. One of the best example is updating the progressbar during the lifetime of messagebox. Once the timer is enabled, the callback function will be automatically fired on discrete time interval. The notify messages are specified in detail in MSDN Documentation. Please check it.

To compile this source code, please use latest version of Visual Studio 2010 or any prior version with Windows Vista/7 SDK. You can also use express edition of Visual C++ to try this API.