Wednesday, December 29, 2010

How to make your ASP.Net label multiline (how to wrap text in your label)

First off, sorry for the absence. Things got a little busy in life as well as work. Not to mention having to get up to speed on 2.0 in a big hurry. All good things, but it left less time for fun stuff.

With that said, I want to offer a little tip to help with formatting your ASP.Net pages. Getting a label to be multiline within a set width. Now many of you know this trick, but I always have to re-remember the trick every time I need it, so this post can be a reference for you as well.

The trick is actually this - Don't use a label. Use a textbox instead. Since all the controls inherit from the same base class, the text box and the label are very similar anyway. But only the textbox has the multiline capability.

Once you have the textbox on your page the trick is to make it look like a label for the end user. To do this you need to set the following properties (This is the part I can never remember):

Wrap = true; (obviously)
rows = {some number greater than 0} (I use the rows property rather than the height property as it tends to be earier to get the formatting right)
ReadOnly = true (makes sense, right)
TextMode = multiline (or there no real reason to wrap the text...)
BorderStyle = None
BorderWidth = 0

Those last two are actually VERY important, and here is why. They get rid of that pesky border that you see around text boxes. That border is a common visual signal to the end user that says "ENTER INFO HERE!". If you leave the border up expect a lot of phone calls from folks saying "The web page is broken. It won't let me enter text."

So use this in good faith. More controls soon. Even my first 2.0 controls.

Tuesday, December 21, 2010

C# Caching

For apps there are many different kinds of caching available. This includes browser caching, partial page caching, data caching, and others.

The first and foremost is browser caching. Browsers will automatically cache references to your js, css, and images. Although you might need to add the following to your web.config to give it a hint about the js files:

The can also have the following to give it a hint on how long to cache the static content:

For the actual pages, see one of the links above. You have pretty good control over what is and isn't cached in the app itself.

Friday, December 17, 2010

Hello World RPC Server

package org.mortbay.gwt.example.client;


public interface HelloWorldService extends RemoteService

public String sayHello(String sender);

package org.mortbay.gwt.example.client;


public interface HelloWorldService extends RemoteService

public String sayHello(String sender);

package org.mortbay.gwt.example.client;


public interface HelloWorldServiceAsync

public void sayHello(String sender, AsyncCallback callback);

Using Continuations (RetryRequest) | jetty6

package org.mortbay.gwt.example.server;

import javax.servlet.http.HttpServletRequest;

import org.mortbay.gwt.AsyncRemoteServiceServlet;
import org.mortbay.gwt.example.client.HelloWorldService;
import org.mortbay.util.ajax.Continuation;
import org.mortbay.util.ajax.ContinuationSupport;

public class HelloWorldServiceImpl extends AsyncRemoteServiceServlet implements HelloWorldService

private static final long serialVersionUID = 1L;

public String sayHello(String sender)
HttpServletRequest request = getThreadLocalRequest();
Continuation continuation = ContinuationSupport.getContinuation(request, null);
if(continuation.isNew() || !continuation.isPending())
request.setAttribute("ts", Long.valueOf(System.currentTimeMillis()));
long elapsed = System.currentTimeMillis() - ((Long)request.getAttribute("ts")).longValue();
return "Hello world *" + sender + "* resumed after " + elapsed + " ms";

Using Servlet-3.0 suspend/resume api | jetty7

package org.mortbay.gwt.example.server;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.mortbay.gwt.AsyncRemoteServiceServlet;
import org.mortbay.gwt.example.client.HelloWorldService;

public class HelloWorldServiceImpl extends AsyncRemoteServiceServlet implements HelloWorldService

private static final long serialVersionUID = 1L;

public String sayHello(String sender)

HttpServletRequest request = getThreadLocalRequest();
HttpServletResponse response = getThreadLocalResponse();
System.err.println("HANDLING: " + request + " | " + request.hashCode() + " | " + response.hashCode());

request.setAttribute("ts", Long.valueOf(System.currentTimeMillis()));
return null;
// timed-out or resumed
long elapsed = System.currentTimeMillis() - ((Long)request.getAttribute("ts")).longValue();
return "Hello world *" + sender + "* resumed after " + elapsed + " ms";



Installs an application-defined hook procedure into a hook chain. You would install a hook procedure to monitor the system for certain types of events. These events are associated either with a specific thread or with all threads in the same desktop as the calling thread.


HHOOK WINAPI SetWindowsHookEx(
__in int idHook,
__in HOOKPROC lpfn,
__in HINSTANCE hMod,
__in DWORD dwThreadId


idHook [in]
Type: int

The type of hook procedure to be installed. This parameter can be one of the following values.

Value Meaning
Installs a hook procedure that monitors messages before the system sends them to the destination window procedure. For more information, see the CallWndProc hook procedure.

Installs a hook procedure that monitors messages after they have been processed by the destination window procedure. For more information, see the CallWndRetProc hook procedure.

Installs a hook procedure that receives notifications useful to a CBT application. For more information, see the CBTProc hook procedure.

Installs a hook procedure useful for debugging other hook procedures. For more information, see the DebugProc hook procedure.

Installs a hook procedure that will be called when the application's foreground thread is about to become idle. This hook is useful for performing low priority tasks during idle time. For more information, see the ForegroundIdleProc hook procedure.

Installs a hook procedure that monitors messages posted to a message queue. For more information, see the GetMsgProc hook procedure.

Installs a hook procedure that posts messages previously recorded by a WH_JOURNALRECORD hook procedure. For more information, see the JournalPlaybackProc hook procedure.

Installs a hook procedure that records input messages posted to the system message queue. This hook is useful for recording macros. For more information, see the JournalRecordProc hook procedure.

Installs a hook procedure that monitors keystroke messages. For more information, see the KeyboardProc hook procedure.

Installs a hook procedure that monitors low-level keyboard input events. For more information, see the LowLevelKeyboardProc hook procedure.

Installs a hook procedure that monitors mouse messages. For more information, see the MouseProc hook procedure.

Installs a hook procedure that monitors low-level mouse input events. For more information, see the LowLevelMouseProc hook procedure.

Installs a hook procedure that monitors messages generated as a result of an input event in a dialog box, message box, menu, or scroll bar. For more information, see the MessageProc hook procedure.

Installs a hook procedure that receives notifications useful to shell applications. For more information, see the ShellProc hook procedure.

Installs a hook procedure that monitors messages generated as a result of an input event in a dialog box, message box, menu, or scroll bar. The hook procedure monitors these messages for all applications in the same desktop as the calling thread. For more information, see the SysMsgProc hook procedure.

lpfn [in]

A pointer to the hook procedure. If the dwThreadId parameter is zero or specifies the identifier of a thread created by a different process, the lpfn parameter must point to a hook procedure in a DLL. Otherwise, lpfn can point to a hook procedure in the code associated with the current process.

hMod [in]

A handle to the DLL containing the hook procedure pointed to by the lpfn parameter. The hMod parameter must be set to NULL if the dwThreadId parameter specifies a thread created by the current process and if the hook procedure is within the code associated with the current process.

dwThreadId [in]

The identifier of the thread with which the hook procedure is to be associated. If this parameter is zero, the hook procedure is associated with all existing threads running in the same desktop as the calling thread.

Return Value


If the function succeeds, the return value is the handle to the hook procedure.

If the function fails, the return value is NULL. To get extended error information, call GetLastError.


SetWindowsHookEx can be used to inject a DLL into another process. A 32-bit DLL cannot be injected into a 64-bit process, and a 64-bit DLL cannot be injected into a 32-bit process. If an application requires the use of hooks in other processes, it is required that a 32-bit application call SetWindowsHookEx to inject a 32-bit DLL into 32-bit processes, and a 64-bit application call SetWindowsHookEx to inject a 64-bit DLL into 64-bit processes. The 32-bit and 64-bit DLLs must have different names.

An error may occur if the hMod parameter is NULL and the dwThreadId parameter is zero or specifies the identifier of a thread created by another process.

Calling the CallNextHookEx function to chain to the next hook procedure is optional, but it is highly recommended; otherwise, other applications that have installed hooks will not receive hook notifications and may behave incorrectly as a result. You should call CallNextHookEx unless you absolutely need to prevent the notification from being seen by other applications.

Before terminating, an application must call the UnhookWindowsHookEx function to free system resources associated with the hook.

The scope of a hook depends on the hook type. Some hooks can be set only with global scope; others can also be set for only a specific thread, as shown in the following table.

Hook Scope
WH_CALLWNDPROC Thread or global
WH_CALLWNDPROCRET Thread or global
WH_CBT Thread or global
WH_DEBUG Thread or global
WH_FOREGROUNDIDLE Thread or global
WH_GETMESSAGE Thread or global
WH_KEYBOARD Thread or global
WH_KEYBOARD_LL Global only
WH_MOUSE Thread or global
WH_MOUSE_LL Global only
WH_MSGFILTER Thread or global
WH_SHELL Thread or global

For a specified hook type, thread hooks are called first, then global hooks.

The global hooks are a shared resource, and installing one affects all applications in the same desktop as the calling thread. All global hook functions must be in libraries. Global hooks should be restricted to special-purpose applications or to use as a development aid during application debugging. Libraries that no longer need a hook should remove its hook procedure.


For an example, see Installing and Releasing Hook Procedures.


Minimum supported client

Windows 2000 Professional
Minimum supported server

Windows 2000 Server

Winuser.h (include Windows.h)


Unicode and ANSI names

SetWindowsHookExW (Unicode) and SetWindowsHookExA (ANSI)
See Also



Send comments about this topic to Microsoft

Build date: 12/1/2010

CCR Introduction

Microsoft Robotics
Concurrency and Coordination Runtime (CCR) is a managed code library, a Dynamically Linked Library (DLL), accessible from any language targeting the .NET Common Language Runtime (CLR).
The CCR addresses the need of service-oriented applications to manage asynchronous operations, deal with concurrency, exploit parallel hardware and deal with partial failure. It enables the user to design applications so that the software modules or components can be loosely coupled; meaning they can be developed independently and make minimal assumptions about their runtime environment and other components. This approach changes how the user can think of programs from the start of the design process and deals with concurrency, failure and isolation in a consistent way.

Problem Areas

Asynchrony - When communicating between loosely coupled software components, like programs running across the network, or User Interface (UI) code communicating with the user input and the file I/O subsystem, asynchronous operations enable the code to scale better, be more responsive, and deal with failure across multiple operations. Asynchronous programming however, considerably reduces the readability of user code, since logic is often split between callbacks and the code that originates the operation. In addition, it is an almost impossible task to correctly handle failure across multiple outstanding operations.
Concurrency - Code that needs to better utilize multiple execution resources, must be split into independent logical segments, that can run in parallel, and communicate when necessary to produce results from the combined execution. Often, that logical segment is captured by the thread OS primitive, that is nothing more than a long lived iteration. Because of thread performance implications on thread startup, the thread stays active for long periods of time. This forces a particular pattern. Code is structured as long sequences that use blocking or synchronous calls, and only deals with one thing at a time. Further, threads assume that the primary communication between them is shared memory, forcing the programmer to use very explicit, error-prone methods to synchronize access to that shared memory.
Coordination and Failure Handling - Coordinating between components is where most of the complexity in large software programs lies. A mismatch of interaction patterns, such as calling methods on objects versus using OS signaling primitives versus using queues plus signaling, leads to unreadable code, where the runtime behavior changes drastically between coordination approaches. More importantly, the error handling approaches are ill-defined and again vary drastically.
Application Model

CCR is appropriate for an application model that separates components into pieces that can interact only through messages. Components in this model need means to coordinate between messages, deal with complex failure scenarios, and effectively deal with asynchronous programming. This application model is also very similar to how heterogeneous hardware is integrated and how network applications are built. Most software programs have the same needs, from traditional client PC programs to server applications, to applets running in the Web browser. The software needs to coordinate user input, storage input/output and UI presentation. Although disguised in layers of mostly synchronous application code interfaces, asynchrony is inevitable since the devices operate at different speeds, have large differences in resources available, and we in general know how to use queues to isolate them.

The following sections introduce the CCR programming model and its implementation that addresses the above areas in an efficient, robust and extensible way.

© 2010 Microsoft Corporation. All Rights Reserved.

Array of Tuples

Q: How would use tuples in C# 4.0 to create an array of tuples containing various types of data (i.e. Employee Name, Employee ID#)?

A: Listed below is a sample code snippet to implement an array of tuples.

//Array of Tuples (i.e. EmpName, EmpIDNum)
Tuple[] EmpRecs =
Tuple.Create("Sam Nasr", 891),
Tuple.Create("Jim Smith", 358),
Tuple.Create("Lisa Jones", 962)

string FirstEmpName = EmpRecs[0].Item1;

string SecondEmpName = EmpRecs[1].Item1;
int SecondEmpIDNum = EmpRecs[1].Item2;

More information can be found at

NTLM Authentication for Java http clients

I was working to provide NTLM authentication to a RSS aggregator plugin , in our implementation the rssaggregator needed to access rss feed from an IIS installed application within an AD intergrated setup, so our http request needed to go through NTLM authentication.
What I found out during this exercise is that if one is on the same AD domain as the server hosting the secure contents then JDK 1.5 and 1.6 does a transparent authentication at the backend, automatically transferring the login details from the http client to the server , however if the request is being made from a client outside the domain then the login details have to be provided using the username and password for the client accessing the protected resource, for that I found the Jave Authenticator class to be the best option, since you do not have to alter your existing code and just call the Authenticator before the http request and populate the authentication credentials in it. Worked really well for me.
Two exhaustive definitions of how ntlm works, and the interactions
Useful link to valid Java Implementation
Ads by Google

Oh Yahoo!

Yahoo has hit rock bottom. They’ve now, finally, had their layoffs. Those that are left are keeping their resumes fresh don’t expect to stay there over the long term. Everything we hear from employees boils down to this – the company is in “absolute disarray.”

Take yesterday as an example. They botch news about closing down products like Delicious. The Upcoming team is apparently wiped out, but an apparently timestamped blog post appeared on wednesday, after the team was gone, asking for feedback on a new design for the site. Except the blog post doesn’t have a link to the new design, and still doesn’t as of today. Probably because whoever wrote it is gone, along with the rest of the team.

And today Yahoo realized that people really care about sites like Delicious and put up a blog post saying that they’re going to sell it, not shut it down. Which is great except the Delicious blog is now offline and returns an error (we reprinted it here).

And finally, yesterday Yahoo announced internally that they would be shutting down an instant messaging product called MyM. Have you heard of it? Neither had we. Oh wait, we did – in 2008. It turns out is was an internal project that was never launched and formally shut down nearly three years ago. Apparently the executive team didn’t know that.

In May I spoke with CEO Carol Bartz on stage at TechCrunch Disrupt. The headline was the last few seconds of the talk. But that wasn’t really what was interesting about the interview. What really riled Yahoo up was when I asked if they were really even a technology company any more. I think it’s now clear to the world now that they aren’t. They’re just a nightmarish Dilbert-cartoon version of the old Yahoo, where employees fear for their jobs and stumble around the office trying to protect themselves, not build anything new and ambitious.

There is only one way a company recovers from this. They must have new leadership. And soon. Because at this point they are little more than a holding company for some lucrative Asian Internet assets. This can’t possibly be what the board of directors hoped for when they hired Bartz less than a year ago. So much has changed, so fast.

Tuesday, December 14, 2010

Zombie Farm

A few days ago Apple released its top 10 list of iPhone apps for 2010 and only one freemium app was listed as top grossing, Zombie Farm. Zombie Farm combines all the fun of Farmville with zombies (!), allowing you to plant either crops or corpses (seriously). You can then use the zombies you’ve planted to attack your neighbors or pirates or aliens (no, I am not making this up).

Apparently this is a winning combination, as the game hit 7.3 million downloads in November, up from 6 million in October and growing about 25% a month. Currently it boasts about 2 million monthly active users, a number which has been doubling every couple of months since the app’s launch this February. Users have spent 2.76 billion minutes playing the game, which have resulted in 61.5 million Zombie Farm invasions. And despite complaints about the most recent updates’ slowness in the iTunes reviews, the developers are obviously doing something right.

To the tune of millions of dollars. Playforge developer Vince McDonnell and his wife were in danger of losing their house when he built the app, and now not so much. While McDonnell will not reveal how much total revenue the app has made thus far (people pay for in-game currency like $0.99 brains and tombstones) in comparison, Doodle Jump, the #10 app on the top grossing list sold about 3 million units in five months at $0.99 each which would project to about ($) 7 million sold for the year. Zombie Farm was at number #6 on the list, which means McDonnell has made at least a few million thus far.

Monday, February 8, 2010

GWT games

Many years ago I wrote javascript application that took an image, broke it up into many pieces, then shuffled them into a puzzle for the user. It only worked in I.E. and was horribly written and hard to maintain.

I wanted to revisit this application and was trying to figure out what the best language/framework to use.

I decided that GWT (Google Web Toolkit) would be an excellent choice for this application.

To see the application go here:

Now to the code...

The code consists of the following main classes.



The ImagePuzzleWidget is the main widget that encapsulates the game. It takes no arguments and is added directly to the Root Panel in the GWT entry point.

public void onModuleLoad() {
RootPanel.get().add(new ImagePuzzleWidget());


PuzzleGrid extends the Grid GWT component. Its constructor looks like this:

public PuzzleGrid(final String url,final int cols,final int rows)

This class takes the url of the image you want to scramble as well as how many rows and cols you want.

We add an onLoadHandler that will get executed after the image has been loaded:

image.addLoadHandler(new LoadHandler() {

public void onLoad(LoadEvent event) {
setWidth(image.getWidth() + "px");
setHeight(image.getHeight() + "px");

int blockWidth = image.getWidth() / cols;
int blockHeight = image.getHeight() / rows;
for (int col = 0; col <>
for (int row = 0; row <>
setWidget(row, col,
new ClickableImage(url, blockWidth * col, blockHeight * row, blockWidth, blockHeight, row, col));


It is this class that does most of the work by splitting the image into sub parts and making ClickableImages out of them.

The class then shuffles the images and sets it as visible.

So now we have an image displayed broken into sub parts and displayed in a grid fashion.


ClickableImage class, as its name implies embodies a section of the image that can be clicked.

The class basically just extends Image and adds a ClickHandler. I add some extra convenience methods like select and unselect which I won't show for the sake of brevity.

public ClickableImage(String url, int left, int top, int width, int height, int row, int col) {
super(url, left, top, width, height);
this.row = row;
this.col = col;
this.addClickHandler(new ClickHandler() {

public void onClick(ClickEvent event) {


And that is really all there is to it. By using GWT we can focus on writing our OO style code and not worry about the browser.

Make sure you check out the app at:

This post was written hastily, if there is any interest or question leave a comment and I'll ake the time to expand.