MicrosoftDwayneNeed Forum Rss Feed

New Post: RootElement Measure and Arrange

DwayneNeed — Tue, 29 Sep 2009 17:12:04 GMT

Layout across the threads is difficult, because the threads are independent. So, for example, the controls on the worker thread could decide to change size (their content got larger, or the string got longer, or something). You could asynchronously pass that to the UI thread to use as the HostVisual's size. But if layout on the UI thread further constrains the layout size, then you would have to asynchronously pass the constraint back to the worker thread... who would re-run layout and might end up with a different size again...

The simplest technique is probably more static. Decide on a fixed size for the worker thread's content and use that when measuring the root.

I'm not aware of any issues with shader effects... Can you post a repro?

New Post: RootElement Measure and Arrange

timbot — Tue, 29 Sep 2009 16:17:35 GMT

i'm trying to get a control to run on a second thread. but i'm having a few issues. the first is that i'm not sure how to get the available size to pass into the measure call that's in the RootVisual property of the VisualTargetPresentationSource class. maybe it's a problem in my actual control...

another issue i'm having is with is when i have an animation using HLSL effects it doesn't want to play with me at all B(

New Post: Input events

DwayneNeed — Wed, 28 Jan 2009 07:20:56 GMT

Unfortunately not. Win32 handles reporting the WM_MOUSEMOVE (etc) messages to the top-level window. Win32 does allow a child window to run on a separate thread, but the HostVisual/VisualTarget is not an HWND, so Win32 delivers the messages to the top-level window. WPF does not route events across the HostVisual/VisualTarget boundary.

New Post: Input events

DenisVuyka — Tue, 27 Jan 2009 12:41:45 GMT

Is there any change to implement mouse events triggering within VisualWrapper?

Thanks

New Post: DownloadCompleted do not refresh Image control?

dummyboy — Wed, 15 Oct 2008 21:59:17 GMT

In fact, what surprised me is the fact that the IsDownloading property is never read.

Here's what sounds logical to me :

On the first time an Image control needs to be rendered, the first thing the rendering thread should do is to check if the data is available by reading the IsDownloading property. If the data is not available (ie, IsDownloading is True), the DownloadComplete should then be monitored. When the event is fired, the data should be read, and only from this time the bitmap should become "static", so the next DownloadComplete events are ignored.

In other words, the object model allows to build custom asynchronous bitmap source (which may become static when fully downloaded), but it seems that there's some tweaks in WPF to only allow the BitmapImage class to work this way...

New Post: DownloadCompleted do not refresh Image control?

DwayneNeed — Wed, 15 Oct 2008 19:20:35 GMT

Yes, you are encountering the core issue. WPF bitmaps are designed primarily for static bitmaps (simple PNG, JPG, etc). A bitmap is represented as a "resource" and is marshalled to the rendering thread. Once this is done, WPF generally does not refresh the contents again since they are resumed to be static. There are a couple of exceptions, including the WriteableBitmap class. Of course, when you start downloading the bitmap contents on a seperate thread, even "static" bitmaps become effectively "dynamic". There are a few bugs in WPF that break the scenario where the bitmap download completes after the bitmap has been marshalled to the render thread. The team is aware of the issue, and is working on a fix.

New Post: DownloadCompleted do not refresh Image control?

dummyboy — Tue, 07 Oct 2008 16:56:17 GMT

Hi,

First, thanks for your great article about custom bitmaps in WPF. I learned lots of things!

But I was surprised by the fact that the DownloadCompleted does not trig the refresh of an Image control. It sounds logical that this is the mechanism used by the BitmapImage class, when a remote image (URL) is used as the source. I mean, when assigning a BitmapImage to the Source property of an Image control, the IsDownloading is True and the size (in pixels) is 1x1. CopyPixels is then called with a very small buffer (4 bytes if bgr/bgra). As far as I know, the only way for the Image control to get notified that it should refresh itself is by listening to the DownloadCompleted event. So, I wondering why, if I raise myself the DownloadCompleted event in a custom class, the Image control is not refreshed?

Here's what I did: I created a new class, CMyBitmapSource, which derives from BitmapSource, and which only acts as a wrapper around a BitmapImage. All overridden stuff delegate to the wrapped object. So, when the "internal" DownloadCompleted occurs, the external "DownloadCompleted" is raised, which should cause the refresh of the listening Image control(s). But the event seems to be ignored when it is not directly raised by a BitmapImage class instance. I tested the event by registering a handler which output a debug line in the console, and this line appeared. Also, a breakpoint on the delegate object (multicast delagate) reveals that two delegates will be called (invocation count = 2).

Here's some observations:

1) As soon as the CMyBitmapSource instance is assigned to the Source property of an Image control, a new event handler is registered with the DownloadCompleted event. The target of the delegate is a System.WeakReference object, which itself targets the Image control.

2) The IsDownloading property is never called. So, I think this enforces the fact that the only way for an Image control to know it should refresh itself is by listening to the DownloadCompleted event.

3) The call order is:

    3a) A new handler is registered for the DownloadCompleted event, which targets the Image control.
    3b) CopyPixels is called with a small buffer (4 bytes).
    3c) DownloadCompleted is raised by the internal BitmapImage. The event is then re-raised to the listening clients.

At this point, isn't logical that CopyPixels should be recalled to get the downloaded data? I suspect this is what happens with the BitmapImage class, but this does not work with derived classes :o(

Here's the class I used. Maybe you will see something I missed?

The markup:

    <StackPanel>
        <Button x:Name="MyButton" Click="MyButton_Click">Click</Button>
        <Image x:Name="MyImage"></Image>
    </StackPanel>

The code-behind:

        private void MyButton_Click(object sender, RoutedEventArgs e)
        {
            BitmapImage i = new BitmapImage(new Uri("http://www.microsoft.com/presspass/presskits/windowsvista/images/icons/Security.jpg"));
            CMyBitmapSource b = new CMyBitmapSource(i);
            MyImage.Source = b;

b.DownloadCompleted += new EventHandler(b_DownloadCompleted);
}

        void b_DownloadCompleted(object sender, EventArgs e)
        {
            Console.WriteLine("Completed!");
        }

The class:

    class CMyBitmapSource : BitmapSource
    {
        BitmapSource m_bmp;
        EventHandler m_DownloadCompleted;

        public CMyBitmapSource() {
        }

        public CMyBitmapSource(BitmapSource pbsSource)
        {
            m_bmp = pbsSource;
            m_bmp.DownloadCompleted += new EventHandler(m_bmp_DownloadCompleted);
        }

        protected override Freezable CreateInstanceCore() {
            return new CMyBitmapSource();
        }

        void m_bmp_DownloadCompleted(object sender, EventArgs e)
        {
            if (m_DownloadCompleted != null)
                m_DownloadCompleted(sender, e);
        }

        public override void CopyPixels(Int32Rect sourceRect, Array pixels, int stride, int offset)
        {
            m_bmp.CopyPixels(sourceRect, pixels, stride, offset);
        }

        public override void CopyPixels(Array pixels, int stride, int offset)
        {
            m_bmp.CopyPixels(pixels, stride, offset);
        }

        public override void CopyPixels(Int32Rect sourceRect, IntPtr buffer, int bufferSize, int stride)
        {
            m_bmp.CopyPixels(sourceRect, buffer, bufferSize, stride);
        }

        public override event EventHandler DownloadCompleted
        {
            add
            {
                m_DownloadCompleted += value;
            }
            remove
            {
                m_DownloadCompleted -= value;
            }
        }
        public override event EventHandler<ExceptionEventArgs> DecodeFailed;
        public override event EventHandler<ExceptionEventArgs> DownloadFailed;
        public override event EventHandler<DownloadProgressEventArgs> DownloadProgress;

        public override double DpiX {
            get {
                return m_bmp.DpiX; }}

        public override double DpiY {
            get {
                return m_bmp.DpiY; }}

        public override PixelFormat Format {
            get {
                return m_bmp.Format; }}

        public override double Height {
            get {
                return m_bmp.Height; }}

        public override double Width {
            get {
                return m_bmp.Width; }}

        public override int PixelHeight {
            get {
                return m_bmp.PixelHeight; }}

        public override int PixelWidth {
            get {
                return m_bmp.PixelWidth; }}

        public override BitmapPalette Palette {
            get {
                return m_bmp.Palette; }}

        public override bool IsDownloading {
            get {
                return m_bmp.IsDownloading; }}
    }

Thanks for your help!