msoftnews » Handling

Handling Multi-touch and Mouse Input in All Browsers

admin — Wed, 19 Oct 2011 20:51:54 +0000

Touch interaction with Web sites and apps has the opportunity to improve their usability
and ubiquity as the Web and Windows 8 Metro style apps play a key role on tomorrow’s
touch-enabled devices.

This post explains how Web developers can use the new
IE10 pointer event model along with the
iOS touch event model and the
W3C mouse event model (as
extended) to create a cross-browser, common-code handler for pointer,
touch, and mouse input.

A little background: I’m fortunate to have a
Samsung 700T Windows Developer Preview tablet PC. With it, I’ve been able to
enjoy the IE Test Drive multi-touch
demos Touch Effects
and Lasso Birds.
Like me, you may have noticed that Lasso Birds works across different devices and
browsers in addition to IE10. For example, its multi-touch works on iOS devices.
In this post, I’ve taken some of the patterns from Lasso Birds and generalized and extended them to include
older versions of browsers.

The result of my experimentation is below. It should work in your browser. A discussion
of the coding patterns and lessons learned follows below the demo.

The Code

The basic algorithm for drawing with the mouse model is straightforward:

var drawingStarted =

            false;
function DoEvent(eventObject)

            {
if (eventObject.type

            == "mousedown") {
drawingStarted = true;
startDraw(eventObject.pageX, eventObject.pageY);
}
else 

            if (eventObject.type == "mousemove")

            {
if (drawingStarted)

            {
extendDraw(eventObject.pageX, eventObject.pageY);
}
}
else 

            if (eventObject.type == "mouseup")

            {
drawingStarted = false;
endDraw();
}
}

The only change needed to make this work with IE10’s pointer events is to add awareness
that multiple pointers can be down at the same time, each identified by a different
pointerId value. The IE10 pointer model fires separate MSPointerDown, MSPointerMove,
and MSPointerUp events for each pointer that changes state.

var drawingStarted =

            {};
function DoEvent(eventObject)

            {
eventObject.preventManipulation(); 

            // without this, instead of drawing, you pan
var pointerId = eventObject.pointerId;
if (eventObject.type

            == "MSPointerDown") {
drawingStarted[pointerId] = 

            true;
startDraw(pointerId, eventObject.pageX, eventObject.pageY);
}
else 

            if (eventObject.type == "MSPointerMove")

            {
if (drawingStarted[pointerId])

            {
extendDraw(pointerId, eventObject.pageX, eventObject.pageY);
}
}
else 

            if (eventObject.type == "MSPointerUp")

            {
delete drawingStarted[pointerId];
endDraw(pointerId);
}
}

Adapting the original mouse model to Apple’s iOS touch event model requires that
you iterate through the list of changedTouches for each touchstart, touchmove, and
touchend event because, in the iOS model, state changes that occur at the same time
are bundled into one event. Like the IE10 pointer model, a unique identifier identifies
each touch point.

var drawingStarted =

            {};
function DoEvent(eventObject)

            {
eventObject.preventDefault(); 

            // without this, instead of drawing, you pan
for (var

            i = 0; i < eventObject.changedTouches.length; ++i) {
var touchPoint = eventObject.changedTouches[i];
var touchPointId = touchPoint.identifier;
if (eventObject.type

            == "touchstart") {
drawingStarted[touchPointId] = 

            true;
startDraw(touchPointId, touchPoint.pageX, touchPoint.pageY);
}
else 

            if (eventObject.type == "touchmove")

            {
if (drawingStarted[touchPointId])

            {
extendDraw(touchPointId, touchPoint.pageX, touchPoint.pageY);
}
}
else 

            if (eventObject.type == "touchend")

            {
delete drawingStarted[touchPointId];
endDraw(touchPointId);
}
}
}

Merging these three individual algorithms requires noting the differences between
the event names and the unique pointer identifier attribute names and accounting
for the lack of an identifier in the mouse model.

In the merged model, below, I also add a check that the “move” position has actually
changed because the IE10 pointer model streams MSPointerMove events with the same
x, y position when a touch point is held down but not moved. By filtering out these
redundant moves, I eliminate calls to extendDraw() that do nothing. I implemented
this check by storing the last x,y position from a start or move in the lastXY object
and, by checking that a lastXY entry exists for a particular id, lastXY replaces
the drawingStarted object used in the previous two examples.

var lastXY = { };
function DoEvent(eventObject)

            {
// stop panning and

            zooming so we can draw
if (eventObject.preventManipulation)
eventObject.preventManipulation();
else
eventObject.preventDefault();
 
// if we have an array

            of changedTouches, use it, else create an array of one with our eventObject
var touchPoints = (
            style="color: Blue;">typeof eventObject.changedTouches != 

                'undefined') ? eventObject.changedTouches : [eventObject];
for (var

            i = 0; i < touchPoints.length; ++i) {
var touchPoint = touchPoints[i];
// pick up the unique

            touchPoint id if we have one or use 1 as the default
var touchPointId = (
            style="color: Blue;">typeof touchPoint.identifier != 

                'undefined') ? touchPoint.identifier : (typeof

            touchPoint.pointerId != 'undefined')

            ? touchPoint.pointerId : 1;
 
if (eventObject.type.match(/(down|start)$  /i))

            {
// process mousedown,

            MSPointerDown, and touchstart
lastXY[touchPointId] = { x: touchPoint.pageX, y: touchPoint.pageY

            };
startDraw(touchPointId, touchPoint.pageX, touchPoint.pageY);
}
else 

            if (eventObject.type.match(/move$  /i)) {
// process mousemove,

            MSPointerMove, and touchmove
if (lastXY[touchPointId]

            && !(lastXY[touchPointId].x == touchPoint.pageX && lastXY[touchPointId].y

            == touchPoint.pageY)) {
lastXY[touchPointId] = { x: touchPoint.pageX, y: touchPoint.pageY

            };
extendDraw(touchPointId, touchPoint.pageX, touchPoint.pageY);
}
}
else 

            if (eventObject.type.match(/(up|end)$  /i)) {
// process mouseup,

            MSPointerUp, and touchend
delete lastXY[touchPointId];
endDraw(touchPointId);
}
}
}

The examples above specifically ignore the issues of registering to receive the events
or ensuring that they apply to the drawing target. Making this work for real and
with all browsers—including versions of Internet Explorer before IE9—requires a
bit more work. Interested parties can peruse the final version of my multi-browser,
multi-touch drawing class here.

By coding for touch alongside mouse, Web developers can assure their sites work with
all browsers—whether desktop, tablet, or phone.

—Ted Johnson, Graphics Program Manager Lead, Internet Explorer

IEBlog

Twitter now handling one billion tweets per week

admin — Tue, 15 Mar 2011 15:53:15 +0000

With the fifth anniversary of the launch of Twitter on March 21 fast approaching, the social networking site has released a few statistics to illustrate the site’s phenomenal growth.

In a blog post, Twitter’s Carolyn Penner said Twitter was, ”on every measure of growth and engagement”, growing at ”a record pace”….

Neowin.net

Tips for Handling Information Overload

admin — Fri, 30 Jul 2010 14:50:22 +0000

The reality for anyone who does most of their work online is that information is endless, and keeping up with the most important information without becoming overwhelmed can be quite a challenge. As a community manager, I have to be able to process large quantities of information quickly and efficiently in order to do my job, but it’s easy to forget that not everyone lives in my world.

As I work with colleagues to help them get more involved in the community, the most common complaint is that they won’t be able to read everything and can’t keep up with the volume of information coming into the community. However, the key is not to try to read everything, but to learn how to filter and find the information that you do need to read.

Filtering

Most email clients have various options for filtering and processing at least some of your email automatically, which allows you to get through your email more quickly. I send community posts from mailing lists or forums to a folder with a threaded view, while also keeping them in my inbox. By keeping them in a threaded view, I can review all of the related posts together, which reduces the time I spend paying attention to each one since I can follow the entire thread. I also take similar actions for other information or community-generated traffic. This allows me to very quickly process certain types of high-volume email traffic.

This same principle holds for other kinds of information. I also filter my RSS feeds using Yahoo Pipes to automatically increase the relevancy of what I read; you can use similar searching and filtering on other types of data that has to be processed and dealt with quickly.

The Art of Skimming and Processing

I’ve talked before about embracing inbox zero. One of the keys to maintaining inbox zero is to be able to quickly skim through your email to process everything and decide whether you need to archive it or put it in a folder to respond later. The filtering techniques talked about earlier allow me to very quickly skim certain types of email while spending more time on others. Accepting that you can’t possibly read everything and staying disciplined about processing your email really does help you get more of the right things accomplished, rather than spending all day reading email without getting to your real work. I also use my phone to process email by setting up my “must respond” folder on the server, along with an “archive later” folder: a temporary folder where I can put email that can be easily dumped into the real archive folder on my hard drive when I get back to my laptop to save server space.

Like the filtering tip, skimming and processing can be applied to many other types of information. You can quickly get through your RSS reader if you flag or star items to read later when you have more time, and you can use various bookmark services to tag articles to read later. I also do this with Twitter by marking tweets as favorites from my phone if they contain a link that I want to read when I get back to a bigger screen or when I have more time.

Prioritization and Time Chunks

Getting through large quantities of information quickly also depends on prioritizing content to deal with important things first while also being able to work in chunks where you can be the most productive. For example, I use a color code system for emails from people who generally send me important email: my boss, the people who report to me, and a few others. By having these in orange, I can quickly see at a glance which emails should be read right away, and I prioritize this email over other types of email. I also try to process my email in big chunks; for example, my community has quite a few people from Europe and Asia, so the volume of email in the morning can be a bit intense. Since it doesn’t take too much effort to skim and process the mailing list email, I try to do it first thing in the morning while I’m making that first pot of tea. The key is that I’m only processing it to find the email that I need to do something with, but I wait to respond until I’ve had time to drink that first cup.

I do something similar with my RSS reader. I set aside chunks of time to spend reading feeds and have carefully prioritized folders with the most important feeds in folders near the top with less important feeds in folders near the bottom that I rarely read. I also set aside chunks of time to spend reading forum posts and other community activities.

These are just a few examples of ways to handle information overload with a focus on email, since that seems to be where most people get overwhelmed to start with. However, these tips also apply to handling information overload of other types.

How do you handle information overload?

Related GigaOM Pro content (sub. req.): Enabling the Web Work Revolution

GigaOM