Just code - Tamir Khason : Vista, WPF

New year – new blog or how to migrate Community Server to any other engine, supports XML-RPC

Tamir Khason — Fri, 02 Jan 2009 02:33:04 GMT

Please update your bookmarks, because the new url of this blog is http://khason.net/ (you have not update RSS feeds, it will be done automatically). Why I did it? Why I decided to go to “stand-alone”… Well. there are some reasons. Generally, I do not want to explain all those here, but trust me, there are some. The main reason is, that there is no responsible person in charge for this blog platform in Microsoft Israel. This why, if your blog is popular and you have a respect to your blog visitors, you cannot host it here… Take a look into new comments notifications in my inbox. Would you answer your readers with such “small amount” of SPAM and capcha, that cannot be fixed already for three years in this platform? This how my inbox looks like for last three years. So now, you should not ask me, why I not answered your email or comments. Aren’t you? :)

Currently, all comments in this blog are disabled, so if you want to comment, please use new url of posts (this will appear shortly in the beginning of each post). Also, this post will not be syndicated in RSS.

So, this post is the last. I loved this platform, and loved people started it. But, unfortunately, it seemed, that bloggers community is not important enough for new platform managers.

Also, If you want to learn how to use C# and XML-RCP to migrate from CS2007, used in this platform, visit my new home :)

Have a great year and, as always, be good people. This post marked with all possible tags automatically. Sorry.

Read and use FM radio (or any other USB HID device) from C#

Tamir Khason — Wed, 31 Dec 2008 01:42:18 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/read-and-use-fm-radio-or-any-other-usb-hid-device-from-c/]

Last time we spoke about reading and decoding RDS information from FM receivers. Also we already know how to stream sound from DirectSound compatible devices. However, before we can do it, we should be able to “speak” with such devices. So, today we’ll spoke about detection and reading information from Radio USB adapters (actually from any Human Input Devices). Let’s start.

First, if you want to do it, go and buy such device. The are not a lot of alternatives, but if you’ll seek, you’ll find it very quickly.

So, let’s start. First of all, we’ll use platform invoke to get and set the information. Also, we have to preserve handle of the device from being collected by GC. After we’ll finish using the device, we’ll have to dispose it. Thus it makes sense to inherit from SafeHandle and IDisposable.

[SecurityPermission(SecurityAction.InheritanceDemand, UnmanagedCode = true)]
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
public class USBDevice : SafeHandleZeroOrMinusOneIsInvalid, IDisposable {

Next, we’ll set a number of arguments, that will be in use during the device lifetime.

public uint ProductID { get; private set; }
public uint VendorID { get; private set; }
public uint VersionNumber { get; private set; }
public string Name { get; private set; }
public string SerialNumber { get; private set; }
public override bool IsInvalid { get { return !isValid; } }

internal ushort FeatureReportLength { get; private set; }
internal ushort[] Registers { get; set; }

Now, we have to find it. The best way of detection human input devices is by product and vendor IDs. Those values are always unique for certain device type.

[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
internal USBDevice(uint pid, uint vid) : base(true) { findDevice(pid, vid); }

Next step is to find a device. To do this, we have to provide extern interfaces to methods of hid.dll and setupapi.dll. Here all methods we will use in our class

[SuppressUnmanagedCodeSecurity()]
internal static class Native {
   #region methods
   [DllImport("hid.dll", SetLastError = true)]
   internal static extern void HidD_GetHidGuid(
      ref Guid lpHidGuid);

   [DllImport("hid.dll", SetLastError = true)]
   internal static extern bool HidD_GetAttributes(
      IntPtr hDevice,
      out HIDD_ATTRIBUTES Attributes);

   [DllImport("hid.dll", SetLastError = true)]
   internal static extern bool HidD_GetPreparsedData(
      IntPtr hDevice,
      out IntPtr hData);

   [DllImport("hid.dll", SetLastError = true)]
   internal static extern bool HidD_FreePreparsedData(
      IntPtr hData);

   [DllImport("hid.dll", SetLastError = true)]
   internal static extern bool HidP_GetCaps(
      IntPtr hData,
      out HIDP_CAPS capabilities);

   [DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
   internal static extern bool HidD_GetFeature(
      IntPtr hDevice,
      IntPtr hReportBuffer,
      uint ReportBufferLength);

   [DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
   internal static extern bool HidD_SetFeature(
      IntPtr hDevice,
      IntPtr ReportBuffer,
      uint ReportBufferLength);

   [DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
   internal static extern bool HidD_GetProductString(
      IntPtr hDevice,
      IntPtr Buffer,
      uint BufferLength);

   [DllImport("hid.dll", SetLastError = true, CallingConvention = CallingConvention.StdCall)]
   internal static extern bool HidD_GetSerialNumberString(
      IntPtr hDevice,
      IntPtr Buffer,
      uint BufferLength);

   [DllImport("setupapi.dll", SetLastError = true)]
   internal static extern IntPtr SetupDiGetClassDevs(
      ref Guid ClassGuid,
      [MarshalAs(UnmanagedType.LPTStr)] string Enumerator,
      IntPtr hwndParent,
      UInt32 Flags);

   [DllImport("setupapi.dll", SetLastError = true)]
   internal static extern bool SetupDiEnumDeviceInterfaces(
      IntPtr DeviceInfoSet,
      int DeviceInfoData,
      ref Guid lpHidGuid,
      uint MemberIndex,
      ref SP_DEVICE_INTERFACE_DATA lpDeviceInterfaceData);

   [DllImport("setupapi.dll", SetLastError = true)]
   internal static extern bool SetupDiGetDeviceInterfaceDetail(
      IntPtr DeviceInfoSet,
      ref SP_DEVICE_INTERFACE_DATA lpDeviceInterfaceData,
      IntPtr hDeviceInterfaceDetailData,
      uint detailSize,
      out uint requiredSize,
      IntPtr hDeviceInfoData);

   [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
   [DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
   internal static extern IntPtr CreateFile(
         string lpFileName,
         uint dwDesiredAccess,
         uint dwShareMode,
         IntPtr SecurityAttributes,
         uint dwCreationDisposition,
         uint dwFlagsAndAttributes,
         IntPtr hTemplateFile);

   [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
   [DllImport("kernel32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall, SetLastError = true)]
   internal static extern bool CloseHandle(IntPtr hHandle);

Also, we will need a number of structures, such as device attributes and capabilities.

[StructLayout(LayoutKind.Sequential)]
internal struct SP_DEVICE_INTERFACE_DATA {
   public int cbSize;
   public Guid InterfaceClassGuid;
   public int Flags;
   public int Reserved;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
internal class PSP_DEVICE_INTERFACE_DETAIL_DATA {
   public int cbSize;
   [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 256)]
   public string DevicePath;
}

[StructLayout(LayoutKind.Sequential)]
internal struct HIDD_ATTRIBUTES {
   public int Size; // = sizeof (struct _HIDD_ATTRIBUTES) = 10
   public UInt16 VendorID;
   public UInt16 ProductID;
   public UInt16 VersionNumber;
}
[StructLayout(LayoutKind.Sequential)]
internal struct HIDP_CAPS {
   public UInt16 Usage;
   public UInt16 UsagePage;
   public UInt16 InputReportByteLength;
   public UInt16 OutputReportByteLength;
   public UInt16 FeatureReportByteLength;
   [MarshalAs(UnmanagedType.ByValArray, SizeConst = 17)]
   public UInt16[] Reserved;
   public UInt16 NumberLinkCollectionNodes;
   public UInt16 NumberInputButtonCaps;
   public UInt16 NumberInputValueCaps;
   public UInt16 NumberInputDataIndices;
   public UInt16 NumberOutputButtonCaps;
   public UInt16 NumberOutputValueCaps;
   public UInt16 NumberOutputDataIndices;
   public UInt16 NumberFeatureButtonCaps;
   public UInt16 NumberFeatureValueCaps;
   public UInt16 NumberFeatureDataIndices;
}

And a number of system constants

internal const uint DIGCF_PRESENT = 0x00000002;
internal const uint DIGCF_DEVICEINTERFACE = 0x00000010;
internal const uint GENERIC_READ = 0x80000000;
internal const uint GENERIC_WRITE = 0x40000000;
internal const uint FILE_SHARE_READ = 0x00000001;
internal const uint FILE_SHARE_WRITE = 0x00000002;
internal const int OPEN_EXISTING = 3;
internal const int FILE_FLAG_OVERLAPPED = 0x40000000;
internal const uint MAX_USB_DEVICES = 16;

Now, we are ready to start. So let’s find all devices and get its information

Native.HidD_GetHidGuid(ref _hidGuid);
hHidDeviceInfo = Native.SetupDiGetClassDevs(ref _hidGuid, null, IntPtr.Zero, Native.DIGCF_PRESENT | Native.DIGCF_DEVICEINTERFACE);

Now, if a handle we get is valid, we should search our specific device. For this purpose, we have to read device interface information and then get details info about this device.

if (hHidDeviceInfo.ToInt32() > -1) {
   uint i = 0;
   while (!isValid && i < Native.MAX_USB_DEVICES) {
      var hidDeviceInterfaceData = new Native.SP_DEVICE_INTERFACE_DATA();
      hidDeviceInterfaceData.cbSize = Marshal.SizeOf(hidDeviceInterfaceData);
      if (Native.SetupDiEnumDeviceInterfaces(hHidDeviceInfo, 0, ref _hidGuid, i, ref hidDeviceInterfaceData)) {

Once we have all this and information is valid, let’s detect its capabilities

bool detailResult;
uint length, required;
Native.SetupDiGetDeviceInterfaceDetail(hHidDeviceInfo, ref hidDeviceInterfaceData, IntPtr.Zero, 0, out length, IntPtr.Zero);
var hidDeviceInterfaceDetailData = new Native.PSP_DEVICE_INTERFACE_DETAIL_DATA();
hidDeviceInterfaceDetailData.cbSize = 5; //DWORD cbSize (size 4) + Char[0] (size 1) for 32bit only!
var hDeviceInterfaceDetailData = Marshal.AllocHGlobal(Marshal.SizeOf(hidDeviceInterfaceDetailData));
Marshal.StructureToPtr(hidDeviceInterfaceDetailData, hDeviceInterfaceDetailData, true);
detailResult = Native.SetupDiGetDeviceInterfaceDetail(hHidDeviceInfo, ref hidDeviceInterfaceData, hDeviceInterfaceDetailData, length, out required, IntPtr.Zero);
Marshal.PtrToStructure(hDeviceInterfaceDetailData, hidDeviceInterfaceDetailData);
if (detailResult) {

To do this, we have to create memory file first and then share device attributes by using this file.

base.handle = Native.CreateFile(hidDeviceInterfaceDetailData.DevicePath,
                        Native.GENERIC_READ |
                        Native.GENERIC_WRITE,
                        Native.FILE_SHARE_READ |
                        Native.FILE_SHARE_WRITE,
                        IntPtr.Zero,
                        Native.OPEN_EXISTING,
                        Native.FILE_FLAG_OVERLAPPED,
                        IntPtr.Zero);
                     if (base.handle.ToInt32() > -1) {
                        Native.HIDD_ATTRIBUTES hidDeviceAttributes;
                        if (Native.HidD_GetAttributes(base.handle, out hidDeviceAttributes)) {

All the rest is straight forward. Just compare info retrieved with one we already have. And, of cause, release all resources were used (remember, we’re in win32 api world!)

if ((hidDeviceAttributes.VendorID == vid) && (hidDeviceAttributes.ProductID == pid)) {
                              isValid = true;
                              ProductID = pid;
                              VendorID = vid;
                              VersionNumber = hidDeviceAttributes.VersionNumber;
                              IntPtr buffer = Marshal.AllocHGlobal(126);//max alloc for string;
                              if (Native.HidD_GetProductString(this.handle, buffer, 126)) Name = Marshal.PtrToStringAuto(buffer);
                              if (Native.HidD_GetSerialNumberString(this.handle, buffer, 126)) SerialNumber = Marshal.PtrToStringAuto(buffer);
                              Marshal.FreeHGlobal(buffer);
                              var capabilities = new Native.HIDP_CAPS();
                              IntPtr hPreparsedData;
                              if (Native.HidD_GetPreparsedData(this.handle, out hPreparsedData)) {
                                 if (Native.HidP_GetCaps(hPreparsedData, out capabilities)) FeatureReportLength = capabilities.FeatureReportByteLength;
                                 Native.HidD_FreePreparsedData(hPreparsedData);
                              }
                              break;
                           }
                        } else {
                           Native.CloseHandle(base.handle);
                        }
                     }
                  }
                  Marshal.FreeHGlobal(hDeviceInterfaceDetailData);
               }
               i++;

            }

Now we have a handle to our device and can manipulate it. Like this:

using (var device = USBRadioDevice.FindDevice(0x0000, 0x1111)) {
…
}

But we still have to provide methods for such usage. Here there are no very complicated code.

public static USBDevice FindDevice(uint pid, uint vid) {
   var device = new USBDevice(pid,vid);
   var fillRegisters = device.InitRegisters();
   if (!device.IsInvalid && fillRegisters) return device;
   else throw new ArgumentOutOfRangeException(string.Format("Human input device {0} was not found.", pid));
}

public override string ToString() {
   return string.Format("{0} (Product:{1:x}, Vendor:{2:x}, Version:{3:x}, S/N:{4})", Name, ProductID, VendorID, VersionNumber, SerialNumber);
}

[ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
protected override bool ReleaseHandle() {
   return Native.CloseHandle(base.handle);
}

#region IDisposable Members
public void Dispose() {
   Dispose(true);
   GC.SuppressFinalize(this);

}
[SecurityPermission(SecurityAction.Demand, UnmanagedCode = true)]
void IDisposable.Dispose() {
   if (base.handle != null && !base.IsInvalid) {
      // Free the handle
      base.Dispose();
   }
}

#endregion

We done. Have a nice day and be good people.

Programming for Windows 7

Tamir Khason — Sun, 09 Nov 2008 17:12:38 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/programming-for-windows-7/]

Well, Windows 7 is going to be released by the end of next year. This is great news, because it seemed, that Microsoft finally understand how to get the best of Windows Vista and make it to work not only on monster machines.

It even works on new brandy my wife's pinky machine. And if it works there and my wife is happy with it, this OS going to be very impressive.

But from the other hand, we, as developers should be ready today to developer Windows 7 ready application (by the way, Vista Battery Saver works for Windows 7 as well as for Windows Vista, in spite of the fact, that power management in Windows 7 was improved dramatically). So let's start!

First thing we need is to read big Windows 7 Developer Guide. This document will explain most of new features for developers to build applications right. What is includes?

Windows Driver Kit (WDK) 3.0

Basically, Windows 7 works with Vista drivers, however, hibernation, power management, networking, PREfast will work much better. You also will have new WMI access for reliability monitors and ACPI.

Management and deployment

By default Windows 7 uses PowerShell 2.0 and Windows Installer. For PowerShell it includes enhanced cmdlets to manage Active Directory, IIS, etc. For Windows Installer, you finally can build "chainers" by yourself (the same approach, used for latest deployment of Microsoft products such as Silverlight, Visual Studio 2008 SP1 etc.) Also, you can get advantage by using Windows Filtering Platform (Firewall) and User Account Control (UAC) from inside your application by using new APIs.

Performance

The most significant change in Windows 7 for end-user point of view is improved performance. Windows 7 kernel is much smaller, that kernel of Windows Vista. Also it uses specific patterns to decrease background activities on low power, based on system triggers. New user-mode and kernel-mode APIs are used by Windows Drivers Foundation much more efficiently. Also system services are much smarter. For example, DCIA starts only when you connect new hardware. After drivers were installed the service shuts down. The same approach used by domain join, GP changes, new IP fetching etc. Windows 7 knows to run and stop services, based on system events, which decreases average work load and enhances whole system performance.

Multi-touch gestures and Interia API and used interface in general

Yes, you can use this API for your applications. Finally we can have more, then just mouse. And it is not only about multiple mouse devices. We can use single finder panning, raw touch input data, internal multitouch ink recognition, which is also supports math. Also it uses build-in MathML export feature.

There are a lot of other enhancements, such as smart bars, windows' stacking, gadget desktop (it does not eat battery as external process anymore), system ribbon menu integration. etc

Graphics

Direct 11, new Direct2D, DirectWrite (we can turn text anti-aliasing for small fonts, hurrah!), improved WIC, DX/GDI interoperability on system level with automatic fallback for weak hardware (yes, you should not be worry about it anymore). Also new video and audio format support with human readable interfaces. Yes, no more DirectDraw hacks. We can use new high level interfaces such as MFPlay to manage playbacks, Source Reader for decoding, Sink Writer for transcoders and re-coding compressions.

Web and communication

WCF is inside, as well as distributed routing table for peer-to-peer operations. BranchCache - new technology to reduce WAN traffic and latency.

Also Windows 7 is compatible with OpenSearch (I told, that Microsoft does not know to build search engines). Sharepoint integration and environment sensors platform, that can be used either for desktop and web applications.

There are much more features, that makes Windows 7 to pretend to be very good operation system. If you want to learn more about all those Windows 7 new features, I highly advice you to download and read this document. It includes most of new features of new OS with explanations and screenshots to make your learn and understand what can your future application do with all those new features.

Have a nice day and be good people.

BTW, if you have PDC version of Windows 7 and want to unlock it for using of some cool features, introduced during keynotes, it worth to visit here and learn how to :)

Download Windows 7 Developer Guide and start programming.

What’s new in MSDN Downloads?

Tamir Khason — Tue, 20 May 2008 18:02:41 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/what%e2%80%99s-new-in-msdn-downloads/]

Just look how many new releases those days in MSDN Download web site.

Virtual PC 2007 SP1 – download and release notes
Scriptomatic 2.0 - download (uses PowerShell 1.0)
Windows PowerShell V2 CTP2 - download
Office Live Update 1.1 - download
.NET Framework 3.5 SP1 beta – download
Visual Studio 2008 SP1 beta - download
Microsoft Expression Blend 2.5 March 2008 Preview - download
Microsoft Office for MAC SP1 – download
Windows XP SP3 – download as ISO or as NEP + release notes
Symbols package for Microsoft XP Service Pack 3 – download
Outlook 2007/2003/2002 Add-in for Personal Folder Backup – download
XNA Game Studio 3.0 CTP – download

Too much – too cool. Turn your download managers on

Have a nice day

Using Vista Preview Handlers in WPF application

Tamir Khason — Fri, 18 Apr 2008 18:08:56 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/using-vista-preview-handlers-in-wpf-application/]

First of all what is Preview Handler? Preview Handler is COM object, that called when you want to display the preview of your item. Other words, Preview Handlers are lightweight, rich and read-only previews of file’s content in a reading pane. You can find preview handlers in Microsoft Outlook 2007, Windows Vista and, even sometimes in XP. Can we use preview handlers within your WPF application? Probably we can. Let’s see how we can do it.

Let’s create simple WPF window, that displays file list from left and preview of items in right side. We’ll use simple file list string collection as our datasource, bind it to Listbox Items and then bind selected item to some contentpresenter. I blogged about this approach earlier.

<Grid DataContext={StaticResource files}>
        <Grid.ColumnDefinitions>
            <ColumnDefinition Width=".2*"/>
            <ColumnDefinition Width=".8*"/>
        </Grid.ColumnDefinitions>
        <ListBox ItemsSource={Binding} IsSynchronizedWithCurrentItem="True" />
        <ContentPresenter Grid.Column=”1” Content={Binding Path=/}/>
        <GridSplitter Width="5"/>
    </Grid>

Our data source should be updated automatically within changes of file system. So, this is very good chance to use FileSystemWatcher object.

class ListManager:ThreadSafeObservableCollection<string>
    {
        string dir = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
        public ListManager()
        {
            FileSystemWatcher fsw = new FileSystemWatcher(dir);
            fsw.NotifyFilter = NotifyFilters.FileName | NotifyFilters.Size | NotifyFilters.LastWrite;
            fsw.Created += new FileSystemEventHandler(fsw_Created);
            fsw.Deleted += new FileSystemEventHandler(fsw_Deleted);

            fsw.EnableRaisingEvents = true;

            string[] files = Directory.GetFiles(dir);
            for (int i = 0; i < files.Length; i++)
            {
                base.Add(files[i]);
            }

        }

        void fsw_Deleted(object sender, FileSystemEventArgs e)
        {
            base.Remove(e.FullPath);
        }

        void fsw_Created(object sender, FileSystemEventArgs e)
        {
            base.Add(e.FullPath);
        }
    }

Now, after applying simple DataTemplate, we can see file list in the left pane of our application. It will be updated automatically upon files change in certain directory.

Next step is to understand how to use Preview Handlers within custom application. After all, preview handler is regular COM object, that implements following interfaces

[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("8895b1c6-b41f-4c1c-a562-0d564250836f")]
interface IPreviewHandler
{
    void SetWindow(IntPtr hwnd, ref RECT rect);
    void SetRect(ref RECT rect);
    void DoPreview();
    void Unload();
    void SetFocus();
    void QueryFocus(out IntPtr phwnd);
    [PreserveSig]
    uint TranslateAccelerator(ref MSG pmsg);
}

[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("b7d14566-0509-4cce-a71f-0a554233bd9b")]
interface IInitializeWithFile
{
    void Initialize([MarshalAs(UnmanagedType.LPWStr)] string pszFilePath, uint grfMode);
}

[ComImport]
[InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
[Guid("b824b49d-22ac-4161-ac8a-9916e8fa3f7f")]
interface IInitializeWithStream
{
    void Initialize(IStream pstream, uint grfMode);
}

In order to find and attach preview handler to specific file type, all we have to do is to look into HKEY_CLASSES_ROOT and find COM Guid of preview handler (8895b1c6-b41f-4c1c-a562-0d564250836f). The default value of this key will be the Guid of COM object, that actually can preview this type of files. Let’s do it

string CLSID = "8895b1c6-b41f-4c1c-a562-0d564250836f";
            Guid g = new Guid(CLSID);
            string[] exts = fileName.Split('.');
            string ext = exts[exts.Length - 1];
            using (RegistryKey hk = Registry.ClassesRoot.OpenSubKey(string.Format(@".{0}\ShellEx\{1:B}", ext, g)))
            {
                if (hk != null)
                {
                    g = new Guid(hk.GetValue("").ToString());

Now, we know, that this file can be previewed, thus let’s initialize appropriate COM instance for preview handler

Type a = Type.GetTypeFromCLSID(g, true);
object o = Activator.CreateInstance(a);

There are two kinds of initializations for preview handlers – file and stream based. Each one has it’s own interface. So, we can only check if the object created implements this interface to be able to initialize the handler

IInitializeWithFile fileInit = o as IInitializeWithFile;
IInitializeWithStream streamInit = o as IInitializeWithStream;

bool isInitialized = false;
if (fileInit != null)
{
   fileInit.Initialize(fileName, 0);
   isInitialized = true;
}
else if (streamInit != null)
{
    COMStream stream = new COMStream(File.Open(fileName, FileMode.Open));
     streamInit.Initialize((IStream)streamInit, 0);
     isInitialized = true;
}

After we initialized the handler we can set handle to the window we want the handler to sit in. Also we should provide bounds of region of the window to handler be placed in.

if (isInitialized)
                    {
                        pHandler = o as IPreviewHandler;
                        if (pHandler != null)
                        {
                            RECT r = new RECT(viewRect);
                            pHandler.SetWindow(handler, ref r);
                            pHandler.SetRect(ref r);

                            pHandler.DoPreview();
                        }
                    }

So far so good, but we’re in WPF. Thus ContentPresenter we’re using has no handle! That’s right, but the main WPF application window has. So, let’s first get the main application window handle, then create rectangle bounds of the region, occupied by ContentControl.

In order to do it, we’ll derive from ContentPresenter and will listen to ActualtHeight and ActualeWidth property of it. First get the window handler (it wont be changed during the application life cycle), then update layout of our WPF Preview Handler for region and bounds of the control.

class WPFPreviewHandler : ContentPresenter
    {
        IntPtr mainWindowHandle = IntPtr.Zero;
        Rect actualRect = new Rect();

        protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
        {
            if (e.Property == ContentControl.ActualHeightProperty | e.Property == ContentControl.ActualWidthProperty)
            {
                if (mainWindowHandle == IntPtr.Zero)
                {
                    HwndSource hwndSource = PresentationSource.FromVisual(App.Current.MainWindow) as HwndSource;
                    mainWindowHandle = hwndSource.Handle;
                }
                else
                {
                    Point p0 = this.TranslatePoint(new Point(),App.Current.MainWindow);
                    Point p1 = this.TranslatePoint(new Point(this.ActualWidth,this.ActualHeight),App.Current.MainWindow);
                    actualRect = new Rect(p0, p1);
                    mainWindowHandle.InvalidateAttachedPreview(actualRect);
                }
            }
…

public static void InvalidateAttachedPreview(this IntPtr handler, Rect viewRect)
        {
            if (pHandler != null)
            {
                RECT r = new RECT(viewRect);
                pHandler.SetRect(ref r);
            }
        }

Now, the only thing we have to do is to listen for ContentProperty change and attache the preview handlers for displayed file to the control

if (e.Property == ContentControl.ContentProperty)
            {
                mainWindowHandle.AttachPreview(e.NewValue.ToString(),actualRect);
            }

We done. Last thing to do is to implement IStream interface in our COMStream C# class in order to be able to load streaming content (for example for PDF previewer)

public sealed class COMStream : IStream, IDisposable
{
     Stream _stream;

     ~COMStream()
     {
         if (_stream != null)
         {
             _stream.Close();
             _stream.Dispose();
             _stream = null;
         }
     }

     private COMStream() { }

     public COMStream(Stream sourceStream)
     {
         _stream = sourceStream;
     }

     #region IStream Members

     public void Clone(out IStream ppstm)
     {
         throw new NotSupportedException();
     }

     public void Commit(int grfCommitFlags)
     {
         throw new NotSupportedException();
     }

     public void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten)
     {
         throw new NotSupportedException();
     }

     public void LockRegion(long libOffset, long cb, int dwLockType)
     {
         throw new NotSupportedException();
     }

     [SecurityCritical]
     public void Read(byte[] pv, int cb, IntPtr pcbRead)
     {
         int count = this._stream.Read(pv, 0, cb);
         if (pcbRead != IntPtr.Zero)
         {
             Marshal.WriteInt32(pcbRead, count);
         }
     }

     public void Revert()
     {
         throw new NotSupportedException();
     }

     [SecurityCritical]
     public void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition)
     {
         SeekOrigin origin = (SeekOrigin)dwOrigin;
         long pos = this._stream.Seek(dlibMove, origin);
         if (plibNewPosition != IntPtr.Zero)
         {
             Marshal.WriteInt64(plibNewPosition, pos);
         }
     }

     public void SetSize(long libNewSize)
     {
         this._stream.SetLength(libNewSize);
     }

     public void Stat(out System.Runtime.InteropServices.ComTypes.STATSTG pstatstg, int grfStatFlag)
     {
         pstatstg = new System.Runtime.InteropServices.ComTypes.STATSTG();
         pstatstg.type = 2;
         pstatstg.cbSize = this._stream.Length;
         pstatstg.grfMode = 0;
         if (this._stream.CanRead && this._stream.CanWrite)
         {
             pstatstg.grfMode |= 2;
         }
         else if (this._stream.CanWrite && !_stream.CanRead)
         {
             pstatstg.grfMode |= 1;
         }
         else
         {
             throw new IOException();
         }

     }

     public void UnlockRegion(long libOffset, long cb, int dwLockType)
     {
         throw new NotSupportedException();
     }

     [SecurityCritical]
     public void Write(byte[] pv, int cb, IntPtr pcbWritten)
     {
         this._stream.Write(pv, 0, cb);
         if (pcbWritten != IntPtr.Zero)
         {
             Marshal.WriteInt32(pcbWritten, cb);
         }
     }

     #endregion

     #region IDisposable Members

     public void Dispose()
     {
         if (this._stream != null)
         {
             this._stream.Close();
             this._stream.Dispose();
             this._stream = null;
         }
     }

     #endregion
}

And now we finished. We can use unmanaged preview handlers to display content of our files, hold by WPF application. Also, if you want, you can create your own preview handlers and they’ll appear in your WPF application as well as they’ll magically appear in Outlook. Following full source code for this article

PreviewHandlerWPF.zip [27.5 Kb]

Good day, Happy Passover and, as always, be good people.

Some new post-mix downloads

Tamir Khason — Tue, 11 Mar 2008 14:01:44 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/some-new-post-mix-downloads/]

Today is download day at MSDN. There are some very interesting things published.

New release of Windows SDK (new classes for WPF 3.5, bugs fixes, and enhanced support for Windows Server 2008, including speech, error reporting and UAC). Download it here. For more information, visit SDK blog
Windows XP SP3 RC2 (it's not final release), but if you want to try it (not in production environment) download it here. As well as if you are ready to harm your system. Give a try to Windows Internet Explorer 8 Beta 1 for XP (or for Vista/Home Server 2008, or Windows Server 2003 SP2).
There are some fixes for Microsoft XNA Game Studio 2.0 (make sure, that you know what is it. If not, come to see my TechEd session). Also, you can download Games for Windows - LIVE redistributable .
If you are lucky Zune owner, you can download PC software 2.3 for it
If you Virtual Earth fun, add realistic 3D capabilities to use online Live Search Maps.
If you still have no Silverlight Tools for VS2008, be sure to download it (this is not chained installer, tools only)

Enough for this morning. Warm up your download machines and start downloading.

A couple of updates - mega update post

Tamir Khason — Fri, 07 Dec 2007 15:37:55 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/a-couple-of-updates-mega-update-post/]

Today, only updates

Yahoo finally releases Yahoo! Messenger for Vista - this was one of very first prototypes, shown in Mix last year. I did not install it, however, here a couple of review Erik Burke, Tim Sneath and Ryan Stewart. As for me, they lost "wow effect" last year

Microsoft Expression Blend 2 - December Preview. What's new? VS2008 integration, inheritance, no SL2.0 support (strange, maybe, because of breaking changes toward near beta)

Vista SP1 RC1 available for MSDN subscribers (via Nick Whites). Nothing special, 40 minutes of installation, profile information loss and performance fixes

Office 2007 SP1 is expected to ship 10-December week. This time it is not RC or Beta, but final product (via Mary Jo Foley). Great work.

Windows XP SP3 is very close to RC1, but nothing about public beta yet.

Starting today, you can configure Messenger presence. Some cool features become available (via Angus Logan). Here is how.

PDC 2008 (canceled last year) will be on October 27-30 in LA (hello, Peter). It promised to be great event about the company's emerging services platform efforts, .NET, Windows and Mobile technologies.

A little about mobile devices, while waiting for my new mega-device (more information soon): Dell is about to enter mobile phone industry in 2008, Opera compiled their browser for Brew platform (hello, Pelephone), while Google create their mobile version for IPhone. Windows Mobile 6.1 is going to be cool. Here screenshorts. Meanwhile, you can update your Mobile Office to version 6.1 for free or your Nokia (N-series) with Internet Radio application. As for me, 8 hours speak time and 30 days standby, quad-band. Those are features, that you need from your handy.

Well, that's it for now. Have a nice weekend.

Now I have a question for you. What do you think, about such format of posts? Should ?I go on with it or continue to write post-per-event?

Thank you

Seek and hide x64 or where my Sound Recoder?

Tamir Khason — Tue, 04 Dec 2007 16:07:01 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/seek-and-hide-x64-or-where-my-sound-recoder/]

Everyone knows a useful Windows utilities, SoundRecorder.exe application. I believe, that most of you knows where this application in your disk. If not, it's always possible to look into shortcut.

So, let's go to %SystemRoot%\system32 and look for the application

So far so good. Now, let's look for this file by using File.Exist method of C#

File.Exists(@"%SystemRoot%\system32\SoundRecorder.exe");

It returns true. Of course, the file SoundRecorder.exe is there. As well as all other "smart" methods for seeking for system directories

File.Exists(Environment.SystemDirectory + @"\SoundRecorder.exe");
File.Exists(Environment.GetFolderPath(Environment.SpecialFolder.System) + @"\SoundRecorder.exe");

All those are true. Now let's compile the file not for "Any CPU", but for x64. It still works! Why now, it is there. Now, let's try to compile for x86 or, just run our process from other 32 bit process (emulation!). You'll get false. Sound Recorder just disappears in x86...

Actually, the problem is x64 file system and registry redirection. Actually, the file exists, but not in C:\Windows\System32. It is in C:\Windows\Sysnative directory, which actually not exists. According MSDN, it should be transparent for your applications. Actually, it's transparent for those applications, which works not in WOW64 mode.

In order to make it work, you should expand the actual location, by using

File.Exists(Environment.ExpandEnvironmentVariables(@"%systemroot%\Sysnative") + @"\SoundRecorder.exe");

Now, the file exists, but not in x64 mode. What to do? Check both locations? Probably yes (don't forget to check the target platform). You can either disable registry redirection, by using native method.

[DllImport("advapi32.dll", SetLastError = true)]
static extern int RegDisableReflectionKey(IntPtr hBase);

One thing is for sure. We should learn more about x64 applications. Maybe in this case, our programs begin to work much faster, by utilizing double power of x64 processors.

For your convenience, here the list of system programs, that can "fool you" in x64 platforms (Vista):

alg.exe
bcdedit.exe
BitLockerWizard.exe
bridgeunattend.exe
change.exe
chglogon.exe
chgport.exe
chgusr.exe
cofire.exe
CompMgmtLauncher.exe
consent.exe
csrss.exe
Defrag.exe
DeviceEject.exe
DFDWiz.exe
dfsr.exe
dispdiag.exe
dpinst.exe
dwm.exe
fsquirt.exe
fvenotify.exe
FXSCOVER.exe
FXSSVC.exe
FXSUNATD.exe
irftp.exe
Locator.exe
logoff.exe
lpksetup.exe
lpremove.exe
lsass.exe
mblctr.exe
MdRes.exe
MdSched.exe
mrt.exe
msconfig.exe
msdtc.exe
msg.exe
Narrator.exe
netcfg.exe
NetProj.exe
ntoskrnl.exe
nvcolor.exe
nvcplui.exe
nvudisp.exe
nvuninst.exe
p2phost.exe
PkgMgr.exe
plasrv.exe
PnPUnattend.exe
PnPutil.exe
poqexec.exe
PresentationSettings.exe
PrintBrmUi.exe
printfilterpipelinesvc.exe
PushPrinterConnections.exe
qappsrv.exe
qprocess.exe
query.exe
quser.exe
qwinsta.exe
rdpclip.exe
RelPost.exe
reset.exe
rstrui.exe
rwinsta.exe
sdclt.exe
setupcl.exe
shadow.exe
sigverif.exe
SLLUA.exe
SLsvc.exe
SLUI.exe
smss.exe
SnippingTool.exe
snmptrap.exe
SoundRecorder.exe
spoolsv.exe
srdelayed.exe
StikyNot.exe
tabcal.exe
tscon.exe
tsdiscon.exe
tskill.exe
ucsvc.exe
UI0Detect.exe
vds.exe
VSJitDebugger.exe
VSSVC.exe
wbadmin.exe
wbengine.exe
wercon.exe
WFS.exe
wiawow64.exe
winload.exe
winresume.exe
WinSAT.exe
wisptis.exe
wpcumi.exe
wpnpinst.exe
wsqmcons.exe
wuauclt.exe
WUDFHost.exe

Have a nice day

DEV411 - WPF for developers: optimizing your WPF application

Tamir Khason — Mon, 26 Nov 2007 14:04:00 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/dev411-wpf-for-developers-optimizing-your-wpf-application/]

Less, then 24 hours until Developer Academy 2 a lot of pressure and stress. Last fixes to my presentation - it's too long now. A lot of stuff, I want to speak about, a lot of demos (mostly very bad performing applications, I'm dealing with), three computers (one is really cool with 8.9 Vista score) and, of cause, a lot of code to write. But I have only 75 minutes to do it all. So, I have to think a lot about how to do it all together with such tight timeframe (do you remember? - 9:30)

What I'll speak about? I'll speak about cool luxury cars, really.

First of all, the most common problem, WPF developers faced with - performance. No, WPF scales it, but you should know how to do it smart way.
Next, practices. Yes, there are practices and it's worth to learn wisdom by the follies of others. So, I'll speak about those follies.
Why sometimes, pixel is matter, and sometimes it is not?
What two threads, you are working with? Are there really two? Where the application problems are lying?
What is tier? How to measure it? How to know when I'm working with GPU and when with CPU? How to influence it?
How much memory (either computer and graphic card) I need?
What's the greatest evil of your WPF application (that is not your customer)?
How to scale very large bitmaps or very large amount of controls?
How to easily make data virtualization by your own hands?
How to create your own UI threads? Yes - you can do it!
How to make your ListBox x70 times smaller and faster, your data x20 smaller and x700 faster
How manage layout and measurement engines
How to do things in background without paying application fees
How to manage dispatchers
How to use visual and data performance measurement tools and how to analyze and profile unmanaged resources
How to make your application starts x400 faster and load resources on demand
How to load XAML without loading System.Xml.dll and using DOM or SAX
How to run the same WPF application on P3 with 128MB RAM and internal graphic card and Core Duo 2 with 4GB RAM and GeForce 880 GTX and get the same behavior of fast running application
...and much much more...

Waiting for you tomorrow at 9:30 AM (this is almost night, kind of morning) at Arbel hall of Avenue at Airport City near Ben Gurion airport. Come an hour before.

How to use Windows Vista Search API from WPF application?

Tamir Khason — Tue, 07 Aug 2007 22:05:00 GMT

[This blog was migrated. You will not be able to comment here.
The new URL of this post is http://khason.net/blog/how-to-use-windows-vista-search-api-from-wpf-application/]

Another great service, provided by Windows Vista is it's integrated search. Can we use it from our WPF application? Sure we can. This how you'll do it.

First of all you'll need to find Windows Search API library inside Windows SDK. Locate SearchAPI.tlb and process it with tlbimp tool to create managed assembly to reference to. You'll get file, named SeachAPILib.dll. This one, you need. In order to use it, refer to MSDN documentation of Windows Search API 3.0. Actually, using of search API is not much different then using database queries. However, this is not so trivial in core. Actually, the syntax of Windows Search (AQS - Advanced Query Syntax) is very different. But search team create brilliant work to make our life easier. CSearchManager and ISeachQueryHelper - those translate AQS to SQL and, even provide us with proper connection string.

Let's start. First of all, we'll have to create CSeachManager

    
CSearchManager cManager = new CSearchManagerClass();

Then, while you are in query, you'll create new ISearchQueryHelper to help you with translations and query strings

    
ISearchQueryHelper cHelper = cManager.GetCatalog("SYSTEMINDEX").GetQueryHelper();
      
cHelper.QuerySelectColumns = "\"System.ItemNameDisplay\"";

Well done, now. Ask Vista with old good OleDB provider

    
using (cConnection = new OleDbConnection(

cHelper.ConnectionString))
{
cConnection.Open();
using (OleDbCommand cmd = new OleDbCommand(
cHelper.GenerateSQLFromUserQuery(
SearchString
),
cConnection))
{
if (cConnection.State == ConnectionState.Open)
{
using (OleDbDataReader reader = cmd.ExecuteReader())
{
m_results.Clear();

while (!reader.IsClosed && reader.Read())
{
m_results.Add(reader[0].ToString());
}
reader.Close();

}
}

}
cConnection.Close();
}

Brilliant. Let's move it into WPF by creating DependencyObject, that provide us with all we need for search - search string and array of results

    
 public static readonly DependencyProperty SearchTextProperty = DependencyProperty.Register("SearchText", typeof(string), typeof(VistaSearchProviderHelper), new UIPropertyMetadata(default(string),
      
 new PropertyChangedCallback(OnSearchTextChanged)));
      


      
 static void OnSearchTextChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
      
 {

      
 //change
      
 ToAbortFlag = IsWorkingFlag;
      


      
 if (workerCallback == null)
      
 workerCallback = new WaitCallback(doSearch);
      


      
 searchObjState.SearchString = e.NewValue.ToString();

      
 //if (searchObjState.SearchString.Length > 2)
      
 {
      
 workerCallback.BeginInvoke(searchObjState, null, null);
      
 }

      


      
 }

    
public string SearchText
      
 {

      
 get { return GetValue(SearchTextProperty).ToString(); }
      
 set { SetValue(SearchTextProperty, value); }
      
 }

      


      
 static ThreadSafeObservableCollection<string> m_results;
      
 public ReadOnlyObservableCollection<string> Results
      
 {

      
 get { return new ReadOnlyObservableCollection<string>(m_results); }
      
 }

I think you know where to get thread safe observable collection :)

The only thing we should do now is to bind input and output to XAML presentation

    
 <StackPanel FocusManager.FocusedElement="{Binding ElementName=searchStr}">
      
 <StackPanel.DataContext>
      
 <ObjectDataProvider ObjectType="l:VistaSearchProviderHelper"/>
      
 </StackPanel.DataContext>
      
 <TextBox Name="searchStr" Text="{Binding Path=SearchText, UpdateSourceTrigger=PropertyChanged }" FontSize="30"/>
      
 <ListBox ItemsSource="{Binding Path=Results}" />
      
 </StackPanel>

We done. Now we can search our Windows Vista from custom WPF application. This is not final application for sure, there is a long way to go to make it work perfectly, but this is the beginning of how to do it.

Source code for this article

WPF controls library, WPF bloggers give away, Silverlight as Forms examples, Virtualization, Hardware Assessment 2.0 for Windows Vista and WPC

Tamir Khason — Wed, 11 Jul 2007 01:04:18 GMT

[This blog was migrated. You will not be able to comment here. The new URL of this post is http://khason.net/blog/wpf-controls-library-wpf-bloggers-give-away-silverlight-as-forms-examples-virtualization-hardware-assessment-20-for-windows-vista-and-wpc/ ] Mike Swanson keeps up-to-day his list of WPF Tools and Controls . Absolutely useful page. Charles Petzold, the author of great WPF books , asks WPF bloggers to send him their blog and postal address, 'cos he think, that those, who write about...(read more)

Visual Studio "Orcas" June 2007 CTP is available

Tamir Khason — Fri, 06 Jul 2007 16:56:35 GMT

[This blog was migrated. You will not be able to comment here. The new URL of this post is http://khason.net/blog/visual-studio-orcas-june-2007-ctp-is-available/ ] After a limited beta Visual Studio 2008 ("Orcas") June CTP VPC is available to wide public. A lot of bugs fixed (thank you all those who tested it), some new features added. Nice work! Download VS2008 June 2007 CTP VPC Technorati Tags: orcas , visual Studio.beta , VSTS , download , CTP , .NET framework 3.5 , WPF , WCF , WF...(read more)

"Acropolis" July CTP available now

Tamir Khason — Thu, 05 Jul 2007 13:31:55 GMT

[This blog was migrated. You will not be able to comment here. The new URL of this post is http://khason.net/blog/acropolis-july-ctp-available-now/ ] July is the best CTP time ever (a lot of sun in Redmond) Katy Kam from Acropolis team announced that Acropolis July CTP is release and can be downloaded here New features: Transition Animation improvements - you can now add transitions when changing page in TabLayoutPanes Better design time support - you can now use Application designer to select themes...(read more)

Orcas June CTP for limited beta is available

Tamir Khason — Wed, 04 Jul 2007 19:33:37 GMT

[This blog was migrated. You will not be able to comment here. The new URL of this post is http://khason.net/blog/orcas-june-ctp-for-limited-beta-is-available/ ] After releasing June CTP of .NET framework 3.5, June CTP bits of Visual Studio 2008 (Team Suite and Visual Web Developer) are also ready for limited beta as Layout or VPC image. If you want to test it, please let me know via comments or by contacting me directly. Technorati Tags: Orcas , Visual Studio , VSTS , beta , download , CTP , .NET...(read more)

Roxio central in WPF

Tamir Khason — Fri, 23 Feb 2007 16:48:05 GMT

[This blog was migrated. You will not be able to comment here. The new URL of this post is http://khason.net/blog/roxio-central-in-wpf/ ] More and more companies move their products to WPF. Actually, why now? Great technology, which able us to create outstanding UI with no time. FX-effects, geek-oriented user experience. New version of CD/DVD burning software from Roxio proofs my claims. Look yourself to free Roxio Central (beta) , build completely with WPF. Great work....(read more)