Command Class

The Command class is a construct that encapsulates the semantic information of an action. The behavior that the command activates is not encapsulated in this object. This means that command contains only information about "command" not the actual action that happens when command is activated. The action is defined in a CommandListener associated with the Displayable. Command objects are presented in the user interface and the way they are presented may depend on the semantic information contained within the command.

Commands may be implemented in any user interface construct that has semantics for activating a single action. This, for example, can be a soft button, item in a menu, or some other direct user interface construct. For example, a speech interface may present these commands as voice tags.

The mapping to concrete user interface constructs may also depend on the total number of the commands. For example, if an application asks for more abstract commands than can be mapped onto the available physical buttons on a device, then the device may use an alternate human interface such as a menu. For example, the abstract commands that cannot be mapped onto physical buttons are placed in a menu and the label "Menu" is mapped onto one of the programmable buttons.

A command contains four pieces of information: a short label, an optional long label, a type, and a priority. One of the labels is used for the visual representation of the command, whereas the type and the priority indicate the semantics of the command.

Labels

Each command includes one or two label strings. The label strings are what the application requests to be shown to the user to represent this command. For example, one of these strings may appear next to a soft button on the device or as an element in a menu. For command types other than SCREEN, the labels provided may be overridden by a system-specific label that is more appropriate for this command on this device. The contents of the label strings are otherwise not interpreted by the implementation.

All commands have a short label. The long label is optional. If the long label is not present on a command, the short label is always used.

The short label string should be as short as possible so that it consumes a minimum of screen real estate. The long label can be longer and more descriptive, but it should be no longer than a few words. For example, a command's short label might be "Play", and its long label might be "Play Sound Clip".

The implementation chooses one of the labels to be presented in the user interface based on the context and the amount of space available. For example, the implementation might use the short label if the command appears on a soft button, and it might use the long label if the command appears on a menu, but only if there is room on the menu for the long label. The implementation may use the short labels of some commands and the long labels of other commands, and it is allowed to switch between using the short and long label at will. The application cannot determine which label is being used at any given time.

Type

The application uses the command type to specify the intent of this command. For example, if the application specifies that the command is of type BACK, and if the device has a standard of placing the "back" operation on a certain soft-button, the implementation can follow the style of the device by using the semantic information as a guide. The defined types are BACK, CANCEL, EXIT, HELP, ITEM, OK, SCREEN, and STOP.

Priority

The application uses the priority value to describe the importance of this command relative to other commands on the same screen. Priority values are integers, where a lower number indicates greater importance. The actual values are chosen by the application. A priority value of one might indicate the most important command, priority values of two, three, four, and so on indicate commands of lesser importance.

Typically, the implementation first chooses the placement of a command based on the type of command and then places similar commands based on a priority order. This could mean that the command with the highest priority is placed so that user can trigger it directly and that commands with lower priority are placed on a menu. It is not an error for there to be commands on the same screen with the same priorities and types. If this occurs, the implementation will choose the order in which they are presented.

For example, if the application has the following set of commands:

new Command("Buy", Command.ITEM, 1); new Command("Info", Command.ITEM, 1); new Command("Back", Command.BACK, 1);

An implementation with two soft buttons may map the BACK command to the right soft button and create an "Options" menu on the left soft button to contain the other commands.

When user presses the left soft button, a menu with the two remaining Commands appears:

If the application had three soft buttons, all commands can be mapped to soft buttons:

The application is always responsible for providing the means for the user to progress through different screens. An application may set up a screen that has no commands. This is allowed by the API but is generally not useful; if this occurs the user would have no means to move to another screen. Such program would simply considered to be in error. A typical device should provide a means for the user to direct the application manager to kill the erroneous application.

How to show/hide webpart programmatically ?

Sometimes, we need to show and hide webparts programmatically based on some events. This can be done by the following code:

SPWeb myWeb = SPContext.Current.Web;
myWeb.AllowUnsafeUpdates = true;

Microsoft.SharePoint.WebPartPages.SPLimitedWebPartManager mgr = null;
mgr = myWeb.GetLimitedWebPartManager(
"default.aspx",
System.Web.UI.WebControls.WebParts.PersonalizationScope.Shared);
foreach (System.Web.UI.WebControls.WebParts.WebPart myWebPart in mgr.WebParts)
{
// If this is the webpart we want to change...
if (myWebPart.Title == "SomeWebpartName")
{
myWebPart.Hidden = true;
mgr.SaveChanges(myWebPart);
break;
}
}

Global Assembly Cache is Empty !

Problem:

When trying to build and copy to GAC, you see that GAC is empty !!!

Solution:

Restart the "indexing service".

Cannot open Office 2010 documents in sharepoint using Windows 7

Problem:

After installing Office 2010 you discover that it ahs no integration with Sharepoint, and it refuses to open any sharepoint document from it.

Solution:

1- Open Internet Explorer.

2- Go to "Tools".

3- Go to "Internet Options".

4- Click "LAN Settings" ubder "Connections" tab.

5- Check mark for "Use a proxy server for the LAN".

6- Specify 127.0.0.1 as the address.

Dependency Injection Pattern

Topic: Don’t Look For Things!
Speaker: Miško Hevery
Subject: Dependency Injection

Video: 


Slides:

for more details: http://martinfowler.com/articles/injection.html

Subpixel Layout And Rendering

Gecko does subpixel layout and rounds coordinates to device pixels for rendering.

He's right that in some sense, when you have to render a CSS layout to a screen with discrete pixels, all the options are imperfect and browsers are choosing different imperfect options. However I think we need to explain the big picture a little better.

Gecko intentionally supports subpixel layout because for high resolution output devices, especially printers but also high-DPI screens that will become more common, one CSS "px" should be mapped to many device pixels, so you can in fact do sub-CSS-pixel rendering. For those devices, rounding layout units to CSS pixels is actually throwing away information and giving you a strictly worse layout than Gecko will give. For example, try printing in FF3 beta. You should see that in the printout (or generated PDF), no rounding has occurred and each child DIV looks identical.

Because this is important and we don't want layout to vary unnecessarily across devices, we do subpixel layout on all devices. When we have to draw to a regular-DPI screen, we then have to round the edges of drawn objects to the nearest screen pixel. This explains the results. Note that our approach of rounding at drawing time is optimal for avoiding gross layout changes due to rounding; it limits the impact of rounding to moving object edges by one pixel in some direction. It avoids gross layout changes like IE moving a DIV to the next line, or Safari leaving a 2px strip vacant at the end of the line. Thus I believe our approach is better than the alternatives in important ways.

The preceding paragraph is actually a slight oversimplification. We do have to do some rounding during layout simply due to the fact that computer arithmetic has limited precision. So during layout we round measurements to the nearest 1/60th of a CSS pixel. This number was chosen so that common fractions of a CSS pixel can be represented exactly. Note that rounding to 1/60th of a CSS pixel is far more benign than rounding to CSS pixels; 1/60th of a CSS pixel is approximately 1/5760th of an inch, not something most people are going to worry about!

In practice, we have seen very few Web compatibility issues caused by this scheme. Web authors should just not worry about the rounding, and should not attempt to round coordinates themselves. The new getBoundingClientRect and getClientRects APIs in FF3 can return fractional coordinates, just go with the flow. Feel free to position elements at those fractional boundaries, it will be lined up visually. If you insist on consistent rendering down to the pixel, then the only way to go is to specify px values for everything, including line-heights, and avoid percentage units. Or better still, use SVG. Or a PNG.

Flex in a week (47 video tutorial)

• Video 01 - Comparing Flash, Flex, FP and AIR
• Video 02 - Introducing Flex Builder
• Video 03 - Flex Builder Workspace and Project
• Video 04 - Using Pre-Built Flex Controls
• Video 05 - Understanding MXML
• Video 06 - Binding Data Between Controls
• Video 07 - Handling User Events
• Video 08 - Introducing the Event Object
• Video 09 - Adding Event Listeners with AS3
• Video 10 - Retrieving data via HTTPService
• Video 11 - Displaying Data in the DataGrid
• Video 12 - Working with Containers
• Video 13 - Creating Custom MXML Components
• Video 14 - Implementing Value Object Classes
• Video 15 - Creating Custom Events
• Video 16 - Creating Custom Event Classes
• Video 17 - Customizing Item Renderers
• Video 18 - Exploring Flex Builder Tips
• Video 19 - Validating Data
• Video 20 - Passing Data to Server with RemoteObject
• Video 21 - Formatting Data
• Video 22 - Dragging Data Between List Components
• Video 23 - Filtering XML with E4X
• Video 24 - Deploying Flex and AIR Applications
• Video 25 - Implementing Navigator Containers
• Video 26 - Embedding Images
• Video 27 - Embedding Fonts
• Video 28 - Creating Constraint-Based Layouts
• Video 29 - Applying Styles to MXML Components
• Video 30 - Skinning Components with Adobe CS3
• Video 31 - Creating View States
• Video 32 - Animating - Behaviors and Transitions
• Video 33 - Drawing Shapes with the Drawing API
• Video 34 - Skinning Components Programmatically
• Video 35 - Extending Components
• Video 48 - Reducing file size
• Video 40 - Building runtime shared libraries
• Video 36 - Flash timer mechanism
• Video 37 - Custom Flash graphics in comp
• Video 38 - Using and animating filters
• Video 39 - Creating SWC files
• Video 41 - Splitting your app into modules
• Video 42 - Communicating over local connections
• Video 43 - Using shared objects
• Video 44 - Embedding video in your application
• Video 46 - Localization using resource bundles
• Video 45 - Controlling video using Ajax
• Video 47 - Integrating Flex with PHP using XML

Add Copy To / Move To to the Windows Explorer Right Click Menu

A hidden functionality in Windows allows you to right click on a file, select Copy To Folder or Move To Folder, and the move to box will pop up and let you choose a location to either copy or move the file or folder to.

Here's the quick registry hack to get this working. As usual, back up your registry just in case. You will want to browse down to this key:

HKEY_CLASSES_ROOT\AllFilesystemObjects\shellex\ContextMenuHandlers

Once you are at that key, right click and choose the New Key option:

Now you will double-click on the (Default) value and enter the following:

{C2FBB630-2971-11D1-A18C-00C04FD75D13}

Click OK and continue.

If you want to enable Move To, you will repeat the same steps, except creating a new key named Move To, and using this value:

{C2FBB631-2971-11D1-A18C-00C04FD75D13}

Now when you right click on a file or folder, you should see the following options:

Let's click Copy To Folder just to see what happens….

And that's it. Useful!

Open PCs (WIN XP) protected by passwords.

1. Power on the PC.
2. Press CTRL+ALT+DEL
3. Press CTRL+ALT+DEL, again
   
4. Type in the user name field the word "Administrator"
5. Leave the password field empty.

That's all !!

.SO extension

• Extension: .so
• Type: Unix Shared Library
• Category: Development
• Mime type: application/octet-stream
• Description: SO file is an Unix Shared Library (Shared Object). A shared library is a library of functions or classes (for C/C++ programmers) that are compiled, linked, and stored separately from the clients (applications) that use them. The UNIX equivalent of a DLL file in Windows is a Shared Library (SO) file.