The Assembly demo party is a demoscene and gaming event in Finland. The most recent Assembly was held from the 4th to 7th August 2011 at Hartwall Areena in Helsinki.

The first Assembly was held from July 24th to July 26th 1992, in Kauniainen. It was organized by the Amiga demo groups Complex and Rebels, and the PC demo group Future Crew. The staff grew into a large non-profit group of individuals known as Assembly Organizing. Through the 1990s, Assembly grew so large that even exposition halls no longer sufficed, and only the largest of sports arenas met the partygoers’ needs. In 1999 they rented the largest sports arena in the country, Hartwall Areena in Helsinki, with over 5000 visitors and 3500 computers on the ice rink and it has been held there ever since. As of 2011 the party has been held for 20 consecutive years.

Ever since becoming a Microsoft Student Partner in 2007 i have been helping out Microsoft to demonstrate it’s technologies for Assembly guests on the Microsoft stand. Assembly has always been great fun with interesting people so I decided to participate this year too. Microsoft also had a competition that  was giving away a free Windows Phone 7 to the best entry made on that platform that was participating on the Real Wild competition. I figured there wouldn’t be many entries like that so i decided to also participate.

I only had 4 hours to make my demo, so don’t expect anything spectacular (from which i was listening lectures for 2 hours).

Demos are basically a bunch of code put together that display graphics and music. Mine is called NeuralWorld and it’s a copy of a similar android screensaver, with some twists . It works on both Silverlight on the web and Windows Phone and should you need it’s source code for something feel free to ask.

It starts with flashing squares and does it for 10 seconds I’m doing this with a DispatcherTimer ticking every on 100milliseconds and then randomly selecting 20 background items to flash on random colour. After it becomes 8 differently coloured worms running across the screen. I did this by having 8 different storyboards animating the worms. Every time a worm gets over the edge i randomly select a new starting point and begin the animation again. Lastly my demo ends with all backgrouditems dropping in from the sky. I ran into some serious performance issues while doing this and it seems that DispatcherTimer cannot tick as fast as i would want it to. For better results i should have probably used XNA. Finally to make it better i should have also added some music in it, but i couldn’t find anything that would fit

At the end i missed the deadline for the competition with few hours so i couldn’t participate in it, but still learnt few things while doing it so there’s no reason to be disappointed. Here’s a video of the final demo!

NeuralWorld

PICTURES FROM THE EVENT

Loads more can be found from here:

http://www.assembly.galleria.fi/kuvat/Assembly+Summer+2011/

Cheers,

Petteri Lehtonen

This might no be very useful information when creating line of business applications, but I thought that it is cool enough that it’s worth sharing.

It all started when my brother decided to get married and organize a party after the ceremony… you know the usual wedding stuff… As a best man i wanted to do something to make this wedding stand out from the rest. Since i pretty much suck at everything not computer related so that’s what I had to go for.

Idea

People will be arriving to the party after church and i wanted to provide them something to do while they are getting seated and waiting for others to arrive. (They are mainly regular Finnish people, so they are not yet drunk enough to actually talk to other people yet). So I’m going to automatically take pictures from people arriving to the party and project them on a wall to a virtual wedding album made with Silverlight.

What do you need

• Server laptop that’s taking the pictures and hosting them on IIS.
• Client laptop that’s getting the images.
• Webcam to take the pictures.
• Router or a hub of some kind to create a network between these machines.
• Bit of craziness to do something like this.

How to do it

The Server laptop was a Macbook with Windows 7 and IIS configured with pretty much the default settings. Only thing i needed to change was some file rights for the client to be able to access the files. It  also needs some software to take the images from the Webcam periodically. I ended up using Yawcam, but i wouldn’t recommend it since it only allows you to take 640×480 images even though my webcams max supported resolution was 1280×800 (1.3MP). I set Yawcam to take images every 10 seconds and put them directly on the folder that was mapped to the IIS.

Client was also a Windows 7 laptop and i was running the Silverlight app directly from Visual Studio development server. For the wedding album i needed ready made control of a popular “Silverlight book implementation” and i found this http://www.rajneeshnoonia.com/blog/2011/06/page-flip-with-deep-zoom/ . There are better looking similar controls but this had a method for turning the page i could call programmatically, which was my only requirement. By default that control looks quite horrible so time for some Photoshop magic :).

Steps

1. Make the huge shadows a lot smaller
2. Add some “weddingish” silk to the background
3. Make the pages look like a stylish paper
4. Start page with the lovely couple and some text to greet the guests
5. Another page to display the images from arriving guests

And here’s how they ended up looking, first the page with the couple and the text’s i but this page to come up every once a while.

And the page to display images from guest’s. The content in them is created during runtime and you can browse trough the album like you would do on an regular photoalbum.

To add the chewing gum code to make it work i used an empty stroryboard that takes 20 seconds to complete and once it completes i get new images from the server and display them on the right position. There’s nothing fancy about the code, but here’s how to do one item:

Storyboard sb = new Storyboard();
        int i = 0;
        public MainPage()
        {
            InitializeComponent();
            this.Loaded += new RoutedEventHandler(MainPage_Loaded);
            sb.Duration = new Duration(new TimeSpan(0, 0, 20));
            sb.Completed += new EventHandler(sb_Completed);
        }
        void MainPage_Loaded(object sender, RoutedEventArgs e)
        {
            sb.Begin();
        }
        void sb_Completed(object sender, EventArgs e)
        {
            //THE BACKGROUND FOR THE PAGE
            Image recr = new Image();
            BitmapImage bmi = new BitmapImage(new Uri("3 sivu.png", UriKind.Relative));
            recr.Source = bmi;
            //THE LIVE IMAGE FROM GUESTS MARGINS TAKEN FROM BACKGROUND IMAGE
            Image live1 = new Image();
            BitmapImage livebitmap = new BitmapImage(new Uri("http://10.0.1.150/" + i + ".jpg", UriKind.Absolute));
            live1.Source = livebitmap;
            live1.Stretch = Stretch.Fill;
            live1.Margin = new Thickness(27, 156, 26, 163);
            i++;
            Grid newchild = new Grid();
            newchild.Children.Add(recr);
            newchild.Children.Add(live1);
            BookItem newitem = new BookItem();
            newitem.Content = newchild;
            kirja.Items.Add(newitem);
            kirja.TurnPage(true);
            sb.Begin();
            }
        }

All content to the book is created at runtime. The book control accepts a Grid as it’s BookItem’s content so i just created a grid and put my two images inside it. Every time the storyboard ends i start it again and add +1 to the index number so i always get new images from the webcam server. I set up YawCam to take images corresponding to this. My webcam server ended up taking approx. 1500 images from the wedding, in the 4~ hours it was running, and I’m hoping the guests had as much fun looking at them that I had creating this whole thing.

Should you have any questions i would be happy to answer them.

Cheers,

Petteri Lehtonen

Every now and then customers want waterfall charts in our QlikView applications. As this is not a standard chart type in QlikView, it is not completely straightforward. This is how we have done it.

The Source Data

In this example, we will use this oversimplified source data.

It is as easy to use data with different years on different rows. However, in order to keep the expressions as readable as possible, we use this really simple data.

The Waterfall Definition

In this example, the waterfall dimensions are defined in Excel, in order to make it easier to modify them, even for users without any QlikView knowledge. A part of the Excel file looks like this:

The fields in this sheet are:

• BU
  • Defines the Business Units to be shown in the graph. In other words, this is the part that tells which data to show for each bar.
• Waterfall1
  • Used as a Dimension in the graph. The text in this field is shown as the dimension below the bars in the graph.
• OrderBy
  • The order in which the columns are shown in the graph.
• WaterfallFormatting
  • The color of the bar. RedGreen is used for bars that are red if the numbers are negative and green if the bars are positive. Other formatting can be applied here too, as long as it is defined in the graph in QlikView.
• OffsetRowsBack
  • The sum of the previous x rows are used as offset to get the starting point for the current bar. If this is 0, the bar will start from 0.
• ActMultiplier
  • The actual value of the account is multiplied by this value. In this example, the Act value is not taken into account in the “Plan” bar, as it is 0.
• PrevMultiplier
  • The Previous year’s value of the BU is multiplied by this value. In this example, the Previous year’s value is not taken into account in the “Act” bar, as it is 0. As we want to show the difference between Actual and Previous values, most PrevMultipliers here are -1, making the bar value Actual – Previous Year.

As you can see, every waterfall has a distinct column for defining the bars in the waterfall. If a new waterfall is added, just one new column needs to be added in this sheet.

The Waterfall in QlikView

In QlikView, the graph is created as a bar chart with offsets to make it a waterfall diagram.

Dimensions

On the dimensions tab, we use Waterfall1 as the dimension, as defined in the Excel file. As we may have multiple waterfalls defined in the same table, it is important that we check Suppress When Value Is Null. This is because we want to show the values for just this waterfall.

Expressions

On the Expression tab, there is just one expression, which looks like this:

Sum(CurrentYear)*ActMultiplier
+
Sum(PrevYear)*PrevMultiplier

This sums together the Actual value (considering the ActMultiplier), the Previous Year’s value (considering the PrevMultiplier).

Offset

The bar offset is defined as:

rangesum (above(Column(1),1,only(OffsetRowsBack)))

This sums the previous columns together, in order to define the starting point for the current column. In other words, this is the part that makes the chart a waterfall chart.

Coloring

The background color of the bar is defined as:

if(only(WaterfallFormatting)='Base',
    Blue(),
    if(column(1) <0,Red(),Green())
)

Which makes the bar the selected color.

In this case, the final waterfall graph will look like this:

The QlikView example file can be found here and the source data can be found here.

In a previous post, I wrote about a few gotchas that you may come across when doing event handlers in SharePoint. After writing that one, I’ve come across a few more. These are related to number fields.

Gotcha number one, which is not that weird actually, but is good to know about, is that number columns are always stored as doubles. I had a column defined to include numbers from 0 and up, with zero decimals. The error occurred in my event handler, when I tried to do int.Parse(properties.AfterProperties[<field name>].ToString()). This failed miserably. When inspecting the actual result of the .ToString(), it turned out to be “1.000000000000”, and not “1”, as expected.

Gotcha number two, which is a bit stranger, turned up after I had found out about gotcha number one. Both properties.AfterProperties[<field name>] and properties.ListItem[<field name>] return objects, BUT the underlying type for the AfterProperties is string, while the ListItem properties are the real type, in this case double. So, the properties.ListItem[<field name>] could be cast directly to a double, while the properties.AfterProperties[<field name>] had to go through a double.Parse(properties.AfterProperties[<field name>] .ToString()).

Well, that’s it for now. I have a few more “gotcha”-posts, and a couple of “did you know that”-posts waiting to be written, so stay tuned.

Both ISA Server 2004/2006 and TMG 2010 can store logs in SQL Server (MSDE/Express Edition) which is recommended configuration.

Unlike ISA Server which stores IP address as bigint type TMG 2010 stores them as GUIDs for IPv4 and IPv6 compatibility.

So, a function is needed to see IPv4 addresses in easily readable way.

CREATE FUNCTION [dbo].[GuidToIPv4]
(
@guid VARCHAR(36)
)
RETURNS VARCHAR(15)
AS
BEGIN
 DECLARE @hex VARCHAR(8)
 SET @hex = LEFT(@guid, 8 )
 RETURN CONVERT(VARCHAR(3), sys.fn_replvarbintoint(sys.fn_cdc_hexstrtobin(LEFT(@hex, 2))), 0) + '.' +
  CONVERT(VARCHAR(3), sys.fn_replvarbintoint(sys.fn_cdc_hexstrtobin(SUBSTRING(@hex, 3, 2))), 0) + '.' +
  CONVERT(VARCHAR(3), sys.fn_replvarbintoint(sys.fn_cdc_hexstrtobin(SUBSTRING(@hex, 5, 2))), 0) + '.' +
  CONVERT(VARCHAR(3), sys.fn_replvarbintoint(sys.fn_cdc_hexstrtobin(RIGHT(@hex, 2))), 0)
END
GO

Actually, IPv4 address forms a GUID where first 8 characters naturally make 4 bytes in hex – 1.1.1.1 makes 01010101-FFFF-0000-0000-000000000000 and 255.255.255.255 makes FFFFFFFF-FFFF-0000-0000-000000000000, so if you read hex fluently – here you go.

When using the SharePoint object model, it is important to properly dispose of instantiated objects of certain classes to avoid memory leaks. The most common objects that need to be disposed are SPSite and SPWeb. However, there are certain situations where it is not obvious that an instance is even created.

The SharePoint Dispose Checker Tool checks your assemblies against the dispose patterns listed in Roger Lamb’s SharePoint Developer Blog to check whether any of the patterns are in your code without being disposed.

The tool is run from the command prompt with your assembly as argument, or alternatively, a path to a folder containing several assemblies. If the PDB-files are in the same folder, the output will include additional source information about the problems detected.

Check it out at http://code.msdn.microsoft.com/SPDisposeCheck

When developing using the SharePoint object model, certain operations has to be run with elevated privileges. For instance, setting information into the property bag of a site needs to be done with elevated privileges. This post shows how this is done, and also includes a helper method for making it easier and shorter to do this.

There is a method called SPSecurity.RunWithElevatedPrivileges in the object model that takes a delegate as argument. The delegate is then run with more permissions. An important note regarding this: You must not use old references to SPWeb or SPSite instances inside your delegate, since they are “contaminated” with lower permissions. What you have to do is to create new SPSite and SPWeb instances using the Ids of the sites and webs you already have a reference to, like this:

SPSecurity.RunWithElevatedPrivileges(delegate()
{
    using (SPSite site = new SPSite(SPContext.Current.Site.ID))
    {
        using (SPWeb elevatedWeb = site.OpenWeb(webId))
        {
            //Your code here
        }
    }
});

If you need to do these kind of operations in several locations, this is a lot of repeating code to include. A colleague of mine made a small helper method that does the setup for elevated privileges for you. Here’s the short code snippet:

private delegate void CodeToRunElevated(SPWeb elevatedWeb);
private static void RunElevated(Guid webId, CodeToRunElevated secureCode)
{
    SPSecurity.RunWithElevatedPrivileges(delegate()
    {
        using (SPSite site = new SPSite(SPContext.Current.Site.ID))
        {
            using (SPWeb elevatedWeb = site.OpenWeb(webId))
            {
               secureCode(elevatedWeb);
            }
        }
    });
}

To invoke this, you call on the method with the Id of your web as one argument, and a delegate taking an SPWeb as the other. When the method is invoked, the SPWeb argument will be “uncontaminated” and pushed to elevated privileges. This example sets the name, title, and description of a site.

RunElevated(web.ID, delegate(SPWeb elevatedWeb)
{
    elevatedWeb.Name = siteTitle;
    elevatedWeb.Title = siteTitle;
    elevatedWeb.Description = siteDescription;
    elevatedWeb.Update();
});

We have been on the quiet side on the blog lately, but fortunately that’s because we’ve been super busy with customer work. This means we need more dev muscle.

Sorry for spamming the blog with a recruitment plug, but if you are a guru dev looking for a change of scenery in the Vaasa region, have a look at our job posting on our main web site here. Thanks!

In a previous SharePoint project, I implemented a few event handlers that get called whenever an item in a list gets changed (or added/deleted). There were a few problems along the way that took a bit of searching before I found solutions. This post documents a few of the things that are good to know.

The event handlers that I implemented where all of the synchronous ItemUpdating kind. There are also asynchronous events, like for instance ItemUpdated, but for the scenario at hand, I wanted to have some special handling depending on certain values of an item.

The event handler is of the form

public override void ItemUpdating(SPItemEventProperties properties)

The properties object contains the collections BeforeProperties and AfterProperties that helps you to find out what has changed for your item,  i.e. compare
properties.BeforeProperties[<field name>].ToString() to
properties.AfterProperties[<field name>].ToString(). You can also modify the value of the fields in AfterProperties to affect what is actually stored in the list.

Here comes the first gotcha; the BeforeProperties are only populated for document libraries. If you have an event handler on a custom list, the BeforeProperties collection is empty. So in order to check the current value of a field, you have to use properties.ListItem[<field name>] instead.

Second gotcha; be aware of the internal name of fields. They have a sneaky behaviour in this case. As usual you should use the internal name of the field instead of the display name when accessing the field, i.e. “Evaluation_x0020_Date” instead of “Evaluation Date”. However, you can do properties.ListItem[“Evaluation Date”] to get the current value of the field, BUT to get the new value from AfterProperties, you have to do properties.AfterProperties[“Evaluation_x0020_Date”]. Here comes the even sneakier behaviour; if you try to do properties.AfterProperties[“Evaluation Date”], it doesn’t fail, but returns null. Usually, if you try to access a field that does not exist, an exception is thrown. However, “Evaluation Date” passes as a valid field name, but the value cannot be found.

The third problem I had was related to date fields. In my event handler, I wanted to make sure that a certain date field remained unchanged if some other condition was met. The easiest solution would of course be

properties.AfterProperties[“Decision Date”] = properties.BeforeProperties[“Decision Date”]

As already stated in the first gotcha, the BeforeProperties is not populated for lists, so the statement was revised to

properties.AfterProperties[“Decision Date”] = properties.ListItem[“Decision Date”]

Now, this is still too simple, if you read the gotcha number two, you know that we have to use the internal name. Taking this into account, the third revision of the line is

properties.AfterProperties[“Decision_x0020_Date”] = properties.ListItem[“Decision_x0020_Date”]

This still doesn’t work. Even though all the properties are strings, and it is the same field, the formats of the strings are somehow still incompatible. The data type in this case was a datetime. It turns out that the format that comes out of the ListItem is in the format the SharePoint site uses, while the AfterProperties need the date in ISO8601 format. The fourth and final iteration (that actually works) of the line ended up as

properties.AfterProperties[“Decision_x0020_Date”] = Microsoft.SharePoint.Utilities.SPUtility.CreateISO8601DateTimeFromSystemDateTime(DateTime.Parse(properties.ListItem[“Decision_x0020_Date”].ToString()))

Short and concise.

When creating custom webparts or other custom features in SharePoint that retrieves data from a SQL server, there are a few gotchas and pitfalls that you should be aware of. I spent a few hours battling a couple of problems, so I thought I’d document the things I found out here to spread the knowledge.

I was creating a custom webpart that retrieved data from a SQL server. On my development machine, I used a test SQL user with username and password directly in the connection string in the web.config and things worked as they should. The problems started when I deployed my solution to the test server.

On the test server, I changed the connection string to use integrated security instead, and when trying to access the page, I was greeted with an error message stating that I was not allowed to have a connection string with the words Integrated Security in it. This happens since SharePoint adds a tag mapping that replaces the normal SqlClient assembly with SharePoint’s own. Apparently that SqlClient does not support integrated security. So, what I had to do was to add the following line to my web.config in the tagMappings-section:

<remove tagType=”System.Web.UI.WebControls.SqlDataSource, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a” />

After I added this line, things worked ok when I tried the page on the test server. However, when I asked a colleague to try out the page from his machine, another issue arose. He was greeted with the message: Login failed for user ‘NT AUTHORITY\ANONYMOUS LOGON’. This happens since SharePoint by default tries to impersonate the user browsing the site, so when using integrated security (if your environment is set up for impersonation multi-hop) SharePoint actually connects to the database as you. If impersonation-forwarding is not supported, you are instead greeted with the previously mentioned login failed message.

What I actually wanted to do in my webpart was to connect to the database as the SharePoint service user, not using impersonation. To fix this, I created two helper methods that turns off impersonation temporarily.

private WindowsImpersonationContext ctx = null;
public void UseAppPoolIdentity()
{
  try
  {
    if (!WindowsIdentity.GetCurrent().IsSystem)
    {
      ctx = WindowsIdentity.Impersonate(System.IntPtr.Zero);
    }
  } catch { }
}
public void ReturnToImpersonatingCurrentUser()
{
  try
  {
    if (ctx != null) { ctx.Undo(); }
  }
  catch { }
}

These calls are then placed around the code that should be run as the service user, for instance when retrieving information from the SQL database, like this:

UseAppPoolIdentity();
// Code to retrieve data
ReturnToImpersonatingCurrentUser();