private void RadioButton_Click(object sender, RoutedEventArgs e)
{
    if (rbt4x4.IsChecked.Value)
        size = 4;
    else if (rbt7x7.IsChecked.Value)
        size = 7;
    else if (rbt10x10.IsChecked.Value)
        size = 10;

    var canPlay = true;

    btnNewGame.Visibility = canPlay ? Visibility.Visible : Visibility.Collapsed;
    btnPurchase.Visibility = canPlay ? Visibility.Collapsed : Visibility.Visible;

    imgSize.Source = new BitmapImage(new Uri(string.Format(@"Images/{0}x{0}.png",
        size), UriKind.Relative));
}

private void btnNewGame_Click(object sender, RoutedEventArgs e)
{
    NavigationService.Navigate(
        new Uri(string.Format("/Board.xaml?StartMode=2&Size={0}", size),
        UriKind.Relative));
}

public class HtmlParser
    {
        .
        .
        .
        public void GetPuzzleHtml(int size, Action<string> onSuccess, 
        Action onFailure, Action<int> onProgressChanged)
        {
            var ret = string.Empty;
            var tileMap = string.Empty;

            switch (size)
            {
                case 4:
                    tileMap = string.Concat(
                        "0000",
                        "0000",
                        "0000",
                        "0000");
                    break;
                case 7:
                    tileMap = string.Concat(
                        "0000011",
                        "0000100",
                        "0000100",
                        "0110000",
                        "1000000",
                        "0000000",
                        "0000100");
                    break;
                case 10:
                    tileMap = string.Concat(
                        "0000110001",
                        "0000100001",
                        "0000000000",
                        "0000000000",
                        "1110001000",
                        "1000000100",
                        "0001000011",
                        "0000100000",
                        "0000010000",
                        "1000000000");
                    break;
            }

            var queryString = GetRequestQueryStringBySize(size, tileMap);
            
            var url = string.Format("http://pdos.csail.mit.edu/cgi-bin/theme-cword{0}", 
            queryString.AppendFormat("&t={0}", DateTime.Now.Millisecond));

            DownloadString
                (url,
                //onSuccess
                (html) =>
                {
                    onSuccess(html);
                },
                //onFailure
                () =>
                {
                    onFailure();
                },
                //progress
                (percentage) =>
                {
                    onProgressChanged(percentage);
                });
        }

    private static StringBuilder GetRequestQueryStringBySize(int size, string tileMap)
    {
        var queryString = new StringBuilder();
        for (var row = 0; row < size; row++)
        {
            for (var col = 0; col < size; col++)
            {
                var val = tileMap[row * size + col];
                if (val == '0')
                {
                    var prefix = "&";
                    if (string.IsNullOrEmpty(queryString.ToString()))
                    {
                        prefix = "?";
                    }
                    queryString.AppendFormat("{0}r{1}c{2}=", prefix, row, col);
                }
            }
        }
        return queryString;
    }
}

public class HtmlParser
{
    const string msgFormat = "table[{0}], tr[{1}], td[{2}], code: {3}";
    const string table_pattern = "<table.*?>(.*?)</table>";
    const string tr_pattern = "<tr>(.*?)</tr>";
    const string td_pattern = "<td.*?>(.*?)</td>";
    const string code_pattern = "<code>(.*?)</code>";

    string html = string.Empty;
    WebRequest request;

    public HtmlParser(int size, Action<string> onSuccess,
                      Action onFailure, Action<int> onProgressChanged
        )
    {
        GetPuzzleHtml(size,
            //onSucess
            (html) =>
            {
                this.html = html;
                onSuccess(html);
            },
            //onFailure
            () =>
            {
                onFailure();
            },
            //onProgressChanged
            (percentage) =>
            {
                onProgressChanged(percentage);
            }
        );
    }

    public HtmlParser(string html)
    {
        this.html = html;
    }

    private List<string> GetContents(string input, string pattern)
    {
        MatchCollection matches = Regex.Matches(input, pattern, RegexOptions.Singleline);
        List<string> contents = new List<string>();
        foreach (Match match in matches)
            contents.Add(match.Value);

        return contents;
    }

    public string Parse()
    {
        List<string> tableContents = GetContents(html, table_pattern);
        StringBuilder ret = new StringBuilder();
        int tableIndex = 0;
        foreach (string tableContent in tableContents)
        {
            List<string> trContents = GetContents(tableContent, tr_pattern);
            int trIndex = 0;
            foreach (string trContent in trContents)
            {
                List<string> tdContents = GetContents(trContent, td_pattern);
                int tdIndex = 0;
                foreach (string tdContent in tdContents)
                {
                    Match code_match = Regex.Match(tdContent, code_pattern);
                    string code_value = code_match.Groups[1].Value.Replace(" ", "");

                    if (string.IsNullOrEmpty(code_value))
                        code_value = " ";

                    ret.Append(code_value);
                    tdIndex++;
                }
                ret.Append("");
                trIndex++;
            }
            tableIndex++;
        }

        var words = ret.ToString();

        return words;
    }
    .
    .
    .
}

public HtmlParser(int size, Action<string> onHtmlReady)
{
    GetPuzzleHtml(size, (html) =>
    {
        this.html = html;
        onHtmlReady(html);
    });
}

public class DictionaryHelper
{
    Dictionary<string, string> wordDict = new Dictionary<string, string>();
    public DictionaryHelper(Dictionary<string, string> wordDict)
    {
        this.wordDict = wordDict;
    }

    public void GetDictionaryEntries(Action<string, string, string> callback)
    {
        var client = new dictServiceRef.DictServiceSoapClient();

        client.DefineInDictCompleted +=
           new EventHandler<dictServiceRef.DefineInDictCompletedEventArgs>((s, e) =>
        {
            if (e.Error == null)
            {
                client_DefineInDictCompleted((string)e.UserState, e.Result, callback);
            }
        });

        foreach (var word in wordDict)
        {
            try
            {
                client.DefineInDictAsync("wn", word.Value,
                         string.Format("{0}|{1}", word.Key, word.Value));
            }
            catch
            {
            }
        }
    }

    void client_DefineInDictCompleted(string keyAndValue,
        WordDefinition wordDefinition, Action<string, string, string> callback)
    {
        var definitions = wordDefinition.Definitions;

        var dic = new Dictionary<string, string>();

        var split = keyAndValue.Split('|');
        var key = split[0];
        var value = split[1];
        if (definitions.Length == 0)
        {
            callback(key, value, "");
        }
        else
        {
            foreach (var definition in definitions)
            {
                if (definition.Dictionary.Id == "wn")
                {
                    var def = definition.WordDefinition.ToLower();
                    var postColon = def;

                    if (def.Split(':').Length > 1)
                        postColon = def.Split(':')[1];

                    var preSemicolon = postColon.Split(';')[0];
                    preSemicolon = preSemicolon
                        .Replace("\n", " ");

                    RegexOptions options = RegexOptions.None;
                    Regex regex = new Regex(@"[ ]{2,}", options);
                    preSemicolon = regex.Replace(preSemicolon, @" ");

                    var preOpenBrackets = preSemicolon.Split('[')[0];

                    var preNumber = preOpenBrackets.Split("2:".ToCharArray())[0];

                    preNumber = preNumber.Trim().Replace("\r\n", "");

                    var shortDefinition = preNumber;

                    if (def.StartsWith(string.Format("{0}\n     n", value.ToLower())))
                    {
                        shortDefinition += " (noun)";
                    }

                    callback(key, value, shortDefinition);
                    break;
                }
            }
        }
    }
}

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    AfterEnteredPage();
    Touch.FrameReported += new TouchFrameEventHandler(Touch_FrameReported);
}

void Touch_FrameReported(object sender, TouchFrameEventArgs e)
{
    try
    {
        var touchPoint = e.GetPrimaryTouchPoint(grdTileContainer);
        if (touchPoint.Action == TouchAction.Down)
        {
            swipeDownPoint = touchPoint.Position;
        }
        else if (touchPoint.Action == TouchAction.Move)
        {
            swipeMovePoint = touchPoint.Position;
        }
        else if (touchPoint.Action == TouchAction.Up)
        {
            swipeUpPoint = touchPoint.Position;

            if (swipeDownPoint != new Point(0, 0) &&
                swipeMovePoint != new Point(0, 0))
            {
                boardViewModel.SelectSquaresByPosition(grdTileContainer.ActualWidth,
                grdTileContainer.ActualHeight, swipeDownPoint, swipeUpPoint);

                swipeDownPoint =
                swipeMovePoint =
                swipeUpPoint = new Point(0, 0);

                ShowClues();
            }
        }
    }
    catch (ArgumentException ex)
    {
    }
}

public void SelectSquaresByWordId(string wordId1)
{
    var isSomeSquareUnSelected =
        squares
            .Where(s => s.WordId.Split(',').Contains(wordId1)
                        && !s.IsSelected).Any();

    var isSomeEmptySquareUnSelected =
        squares
            .Where(s => s.WordId.Split(',').Contains(wordId1)
                        && (s.UserLetter ?? "").Trim() == ""
                        && !s.IsSelected).Any();

    if (isSomeEmptySquareUnSelected || !isSomeSquareUnSelected)
    {
        squares
            .ToList()
            .ForEach(s =>
            {
                var split = s.WordId.Split(',');
                s.IsSelected = split.Contains(wordId1) &&
                               (s.UserLetter ?? "").Trim() == "";
                squaresChangedCallback(squares,
                    new NotifyCollectionChangedEventArgs
                              (NotifyCollectionChangedAction.Add,
                     s, s.Row * size + s.Column));
            });
    }
    else
    {
        squares
            .ToList()
            .ForEach(s =>
            {
                var split = s.WordId.Split(',');
                s.IsSelected = split.Contains(wordId1);
                squaresChangedCallback(squares,
                    new NotifyCollectionChangedEventArgs
                              (NotifyCollectionChangedAction.Add,
                     s, s.Row * size + s.Column));
            });
    }

    var txt = "";

    if (clues.Count() > 0)
    {
        var selectedClue = clues.Where(c => c.WordId == wordId1);
        if (selectedClue.Any())
        {
            var clue = selectedClue.First();
            txt = clue.Definition;
        }
        TxtClue = txt.Trim();
    }
}