While going through the design phase of our new in-house enterprise-level application, one of the topics our team touched upon is whether we should look into WPF. I think the idea was compeling and besides, it’s always nice to jump into something new. I had some time to mess around with WPF and i have to admit, the things that i don’t like about it are piling up by the hour.

WPF roadmap

My biggest question is whether WPF will actually replace WinForms. The lack of definite answer from Microsoft leads me to think that this is probably what’s going to happen when the framework matures. I have read a few blogs where some folks suggest otherwise. However, I just don’t see a reason why you would consider supporting WinForms when you have something much superior and flexible to offer. Aside from that, what’s stopping Microsoft from screwing a major part of their community developing in WinForms. They’ve already done it with Web Service Enhancements and its support in Visual Studio 2008. VS 2008 itself was pretty much abandoned after the first service pack release, and according to this, we can all suck a big fat one because Microsoft sees more value in getting your benjamins for new licenses of VS 2010 than actually releasing a new service pack for potentially one of the worst Visual Studio releases. (if it isn’t the worst, it’s probably up there with the shitty ones)

Flashy design or back to WinForms?

There is no doubt that WPF is a good enhancement to software design process. It’s a powerful framework and with power comes complexity. Unfortunately, managing that complexity comes at a significant expense. You can either screw around with the XML markup that generates trendy UI or you can get Expression Blend and screw with it, which adds another layer of complexity on its own. Your other option is, of course, to hire a good UI designer who’s not only familiar with all of the tools necessary to work with the framework, but who can also do some design, animation programming and etc. I don’t know what the statistic is for software companies hiring graphics designers, but i have yet to work for one which actually did. Besides, considering how new this technology is, I can only wonder how difficult it would be to fill such a position.

Working with Expression Blend

My exposure with Blend was very limited and frustrating. I’ve had the chance to work with Expression Blend 2, which appears to be out of date since the version 3 is out already. I’m sure a lot of folks worked with Photoshop and its intuitive UI. It seemed much of Blend interface is borrowed from Photoshop, which at first was a great indicator. However, working with the application revealed that it is a new charlie foxtrot from Microsoft. I played around with a few features and tried what i thought was going to be an easy task – adding background image to a rectangle. I spent an hour attempting to do this and got absolutely nowhere. As was explained in this article, performing such a simple task is completely counter-intuitive. At this point, i had absolutely no doubt in my mind that this wasn’t going to go anywhere, and off this hunk of shit went from my machine. What a complete waste of time that was.

A good WPF showcase project?

I find it really difficult to actually get my hands on one. StockTrader is a good candidate for a sample WPF project to look at. However, most of its focus is on service-oriented software design, not so much on WPF. And it shows, as the project is just scratching the surface when it comes to WPF. Otherwise, i can’t recall any showcase projects with decent UI implementation. I wonder why Microsoft hasn’t stepped in and released a real-world WPF solution, just like they did Oxite for ASP.NET MVC. The lack of any decent material on WPF and Blend is also pretty astounding for such a hype both caused. All i was able to find was bits and pieces of information, nothing concrete like design patterns, specific design guidelines and such. It just seems like everything’s up in the air at this point.

I’m not even sure how to conclude this. I would probably still consider utilizing WPF for new solutions. You still have your standard set of controls and everything to get you started. The unfortunate thing is that you’ll probably not going to benefit much from the main features of the framework, but you’ll have to migrate at some point. Might as well do it now and hope that MS enhances their tools a little as the whole thing matures.

I have a strange fascination with hybrids.  Combining old and new technologies in bizarre and interesting ways.   Why must developers make “the choice” between a web or native technology? It would be great to build applications that would increase or decrease in features depending on the platform they were run on.

Do you have a Winforms application that you’d like to host in a web browser?  There’s an interesting technique you can use to do this enabled by .net Framework 3.5.

The .net framework provides the ability to create WPF web applications (commonly called XBAP).  WPF has the ability, in turn, to host Winforms. 

Security

It appears that in order to do this effectively, it’s necessary to deploy your XBAP application as a “Full Trust” application.

The code

To use this, create an XBAP project, then a page a “WinformHost” control on it.   The XAML could look like this:

<Page x:Class="Page1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Page1">
    <DockPanel LastChildFill="True">
        <Button Name="Button1"  DockPanel.Dock="Bottom"  >This is a WPF Button</Button>
        <WindowsFormsHost Name="WinformHost"   />
    </DockPanel>
</Page>

Then, create some code to instantiate your winform and show it on the Winform host:

Class Page1

Here’s the subroutine:

Public NotInheritable Class WinformToUserControl

Interesting bits and pieces

We found that in order for the items inside the control to scale properly, the AutoScaleMode property on the Winform must be set to Dpi instead of the default, which is Font.  I have a feeling this is because Dpi is the mode preferred for WPF, but I am uncertain.

In the sample WinformToUserControl class I found it better to contain the Winform inside a panel rather than exposing the Winform directly.  It seemed to make it more stable.  Feel free to experiment with taking it off.

Gotchas

As of time of writing, Firefox on my Windows 7 64 bit machine steadfastly refuses to run xbap.  It appears the “Windows Presentation Foundation” addin has not been automatically installed.  I have no idea how to install it.  There’ appears to be no information about how to do so.  So if you have it, good for you.  If you don’t….try re-installing the .net framework 3.51 (which didn’t work for me…)

I do know there was some controversy about this addin being temporarily blacklisted by Mozilla due to security concerns last month, but that’s all over now isn’t it?  

Download

You can download a sample project here.

Links

• I didn’t use anything from this project, but you might find it interesting MdiWindowManager
• StackOverflow post on Embedding winforms in usercontrols

Firefox vient de blacklister un module complémentaire de Microsoft: “Windows Presentation Foundation”
La raison ? Firefox a déterminé que le module complémentaire est connu pour causer des problèmes de stabilité ou de sécurité.

Je demande est ce que Microsoft a fait ça exprès pour diminuer la popularité de FF ? xD

Começa a parecer que é de propósito. A Microsoft liberou duas extensões para o Internet Explorer e Mozilla Firefox com vulnerabilidades graves. Uma dessas extensões, lançada em fevereiro, também enviava informações do usuário para a Microsoft, sem o seu conhecimento ou consentimento. Trata-se da .Net Framework 3.5 Service Pack 1, que continha uma falhade segurança que poderia ser explorada simplesmente entrando-se num site com conteúdo malicioso. A correção para o Internet Explorer foi realizada em 13/10 (8 meses depois de liberada a atualização defeituosa). Esta falha também está relacionada a outro plugin, o Windows Presentation Foundation.

A Fundação Mozilla comunicou à Microsoft que bloqueou ambas as extensões no navegador Firefox.

Se você utiliza o navegador Mozilla Firefox, a Fundação Mozilla lançou a página Plugin Check para que seus usuários atualizem seus plugins, já que alguns novos plugins do RealPlayer, Adobe Flash e Microsoft Silverlight não têm suas atualizações feitas automaticamente pelo site de addons (http://addons.mozilla.org)

É bom lembrar que essas extensões da Microsoft são apenas para navegadores rodando em sistemas operacionais Windows. Quem está utilizando GNU/Linux pode ficar tranquilo, desde que não esteja utilizando navegadores via WINE.

Η Mozilla απενεργοποιεί add-on της Microsoft για τον Firefox και το επανενεργοποιεί τρεις μέρες μετά | PC Magazine
Τελικά, φαίνεται ότι ήταν περιττή η αναστάτωση που προκλήθηκε από την ξαφνική ενοχοποίηση ενός browser add-on της Microsoft. Λίγες ημέρες πριν, η Mozilla ανακοίνωσε στους χρήστες του Firefox ότι είναι εκτεθειμένοι σε κίνδυνο λόγω του add-on Microsoft .NET Framework Assistant. Η Mozilla θεώρησε ότι το εν λόγω add-on μπορεί να αποτελέσει το όχημα για παραβίαση της ασφάλειας του υπολογιστή και ξεκίνησε επείγουσες διαβουλεύσεις με τη Microsoft.[next]

Η Mozilla μπλοκάρει το plug-in της Microsoft – Mozilla μπλοκάρει το λογισμικό της Microsoft, Firefox, κακόβουλο λογισμικό – PCW
Η εταιρεία μπλόκαρε, την Παρασκευή, το plug-in που είχε «εμφυτέψει» η Microsoft στον Firefox και το οποίο έβαζε τους χρήστες του browser σε κίνδυνο

Όπως δήλωσε ο Mike Shaver, εκπρόσωπος της Mozilla,η εταιρεία πήρε προληπτικά μέτρα μπλοκάροντας το λογισμικό της Microsoft που βρέθηκε στον Firefox και το οποίο αποτελούνταν από δύο μέρη – το add-on με την ονομασία “.NET Framework Assistant” και το plug-in “Windows Presentation Foundation”.[next]

A question appeared over on the Code Project forums today about binding the output from log4net into WPF. The question asked was:

This is a very good question, so I thought I’d knock together a quick sample application to demonstrate how to do this. The first thing to remember is that log4net allows you to create your own appenders and use them in your application. The second thing to remember is that you need to hook INotifyPropertyChanged into the mechanism. To that end, I created the following appender:

namespace log4netSample.Logging
{
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using log4net.Appender;
  using System.ComponentModel;
  using System.IO;
  using System.Globalization;
  using log4net;
  using log4net.Core;

  /// <summary>
  /// The appender we are going to bind to for our logging.
  /// </summary>
  public class NotifyAppender : AppenderSkeleton, INotifyPropertyChanged
  {
    #region Members and events
    private static string _notification;
    private event PropertyChangedEventHandler _propertyChanged;

    public event PropertyChangedEventHandler PropertyChanged
    {
      add { _propertyChanged += value; }
      remove { _propertyChanged -= value; }
    }
    #endregion

    /// <summary>
    /// Get or set the notification message.
    /// </summary>
    public string Notification
    {
      get
      {
        return _notification; ;
      }
      set
      {
        if (_notification != value)
        {
          _notification = value;
          OnChange();
        }
      }
    }

    /// <summary>
    /// Raise the change notification.
    /// </summary>
    private void OnChange()
    {
      PropertyChangedEventHandler handler = _propertyChanged;
      if (handler != null)
      {
        handler(this, new PropertyChangedEventArgs(string.Empty));
      }
    }

    /// <summary>
    /// Get a reference to the log instance.
    /// </summary>
    public NotifyAppender Appender
    {
      get
      {
        return Log.Appender;
      }

    }

    /// <summary>
    /// Append the log information to the notification.
    /// </summary>
    /// <param name="loggingEvent">The log event.</param>
    protected override void Append(LoggingEvent loggingEvent)
    {
      StringWriter writer = new StringWriter(CultureInfo.InvariantCulture);
      Layout.Format(writer, loggingEvent);
      Notification += writer.ToString();
    }
  }
}

Whenever a new message is appended, the Notification is updated and the PropertyChangedEventHandler is called to notify the calling application that the binding has been updated. In order to use this appender, you need to hook it into your configuration:

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
  <configSections>
    <section name="log4net"
      type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
  </configSections>
  <appSettings>
    <add key="log4net.Internal.Debug" value="false"/>
  </appSettings>
  <system.diagnostics>
    <trace autoflush="true">
      <listeners>
        <add name="textWriterTraceListener"
             type="System.Diagnostics.TextWriterTraceListener"
             initializeData="C:\log4net_internal.log"/>
      </listeners>
    </trace>
  </system.diagnostics>
  <log4net>
    <appender name="NotifyAppender" type="log4netSample.Logging.NotifyAppender" >
      <layout type="log4net.Layout.PatternLayout">
        <param name="Header" value="[Header]\r\n" />
        <param name="Footer" value="[Footer]\r\n" />
        <param name="ConversionPattern" value="%d [%t] %-5p %c %m%n" />
      </layout>
    </appender>

    <root>
      <level value="ALL" />
      <appender-ref ref="NotifyAppender" />
    </root>
  </log4net>
</configuration>

Note that you might want to add the following line into your AssemblyInfo.cs file:

[assembly: log4net.Config.XmlConfigurator(Watch=true)]

I find the following class really helpful when logging:

namespace log4netSample.Logging
{
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  using log4net;
  using log4net.Config;
  using log4net.Appender;
  using log4net.Repository.Hierarchy;

  public enum LogLevel
  {
    Debug = 0,
    Error = 1,
    Fatal = 2,
    Info = 3,
    Warning = 4
  }
  /// <summary>
  /// Write out messages using the logging provider.
  /// </summary>
  public static class Log
  {
    #region Members
    private static readonly ILog _logger = LogManager.GetLogger(typeof(Log));
    private static Dictionary<LogLevel, Action<string>> _actions;
    #endregion

    /// <summary>
    /// Static instance of the log manager.
    /// </summary>
    static Log()
    {
      XmlConfigurator.Configure();
      _actions = new Dictionary<LogLevel, Action<string>>();
      _actions.Add(LogLevel.Debug, WriteDebug);
      _actions.Add(LogLevel.Error, WriteError);
      _actions.Add(LogLevel.Fatal, WriteFatal);
      _actions.Add(LogLevel.Info, WriteInfo);
      _actions.Add(LogLevel.Warning, WriteWarning);
    }

    /// <summary>
    /// Get the <see cref="NotifyAppender"/> log.
    /// </summary>
    /// <returns>The instance of the <see cref="NotifyAppender"/> log, if configured.
    /// Null otherwise.</returns>
    public static NotifyAppender Appender
    {
      get
      {
        foreach (ILog log in LogManager.GetCurrentLoggers())
        {
          foreach (IAppender appender in log.Logger.Repository.GetAppenders())
          {
            if (appender is NotifyAppender)
            {
              return appender as NotifyAppender;
            }
          }
        }
        return null;
      }
    }

    /// <summary>
    /// Write the message to the appropriate log based on the relevant log level.
    /// </summary>
    /// <param name="level">The log level to be used.</param>
    /// <param name="message">The message to be written.</param>
    /// <exception cref="ArgumentNullException">Thrown if the message is empty.</exception>
    public static void Write(LogLevel level, string message)
    {
      if (!string.IsNullOrEmpty(message))
      {
        if (level > LogLevel.Warning || level < LogLevel.Debug)
          throw new ArgumentOutOfRangeException("level");

        // Now call the appropriate log level message.
        _actions[level](message);
      }
    }

    #region Action methods
    private static void WriteDebug(string message)
    {
      if (_logger.IsDebugEnabled)
        _logger.Debug(message);
    }

    private static void WriteError(string message)
    {
      if (_logger.IsErrorEnabled)
        _logger.Error(message);
    }

    private static void WriteFatal(string message)
    {
      if (_logger.IsFatalEnabled)
        _logger.Fatal(message);
    }

    private static void WriteInfo(string message)
    {
      if (_logger.IsInfoEnabled)
        _logger.Info(message);
    }

    private static void WriteWarning(string message)
    {
      if (_logger.IsWarnEnabled)
        _logger.Warn(message);
    }
    #endregion
  }
}

It’s a simple matter then to do something like Log.Write(LogLevel.Info, “This is my message”);

If you download the attached sample, you’ll get to see the whole application running in all its glory, and you can see how updating the log results in the output being updated. Don’t forget to rename the .doc file to .zip when you save it.

log4netsamplezip

WPF (Windows Presentaion Foundation) has some cool features that attract most of the GUI developers to migrate to it. Since WPF uses a markup language called XAML(eXtensible Application Markup Language) you can make your GUI application with ease and higher degree of confidence. Another good part of WPF is that you can program it in C# or Visual Basic.Net, which makes it manageable compared to applications programmed in native language like C++. Built on top of DirectX, with WPF you can harness the power which you can acquire by programming the DirectX API. But, If you are a developer who really wants to hardcode, then I would like you to go and try using the DirectX API.

Here is a sample application that plays video

First create a new WPF application in Visual Studio. Drag the MediaElement Control to the stage. Manually you can do that by writing similar code as given below. In this article I the video that I used is the Windows Vista sample video. You can specify the source of your own video for the Source attribute.

<MediaElement Name=”myVid” Source=”C:\Users\Public\Videos\Sample Videos\Bear.wmv” LoadedBehavior=”Manual” Width=”320″ Height=”240″ />

Add 3 button controls on the designer window to control the media playback.

<StackPanel Orientation=”Horizontal” Margin=”0,10,0,0″>
<Button Content=”Play” Margin=”0,0,10,0″ Padding=”5″ Click=”mediaPlay” />
<Button Content=”Pause” Margin=”0,0,10,0″ Padding=”5″ Click=”mediaPause” />
<Button x:Name=”muteButt” Content=”Mute” Padding=”5″ Click=”mediaMute” />
</StackPanel>

Add the following code in your Window1.xaml.cs file

void mediaPlay(Object sender, EventArgs e){

myVid.Play();

}

void mediaPause(Object sender, EventArgs e){

myVid.Pause();

}

void mediaMute(Object sender, EventArgs e){

if (myVid.Volume == 100){

myVid.Volume = 0;

muteButt.Content =

“Listen”;
}

else

{

myVid.Volume = 100;

muteButt.Content =

“Mute”;
}

}

Press F5 to test your application.

So last week, somebody posted a question on Code Project about why a Drag Drop into a TextBox in WPF doesn’t actually work. When you attempt to drag and drop an item into a TextBox, it refuses to cooperate and leaves the mouse cursor as the Drop denied cursor and you can’t drop into the field. (Incidentally, this behaviour also applies to RichTextBox and FlowDocument controls). The reason that you can’t drop into these fields, even if you set AllowDrop to true, is that these particular controls mark drag and drop events as handled, preventing you from handling them yourself.

Now this might seem like a big problem – it certainly makes it look like you can’t drag/drop into a textbox, and this would seem to be a huge oversight on Microsoft’s part. Fortunately, with a little bit of knowledge of how WPF handles commands, it’s actually fairly easy to come up with a workaround. Remember that I said that WPF marks these operations as handled? This is the key to being able to work around it – each particular event (such as a DragOver event), also has a corresponding Preview event which we can hook into to perform our processing. Before I show you the code though, the OP posted a follow up query:

The following filename drag/drop sample demonstrates how changing the DragDropEffects parameter changes the appearance of the drop cursor, in answer to the Original Posters followup question:

<Window x:Class="SampleDragDrop.Window1"
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  xmlns:sys="clr-namespace:System;assembly=mscorlib"
  Title="Window1" Height="274" Width="300">
  <Window.Resources>
    <ObjectDataProvider
        MethodName="GetValues"
        ObjectType="{x:Type sys:Enum}"
        x:Key="DragProvider">
      <ObjectDataProvider.MethodParameters>
        <x:Type TypeName="DragDropEffects" />
      </ObjectDataProvider.MethodParameters>
    </ObjectDataProvider>
    <Style TargetType="{x:Type TextBlock}">
      <Setter Property="Margin" Value="3" />
      <Setter Property="VerticalAlignment" Value="Center" />
    </Style>
  </Window.Resources>
  <Grid>
    <Grid.ColumnDefinitions>
      <ColumnDefinition Width="101*" />
      <ColumnDefinition Width="177*" />
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
      <RowDefinition Height="27*" />
      <RowDefinition Height="203.258*" />
      <RowDefinition Height="Auto" />
    </Grid.RowDefinitions>
    <TextBlock Text="Drag Drop Effects" Grid.Column="0" Grid.Row="0" />
    <TextBlock Text="Drop target" Grid.Column="0" Grid.Row="1" />
    <TextBlock Text="Handled" Grid.Column="0" Grid.Row="2" />
    <ComboBox
      x:Name="cboDropEffects"
      Grid.Row="0"
      Grid.Column="1"
      Margin="2"
      SelectedIndex="0"
      ItemsSource="{Binding Source={StaticResource DragProvider}}" />
    <TextBox
      Grid.Row="1"
      Grid.Column="1"
      Margin="2"
      PreviewDragEnter="TextBox_PreviewDragEnter"
      PreviewDragOver="TextBox_PreviewDragEnter"
      PreviewDrop="TextBox_PreviewDrop" />
    <CheckBox x:Name="chkHandled" IsChecked="True" Grid.Row="2" Grid.Column="1" Margin="2" />
  </Grid>
</Window>

If you look carefully at the code, you see that we bind PreviewDragEnter and the PreviewDragOver to the same event handler. The PreviewDrop event maps to a different event handler, where we actually perform the drop of the filename.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace SampleDragDrop
{
  /// <summary>
  /// Interaction logic for Window1.xaml
  /// </summary>
  public partial class Window1 : Window
  {
    public Window1()
    {
      InitializeComponent();
    }

    private void TextBox_PreviewDragEnter(object sender, DragEventArgs e)
    {
      e.Effects = (DragDropEffects)cboDropEffects.SelectedItem;
      if (chkHandled.IsChecked.HasValue)
      {
        e.Handled = chkHandled.IsChecked.Value;
      }
    }

    private void TextBox_PreviewDrop(object sender, DragEventArgs e)
    {
      object text = e.Data.GetData(DataFormats.FileDrop);
      TextBox tb = sender as TextBox;
      if (tb != null)
      {
        tb.Text = string.Format("{0}", ((string[])text)[0]);
      }
    }
  }
}

When you run the sample, play around with the Drag Drop Effects values, and setting/unsetting the Handled checkbox, to see what behaviour the textbox exhibits (and the answer to the OPs question, is that setting e.Effects to DragDropEffects.All sets the cursor to the relevant cursor).

This sample is available here: SampleDragDrop. Don’t forget to change the extension from .doc to .zip when you download it.

Ontem estava eu em meu trabalho, lidando com minhas atribuições diárias, quando me deparei com um problema, precisava criar “On the fly” um DataTemplate na aplicação na qual estou trabalhando.

O problema com isso é que o DataTemplate não possui um LogicalTree, apenas um VisualTree, e o elemento VisualTree não recebe nenhum elemento (FrameworkElement), mas sim um FrameworkElementFactory, que irá criar para você os elementos necessarios.

Agora como setar valores nas propriedades de meu elemento se eu não possuo referência do mesmo?
Primeiramente definimos o DataTemplate, e então adicionamos a ele uma nova instância do objeto desejado, e então setamos as propriedades com o uso do método SetValue (do DependencyObject que é a classe “pai” do FrameworkElementFactory). Assim sendo o código ficaria:


public DataTemplate CriarTemplate()
{
DataTemplate dt = new DataTemplate();
FrameworkElementFactory filho = new FrameworkElementFactory(typeof(Border));
filho.SetValue(Border.CornerRadiusProperty, new CornerRadius(5));
filho.SetValue(Border.BackgroundProperty, new LinearGradientBrush(Colors.Gray, Colors.Black, 90);
dt.VisualTree = filho;
return dt;
}


Raul

For several days, I looked for hooks into the Windows Presentation Foundation (WPF) System.Windows.Controls.TextBox control to display shadowed text:

WPF does not make the shadow effect easy. Changing the Foreground property can change the text color to any brush (even to a video or an image brush), but it does not achieve the shadow effect.

Using Snoop, I looked at the visual composition of a TextBox:

The TextBoxView control shown in Snoop does not have a public API. Lester Lobo says in this WPF forum post, “It is an internal lightweight class handling the rendering of content in the textbox.” If you re-templated a TextBox to try to replace the TextBoxView, you would have to implement all of the text-management functions provided by a TextBox—no small undertaking.

I then found a blog entry by Ken Johnson on CodeProject.com describing a clever hack for tricking a TextBox into doing what I wanted. His article is called CodeBox 2, and it uses the following algorithm:

1. Derive a class from TextBox.
2. Set the Foreground property to Brushes.Transparent. This hides the TextBox’s built-in text rendering.
3. Override OnRender().
4. Create a FormattedText object with the TextBox.Text string and set some properties to make it align and wrap just like the TextBoxView would normally do.
5. Call DrawingContext.DrawText() to output the FormattedText such that it draws in the exact same position as the TextBoxView would normally do. To achieve the shadowed text effect, first use DrawingContext.DrawText() to draw the shadow offset a couple of units from the primary text, and then call it again to draw the primary text.
6. What you now see is your shadowed text in a fully-functional TextBox. If you highlight text, you are actually interacting with the transparent text that is drawn in the TextBox.

It may be a hack, but it’s a clever hack, and aside from some scrolling and margin adjustments described well in Ken Johnson’s article and code, you can implement it relatively painlessly.

WPF’s in-depth text formatting features pay a price in CPU performance. This custom TextBox pays an even bigger price. First, drawing transparent text likely goes through all the formatting and rendering steps for no obvious visual effect. The text formatting likely provides some hit-testing and/or control sizing (layout) features even when formatting invisible text. Second, in addition to drawing transparent text, constructing a new FormattedText object and calling DrawingContext.DrawText() twice (once for the shadow and once for the primary text) adds overhead.

While I have not tested performance of my shadowed-text custom TextBox as shown in the screenshots above, I imagine that it will perform well enough on mid-level computers even with large amounts of text. However, if your application used these shadowed text effects in many places, the accumulation of CPU overhead would likely add up to significant performance problems.

I would appreciate any comments about other ways to draw shadowed text in a TextBox or to gain hooks into TextBox’s inner workings.

Good luck!

Dale

The Problem

At the moment I’m trialling Sketchflow for Expression Blend.  There’s an annoying bug that happens when you use the “Duplicate” action on a node:

If you use this action, sooner or later you’ll end up with this error:

‘InitializeComponent’ is not a member of ‘xxxxxxxxxx.xxxxxxxxxxxxxx’

This can be very frustrating if you are trying to advocate Sketchflow as a prototyping tool for non wpf savvy analysts.

The Workaround

The simplest workaround is to delete the code-behind file.  To do this, go to the project pane and choose “Delete”.

At first I tried hard to ensure that the xaml filenames and classnames were correct.  This just causes a cascading comedy of errors.

Upgrading Sketchflow prototype projects to real code is a pipe-dream at the moment.

If you know of a better way of handling this situation (and fixing the errors) more quickly, feel free to comment.  I just want get on with the prototyping.

What we do: We empower your content with amazing user experience while helping you manage and publish to the widest possible audience with minimal effort.

• We have solved the data incompatibilities and you have one source for iTunes video podcasts, as well as all the Media RSS consumers. What you see in iTunes is using the same format for data we use internally, as well as inside Boxee and the other major distribution channels

  • Oone Media RSS stream is driving everything you see as content here. We handle integrating with all of the complex metadata to seamless ‘just work’ in almost any environment.
    

• We are one of the first to support all existing HD and non-HD formats as well as the emerging and compelling Smooth Streaming formats including Deep Zoom navigation (click to see what the Hard Rock Cafe achieved)We are the first company to deliver this for live events combined with synchronized non-static data with auto-transition to on-demand content. See our example here

• EXPONENTIAL speed improvements (via the cloud-integrated Content Delivery Network)

• High Definition is now possible for anyone at the levels previously reserved for a handful (Amazon-Google levels we bring to anyone)

We integrate content encoding, Podcast management and distribution, CDN deployment for amazingly fast consumer speeds,  streaming media formats, new content creation, live presentation services, Synchronization – such as presentations with PowerPoint slide integration.

We get you to global best-practices in media in minimal effort or cost

Just explore what we publish such as our District 9 and DeepZoom examples. And we are not a content provider (!).

Imagine how fast and easy we can improve your exposure at nearly zero cost.

Overview

The Windows Presentation Foundation is Microsofts next generation UI framework to create applications with a rich user experience. It is part of the .NET framework 3.0 and higher.

WPF combines application UIs, 2D graphics, 3D graphics, documents and multimedia into one single framework. Its vector based rendering engine uses hardware acceleration of modern graphic cards. This makes the UI faster, scalable and resolution independent.

The following illustration gives you an overview of the main new features of WPF

Separation of Appearance and Behavior

WPF separates the appearance of an user interface from its behavior. The appearance is generally specified in the Extensible Application Markup Language (XAML), the behavior is implemented in a managed programming language like C# or Visual Basic. The two parts are tied together by databinding, events and commands. The separation of appearance and behavior brings the following benefits:

• Appearance and behaviour are loosely coupled
• Designers and developers can work on separate models.
• Graphical design tools can work on simple XML documents instead of parsing code.

Rich composition

Controls in WPF are extremely composable. You can define almost any type of controls as content of another. Although these flexibility sounds horrible to designers, its a very powerful feature if you use it appropriate. Put an image into a button to create an image button, or put a list of videos into a combobox to choose a video file.

 
<Button>
    <StackPanel Orientation="Horizontal">
        <Image Source="speaker.png" Stretch="Uniform"/>
        <TextBlock Text="Play Sound" />
    </StackPanel>
</Button>

Highly customizable

Because of the strict separation of appearance and behavior you can easily change the look of a control. The concept of styles let you skin controls almost like CSS in HTML. Templates let you replace the entire appearance of a control.

The following example shows an default WPF button and a customized button.

Resolution independence

All measures in WPF are logical units – not pixels. A logical unit is a 1/96 of an inch. If you increase the resolution of your screen, the user interface stays the same size – if just gets crispier. Since WPF builds on a vector based rendering engine its incredibly easy to build scaleable user interfaces.

How to create a simple WPF application

In Visual Studio 2008

Open Visual Studio 2008 and choose “File”, “New”, “Project…” in the main menu. Choose “WPF Application” as project type.

Choose a folder for your project and give it a name. Then press “OK”

Visual Studio creates the project and automatically adds some files to the solution. A Window1.xaml and an App.xaml. The structure looks quite similar to WinForms, except that the Window1.designer.cs file is no longer code but it’s now declared in XAML as Window1.xaml

Open the Window1.xaml file in the WPF designer and drag a Button and a TextBox from the toolbox to the Window

Select the Button and switch to the event view in the properties window (click on the little yellow lightning icon). Doubleclick on the “Click” event to create a method in the codebehind that is called, when the user clicks on the button.

Note: If you do not find a yellow lightning icon, you need to install the Service Pack 1 for VisualStudio on your machine. Alternatively you can doubleclick on the button in the designer to achieve the same result.

Visual Studio automatically creates a method in the code-behind file that gets called when the button is clicked.

 
private void button1_Click(object sender, RoutedEventArgs e)
{
    textBox1.Text = "Hello WPF!";
}

The textbox has automatically become assigned the name textBox1 by the WPF designer. Set text Text to “Hello WPF!” when the button gets clicked and we are done!. Start the application by hit [F5] on your keyboard.

Isn’t this cool!

Learn PWF click here

Everyone who get introduced to Windows Presentation Foundation(WPF) are familiar with this term. But lot many get confused on it or never get what it is. I will try and make this post very simple so that it is easier to understand. My intentions are not to provide the complete technical stuff behind the Dependency property, but to keep things simple to understand and to get started. You should probably work on this lot many times to understand it better.

If you are not new to .net or any other OOP language, you are not new to Property. Dependency property was introduced in .net 3.0 and it is all together new implementation of normal properties. Dependency property differ in terms of its storage mechanism, it uses Sparse Storage and its implementation saves per-instance memory compared to a typical .NET property. However benefits of dependency property is more than just storage. One of the significances of Dependency property is its support for notification change – that means any change in the value of the property is notified down the element tree in WPF. This point particularly becomes very important to understand this.

Before I completely get on with Dependency property, let me give a gist of what attached property is. Let me explain this in a way a lay man understands: Consider a “<Canvas></Canvas>” element in your XAML. Now if you want to add a child element “<TextBlock>” to it, how do you place them in the canvas? – Here it is:

<Canvas>
       <TextBlock Canvas.Top=”100″ Canvas.Left=”100″ Text=”Hello World”/>
</Canvas>

OR an example with a Grid

<Grid>
   <Grid.ColumnDefinitions>
      <ColumnDefinition/>
      <ColumnDefinition/>
   </Grid.ColumnDefinitions>
   <Grid.RowDefinitions>
      <RowDefinition/>
       <RowDefinition/>
   </Grid.RowDefinitions>
   <TextBlock Grid.Column=”0″ Grid.Row=”0″ Text=”Hello World  1″/>
   <TextBlock Grid.Column=”1″ Grid.Row=”0″ Text=”Hello World 2″/>
   <TextBlock Grid.Column=”0″ Grid.Row=”1″ Text=”Hello World 3″/>
   <TextBlock Grid.Column=”1″ Grid.Row=”1″ Text=”Hello World 4″/> 
 </Grid>

So what we do is we set the Canvas’s Top and Left property in the TextBlock child element or even the Grid’s Column and Row property in the child elements. This is achieved using attached property.

So here is the MSDN explanation: “An attached property is intended to be used as a type of global property that is settable on any object. One purpose of an attached property is to allow different child elements to specify unique values for a property that is actually defined in a parent element.”

In the above example, we see the property element of a parent is changed by the child, and the same gets reflected throughout the child elements. I have explained this so that you don’t confuse attached property with dependency property.

Let us extend couple of lines of code more and now understand dependency property.

And here it is:

<Canvas>
<Slider Canvas.Top=”10″ Canvas.Left=”10″ Name=”MySlider” Minimum=”10″ Maximum=”1000″ Ticks=”100″ Width=”300″/>
 <Ellipse Canvas.Top=”130″ Canvas.Left=”150″ Width=”{Binding ElementName=MySlider, Path=Value}” Height=”{Binding ElementName=MySlider, Path=Value}” Fill=”Red”/>
 </Canvas>

The output of the above example is: When the slider is moved, automatically the ellipse gets larger or smaller based on the value of the slider. So what we understand from this is without writing event handlers or any code behind to handle the slider movement and the ellipse height and width setters – we achieve this. This is because the property “Value” of the slider is a dependency property and it notifies the change to all the elements in the XAML, and since the Ellipse’s width and height are bound to the “Slider.Value” it automatically reflects the change.

This was just an introduction, there are couple of more things I want to cover like – creating your own dependency properties for the custom controls etc, which will be updated in the next post.

Cheers!