Lester's WPF blog

Since most LOB applications require such controls as Calendar, DateTimePicker, MaskedTextBox and Grid, you certainly need to add native WPF controls for those. I know that some of those are available as third party components, but how many organizations want to add so many third party dependencies to their projects (ie. Xceed datagrid, Kevin's Bag-O-Tricks datepicker, AvalonControlsLibrary TimePicker and MaskedTextBox)? Also, not sure about the grid, but most of the other controls are not exactly production grade. I'm believe many more organizations would consider using WPF if at least those basic controls would be included in the framework.

DataGrid, DataGrid, DataGrid!!!

Personally, I've been pushing for support of blend modes from the beginning.

http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=1001946

I'm totally agree with Basile. We need more built in controls.

Maybe a little bit more control over controls hierarchy is welcome (something like public methods to add and remove logical childs, not only protected internal).

More performance for 2D or 3D gimmicks and off curse controls like the normal WindowsForms controls.

allow us to set properties from other threads without needing to use Dispatcher.BeginInvoke

Very important, a must:

- Add missing controls for LOB applications, eg (Date / calendar controls, data grids, numeric box, masked edit, ...)

Good to have:

- Allow to skin (control template) the window header.

Split control template to make controls easier to skin.

- Add missing but often needed properties:

(like in the Expander: left to right button placement)

- Add more virtualizing panels out of the box. Just think of a photo album with thousands of photos. A StackPanel does not optimize the presentation.

- Window / Page Inheritance, I know it's probably better to have composability instead of inheritance but something like "Traits" are a good alternative.

- More gradient style (Linear and Radial are good but...)

How about having more hardware-accelerated effect, like the blur thingy?

1.) ability to create custom bitmap effects as pixel shaders

2.) gradient meshes

Can we get some examples from the WPF Team for control designers.  Specifically, which control designer attributes are honored by VS2008 and Blend.  

Which attributes to use with which property Type.

Thank you for asking!

Karl

I know it's been worked on, but the blurry text issue for size 14 fonts and below has to be resolved before any company will use it in LOB applications

DataGrid and visual studio style tabbed-mdi control

In addition to the controls already mentioned, I would really like to see the following:

- Charts/Graphs,

- Further remove dependence on Windows Forms (I would like to do system tray stuff with WPF),

- Extend the content model to the PasswordBox (maybe someone would like to use hearts instead of bullets for the masks :))

- Support for HTML or an easy way to strip HTML content from a string.  This is necessary for working with RSS feeds. Technically RSS shouldn't have HTML in it, but a lot of people do it.

Accelerate Animations with BitmapEffects.

Virtualizing listbox templated with WrapPanel

Better access to auto generated FrameworkElements.

1. Faster cold startup. It is really hard to make a customer accept that even the smallest LOB application will require > 10 seconds to start on an otherwise fast computer.

2. Access to a fast 32-bit array of pixels for doing graphical effects

There's lots of extensibility issues you should address.  Just an example, making the constructors for the RoutedCommand event arguments public would help a lot with being able to modify the commanding architecture.  There are lots of examples of this nature.

Make it easier to bind events/commands to handlers somewhere other than in the codebehind.  M-V-poo architectures are much more difficult to build when you can't declaratively bind events/commands to your "poo".  It's obviously possible to roll your own solutions here, but this is something that should be baked in, and with a clean syntax.

Allow lazy creation of collections from XAML.  If a property is a collection type and I provide a bunch of child items but there's no collection, instantiate it first rather than throwing an exception.  This is especially important for attached properties, where there's no way to instantiate the collection for the user.  The XAML becomes too bloated when we have to specify creation of the collection here.  In this same area, you should provide a means to declare read-only attached collection properties that still lazily create the collection.

Do "something" about the weird behavior of the PageFunction Return event.  The bizarre behavior of recreating the handler to the newly created page in order to not have to cache the page in the navigation history is just confusing.  Worse, the requirement this causes where you have to only add handlers from the calling page is awful.  At the very least, you'd better document that one better, but it would be preferable to remove this restriction entirely.

If there's a control in the OS, there'd better be an equivalent in WPF.  Even something as simple as a Vista task dialog, though it can be coded in WPF in under 30 seconds, is not something we should have to do.  More complicated controls, like a date picker, are actually beyond the ability of most developers to code correctly.  Problems with internationalization and accessibility will plague too many programs when these aren't provided by the framework.  Advanced controls, like a Ribbon, would be nice, but are of less importance, IMO.

Common dialogs had better allow us full capabilities.  The lack of Vista styled open/save dialogs with out resorting to WinForms, for instance, is just sad.

Add MDI capabilities.  This isn't too hard to do yourself, but it's something that should be provided by the framework.

Add more "standard" commands.  Things like About, Exit (Close causes confusion, especially if you've got an MDI window).

Provide some decent reference applications.  There's rumors that Wordpad, Calculator and Paint have been redone for Windows 7 in WPF.  Applications like those, provided as sample applications with source code in MSDN, would be invaluable to new WPF developers.  Simple but complete applications, coded as a production application should be, with source code provided.

Oh yeah:

3. Built-in Undo/Redo for commanding.

Last time I checked, I couldn't find a WPF TreeView control that supports multi-select... it'd be very nice to have one

WPF is way too complex, you seriously need to find a way to simplify it.

Also it would be good to have a better out-of-the-box experience when it comes to styles and templates. Face it, not every small shop will hire a designer to pull off a small LOB app. A simplified way to use simple styles as default plus some good choices for default margins might help.

More text antialiasing options (none/gray scale/different modes of cleartype).

Get rid of blurry text effect while scrolling/animating content.

VS designer property grid improvements (more property editors).

Enhance Expression Blend to make it ready for the industry (fully-functional code editor, IntelliSense in code/XAML, work with events without VS, classic white UI style (VS-like) without blurry text).

Let the Frame control render html from a string. The Frame control is based around the webbrowser control so it should be possible.

My company would love to adopt WPF for our statistical/scientific visualization application, but the retained-mode-only nature of WPF makes it impossible.  Retained mode is great for a snazzy UI with a few hundred objects.  We render arrays of graphs which together contain more than a million points/markers.  No retained-mode system can handle that - memory usage skyrockets.

If WPF is ever to deprecate GDI (and heaven knows it needs to), it must have immediate-mode support, somehow.  There are classes of applications that simply will never be brought to a retained-mode-only system.

Please save us from GDI by adding immediate-mode support to WPF.

Allow to set the readonly / disabled color from the style. I don't want to edit the control template to change colors.

There's a few good things here:

http://rrelyea.spaces.live.com/blog/cns!167AD7A5AB58D5FE!698.entry

And on my web site:

http://www.wiredprairie.us/journal/2006/10/wpf_lob_feedback.html

WishList (or do you really listen?)

Techninal Aspects:

Blurry Text:

That "Problem" must be solved! How can the "Next Generation Presentation Technologie" be a selling point for WPF, if not even text seems readable?

Transparancies and Animation:

Take a look at AIR and Flash!!! - i recently saw "them" animating native OS Windows as well as any kind of shaped Window (like WPF Transparent Windows)

that was universes ahead of the current WPF Performance! (Frusttrating to see that "strangers" seem to understand more about how to set this up than the creators of the operating system themselfs)

3D:

Overall Performance, Features and ease of use.

(Take a look at PaperVision3D! - Excellent performance, easy to use, and even shaders included)

Bitmap effects/ Filters:

Well, what to say - where are they and when will they be usable? (compare Bitmap Filter Effects in Flahs - once more universes ahead!)Yes, i have heard of  cumbersome workarounds like Blendables ElementSnapshot

When comes all the promised power of hardware acceleration into play?

Complexity (examples):

Drag n Drop:

I am totaly confused that a totally common pattern in todays applications like Drag n Drop requires still reading tons of blogs and MSDN articles (Have you tried to do drag n drop in listbox or Treeview).

Why is that not baked into the Framework as a matter or setting a couple of proberties?

Controls:

More or them out of the Box or at least more ideas best practices of how to develop them. (Thousand ways of doing things hard to find the red line.)

Spiritual Side:

Support and enthusiasm:

This sections is probably the most important for me and harder to implement/ reimplement than any of the others issues

A sad general observation is that most of the WPF people in MS who provided valuable information with their blogs in the beginning seem to have disappeared like "platform developed-job done". Left behind: still a thousand questions and noone to fill the knowledge gap.

Where have all the Chris Andersons, Fillipe Fortes, John Gossmans, Dan Creviers, Kevin Moores and many others gone - where is all the passion gone?

(to people who dont know what i am talking about check out tim sneaths wpf-blogger list and see the last blog entries about WPF in any of those)

Extra mention: Kevin Moore was to me the last WPF man standing - Big loss-no replacement seen yet)

You've been kicked (a good thing) - Trackback from DotNetKicks.com

a comparable construct in C# to match VB's With...End With statement so it's super easy to set WPF attributes in code rather than XAML markup. In case you're going to ask what's wrong with XAML: it can't easily be obfuscated; business UI's don't need to be designer skinnable therefore it's pointless for many scenarios; it's more to learn; it's not easy for designers to hand edit anyway (if they need Blend to edit it, might just as well be a binary format).

* Make xaml a first class citizen in VS:

 * Allow refactoring to include xaml code

 * Allow "find symbols" to include xaml code

 * improve navigation into xaml and away from xaml into code behind

* Improve XBAP platform:

 * Revisit security and remove restrictions where they are not warranted (e.g. XPS, printing, clipboard)

 * Fix navigation bugs

 * Allow more control over forward/back-stacks (e.g. allow me to remove items from backstack)

 * Allow me to stop the user from navigating away from XBAP (e.g. when the user forgot he/she was in the middle of editing data on one of my XBAP pages)

 * Support modal dialogs (or allow me to create my own)

* Allow us to control the look of Windows dialogs (open file, show message, print, etc.)

* Reporting engine

* Increase support for generics in xaml

* Improve Cider and Blend

1. Better support for linq to sql namely the ability for additions and deletions to child entity to reflect in the ui.

2. Make it easier to access controls inside of datatemplate to set properties on those controls in the code behind.

http://weblogs.asp.net/okloeten/archive/2007/12/22/5489157.aspx

1.)  Better multimedia support.  This means being able to render my own video (w/o MediaElement) with at least the same performance of MediaElement.  Maybe even chroma key support.

2.)  Better layered window performance.  938660 hotfix does improve the issue, but even on a $3,500 mac-daddy machine, it still doesn't come close to a regular window.

3.) Hardware accelerated bitmap effects or at least a framework for supplying our own shaders.

4.) If none of these, many of us can survive with tight integration with direct3d.  That meaning no air-space issues and being able to manipulate WPF resources via a D3D API.

5.)  Better software rendering performance.  I've seen SL 2.0 do some pretty hefty rendering at a pretty high FPS.  I'm sure WPF uses the DX software rendering path...but couldn't there be improvements?

6.) DWM integration (and milcore documentation) - VisualBrush for a top level window.

7.) Multicore support - Does this have a place in WPF rendering/layout?  You tell me.

8.) Cast shadows for 3d / volumentric lighting even?

9.) (This one is out of right field for sure) Be able to set a 3d light to project a texture onto a 3d surface.

Yup, thats about it.  I want d3d performance/power with an easy to use WPF API (cake and eat it too).  I need this all done by Friday too. Thanks!

-Jer

Anything you can do to simplify using converters in databinding would be much appreciated. It's messy!

For instance, why do you need to instance a converter?

Better multimedia integration. I would like to see DirectShow capture supported.

Allow us to use shaders.

Better Direct3D/XNA integration. Would be great not to have airspace issues with WPF/D3D/MDX.

Accelerate GFX if we have multicore. Two cores is becoming the norm, seems a pity to not use them to their fullest.

Since I see suggestions diverging from core WPF, I'll throw in another related suggestion:

Impove Expression Blend and Visual Studio.

I gave up on a WPF project last year because the XAML editors were too cumbersome, slow, and buggy.  Creating and working with a highly layed UI in Expression Blend was extremely tedious.  The IDE is too slow, and I quickly came to loath it.  Switching to Visual Studio was no better since it could even render the XAML or would mistake valid code for errors.

You should concentrate on making the design experience more easier and pleasant.  Don't let your IDEs become a barrier of entry to WPF.

One quick UX improvement which comes to mind is to provide a 2.5D view of the layers so that they are easier to work with...

1) Reiterating what others said on more new controls and more polished and functional existing controls

2) Enhanced triggers and setters, especially regarding source, target and property path specifications. Different types of triggers allowed in one context and not in another are confusing.

3) More extensions and built-in converters that don't force the developer to use code-behind for things that are trivial.

I would like a much better educational drive (not just US!). It takes forever to accomplish some basic templating just from a point of trying to figure out what to do and how the things work together.

I do think it is a powerful and exiting platform but if people don't know how to utilize it to its full potential it wont be as readily adopted!

And yes controls :)

Yup, all of the above !  :-)

But since I'm mostly using 3D in WPF I want S H A D E R support, or at least (as some other guys have suggested) a closer integration with Direct3D. Alternatively (maybe more in alignment with WPF's philosphy) you could offer more advanced materials by way of a fixed built-in set of (configurable) predefined shaders (e.g. glass, metal, plastic)

What's also hurting me big-time is the lack of a decent designer (please don't even mention cider). I've become accustomed to hand-coding XAML but I'm always glad to be able to get back to the winforms designer when working on the "LOB" screens of our CAD-oriented application.

Oh, I almost forgot to mention (real) support for drawing 3D lines ! (Yes, I know about the line stuff in 3DTools. It slows your system to a crawl when drawing a couple of thousand lines.)

Please add multi-select capability to the TreeView control.  This might not seem useful for the default style, but don't forget about restyling scenarios!  As a part of the core WPF library, I'm surprised it can't already do this.  Also please make it possible to programmatically select a TreeView's item(s).

- autocomplete with filtered list in combobox like old winforms combobox

- autocomplete in TextBox

- Office Ribbon

- MdiTabs like in Expression or visual studio

Repeating some above/past requests:

1.  Hardware/GPU-accelerated pixel shader/effects support, extensible so developers can add more, ship lots of built in effects

2.  Ability to turn off ClearType

3.  DWM integration (milcore documentation but hoping not)

4.  Better multimedia support, DirectShow capture support

5.  Charts/Graphs components

6.  Make Blend as powerful and featureful as the Flash Professional CS3 IDE and Flex Builder

7.  Rich common dialogs for Font and Color

8.  Improve text engine: smart quote support, hyperlinks, grammar, custom dictionary words, copying and pasting multiple selections, smart tags like Office, complete OpenType support esp extended language support/complex scripts

9.  Do some apps as well, actually making use of untapped APIs like the WPF text engine. How about WordPad.NET or Word.NET Express? Where are the mainstream desktop apps today? How about making an official MS WPF app gallery? Or does your team only ship the framework, no apps?

10. Beat Core Image and Core Animation in all aspects. Something like Quartz Composer to play for fun.

Improve performances :

- Some cool effects that are used in demos are not usable in real applications ( Bitmap effects etc. )

- Virtualizing in ListView *with* grouping : another cool feature that is not usable in real life application ( applications with more than 50 items in the list !! )

- GridViewRowPresenter with virtualization enabled ( add 50 columns in a listview and see what i mean )

- the defalut cell margin in GridViewRowPresenter should be "stylable"

- search wpf forums for performance issues and try to improve things

- xps generation should need less memory ( search for FlowDocument memory leaks ... )

Will it be possible to create graphical objects ( ex: Grid or Label ) and to use them in a backgroundworker as long as they are not displayed  ? ( and without the need to BeginInvoke !)

Improve tools : VS2008 wpf designer is slow and buggy. XAML editor is buggy and need the same functions than the code editor ( refactoring ... )

Conclusion : i don't need new controls ( i can make them myself quite quickly ) but i need a serious platform : fast even in real situations. When the same application need 10x memory in wpf than in winforms and is slower, it's hard to sell it to my customers.

Very simple one - we do a lot of interactive 3D and there's no easy way to get from a pick on a mesh back to anything in the modelled world. If we could have a Tag object on a GeometryModel3D (and everything else that a hit test sees) it would save us carrying a ton of dictionaries round. We also have a desperate need to be able to play media from a byte[] instead of a Uri - you wouldn't believe the hoops we have to jump through to deal with rights-managed media!

Another barrier to adopting WPF has been lack of a WPF/XAML clipboard format that is pastable into Office applications.  A WPF/XAML clipboard format was discussed at the 2003 PDC but not yet delivered on.

Thanks.

The ability to inherit xaml.  Want to be able to create a base page.xaml and then inherit it and have the base page populate the inheriting page in design time.  Much like winforms does.

The most critical need is attentiveness to https://connect.microsoft.com/feedback/default.aspx?SiteID=212, or some other place where we can submit bug reports and feature suggestions and see timely response.

For example: https://connect.microsoft.com/feedback/ViewFeedback.aspx?FeedbackID=296623&SiteID=212

Broadly, I think bug fixes and performance issues are the most important. We can work around missing controls, implement our own features, and hand-code our XAML, but some bugs have no workarounds, and there's only so much we can do to speed startup time and reduce memory usage.

- Editable text run

- Localization

- Localization

- Have I mentioned localization?

- Extensibility model for spell-checking

1)WindowsFormHost control to respect the WPF airspace!!!

The WindowsFormHost should not steal focus and insert itself as the topmost control on the screen.

2)The MediaElement/MediaPlayer needs to be able to play DVD's.  We also need lower level access to the dshow filter graph.  Perhaps some events like OnBuildingGraph that will allow us to override the default and build the graph ourselves.

I'll second the need to open up WPF programming from retained mode. Our engineering app cannot possibly represent all that we need to using retained-mode objects.  Our experiments have shown that the memory overhead and perf is just waay too poor to seriously consider WPF even though we'd love to use it for the h/w accel and richer capabilities.  Please open up milcore and document an immediate-mode API into WPF.  

Also, +1 on a clipboard format to pass rich contents (e.g. WPF-created drawings) between our app and others like Office.

Please provide better support for rendering streamed video. I will settle for the ability to set direct show filter properties and build and run the filter graph in a MediaElement or something similar. I got direct show filters but I can't use them in WPF at the moment!

- DirectShow. For video capture.

- VisualBrush from other Applications. Like DWM makes it in taskbar thumbnails or flip3d. With RenderTransform support.

- Hardware BitmapEffects

- Managed BitmapEffects

- public IInputProvider and related classes and methods (InputManager.RegisterInputProvider).

- Multi-Tier reference application samples.

1. Allow data templates to be selected via exposing an interface such as "IDataTemplateType" with a string GetTemplateName(), an attribute, or using the TypeDescriptor system.  Get rid of the hacky special case data template selection code for XmlDataSource and XLinq.

2. Fix the performance of the tree control when displaying large data sets.

3. Add a native data grid control.

4. Add multiple selections support to CollectionView to fully support the Model/View/ModelView system.

4.

A few more things..

5. Eliminate the airspace requirements for embedded non-wpf controls.

6. Provide better interop access to allow drawing to internal textures via OpenGl or DirectX.

7. Support the "Event" tags in XamlReader to better support dynamically loaded UI and dynamic languages such as IronPython.

DataGridViews! a DataGridView that surpasses all DataGridViews, especially when the backend is SQL Server 2008--drag and drop tables, master-detail relationships, table navigator bar (first record, next record, etc.), search, fixed columns, fast access, one-click alternation between different views (card, repeating rows, etc), RAD experience of MS Access, different customizations for large datasets and small. WPF is elegant and pretty, but DATA DATA DATA power is what businesses need.

Rather than asking for new things, I would like to thank the WPF team for what they gave us.... WPF, we love you

--but we'd love you even more if you had a datagrid.

One more thing....

- The ability to outline a TextBlock.

Thanks for listening!

While on the subject of text, how about adding kerning and tracking features to TextBlock (or create a specialized Text element with these features).

1) Better language support:

- more spell check dictionaries (Dutch would be my personal no. 1)

- custom spell check dictionaries: a) for adding words not yet in the built-in dictionary and b) for allowing the community to add languages you don't deem important; again Dutch would be an example.

- more control over hyphenation: a) re-cord and rec-ord are different things; let us specify which one we mean; b) also, sometimes hyphenation isn't regular at all; let us decide: Dutch autootje becomes au-to-tje, baby'tje becomes ba-by-tje.

2) More/Better built-in controls / dialogs

- All common Vista controls should be present, for example Date/Time picker, month calendar, masked text box, IP address input, up-down/spinners, command links, splitter buttons, etc.

- All common dialogs should be accessible; no more WinForms please. The font selection should be most obvious, as WinForms doesn't list OpenType fonts, even though they are supported by WPF (they're just not supported by the horror that's known as GDI+). Also, the forms should be the Vista dialogs, not the pre-Vista dialogs.

- Support for Aero Glass.

- Support for balloon tips and notification area icons without WinForms.

- Toolbars with a) true drag&drop (i.e., tearing off a tool bar from the window to allow it to float as a separate window, b) built-in customization support (like VS & Office < 2007)

- Vista task dialog and wizard support.

3) Better support for bitmaps

- Better support for bitmap rendering; most bitmaps are blurry in WPF; there should be a setting analogous to SnapToDevicePixels for bitmaps.

- Support for .ico: a) WPF should choose the right icon based on the size of the <Image>; .ico files contain multiple resolutions--use them! b) .ico files are just about the only image type you cannot save through the imaging classes. Why?

- Where did the 9-grid from the early Avalon bits go?

4) Better text rendering support

- Support sub pixel Clear Type on partially transparent windows. If the background behind text is opaque, WPF shouldn't care other parts of the window aren't. Drop down lists are an example.

- Support anti-aliassing options for better control (animation is horrible as text keeps blurring, snapping, blurring, snapping, etc.)

- Make the Clear Type kick-in delay for aninated text faster. Now when a drop down list opens, it takes a while for text to become sharp. Very nausiating.

- Support faux small caps. Currently, small caps is only suppported if the font supports it. If it doesn't, it's just ignored. Should probably be extended to all caps and all lower case.

- Support Type 1 in addition to TTF and OpenType (TTF+CFF).

5) Misc

- PdfDocumentWriter next to XpsDocumentWriter. Dito for document serialization.

- Allow the WPF graphics system to be used in server scenario's. Currently only GDI+ is semi-supported, which mean .NET has NO graphics stack for server scenarios.

- Deeper media support (audio & video from streams, feedback for things like audio visualizations).

- Allow BitmapEffects in low-trust scenarios.

- Make drop down shadow, blur, glow etc. accellerated.

- Allow bitmap effects to integrate with the DWM (e.g., blurring also causes underlying windows to be blurred, etc.)

- More obvious support for non-RGB color models in WPF, such as CMYK and HSL (e.g. Fill="CMYK 10,15,20,0").

- Better gradients (midpoint support and path gradients like GDI+).

6) Speed

- WPF really needs to have a speed boost. Animations, especially of windows are too choppy; waaay too much processor power is used; startup speed is atrocious; etc.

I would love to see built in support for 3D curve patches

It would be helpful to be able to use some simple equations to set XAML properties. A little bit of simple functionality could eliminate the need for code behind in many cases.

Sometimes a XAML propety is related to another XAML property by a simple equation, usually an addition or subtraction. XAML can not do this now and therefore requires code behind to do simple tasks.

My major request:

- A guarantee that WPF isn't going to be replaced in two years time, just like WinForms was.

My requests:

- Make hand XAML editing nicer (no lock-ups, more Intellisense on bindings, etc).

- Fix the caret (it should be SnapsToDevicePixels, not a blurry grey rectangle).

- I'll add my vote to faster bitmap effects: come on, Vista blurs things in real time, we know it's possible. Common bitmap effects should be common-cased (eg, blurring a (rounded) rectangle is very common, and could be rendered as geometries).

- Binding on Text property of Run.

- Cell padding / cell spacing for grids, stacks, etc.

Incidentally:

- Rod Mac: are you aware of the new C# constructor/property assignment syntax? eg, var f = new Foo { Width = 100, Height = 200 };

En un blog msdn encontr&#233; el siguiente t&#237;tulo &quot; Want some WPF improvements/features: Tell

- Extend the Command system

see here for details: http://joshsmithonwpf.wordpress.com/2007/07/12/extending-the-wpf-command-system/

- allow more control over the CommandManager...

a complete refresh on every click and keystroke is sometimes not what I want (for performance reason) so a bit more control over the CommandManager behavior would be good.

-better support of generics in xaml and data binding

(http://forums.microsoft.com/MSDN/ShowPost.aspx?PostID=2340174&SiteID=1)

-professional and easy to use localization/globalization support

-API support for spell checking (so that it can be used in a custom control)

-data binding for documents (FlowDocument)

-fix the blurry text and image issue

other things:

-refactoring for XAML would be nice.

-enable vista file dialogs in wpf and make them easily extensible

-improve start up time

Thought of another one...

I'd like to see WPF supported in a server (ASP.NET) environment. WPF makes it really easy to create images on-the-fly, and although it currently seems to work OK, the official MS position is that's it's unsupported (meaning it could stop working at any time).

I would also like a GridView type object.  I have made my own in projects now, but it would be VERY handy.  The only excuse I have heard so far from MS is that "third party providers are making solutions for this".  The only problem is 3rd party providers charge $600 for it.  That is not a valid excuse and the GridView is something MS needs!  Just about any tool that winforms has, WPF should have too, but GridView is the most important!!!

Thanks.

* Support for the vertical text writing mode would be great.

Pixel Shader Support

Alpha Channel Video Codec

Expressions in Bindings

Layer Blending Modes (with a new Layer container, or blending modes specifiable for Canvas, Grid, etc..)

Succinct On-demand Drawing interface..for massive data visualization.

1) DirectShow-like capture supported.

2) Direct3D/XNA integration. Would be great not to have airspace issues with WPF/D3D/MDX. May be it would be enough if you provide shared texture (or something like this to allow VRAM <-> VRAM manipulation)

Yes, the built-in controls are lacking, but its pretty easy to implement these controls / buy libraries that can do this.

To be honest, this isn't the real issue. What we developers can never do without intervention from Microsoft is have access to the underlying API.

1. BitmapSource wont even allow you to get a pointer to the native buffer. This has to be done via a dodgy reflection hack (see link), without which image processing is impossibly slow.

http://jmorrill.hjtcentral.com/Home/tabid/428/EntryID/15/Default.aspx

2. Bitmap Effects really need to allow access to the GPU to execute shaders - ive actually implemented this by sending the bitmap to the GPU, performing a shader, getting it back and appying it in the bitmap effect API - obviously, this is not optimum ...

3. Blending modes are lacking. No way to specify how layered objects are combined.

4. Shader support in WPF 3D would be nice.

5. MILCORE documentation / DWM integration!!

Certain controls are missing from WPF - propertryGrid etc.

It is posible to implement them using a WinForms container, but it is an extra level of hassel, and can go wrong.

As these controls are included as standard in non-wpf, it would be nice to be able to use them natively in wpf without shelling out even more for third party controls.

Thank you for taking the time to ask about what we needed in wpf

I've been using VS 2008 for a couple of weeks now, and find editing XAML in XAML view really needs a lot of work.

All the squiggles show up the very second you type something that has the wrong syntax, then after you finish typing the XAML squiggles are still all over the place.  You have to close the file then, reopen it to view the XAMl without the squiggles.  Real pain...

When you declare a converter at the top of the XAML file, VS put's squiggles under the class name.  The program runs fine, etc, but you still get those erroneous squiggles.

Thanks

Karl

Something like DirectShow (VMR9) but easier to use!MediaElement & MediaPlayer are very slow and it is impossible to code a real video application where multiple layers get rendered together with common alpha blending modes like Add, substract, multiply, diffrence.... and all in realtime with hardware acceleration please. direct byte manipulation of bitmaps and preload / cache possibilities to play back videofiles directly from memory.

Windows Presentation Foundation is a big laugh for video!

where is the c# managed version of Media Foundation???

something like DirectSound (low latency) please!

just want to say: First I started with c# and managed directx - it was depricated! Why???

Then I turned over to xna (fast! - good work!) but no video library!!! no dual monitor support!!

Then my hope was wpf - video based on mediaplayer grrrr. slow!  seeking sucks! only streams directly from harddrive...

Dear Microsoft please tell me - you directed me that the new language is c# and the managed code world but how should I code a fast performant real video application with one of these api's ???

Now make your fingers dirty and think twice before you move! finish what you began and give us developers the libraries and tools we need. Otherwise people stay at c++ and the wpf big media revolution will nerver start!

and by the way DOCUMENTATION EXAPLES VIDEOTUTORIALS in diffrent languages.

I'm new to WPF, but my initial thoughts:

WPF out-of-the-box is very lacking for business applications. There's no choice but to buy 3rd party controls (some very expensive).  If you want any take-up of WPF for LOB apps this really needs sorting.

Lets see  - a *high-performance* data grid that can handle high volumes of data (tens of thousands of records with ease).

The usual "missing controls list" such as DateTimePicker, PropertyGrid, numeric text box, month calendar, notify icon, Office 2007 ribbon, MDI support, easy drag/drop etc. http://msdn2.microsoft.com/en-us/library/ms750559.aspx .

Everything capable of working in partial trust XBAP's, so no "use Winforms Interop" nonsense. More sensible XBAP security restrictions (see previous posts)

Much better VS Designer, refactoring to apply to XAML as well. Better performance.

In built, easy to use localization, *scalable* to very large applications (not some sample application).

End-to-End n-tier LOB app illustrating best practice in WPF/WCF, and proving that WPF really is up to the job and not stuck at v1 "it will be OK in a couple of years".

Considering all this, perhaps good-old Winforms isn't so bad after all !

The biggie:

Generics support. This probably won't happen but the whole framework should have supported generics from the ground up.

List of show stoppers that keeps us from moving to WPF:

* DirectX interoperability - now, WPF is implemented on top of DirectX, but there's no  (usable) way of mixing it with your own DirectX content? Please give us something like DirectXCanvas...

* The blurry text issue... mentioned many times before, but it's really ironic that the next generation presentation framework isn't even able to render text correctly

* Refactoring support in VS. I know this is not easy (and in some cases practically impossible due to missing type information), but this is really a big problem for large applications...

Something I haven't seen mentioned: some sort of "native" vector graphics format, an analogue to the bitmap formats like BMP, PNG. Why not have a SVG importer that returns a DrawingImage? XAML may be ok for representing vector graphics, but it is write-only - even MS's very own famed Expression Design cannot re-import the XAML files it wrote itself.

I would really like that the specialized collections used in controls would implement the generic IEnumerable<>, ICollection<> and IList<> interfaces, instead of their non-generic conterparts. That would ease the use of LINQ without resorting to Enumerable.Cast. Some of them are already typified, but just don't implemente the interface.

Anothe welcome addition would be a multi-select tree view

- Bitmap effects not rendered in software

- Multi-selection treeview

I think there should be a way to data bind the PasswordBox.Password property. I know this can introduce a security issue, but, there are cases where it doesn't matter. I think it should be possible, just have a warning in the documentation about it. Either that, or there should be a way to easily make it use the same ErrorTemplate that is used for TextBox where it displays the red border around it if there's a validation error.

Some WPF RichTextBox enhancements:

Optionally allow extraction of XAML that includes UIElements with text (from TextRange, Selection and DragDrop data object).

Offer attributes to hide content (consistent with RTF codes \v and \v0 to mark hidden text)

Offer attributes to protect content (consistent with RTF codes \protect and \protect0)

Offer attributes to enable/disable spell checking for individual text runs (so as-you-type spell-checking will skip specially-formatted but valid text).

Offer custom dictionaries for spell-check.

Improve performance of RichTextBox editing (so  characters typed and changes made appear more quickly even with a large amount of text).

1) I'd love to see a "LocalStyle" property layer added.  This would sit just above the control's local properties but replace value define by the Style that is applied today.

I want to override some items in the current style but not replace the whole style. I don't know how the control is currently styled (so I don't know what I could define for the BasedOn of a new style).

2) An databinding UpdateTrigger of PreviewLostFocus (as opposed to the current LostFocus).  I need to be able to ensure that the data being bound is valid before I let the focus move.  This means attempting binding when the control is about to lose focus - not after.  There are other focus issues that should be addressed as well (a button, for example, should have a flag that tells it to grab the focus before firing its Click event. Without this, databinding doesn't happen until after th Click code has executed -- at it typically saves the data... except for that last field :-))

3) Multiple monitor support

4) Additional votes for the following:

 * Text (including tooltips) that is not blurry.

 * HTML rendering in the Frame from a String.

1. Blend modes.

2. Ability to warp/deform visuals (afaik there isn't even a way to go about even simple "fake perspective" effects (like skewing a rectangle into a trapezoid shape), never mind more complex grid deformations.

3. Better media APIs (something like DirectSound would be good). It should be easy to create somethign like a fully functional managed graphic equalizer with WPF.

I would like to see an improvement on the Data Providers provided, which means:

1. Improvements on the existing providers like the ObjectDataProvider

2. Include additional providers; seems to me there could easily be a LINQ data provider that works with a DataContext derived object..., or an ADO.NET data provider that works with table adapters, datasets, etc.

I would also like to see improvements on the ListView, and the views that are supported.  I was reading on a blog about some of the new controls coming.  Any additional controls you could provide would be very helpful.

Obviously I'd second the need for Calendar, DateTimePicker and DataGrid (which I believe are coming in a service pack for 3.5?).

But what I'd like to see is an extension to Visual Studio 2008 that displays a diagram view of Bindings display them as wires between controls and data objects.

ListView should support Tile View and other views that Windows Explorer has.

I understand why the Window.Icon property needs to be an actual Icon (rather than some other bitmap image).  However, I've got vector graphics that can have brushes applied to them at runtime, and I'd like to be able to set the icon accordingly.  It would be nice if there was some (non-ugly) way, starting with an ImageSource, to get an icon.  A converter, perhaps?

Blending Modes

Even if it isn't perfect, it would open up a lot of doors.

A Transitions Framework

There are already many out there so creating an official one shouldn't be that hard. Even just a simple TransitionContentPresenter. I would wrather use a build in transitions framework.

It seems like a lot of these features boil down to a few things...

Fix text rendering (or give the option for subpixel positioning to be disabled, etc)

Better interop / pull in more features from DirectX.

Include all the controls in the current version of WinForms.

I'd like to see additional LOB support.

1. Support for creating metafiles so that I can add the WPF graphics into MS-Office applications.

2. More controls as mentioned earlier

3. Better tutorials for WPF

Start up times must be improved.  Pretty tough to have a client enjoy an application (beautiful as it may be), that takes a year to load.

I need to enable or disable controls in WPF Windows form using Converters in Xaml

I need to enable or disable controls in WPF Windows form using Converters in Xaml

PLEASE

1. Read/Write cells in ListView in DetailView

2. TextWrap for Labels

ThanQ :)

AND

3. CheckListBox/RadioListBox controls

4. Events in Properties Window in the IDE

5. Update to the Visual Studio 2005 WPF/WCF Extensions of November 2006.

<help yourself by helping others...>

A build-in IValueConverter which supports advanced C# like expression. Would be a great feature for Data Binding.

Ability to refresh command more selectiveley. In our apps we have zillion of commands. Plus we do heavy work on keystrokes (not just text layouting, but whole document relayouting). Anyway that was ok in WinForm/GDI+, now in WPF every keystroke also trigger an IsEnabled check on all the command, and that has some visible negative performance impact.

How about making real world LOB application examples?  How about a modern data grid?

Combo box ISeditable option doesnt support with images

The interview took place late last month as a result of the book that Van der Eem is having an American journalist write. The maker of the programme Un Dia Den Bida said before De Telegraaf: “ I have taken two cameras with me. I had one turned off after