private void VariablesAction()
        {
            var message = new GenericMessage<BrickCategory>(BrickCategory.Variables);
            Messenger.Default.Send(message, ViewModelMessagingToken.ScriptBrickCategoryListener);

            ServiceLocator.NavigationService.NavigateTo<AddNewScriptBrickViewModel>();
        }

 private void CommandSelectParameterRelease(Y_NORM_PARAMETERS param)
 {
     var message = new GenericMessage<MessageArgsParameterCallback>(this, _cellViewModel,
                                                                          new MessageArgsParameterCallback { Parameter = param });
     Messenger.Default.Send(message);
     Messenger.Default.Send(new NotificationMessage("CloseEditParameter"));
 }

        public static async Task Initialize()
        {
            if (_context != null)
                return;

            //_app.InitializeInterfaces();
            //((ViewModelLocator)ServiceLocator.ViewModelLocator).RegisterViewModels();
            ServiceLocator.ViewModelLocator.RaiseAppPropertiesChanged();

            InitializeSaveHandler();

            if (ViewModelBase.IsInDesignModeStatic)
            {
                var context = new CatrobatContextDesign();

                var messageContext = new GenericMessage<CatrobatContextBase>(context);
                Messenger.Default.Send(messageContext, ViewModelMessagingToken.ContextListener);

                var messageCurrentSprite = new GenericMessage<Sprite>(context.CurrentProject.Sprites[0]);
                Messenger.Default.Send(messageCurrentSprite, ViewModelMessagingToken.CurrentSpriteChangedListener);
            }
            else
            {
                await LoadContext();
            }
        }

        private void ReceivedId(GenericMessage<string> msg)
        {
            if (Album != null && msg.Content == Album.Id) return;

            Album = null;
            Tracks = null;
            LoadData(msg.Content);
        }

        private void ReceivedId(GenericMessage<LastAlbum> msg)
        {
            if (Album != null && msg.Content.Name == Album.Name) return;

            Album = null;
            Tracks = null;
            LoadData(msg.Content);
        }

 private void MessageParameterHandler(GenericMessage<MessageArgsParameter> message)
 {
     _cellViewModel = message.Sender as CellViewModel;
     Parameters = GenericRepository.GetAllList<Y_NORM_PARAMETERS>();
     foreach (var param in message.Content.Parameters)
     {
         Parameters.Remove(param);
     }
 }

        /// <summary>
        /// Returns a generic message view.
        /// </summary>
        /// <param name="message"></param>
        /// <param name="url"></param>
        /// <returns></returns>
        public ActionResult GenericMessage(string message, string url)
        {
            var gm = new GenericMessage()
            {
                Message = message,
                URL = url
            };

            return View("GenericMessage", gm);
        }

 private void HandleMainNavigationMessage(GenericMessage<string> message)
 {
     switch (message.Content)
     {
         case MainNavigation.MAIN_MENU:
             MainContent.Content = null;
             MainMenu.Visibility = Visibility.Visible;
             break;
     }
 }

        public override void NavigatedTo(NavigationMode mode, object parameter)
        {
            base.NavigatedTo(mode, parameter);
            var album = parameter as string;

            if (album == null) return;

            var msg = new GenericMessage<string>(album);
            Messenger.Default.Send(msg, "spotify-album-detail");
        }

        public override void NavigatedTo(NavigationMode mode, object parameter)
        {
            base.NavigatedTo(mode, parameter);

            var album = parameter as LastAlbum;

            if (album == null || mode == NavigationMode.Back) return;

            var msg = new GenericMessage<LastAlbum>(album);
            Messenger.Default.Send(msg, "album-detail");
        }

        public void InitializeInterfaces()
        {
            if(ViewModelBase.IsInDesignModeStatic)
                ServiceLocator.Register(new DispatcherServiceWindowsShared(null));

            ServiceLocator.Register<NavigationServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<SystemInformationServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<CultureServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ImageResizeServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<PlayerLauncherServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ResourceLoaderWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<StorageFactoryWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ImageSourceConversionServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<SoundRecorderServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<PictureServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<NotificationServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ColorConversionServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ShareServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<PortableUIElementsConvertionServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<SoundServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ActionTemplateServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<SensorServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<WebCommunicationServiceWindowsShared>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ZipService>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ProgramImportService>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ContextService>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ProgramExportService>(TypeCreationMode.Lazy);
            ServiceLocator.Register<ProgramValidationService>(TypeCreationMode.Lazy);
            ServiceLocator.Register<TraceService>(TypeCreationMode.Lazy);

            ServiceLocator.ViewModelLocator = new ViewModelLocator();
            ServiceLocator.ViewModelLocator.RegisterViewModels();

            ServiceLocator.ThemeChooser = new ThemeChooser();
            ServiceLocator.LocalizedStrings = new LocalizedStrings();

            Application.Current.Resources["Locator"] = ServiceLocator.ViewModelLocator;
            Application.Current.Resources["ThemeChooser"] = ServiceLocator.ThemeChooser;
            Application.Current.Resources["LocalizedStrings"] = ServiceLocator.LocalizedStrings;

            if (!ViewModelBase.IsInDesignModeStatic)
                InitPresenters();

            if (ViewModelBase.IsInDesignModeStatic)
            {
                Task.Run(async () =>
                {
                    var defaultProject = await new ProgramGeneratorWhackAMole().GenerateProgram("WhackAMole", false);
                    var projectChangedMessage = new GenericMessage<Core.Models.Program>(defaultProject);
                    Messenger.Default.Send(projectChangedMessage, ViewModelMessagingToken.CurrentProgramChangedListener);
                });
            }
        }

        public async Task LaunchPlayer(string programName, bool isLaunchedFromTile)
        {
            var messageProjectName = new GenericMessage<string>(programName);
            Messenger.Default.Send(messageProjectName, 
                                   ViewModelMessagingToken.PlayerProgramNameListener);

            var messageIsStartFromTile = new GenericMessage<bool>(isLaunchedFromTile);
            Messenger.Default.Send(messageIsStartFromTile, 
                                   ViewModelMessagingToken.PlayerIsStartFromTileListener);

            Window.Current.Content = pageFrame;
            ServiceLocator.NavigationService.NavigateTo<PlayerViewModel>();
        }

 private void HandleLightboxNavigationMessage(GenericMessage<string> message)
 {
     switch (message.Content)
     {
         case LightboxNavigation.SELECT_RACE:
             LightboxContent.Content = new SelectRaceView();
             LightboxContent.Visibility = Visibility.Visible;
             break;
         case LightboxNavigation.CLOSE_Lightbox:
             LightboxContent.Visibility = Visibility.Collapsed;
             break;
     }
 }

        public override void NavigatedTo(NavigationMode mode, object parameter)
        {
            base.NavigatedTo(mode, parameter);
            var name = parameter as string;

            if (name == null || mode == NavigationMode.Back)
            {
                return;
            }

            var msg = new GenericMessage<string>(name);
            Messenger.Default.Send(msg, "artist-detail-name");
        }

 private async void StreamingFriends(GenericMessage<TwitterIdCollection> o)
 {
   List<long> userstoadd = new List<long>();
   if (o.Content == null || o.Content.Count <= 0)
     return;
   foreach (KeyValuePair<string, CacheUser> keyValuePair in Enumerable.ToArray<KeyValuePair<string, CacheUser>>((IEnumerable<KeyValuePair<string, CacheUser>>) this.CachedUsers))
   {
     KeyValuePair<string, CacheUser> cacheuser = keyValuePair;
     if (Enumerable.Count<long>(Enumerable.Where<long>((IEnumerable<long>) o.Content, (Func<long, int, bool>) ((y, z) => (Decimal) y == cacheuser.Value.TwitterID))) == 0)
       this.CachedUsers.Remove(cacheuser.Key);
   }
   foreach (long num in (Collection<long>) o.Content)
   {
     Decimal userid = (Decimal) num;
     if (Enumerable.Count<KeyValuePair<string, CacheUser>>(Enumerable.Where<KeyValuePair<string, CacheUser>>((IEnumerable<KeyValuePair<string, CacheUser>>) this.CachedUsers, (Func<KeyValuePair<string, CacheUser>, int, bool>) ((x, r) => x.Value.TwitterID == userid))) == 0)
       userstoadd.Add((long) userid);
   }
   if (userstoadd.Count > 0)
     await this.LoadUsersfromTwitter(userstoadd);
 }

        public async void RecievedFiles(IEnumerable<object> files)
        {
            var fileArray = files as object[] ?? files.ToArray();

            if (fileArray.Length == 0)
            {
                ServiceLocator.DispatcherService.RunOnMainThread(() =>
                    ServiceLocator.NavigationService.NavigateTo<NewSoundSourceSelectionViewModel>());
            }

            var file = (StorageFile)fileArray[0];
            var memoryStream = new MemoryStream();
            var inputStream = await file.OpenReadAsync();
            inputStream.AsStream().CopyTo(memoryStream);
            memoryStream.Seek(0, SeekOrigin.Begin);

            var message = new GenericMessage<Stream>(memoryStream);
            Messenger.Default.Send(message, ViewModelMessagingToken.SoundStreamListener);

            ServiceLocator.DispatcherService.RunOnMainThread(() =>
                    ServiceLocator.NavigationService.NavigateTo<SoundNameChooserViewModel>());
        }

        private void SaveAction()
        {
            var message = new GenericMessage<BroadcastMessage>(BroadcastMessage);
            Messenger.Default.Send(message, ViewModelMessagingToken.BroadcastMessageListener);

            if (_broadcastObject is BroadcastReceivedScript)
            {
                (_broadcastObject as BroadcastReceivedScript).Message = BroadcastMessage;
            }
            if (_broadcastObject is BroadcastSendBrick)
            {
                (_broadcastObject as BroadcastSendBrick).Message = BroadcastMessage;
            }
            if (_broadcastObject is BroadcastSendBlockingBrick)
            {
                (_broadcastObject as BroadcastSendBlockingBrick).Message = BroadcastMessage;
            }

            CurrentProgram.Save();

            base.GoBackAction();
        }

        public void TestMultipleMessageTypes()
        {
            var messenger = new Messenger();
            var recipient = new OldTestRecipient();

            messenger.Register(recipient, typeof(OldTestMessage));
            messenger.Register(recipient, typeof(GenericMessage<InvalidOperationException>));
            messenger.Register(recipient, typeof(GenericMessage<MissingMethodException>));

            Assert.IsNull(recipient.Content);
            Assert.IsNull(recipient.ObjectContent1);
            Assert.IsNull(recipient.ObjectContent2);

            var testObject1 = new InvalidOperationException();
            var genericMessage = new GenericMessage<InvalidOperationException>(this, testObject1);
            messenger.Broadcast(genericMessage);
            Assert.AreEqual(this, recipient.Sender);
            Assert.IsNull(recipient.Content);
            Assert.AreEqual(testObject1, recipient.ObjectContent1);
            Assert.IsNull(recipient.ObjectContent2);

            var testObject2 = new MissingMethodException();
            var genericMessage2 = new GenericMessage<MissingMethodException>(this, testObject2);
            messenger.Broadcast(genericMessage2);
            Assert.AreEqual(this, recipient.Sender);
            Assert.IsNull(recipient.Content);
            Assert.AreEqual(testObject1, recipient.ObjectContent1);
            Assert.AreEqual(testObject2, recipient.ObjectContent2);

            const string TestString = "Hello world";
            var message = new OldTestMessage(this, TestString);
            messenger.Broadcast(message);
            Assert.AreEqual(this, recipient.Sender);
            Assert.AreEqual(TestString, recipient.Content);
            Assert.AreEqual(testObject1, recipient.ObjectContent1);
            Assert.AreEqual(testObject2, recipient.ObjectContent2);
        }

 private void ContextChangedAction(GenericMessage<CatrobatContextBase> message)
 {
     Context = message.Content;
 }

        private void RenameVariableAction(FormulaKey data)
        {
            var message = new GenericMessage<Variable>((Variable) data.LocalVariable ?? data.GlobalVariable);
            Messenger.Default.Send(message, ViewModelMessagingToken.SelectedUserVariableChangedListener);

            ServiceLocator.NavigationService.NavigateTo<ChangeVariableViewModel>();
        }