Chris Bensen

Dell Latitude XT2 XFR Rugged Tablet

noreply@blogger.com (Chris Bensen) — Tue, 27 Oct 2009 20:00:00 +0000

Dell just introduced the Latitude XT2 XFR; the rugged version of the XT2 multitouch tablet machine I've mentioned a few times before only with a name that is more of a mouth full. So for those of you waiting for a rugged machine before jumping into multitouch wait no longer. The short spec list is 12 inch multitouch display, 5lbs and 1.5 inches thick and mil spec badassness! It also comes with Vista. I guess Windows 7 isn't rugged certified? Just as well, first thing I do when I get a new machine is format it anyway. For all the awesomeness it'll set you back some serious coin. The base model is $3,600 but I loaded one up for just under $5k! I don't think I can justify one of these to Nick, but damn!

Dell SX2210T - Multitouch Monitors

noreply@blogger.com (Chris Bensen) — Mon, 26 Oct 2009 22:00:00 +0000

The first standalone multi-touch monitor is the SX2210T. Looks pretty awesome for those that want to add a multi-touch monitor tho an existing computer.

Updated: Link goes to the product page (which is up now) rather than the shopping cart.

Delphi Tips and Tricks - Additional Files

noreply@blogger.com (Chris Bensen) — Thu, 15 Oct 2009 14:00:00 +0000

One of the most useful features in the Delphi IDE is CTRL + F12, or the "Search for units" dialog. One of the problems we encounter is we often want to look at files that are not in any of the opened projects. So a hidden registry key was created to add a list of files to the "Search for units" dialog. You can specify the text file by creating a string value under HKEY_CURRENT_USER\Software\CodeGear\BDS\\Globals named "AdditionalViewFiles". Set the string to the file you want the IDE to load. Note that IDE environment variables can be used here. For Example I have $(TP) set to "c:\source" and the AdditionalViewFiles string value is set to $(TP)\AdditionalViewFiles.txt.

The text file format is name value pairs like any other INI file where the name is the short name you want to see and the value is the full path to the file (and this will expand IDE environment variables as well). For example:

Foo.pas=$(TP)\somedirectory\Foo.pas

Sony Touchscreen Computer/TV

noreply@blogger.com (Chris Bensen) — Mon, 12 Oct 2009 14:00:00 +0000

From the specs I think this Sony Vaio L beats pants off the HP Touchsmart. It's got glass, HDMI input, 1080p (I'm not sure if this is the computer resolution as well) Blue-ray, NVIDIA graphics and the monitor can be used as a TV without turning on the computer. I'm not sure what the other computer specs are, but the mouse does look horrible. It also appears that the DVD drive isn't a slot loading drive so that's a bit odd. Check out Sony website for more information.

Touch Demo Part III

noreply@blogger.com (Chris Bensen) — Wed, 07 Oct 2009 16:00:00 +0000

Previously I posted Part I and Part II of the Touch Demo.

This time around we will add the glowing spots and the basic handling of the WM_TOUCH message. Add Generics.Collections to your uses and copy the following code to your unit:


type
  TGlowSpot = class
  public
    X, Y, Radius: Integer;
    Alpha: Extended;
    FadeIn: Boolean;
    Color: TColor;

  public
    constructor Create(AParent: TWinControl);

    procedure Paint(Canvas: TDirect2DCanvas);
  end;

  TGlowSpotList = class(TList<TGlowSpot>);
...
implementation

{$R *.dfm}

procedure PaintGlow(Canvas: TDirect2DCanvas; Alpha: Single;
  X, Y, Radius: Integer; Color: TColor);
var
  Stops: array[0 .. 1] of TD2D1GradientStop;
  Gradient: ID2D1GradientStopCollection;
  BrushProperties: TD2D1RadialGradientBrushProperties;
  RadialBrush: ID2D1RadialGradientBrush;
  Brush: TDirect2DBrush;
begin
  Stops[0].position := 0;
  Stops[0].Color := D2D1ColorF(Color, Alpha);
  Stops[1].position := 1;
  Stops[1].Color := D2D1ColorF(Color, 0);
  Canvas.RenderTarget.CreateGradientStopCollection
    (@Stops[0], Length(Stops), D2D1_GAMMA_2_2, D2D1_EXTEND_MODE_CLAMP,
    Gradient);
  BrushProperties.center := D2D1PointF(X, Y);
  BrushProperties.gradientOriginOffset.X := 0;
  BrushProperties.gradientOriginOffset.Y := 0;
  BrushProperties.radiusX := Radius;
  BrushProperties.radiusY := Radius;
  Canvas.RenderTarget.CreateRadialGradientBrush
    (BrushProperties, nil, Gradient, RadialBrush);
  Brush := TDirect2DBrush.Create(Canvas);
  Brush.Handle := RadialBrush;
  Canvas.Pen.Color := clNone;
  Canvas.Brush := Brush;
  Canvas.Ellipse(X - Radius, Y - Radius,
    X + Radius, Y + Radius);
end;

{ TGlowButton }

constructor TGlowSpot.Create(AParent: TWinControl);
begin
  inherited Create;
  Alpha := 1;
  Radius := 80;
  FadeIn := False;
  Randomize;
  Color := RGB(Random(255), Random(256), Random(256));
end;

procedure TGlowSpot.Paint(Canvas: TDirect2DCanvas);
begin
  PaintGlow(Canvas, Alpha, X, Y, Radius, Color);
end;

Add a local to hold a lists of TGlowSpots to your form then create it and free it:


  TTouchForm = class(TForm)
...  
  private
    FSpots: TGlowSpotList;
...
constructor TTouchForm.Create(AOwner: TComponent);
begin
  inherited;
  FCanvas := TDirect2DCanvas.Create(Handle);
  FSpots := TGlowSpotList.Create;
end;

destructor TTouchForm.Destroy;
begin
  FCanvas.Free;
  FSpots.Free;
  inherited;
end;

Update the Paint routine to paint the spots:


procedure TTouchForm.Paint;
var
  Spot: TGlowSpot;
begin
  Canvas.BeginDraw;

  try
    // Clear Background
    Canvas.RenderTarget.Clear(D2D1ColorF(clBlack));

    for Spot in FSpots do
      Spot.Paint(Canvas);

    // FPS
    Canvas.Font.Color := clWhite;
    Canvas.Brush.Color := clNone;
    Canvas.Font.Size := 14;
    Canvas.TextOut(10, 10, FloatToStrF(FFPS, ffFixed, 2, 2) + ' FPS');
  finally
    Canvas.EndDraw;
  end;
end;

Modify the Update method to fade the spots:


procedure TTouchForm.Update;
var
  Spot: TGlowSpot;
begin
  Inc(FFrames);

  if GetTickCount - FStartTime >= 1000 then
  begin
    FFPS := FFrames;
    FFrames := 0;
    FStartTime := GetTickCount;
  end;

  for Spot in FSpots do
  begin
    if Spot.FadeIn then
      Spot.Alpha := Spot.Alpha + 0.012
    else
      Spot.Alpha := Spot.Alpha - 0.012;

    if Spot.Alpha < 0.3 then
    begin
      Spot.FadeIn := True;
      Spot.Alpha := 0.4
    end
    else if Spot.Alpha > 1 then
      Spot.FadeIn := False;
  end;
end;

And last handle the WM_TOUCH message:


  TTouchForm = class(TForm)
...
  procedure WMTouch(var Message: TMessage); message WM_TOUCH;
...
procedure TTouchForm.WMTouch(var Message: TMessage);

  function TouchPointToPoint(const TouchPoint: TTouchInput): TPoint;
  begin
    Result := Point(TouchPoint.X div 100, TouchPoint.Y div 100);
    PhysicalToLogicalPoint(Handle, Result);
  end;

var
  TouchInputs: array of TTouchInput;
  TouchInput: TTouchInput;
  Handled: Boolean;
  Point: TPoint;
  Spot: TGlowSpot;
begin
  Handled := False;
  SetLength(TouchInputs, Message.WParam);
  GetTouchInputInfo(Message.LParam, Message.WParam, @TouchInputs[0],
    SizeOf(TTouchInput));
  try
    for TouchInput in TouchInputs do
    begin
      Point := TouchPointToPoint(TouchInput);
      Spot := TGlowSpot.Create(Self);
      Spot.X := Point.X;
      Spot.Y := Point.Y;
      FSpots.Add(Spot);
    end;

    Handled := True;
  finally
    if Handled then
      CloseTouchInputHandle(Message.LParam)
    else
      inherited;
  end;
end;

If you ran your app at this point you wouldn't get any touch messages. You need to call RegisterTouchWindow and UnregisterTouchWindow. I find it easiest to call UnregisterTouchWindow in the FormClose:


procedure TTouchForm.FormClose(Sender: TObject; var Action: TCloseAction);
begin
  UnregisterTouchWindow(Handle);
end;

and to call RegisterTouchWindow in the CreateWnd:


procedure TTouchForm.CreateWnd;
begin
  inherited;
  RegisterTouchWindow(Handle, 0);
end;

Now when you run your app and press the screen you'll get glowing spots wherever you touch the screen. Depending on your hardware 1, 2 or more at a time.

UPDATE: There is a memory leak in this program because I didn't want to delete any code for the next step.

UPDATE: Fixed HTML to make TGlowSpotList = class(TList) actually read TGlowSpotList(TList<TGlowSpot>);

How to Write Applications Useful for Color Blind Users

noreply@blogger.com (Chris Bensen) — Tue, 06 Oct 2009 20:00:00 +0000

We Are Color Blind is an online repository of information for anyone involved with creating content for the web and making it accessible to the color blind. This is a great resource that I feel is useful for anyone creating content or building applications, not just for the web.

The Quick Tips is probably a good place to start.

UPDATE: Fixed links.

Touch Demo Part II

noreply@blogger.com (Chris Bensen) — Tue, 06 Oct 2009 15:00:00 +0000

Last week I posted Touch Demo Part I. This is the continuation to that series.

In Part I I demonstrated how to add the Direct2D Canvas to a form. This step is another foundation step that will add frames to your application by adding a timer.

At the moment the form looks like this:


type
  TTouchForm = class(TForm)
  private
    FCanvas: TDirect2DCanvas;
  protected
    procedure Paint; override;
    procedure Resize; override;
    procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND;

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    property Canvas: TDirect2DCanvas read FCanvas
      write FCanvas;
  end;

Add the following private fields to keep track of the frames:


    FFPS: Integer;
    FFrames: Integer;
    FStartTime: Cardinal;

and initialize them in the FormShow:


procedure TTouchForm.FormShow(Sender: TObject);
begin
  FFPS := 0;
  FFrames := 0;
  FStartTime := GetTickCount;
end;

Next update the Paint function:


procedure TTouchForm.Paint;
begin
  Canvas.BeginDraw;
  try
    // Clear Background
    Canvas.RenderTarget.Clear(D2D1ColorF(clBlack));

    // FPS
    Canvas.Font.Color := clWhite;
    Canvas.Brush.Color := clNone;
    Canvas.Font.Size := 14;
    Canvas.TextOut(10, 10, FloatToStrF(FFPS, ffFixed, 2, 2) + ' FPS');  finally
    Canvas.EndDraw;
  end;
end;

And then add a protected Update method that updates the frames:


procedure TTouchForm.Update;
begin
  Inc(FFrames);

  if GetTickCount - FStartTime >= 1000 then
  begin
    FFPS := FFrames;
    FFrames := 0;
    FStartTime := GetTickCount;
  end;
end;

Last, drop a TTimer on your form and set the interval to 10. Also set the form's Align to alClient and the BorderStyle to bsNone.

Next create the OnTimer event and simply call two functions, Update and Paint:


procedure TTouchForm.Timer1Timer(Sender: TObject);
begin
  Update;
  Paint;
end;

At this point your form should look like this:


type
  TTouchForm = class(TForm)
    Timer1: TTimer;
    procedure Timer1Timer(Sender: TObject);
    procedure FormShow(Sender: TObject);
  private
    FCanvas: TDirect2DCanvas;
    FFPS: Integer;
    FFrames: Integer;
    FStartTime: Cardinal;
  protected
    procedure Update;
    procedure Paint; override;
    procedure Resize; override;
    procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND;

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    property Canvas: TDirect2DCanvas read FCanvas
      write FCanvas;
  end;

HP Touchsmart

noreply@blogger.com (Chris Bensen) — Mon, 05 Oct 2009 17:00:00 +0000

If you buy a Touchsmart be sure to spend the extra duckets to get the NVIDIA graphics card. It comes with an NVIDIA GeForce 9300M which is a pretty smokin' card and you'll be much happier.

Failure Doesn't Preclude Success

noreply@blogger.com (Chris Bensen) — Thu, 24 Sep 2009 22:00:00 +0000

This is a brilliant video on how failure doesn't preclude future success:

Touch Demo Part I

noreply@blogger.com (Chris Bensen) — Tue, 22 Sep 2009 17:00:00 +0000

Over the next few posts I am going to walk you through building one of the touch demos I used in my CodeRage 4 Session. This demo demonstrates using Direct2D and the WM_TOUCH message. Before we get started here is a brief explanation of these two technologies.

Since Windows Vista GDI has become a legacy drawing API supported with software rendering on top of Direct3D. Direct3D is great but it is very raw. This is where Direct2D shines for applications. Direct2D has all the performance benefits of Direct3D and adds support for bitmaps and text and support for GDI Interop all with a much simpler API. And Delphi 2010 has made it even simpler by wrapping it up with a TDirect2DCanvas that is very similar to TCanvas. Direct2D supports remote rendering through Remote Desktop which is very cool.

WM_TOUCH is the raw multi-touch message that provides various states of contact with the input digitizer for hot sizzling touch applications.

Now that we got that out of the way, create yourself a VCL Application. We want to start painting with Direct2D so add Direct2D and D2D1 to the uses and a TDirect2DCanvas property to your form like this:


  private
    FCanvas: TDirect2DCanvas;
  ...
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    property Canvas: TDirect2DCanvas read FCanvas
      write FCanvas;
  end;
...
constructor TTouchForm.Create(AOwner: TComponent);
begin
  inherited;
  FCanvas := TDirect2DCanvas.Create(Handle);
end;

destructor TTouchForm.Destroy;
begin
  FCanvas.Free;
  inherited;
end;

This creates a Direct2D surface (TDirect2DCanvas) that we can draw to instead of the traditional GDI surface (TCanvas).

Depending on the type of application you build you may experience some flicker. To avoid this handle the message WM_ERASEBKGND and returns true.


procedure TTouchForm.WMEraseBkgnd(
  var Message: TWMEraseBkgnd);
begin
  Message.Result := 1;
end;

Next override Paint and just draw a line:


procedure TTouchForm.Paint;
begin
  Canvas.BeginDraw;
  try
    Canvas.Pen.Color := clRed;
    Canvas.MoveTo(10, 10);
    Canvas.LineTo(40, 40);
  finally
    Canvas.EndDraw;
  end;
end;

If you run your application at this point and resize the form you will noticed that the line changes size. This is because the view port is resizing to scale to the window and your line will do the same. To prevent this override the Resize method and add the following:


procedure TTouchForm.Resize;
var
  HwndTarget: ID2D1HwndRenderTarget;
begin
  inherited;
  if Supports(Canvas.RenderTarget,
    ID2D1HwndRenderTarget, HwndTarget) then
    HwndTarget.Resize(D2D1SizeU(ClientWidth, ClientHeight));
  Invalidate;
end;

Now you have a form that renders everything drawn to the Canvas through a Direct2D surface.

UPDATE: Added Invalidate to Resize because when resizing the window larger it will force a redraw but smaller will not because typically a redraw isn't required.

Delphi 2010 - Touch and Pen added to TShiftState

noreply@blogger.com (Chris Bensen) — Tue, 22 Sep 2009 15:00:00 +0000

While we were researching adding Touch and Gesturing to VCL we quickly realized it was important to detect what type of input produced the mouse messages. So we introduced some new elements to TShiftState: ssTouch and ssPen:


  TShiftState = set of (ssShift, ssAlt, ssCtrl,
    ssLeft, ssRight, ssMiddle, ssDouble, ssTouch, ssPen);

One of the key reasons this is so important is when handling WM_TOUCH messages the mouse messages are also fired. Chances are you only want to handle one of them. On a non-touch machine you want to handle the mouse. So this allows input to be filtered and handled independently.

September Photo of the Month

noreply@blogger.com (Chris Bensen) — Thu, 17 Sep 2009 04:49:00 +0000

This is a photo of Cottonwood Lake in Inyo National Forest. This photo is a panorama stitched from 14 photos! And one of the most beautiful mornings I've ever had the pleasure to see.

Interactive Gestures 101

noreply@blogger.com (Chris Bensen) — Tue, 15 Sep 2009 16:00:00 +0000

As promised at my CodeRage 4 session I will be blogging about Gestures and the Touch feature of Delphi 2010. So here is a quick set of steps to use interactive gestures. It will require a multi-touch system such as I described here (the mouse will not work here) and some context by watching my CodeRage 4 session from here.

1. File | New VCL Application
2. Drop a TPanel on your form (there is a known bug using interactive gestures on the form)
3. Select Panel1 and expand the Touch property
4. Check igoPanSinglerFingerHorizontal, and check igPan. I also like to turn off toPressandHold
5. Go to events and add the following code to the OnGesture event:


if EventInfo.GestureID = igiPan then
  Caption := IntToStr(EventInfo.Location.X);

Now run the application and move your finger left and right on the panel.

Note: Interactive Gestures don't require a TGestureManage. Only Gestures require the Gesture Manager.

Update: Fixed the code and added links for touch hardware and my CodeRage 4 session.

CodeRage 4

noreply@blogger.com (Chris Bensen) — Wed, 02 Sep 2009 21:00:00 +0000

Register for CodeRage4 and come check out the sessions. It's all free so why not, it should be a lot of fun.

I'll be at three talks answering questions:

Building Awesome Touch Enabled Applications by Chris Bensen
Tuesday, September 8, 2009 -- 11:00am - 11:45am PDT
Wednesday, September 9, 2009 -- 9:00am - 9:45am PDT

Hands-On: Gestures in the VCL by Seppy Bloom
Tuesday, September 8, 2009 -- 4:00pm - 4:45pm PDT

What's New in the VCL *
Tuesday, September 8, 2009 -- 3:00pm - 3:45pm PDT
Thursday, September 10, 2009 -- 8:00am - 8:45am PDT (I won't be here because I'll be on vacation!)

RAD Studio 2010 - SOAP 1.2

noreply@blogger.com (Chris White) — Thu, 20 Aug 2009 21:31:00 +0000

Chris White here. This cycle around I have moved from working on the product's many areas that make up the IDE's Help experience to something that has been brand new to me, SOAP.

This posed quite a few challenges for me, one being I knew nothing about SOAP. So after familiarizing myself with SOAP, I started working on the largest feature request in the SOAP area, upgrading our SOAP client support to SOAP 1.2. So, I flew headlong into learning the differences between the specs for SOAP 1.1 and 1.2. With the new SOAP 1.2 client support, our ability to communicate with other SOAP Web Services has greatly increased.

Also since it had been a while, I gave the WSDL Importer Wizard a face lift. I simplified the UI greatly. There are only 3 dialogs (4 if you don't have a project open), all of which are in succession; as well as moved it to an easier to get to location (Component -> Import WSDL...). One nice thing about moving it to the Component menu, you can now import a WSDL without a project open. Hopefully this will be as useful to users as it has been to me; creating a project just to look at a WSDL got tiresome.

WSDLImp.exe also got sync'd up with the IDE's WSDL Importer Wizard. So now you can do everything with the commandline as you can with the IDE.

Touch Hardware

noreply@blogger.com (Chris Bensen) — Mon, 17 Aug 2009 21:00:00 +0000

One of the first questions people ask about multi-touch is what hardware to get.

Everything is supported just at different levels. First you have touch screens that emulate the mouse such as most Point-of-Sale monitors. We have a Dell POS and a Planar PT 19. These are only good for big buttons. Any sort of dragging your finger across the screen is lost by the device/driver. The Planar doesn't loose the mouse as bad as the Dell.

Then you have the old school tablet laptops. These add pen and sometimes support touch with the finger as well. The pen resolution is equal to or better than the mouse. The finger with these older systems is an afterthought. Lenovo IBM X61 is an example of such a system.

Next you have all-in-one systems such as the Asus EeeTop which has better drivers/hardware than the Point-of-Sale monitors but they are still just a touch screen mouse. I.E. push the monitor with your finger and you get a left mouse click. The Asus has a pretty decent touch screen but still only supports one touch point and it is just emulating the mouse. The processor on the Asus is really slow.

Now enters multi-touch which only Windows 7 really supports. Some Vista systems support multi-touch but just go with Windows 7, you'll be much happier.

Building on the tablet there are currently two shipping multi-touch laptops. One by Dell and one by HP. These make touch a forethought and add multi-touch. The HP supports 2 touch points and with an updated driver 4. The Dell supports 10 touch points. They are the exact same display so it must be the driver or other components that allow the extra touch points on the Dell. A Dell is currently sitting on my desk and it is the nicest of the systems. It feels like a laptop that I would buy for myself. The Dell is priced a bit high but it is a nice slimline laptop. The HP feels a bit cheap and has some flowery patterns on it.

Lastly you have the all-in-one multi-touch systems such as the HP TouchSmart which features a large display and two touch points. We have purchased two batches of these. The first batch is pretty bad. I'm pretty sure these are the ones currently selling on Woot. The second batch is a lot better but the Dell and HP laptops I mentioned above are better. Update: If you buy one of these be sure to get the NVIDIA graphics card.

Delphi 2010 - New Units

noreply@blogger.com (Chris Bensen) — Thu, 13 Aug 2009 16:00:00 +0000

A lot of header translations and new units have been added. Here are just a few that are interesting:

Wincodec.pas
Enables TWICImage. Support for Tiff, CR2 or NEF anyone?

Cor.pas
.NET unmanaged compiler API. Always fun to crack open Assemblies from native code.

Direct3D.pas, D3DX9.pas, D2D1.pas
DirectX header translations.

Direct2D.pas
TDirect2DCanvas. Get to Direct2D using the same TCanvas methods you know and love.

Manipulations.pas
The inertia manipulators. Great for spinning and throwing things around your screen.

Gestures.pas, GestureMgr.pas, GestureCtrls.pas
Hot gesturing goodness.

Keyboard.pas, KeyboardTypes.pas
TTouchKeyboard for all your touchscreen input needs.

IOUtils.pas
A serious addition to the RTL with TDirectory, TPath, and TFile.

Update: I forgot one RTTI.pas
For some very cool runtime stuff.

RAD Studio 2010 - Gestures and Multi-Touch

noreply@blogger.com (Chris Bensen) — Thu, 13 Aug 2009 01:00:00 +0000

One of the most exciting features in RAD Studio 2010 is Gestures and Multi-Touch (or what I like to call Interactive Gestures). I can't really show much here because it requires video, but if you've seen the videos or my Delphi Live! talk then you've seen some of what can be done.

Gestures takes full advantage of synthetic properties so you don't see much in the Object Inspector until a GestureManager is assigned. But Interactive Gestures and Tablet Options can be fully utilized without any setup, just check a few check boxes and add some code to the OnGesture event.

Gestures of all flavors can be added per control but different flavors of gestures are mutually exclusive. So you can have a panel with the Gestures and another panel with Interactive Gestures. It's pretty slick.

RAD Studio 2010 - Touch Keyboard

noreply@blogger.com (Chris Bensen) — Wed, 12 Aug 2009 13:00:00 +0000

The Touch Keyboard (TTouchKeyboard) is a new component designed specifically for touch systems. It supports a pile of languages and multi-touch. You can see the multi-touch in action in the screen shot above where I was holding down shift and pressing G. The Touch Keyboard is supported on Windows 2000, XP, Vista and Windows 7, but only Windows 7 gets multi-touch.

The Touch Keyboard is designed to be embedded in your applications where you need input from the users. Notice there is no Windows key. After much thought we decided to take a different approach to the Touch Keyboard than Microsoft did with their on screen keyboard. Our focus was on touch systems without a physical keyboard, hence the name, where Microsoft emulated the hardware keyboard.

A lot of thought was given to the colors and the font uses. Touch systems are probably more likely to be used in harsh light so there needed to be a lot of contrast between the keys and the background.

RAD Studio 2010 - Touch Preview Video

noreply@blogger.com (Chris Bensen) — Tue, 11 Aug 2009 13:00:00 +0000

Watch the Touch and Gesturing preview video where David I and I did some serious acting. And then there was some serious editing by someone that isn't David I.

Update: Here is a Japanese version that was translated before the editing:

For those interested the songs used in the video are "I Touch Myself by Divinyls" and "Touch Me by The Doors". You can listen or buy them here (I wish Amazon would just let me put a little play button so you didn't have to go to their website):

RAD Studio 2010 - Actions

noreply@blogger.com (Chris Bensen) — Thu, 06 Aug 2009 15:30:00 +0000

One very useful feature is an updated Action property editor. The little drop down hasn't changed in years and we wanted to get to our Actions quicker. So Seppy Bloom through some Object Inspector trickery, which you can find all about in his CodeRage 4 session Customizing the Object Inspector, updated the Action property editor.

What you are looking at is a new drop down that allows you to selection from one simple menu any standard action from the action list, choose any existing actions, or create a new action.

If you have more than one action list then just choose which one to use.

Just one more example of increased productivity.

RAD Studio 2010 - The IDE

noreply@blogger.com (Chris Bensen) — Wed, 05 Aug 2009 16:00:00 +0000

Here is a screen shot of the entire IDE showing many of the new features. From top to bottom you can see a retro component palette. In the middle of the screen you can see IDE Insight. In the object inspector you can see the check boxes I mentioned yesterday. And at the bottom of the editor you can see the search bar. And of course I'm running it on Windows 7.

As you can tell from all the blog posts everyone here loves IDE Insight. And I briefly mentioned yesterday find units has changed to use IDE Insight. Find Units (CTRL + F12) and Find Forms (Shift + F12) are specialized versions of IDE Insight. Here's a screenshot of each of them to compare:

Embarcadero RAD Studio 2010

noreply@blogger.com (Chris Bensen) — Tue, 04 Aug 2009 17:00:00 +0000

Finally I can talk about Delphi 2010/C++Builder 2010/RAD Studio 2010! This should be a pretty awesome release with some cool stuff. For anyone that didn't attended my Delphi Live! talk, I've been working on something a bit different from COM and ActiveX this release, but that'll have to wait because first I want to talk about some of the IDE features we worked on.

For the official RAD Studio 2010 preview page click here where you can watch a video of David I getting the Delphi 2010 low down from Nick Hodges.

At the very end of the video you can see my office door.

I've talked about CTRL + F12 before here but this release it has gotten way better. In the video Nick showed off IDE Insight which is a totally awesome feature built by Mark Duncan using my search edit. Everyone one of us here use it every day. Features like this don't just spring out of nowhere. It went through various incarnations and refinements. Features like this are always fun because they build from collaboration of a few different features getting smashed together. One of the earliest versions of Find Units was embedded in the Project Manager.

The search edit is the same search edit seen throughout the IDE but with a few more bells and whistles because this one supports pattern matching with '*' and '?'. And it's fast! Which is why we didn't want to support regular expressions. All information gathered and searched is gathered on the fly, not indexed which is why a fast pattern search is needed.

The Gallery also has been augmented with a search feature. And as an extra productivity enhancement, all gallery items show up but the ones that used to be invisible are grayed out. This should really help those customers migrating from Delphi 7 where all COM wizards were visible but you had to know the order to create them. Now, you can run any wizard that is enabled and there won't be any question of where the COM wizards went.

Another place the search edit shows up is in the C++ class browser built by Bruneau Babet. Did I mention the search is fast? Well in a fraction of a second you can search with wild cards through all symbols in your C++ projects.

One last feature before I wrap this up. The Object Inspector got a small update from our newest VCL memeber Thom Gerdes. Boolean values now have check boxes. It might seem silly but it's really hard to use an older version of Delphi after getting used to the check boxes. We've also enhanced some of the property editors such as TDateTimePicker.Date.

June Photo of the Month

noreply@blogger.com (Chris Bensen) — Fri, 05 Jun 2009 04:46:00 +0000

This photo was taken at Año Nuevo State Reserver. Wikipedia also has a good bit of information on Año Nuevo. This is one of the most amazing parks to visit. These little pups just roll all over one another.

California with it's sizable budget problem is entertaining the possibility of closing over 80% of the parks, including Año Nuevo State Reserver and every beach and park in and around Santa Cruz. Most of the photos you see on my website are taken at these parks and every year I buy a State Parks pass to support the parks. Who knows what will actually happen. Only time will tell, but needless to say I really hope they find another solution since overall the closure will do more harm than good. You can read up on the potential closing here.

In other news, the National Parks will be free to visit three weekends this summer. Check out
Fee-Free Weekends In Your National Parks.

Touch

noreply@blogger.com (Chris Bensen) — Sat, 16 May 2009 04:35:00 +0000

At 5pm today I presented my talk on Touch at Delphi Live!. This is all raw, straight from the labs, by the Delphi frameworks team, which I'm part of now. Everyone seemed excited. The energy level was pegged on excitement. After all, this is some cool stuff. I'd like to thank everyone for attending the session and for packing the room. Standing room only it hot! Temperature wise that is.

So check back for more low down on Touch.

Peace out Delphi Live!.