public void LoadEngineContext(IEngineContext context)
        {
            this.context = context;
            this.soundpath = context.Configuration[EngineConfigurationName.SoundsRoot];

            this.isloaded = true;
        }

 public static void SetAuthCookie(IEngineContext context, User user)
 {
     var username = user.GetType().FullName + "_" + user.Id;
     FormsAuthentication.SetAuthCookie(username, true);
     context.CurrentUser = user;
     Thread.CurrentPrincipal = user;
 }

        public void Init()
        {
            mocks = new MockRepository();
            factory = new SparkViewFactory();
            engineContext = mocks.CreateMock<IEngineContext>();
            server = new MockServerUtility();
            request = mocks.CreateMock<IRequest>();
            response = mocks.CreateMock<IResponse>();

            controller = mocks.CreateMock<IController>();
            controllerContext = mocks.CreateMock<IControllerContext>();
            routingEngine = mocks.CreateMock<IRoutingEngine>();
            output = new StringWriter();
            helpers = new HelperDictionary();

            propertyBag = new Dictionary<string, object>();
            flash = new Flash();
            session = new Dictionary<string, object>();
            requestParams = new NameValueCollection();
            contextItems = new Dictionary<string, object>();


            SetupResult.For(engineContext.Server).Return(server);
            SetupResult.For(engineContext.Request).Return(request);
            SetupResult.For(engineContext.Response).Return(response);
            SetupResult.For(engineContext.CurrentController).Return(controller);
            SetupResult.For(engineContext.CurrentControllerContext).Return(controllerContext);
            SetupResult.For(engineContext.Flash).Return(flash);
            SetupResult.For(engineContext.Session).Return(session);
            SetupResult.For(engineContext.Items).Return(contextItems);

            SetupResult.For(request.Params).Return(requestParams);

            SetupResult.For(controllerContext.LayoutNames).Return(new[] { "default" });
            SetupResult.For(controllerContext.Helpers).Return(helpers);
            SetupResult.For(controllerContext.PropertyBag).Return(propertyBag);

            SetupResult.For(routingEngine.IsEmpty).Return(true);

            var urlBuilder = new DefaultUrlBuilder(server, routingEngine);

            var serviceProvider = mocks.CreateMock<IServiceProvider>();
            var viewSourceLoader = new FileAssemblyViewSourceLoader("Views");
            SetupResult.For(serviceProvider.GetService(typeof(IViewSourceLoader))).Return(viewSourceLoader);
            SetupResult.For(serviceProvider.GetService(typeof(ILoggerFactory))).Return(new NullLogFactory());
            SetupResult.For(serviceProvider.GetService(typeof(ISparkViewEngine))).Return(null);
            SetupResult.For(serviceProvider.GetService(typeof(IUrlBuilder))).Return(urlBuilder);
            SetupResult.For(serviceProvider.GetService(typeof(IViewComponentFactory))).Return(null);
            mocks.Replay(serviceProvider);

            SetupResult.For(engineContext.GetService(null)).IgnoreArguments().Do(
                new Func<Type, object>(serviceProvider.GetService));

            factory.Service(serviceProvider);


            manager = new DefaultViewEngineManager();
            manager.RegisterEngineForExtesionLookup(factory);
            manager.RegisterEngineForView(factory);
        }

		/// <summary>
		/// Sets the context for the controller
		/// </summary>
		/// <param name="engineContext">The engine context.</param>
		/// <param name="context">The controller context.</param>
		public virtual void Contextualize(IEngineContext engineContext, IControllerContext context)
		{
			this.context = context;
			SetEngineContext(engineContext);
			renderingSupport = new RenderingSupport(context, engineContext);
			isContextualized = true;
		}

 /// <summary>
 /// 
 /// </summary>
 /// <param name="context"></param>
 public static void RedirectToLoginAction(IEngineContext context)
 {
     // redirect to login or automatically relogin using cookie.
     NameValueCollection queryStringParameters = new NameValueCollection();
     queryStringParameters.Add("returnUrl", context.Request.Url);
     context.Response.Redirect("authentication", "login", queryStringParameters);
 }

        /// <summary>
        /// Creates the JS code generator info. Temporarily on IViewEngineManager
        /// </summary>
        /// <param name="engineContext">The engine context.</param>
        /// <param name="controller">The controller.</param>
        /// <param name="controllerContext">The controller context.</param>
        /// <returns></returns>
        public JSCodeGeneratorInfo CreateJSCodeGeneratorInfo(IEngineContext engineContext, IController controller,
            IControllerContext controllerContext)
        {
            var codeGen = new JSCodeGenerator();

            return new JSCodeGeneratorInfo(codeGen, new PrototypeGenerator(codeGen), new object[0], new object[0]);
        }

        public void Undo(IEngineContext context)
        {
            var world = context.WorldManager.GetWorlds().Values.FirstOrDefault();
            var map = world.Maps.Values.FirstOrDefault();

            map.Map.SetLayerValue(x, y, layer, lastvalue);
        }

 protected override void OnAfterRendering(IEngineContext context, IController controller,
                                          IControllerContext controllerContext){
     if (writeAfterAction){
         return;
     }
     doLog(context);
 }

        public void LoadEngineContext(IEngineContext context)
        {
            if(context != null)
                this.worldmanager = context.WorldManager;

            this.isloaded = true;
        }

        public bool Perform(ExecuteWhen exec, IEngineContext context, IController controller, IControllerContext controllerContext)
        {
            /*
            ArrayList admins = new ArrayList();
            admins.Add("jpino");
            admins.Add("logas");
            admins.Add("lmolina");

            if (admins.Contains (context.CurrentUser.Identity.Name.ToLower()))
                return true;
            else {
                context.Flash["TypeMsg"] = "alert alert-error";
                context.Flash["Msg"] = "Error : No eres admin";

                context.Response.RedirectToUrl ("/");
                return false;
            }
            */
            if (context.CurrentUser.IsInRole ("admin"))
                return true;
            else {
                context.Flash["TypeMsg"] = "alert alert-error";
                context.Flash["Msg"] = "Error : No eres admin";

                context.Response.RedirectToUrl ("/");
                return false;
            }
        }

        public void LoadContent(GraphicsDevice graphicsDevice, IEngineContext context)
        {
            this.context = context;

            this.startpoint = GetNegativeOne();
            this.endpoint = GetNegativeOne();
        }

 protected override void OnAfterRendering(IEngineContext context, IController controller,
                                          IControllerContext controllerContext){
     var mvc = MvcContext.Create((Controller) controller);
     var logname = acl.token(mvc).Replace("/", ".").Substring(1);
     var log = logger.get(logname);
     log.info(() => myapp.usrName + "\t\tAFTER_RENDER:\t" + acl.token(mvc));
 }

 /// <summary>
 ///             Calculates the param points. Implementers should return value equals or greater than
 ///             zero indicating whether the parameter can be bound successfully. The greater the value (points)
 ///             the more successful the implementation indicates to the framework
 /// </summary>
 /// <param name="context">The context.</param>
 /// <param name="controller">The controller.</param>
 /// <param name="controllerContext">The controller context.</param>
 /// <param name="parameterInfo">The parameter info.</param>
 /// <returns>
 /// </returns>
 public int CalculateParamPoints(IEngineContext context, IController controller, IControllerContext controllerContext, ParameterInfo parameterInfo)
 {
     var token = context.Request[parameterName];
     if (CanConvert(parameterInfo.ParameterType, token))
         return 10;
     return 0;
 }

        public ActionManager(IEngineContext context)
        {
            undo = new Stack<IUserAction>();
            redo = new Stack<IUserAction>();

            this.context = context;
        }

        public void Trigger(BaseCharacter character, IEngineContext context)
        {
            String worldname = this.Parameters["World"];
            String pos = this.Parameters["EntryPointName"];

            IMapEvent tmpevent = null;
            MapHeader tmpheader = null;

            foreach(MapHeader header in context.WorldManager.GetWorld(worldname).Maps.Values)
            {
                tmpevent = context.EventProvider.GetMapsEvents(header.Map).Where( m => m.GetStringType() == "EntryPoint" && m.Parameters["Name"] == pos).FirstOrDefault();
                if(tmpevent != null)
                {
                    tmpheader = header;
                    break;
                }
            }

            if(tmpevent == null || tmpheader == null)
                return;

            context.MovementProvider.EndMove (character, false, true);

            character.WorldName = worldname;
            character.Location = new MapPoint (tmpevent.Rectangle.X + tmpheader.MapLocation.X,
                                                            tmpevent.Rectangle.Y + tmpheader.MapLocation.Y).ToScreenPoint ();
            character.CurrentMap = null;

            context.SceneProvider.Cameras["camera1"].CenterOnCharacter (character);
        }

        public NavData GetNav(IEngineContext context, string section)
        {
            Logger.Debug("Getting nav for {0}", section);

            if (section == "navigation")
            {
                return new NavData
                           {
                               Items = new[]
                                           {
                                               Item(context, "Home", "home", "index"),
                                               Item(context, "About", "home", "about"),
                                               Item(context, "Login", "account", "login")
                                           }
                           };
            }

            if (section == "contents")
            {
                return new NavData
                           {
                               Items = new[]
                                           {
                                               Item(context, "Products", "products", "index"),
                                               Item(context, "About", "home", "about"),
                                               Item(context, "Contact Us", "home", "contact"),
                                               Item(context, "Register", "account", "register")
                                           }
                           };
            }

            throw new ApplicationException("Unknown nav section " + section);
        }

 public AddComment(NewsPost post, Comment comment, IEngineContext context)
 {
     this.post = post;
     this.comment = comment;
     this.context = context;
     this.context = context;
 }

        private void doLog(IEngineContext context){
            if (waserror){
                return;
            }
            try{
                var conversation = myapp.conversation.Current;
                var stopwatch = conversation.Data[_stopwatch] as DateRange;
                stopwatch.Finish = DateTime.Now;
                conversation.Data.Remove(_stopwatch);

                var log = storage.New();
                log.Range = stopwatch;
                log.Elapsed = (int) (stopwatch.Finish - stopwatch.Start).TotalMilliseconds;
                log.Usr = myapp.usrName;
                log.System = context.Request.Uri.GetLeftPart(UriPartial.Path).find(@"^\w+://[^/]+?/\w+");
                log.Url = context.Request.Url;
                prepareLogEntry(log, context);
                using (var s = new TemporaryTransactionSession()){
                    storage.Save(log);
                    s.Commit();
                }
            }
            catch (Exception ex){
                logger.get("comdiv.sys").Error("operation log error", ex);
                waserror = true;
            }
        }

        public static User Authenticate(IEngineContext context)
        {
            var cookieText = context.Request.ReadCookie(FormsAuthentication.FormsCookieName);

            if (string.IsNullOrEmpty(cookieText))
            {
                return null;
            }

            if (context.CurrentUser.Identity.IsAuthenticated == false)
                throw new SecurityException("Er is geen gebruiker ingelogd");

            int userId;

            var name = context.CurrentUser.Identity.Name;
            name = name.Replace(typeof(User).FullName + "_", string.Empty);
            var result = int.TryParse(name, out userId);

            if (result == false)
            {
                throw new SecurityException("De gebruikersidentificatie is niet geldig");
            }

            var user = User.Find(userId);

            if (user == null)
            {
                throw new SecurityException("Deze gebruiker staat niet in de database");
            }

            context.CurrentUser = user;
            Thread.CurrentPrincipal = user;
            return user;
        }

		/// <summary>
		/// Invokes the next handler.
		/// </summary>
		/// <param name="context">The context.</param>
		protected void InvokeNext(IEngineContext context)
		{
			if (nextHandler != null)
			{
				nextHandler.Process(context);
			}
		}