Ben Lemmon's Code Ramblings https://docs.microsoft.com/archive/blogs/blemmon/feed.xml Wed, 17 Apr 2019 04:22:37 GMT en-US hourly 1 Reading zip files from Silverlight https://docs.microsoft.com/archive/blogs/blemmon/reading-zip-files-from-silverlight Wed, 25 Nov 2009 08:44:00 GMT https://blogs.msdn.microsoft.com/blemmon/2009/11/25/reading-zip-files-from-silverlight/ Silverlight doesn't have any classes from the System.IO.Compression namespace, but it's gone something better, Application.GetResourceStream.  It's pretty easy to take a stream to a zp file and get a stream to one of the uncomressed files inside it:

StreamResourceInfo zipInfo = new StreamResourceInfo(zipStream, null);
StreamResourceInfo streamInfo = Application.GetResourceStream(zipInfo, new Uri(fileName, UriKind.Relative));
Stream fileStream = streamInfo.Stream;

All you need to do is provide the stream to the zip file, and the name of the file you want to extract, and in three lines of code you have a stream to the uncompressed file.  But there's one snag: What if you don't know the name of the file(s) inside the zip file?  There is no api to browse through the contents of the zip file.  A common workaround is to include a manifest file in the zip which lists the contents of the zip archive, but for some, this isn't possible because they don't conrol the creation of the content, and are just consuming it.  It's actually not too hard to list the files in a zip archive, with a little help from the zip file format specification I wrote a little utility method that lists the files contained in a zip file.  Its usage should be straightforward.

 

public class ZipUtil
{

/// <summary>
/// Reads the file names from the header of the zip file
/// </summary>
/// <param name="zipStream">The stream to the zip file</param>
/// <returns>An array of file names stored within the zip file. These file names may also include relative paths.</returns>
public static string[] GetZipContents(System.IO.Stream zipStream)
{

List<string> names = new List<string>();
BinaryReader reader = new BinaryReader(zipStream);
while (reader.ReadUInt32() == 0x04034b50)
{

// Skip the portions of the header we don't care about
reader.BaseStream.Seek(14, SeekOrigin.Current);
uint compressedSize = reader.ReadUInt32();
uint uncompressedSize = reader.ReadUInt32();
int nameLength = reader.ReadUInt16();
int extraLength = reader.ReadUInt16();
byte[] nameBytes = reader.ReadBytes(nameLength);
names.Add(Encoding.UTF8.GetString(nameBytes, 0, nameLength));
reader.BaseStream.Seek(extraLength + compressedSize, SeekOrigin.Current);

}
// Move the stream back to the begining
zipStream.Seek(0, SeekOrigin.Begin);
return names.ToArray();

}

}

]]> Using the preprocessor to share incompatible XAML between SL and WPF – Part 1 https://docs.microsoft.com/archive/blogs/blemmon/using-the-preprocessor-to-share-incompatible-xaml-between-sl-and-wpf-part-1 Wed, 29 Apr 2009 16:14:00 GMT https://blogs.msdn.microsoft.com/blemmon/2009/04/29/using-the-preprocessor-to-share-incompatible-xaml-between-sl-and-wpf-part-1/ One of the goals of Silverlight is to be a subset of WPF so that you can cross-compile the code between the two frameworks.  This works great when you adhere to the strict subset that Silverlight provides, but when you want to deviate from that to provide richer functionality in your WPF version, you’re left with messy workarounds.  One options is to make the changes in code using the preprocessor #if…#endif directives to conditionally include code, but what if you want to make the change in XAML?  The XAML processor doesn’t allow preprocessor commands such as #if…#endif, so currently the only workaround is to create two copies of the XAML and change them manually.  In doing this, you’d lose all the benefits of code sharing now that you’re maintaining two XAML files.

I’ve created a custom MSBuild targets file that will allow you to take full advantage of the C++ preprocessor to conditionally include code the way you’re used to doing it already.  In part one I’ll just give a high level overview of what it does and how to use it, and I’ll provide more detail, and better incremental build functionality.

To use this build tool, you must add the following paths to your environment PATH variable so that the compiler knows where to find the C++ preprocessor:

c:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\bin\
c:\Program Files (x86)\Microsoft Visual Studio 9.0\Common7\IDE\
NOTE: Your paths may be different.

After you’ve done that, just import PreprocessXaml.targets at the end of your csproj file (see attached example).  This works for Silverlight projects or WPF projects.  Once you do that, all your XAML pages will be preprocessed (except for App.xaml, we’ll add that in part 2) and compiled to Filename.i.xaml and from then on will be processed as normal.

   1: <Project xmlns="https://schemas.microsoft.com/developer/msbuild/2003">
   2:   <!--
   3:     Insert the PreprocessXaml target into the build process
   4:   -->
   5:   <PropertyGroup>
   6:     <!-- For WPF projects -->
   7:     <MarkupCompilePass1DependsOn>
   8:       $(MarkupCompilePass1DependsOn)
   9:       PreprocessXaml;
  10:     </MarkupCompilePass1DependsOn>
  11:     <!-- For Silverlight projects -->
  12:     <CompileXamlDependsOn>
  13:       $(CompileXamlDependsOn)
  14:       PreprocessXaml;
  15:     </CompileXamlDependsOn>
  16:   </PropertyGroup>
  17:   <!--
  18:     Runs the C++ preprocessor over all XAML files before they are compiled and packaged.
  19:     This allows for conditional inclusion of XAML such as 
  20:     <TextBlock
  21:     #if SILVERLIGHT
  22:       Text="This is in Silverlight"
  23:     #else
  24:       Text="This is in WPF"
  25:     #endif
  26:     />
  27:     or use #define to define constants etc.
  28:   -->
  29:   <Target Name="PreprocessXaml">
  30:     <ItemGroup>
  31:       <!-- Create a list of pages post-preprocess -->
  32:       <PreprocessedPages Include="@(Page->'%(RelativeDir)%(Filename).i%(Extension)')" />
  33:       <!-- We don't want to include the unprocessed files as resources, include the preprocessed files instead -->
  34:       <Resource Remove="@(Page)" />
  35:       <Resource Include="@(PreprocessedPages)" />
  36:       <!-- Convert the DefineConstants property into an ItemGroup -->
  37:       <XamlConstants Include="$(DefineConstants)" />
  38:     </ItemGroup>
  39:     <PropertyGroup>
  40:       <!-- Convert the XamlConstants ItemGroup into a list command line switches for CL.exe -->
  41:       <CommandLineDefineConstants>@(XamlConstants->'/D%(Identity)',' ')</CommandLineDefineConstants>
  42:     </PropertyGroup>
  43:     <!-- Run the preprocessor -->
  44:     <Exec Command="CL.exe /nologo /EP $(CommandLineDefineConstants) &quot;%(Page.FullPath)&quot; &gt; %(RelativeDir)%(Filename).i%(Extension)" />
  45:     <!-- Replace the pages with the preprocessed pages so that subsequent targets will use the preprocessed files -->
  46:     <ItemGroup>
  47:       <Page Remove="**" />
  48:       <Page Include="@(PreprocessedPages)" />
  49:     </ItemGroup>
  50:   </Target>
  51: </Project>

PreprocessXaml.targets

Attached is a simple project that shows conditional compilation of XAML at work.

PreprocessorTest.zip

]]> Piping Converters in WPF and Silverlight https://docs.microsoft.com/archive/blogs/blemmon/piping-converters-in-wpf-and-silverlight Sun, 22 Mar 2009 01:30:00 GMT https://blogs.msdn.microsoft.com/blemmon/2009/03/22/piping-converters-in-wpf-and-silverlight/ One limitation in WPF and Silverlight is that a Binding can only have one converter.  At least for me, this has meant that I've created a lot of very specific converters in my projects.  If I needed a converter to format a string then turn it into a uri, I'd make a class to do just that.  After getting frustrated by the abundance of single use converters, I decided there has to be another way.  I tried thinking up this clever scheme where I'd use ConverterParameter as a small-scripting language to tell it which steps to perform.  Anyone reading this is probably already thinking, "that's not clever, that's a crappy idea," and they're right.  It is a crappy idea, which is why I didn't do it.  You see, you have to think up a few bad ideas first so that you know your good idea is actually good.

I'm sure I'm not the only programmer who goes to bed with a problem in his head, and dreams the solution: Well, that's exactly how this came about.  So I wrote up this simple converter that has a list of child converters and pipes the output of each to the input of the next.  Each converter must have a CanConvertAttribute describing the types it can convert from and to so that the PipingConverter can pass the correct targetType to the next converter in line.  I've allowed for multiple CanConvertAttributes in case one converter can serve many purposes.  The PipingConverter performs a depth first search to find the first valid conversion path between the value and the final target type. I've attached the Silverlight project which can easily be ported to WPF to get the same effect.  I'll also leave it as an exercise for the reader to implement two way conversion.

To make use of this, simply create your PipingConverter in xaml or code, and add the child converters in the order you want them executed.  So if you wanted to take a list of strings from one of your data objects, sort it, convert it to a comma delimited string, then make it all caps, your code would look like:

<local:PipingConverter x:Key="ListConverter">
     <local:SortListConverter />
     <local:ListToStringConverter />
     <local:StringCaseConverter LetterCase="Upper" />
</local:PipingConverter>

and to bind, simply use:

<TextBlock Text="{Binding Converter={StaticResource ListConverter}}" />

It fits so well that I'm surprised that it wasn't included at least in WPF.  Maybe someday, I'll try doing the same thing for multi converters.

 

NOTE: After writing this, I found that Josh Smith has posted a quite simmilar solution here.  I didn't know of his solution before coming up with mine, so that fact that they turned out so similarly just validates both of our approaches.

PipingConverter.zip

]]> Animating margins in Silverlight https://docs.microsoft.com/archive/blogs/blemmon/animating-margins-in-silverlight Tue, 17 Mar 2009 22:25:00 GMT https://blogs.msdn.microsoft.com/blemmon/2009/03/17/animating-margins-in-silverlight/ So I ran into a problem the other day where I needed to animate a margin of a control, but Silverlight doesn't allow for animating Thickness objects (WPF does).  The solution I came up with is very simple and can be used to animate the Margin, Padding, or BorderThickness of any control.  Since Silverlight doesn't support custom animations, we'll have to work with this hack for now.

   1:  using System;
   2:  using System.Net;
   3:  using System.Windows;
   4:  using System.Windows.Controls;
   5:  using System.Windows.Documents;
   6:  using System.Windows.Ink;
   7:  using System.Windows.Input;
   8:  using System.Windows.Media;
   9:  using System.Windows.Media.Animation;
  10:  using System.Windows.Shapes;
  11:   
  12:  namespace SLApp1
  13:  {
  14:      public class ThicknessAnimation
  15:      {
  16:          // The time along the animation from 0-1
  17:          public static DependencyProperty TimeProperty = DependencyProperty.RegisterAttached("Time", typeof(double), typeof(DoubleAnimation), new PropertyMetadata(OnTimeChanged));
  18:          // The object being animated
  19:          public static DependencyProperty TargetProperty = DependencyProperty.RegisterAttached("Target", typeof(DependencyObject), typeof(ThicknessAnimation), null);
  20:          // The thickness we're animating to
  21:          public static DependencyProperty FromProperty = DependencyProperty.RegisterAttached("From", typeof(Thickness), typeof(DependencyObject), null);
  22:          // The tickness we're animating from
  23:          public static DependencyProperty ToProperty = DependencyProperty.RegisterAttached("To", typeof(Thickness), typeof(DependencyObject), null);
  24:          // The target property to animate to.  Should have a property type of Thickness
  25:          public static DependencyProperty TargetPropertyProperty = DependencyProperty.RegisterAttached("TargetProperty", typeof(DependencyProperty), typeof(DependencyObject), null);
  26:   
  27:          /// <summary>
  28:          /// Creates a Timeline used to animate the thickness of an object
  29:          /// </summary>
  30:          /// <param name="target">The object to animate</param>
  31:          /// <param name="targetProperty">The property on the object to animate</param>
  32:          /// <param name="duration">The length of the animation</param>
  33:          /// <param name="from">The begining thickness</param>
  34:          /// <param name="to">The final thickness</param>
  35:          /// <returns>A timeline object that can be added to a storyboard</returns>
  36:          public static Timeline Create(DependencyObject target, DependencyProperty targetProperty, Duration duration, Thickness from, Thickness to)
  37:          {
  38:              DoubleAnimation timeAnimation = new DoubleAnimation() {    From = 0, To = 1, Duration = duration };
  39:              timeAnimation.SetValue(TargetProperty, target);
  40:              timeAnimation.SetValue(TargetPropertyProperty, targetProperty);
  41:              timeAnimation.SetValue(FromProperty, from);
  42:              timeAnimation.SetValue(ToProperty, to);
  43:              Storyboard.SetTargetProperty(timeAnimation, new PropertyPath("(ThicknessAnimation.Time)"));
  44:              Storyboard.SetTarget(timeAnimation, timeAnimation);
  45:              return timeAnimation;
  46:          }
  47:   
  48:          /// <summary>
  49:          /// Silverlight's animation system is animating time from 0 to 1.  When time changes we update the thickness to be time
  50:          /// percent between from and to
  51:          /// </summary>
  52:          private static void OnTimeChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
  53:          {
  54:              DoubleAnimation animation = (DoubleAnimation)sender;
  55:              double time = GetTime(animation);
  56:              Thickness from = (Thickness)sender.GetValue(FromProperty);
  57:              Thickness to = (Thickness)sender.GetValue(ToProperty);
  58:              DependencyProperty targetProperty = (DependencyProperty)sender.GetValue(TargetPropertyProperty);
  59:              DependencyObject target = (DependencyObject)sender.GetValue(TargetProperty);
  60:              target.SetValue(targetProperty, new Thickness((to.Left - from.Left) * time + from.Left,
  61:                                                            (to.Top - from.Top) * time + from.Top,
  62:                                                            (to.Right - from.Right) * time + from.Right,
  63:                                                            (to.Bottom - from.Bottom) * time + from.Bottom));
  64:              
  65:          }
  66:   
  67:          public static double GetTime(DoubleAnimation animation)
  68:          {
  69:              return (double)animation.GetValue(TimeProperty);
  70:          }
  71:   
  72:          public static void SetTime(DoubleAnimation animation, double value)
  73:          {
  74:              animation.SetValue(TimeProperty, value);
  75:          }
  76:      }
  77:  }

To use this, simply call ThicknessAnimation.Create with the necessary parameters, add the timeline to a storyboard, and call storyboard.Begin()

]]> Introduction https://docs.microsoft.com/archive/blogs/blemmon/introduction Tue, 17 Mar 2009 20:21:00 GMT https://blogs.msdn.microsoft.com/blemmon/2009/03/17/introduction/