public ActionResult GridData(string entityName)
        {
            GridRequest request = new GridRequest(Request);
            var query = (from a in FlowContract.FlowArchives where a.CreatorUserId==Operator.UserId
                         join i in FlowContract.FlowItems on a.FlowItemId equals i.Id
                         join r in FlowContract.FlowRelateForms on i.FlowDesignId equals r.FlowDesignId
                         join f in FlowContract.FlowForms on r.FlowFormId equals f.Id
                         join d in CommonContract.Dictionarys on f.TypeVal equals d.Value
                         select new FlowFormDto
                         {
                             Id = a.Id,
                             FormName = i.EntityName,
                             TypeVal = f.TypeVal,
                             TypeName = d.Name,
                             CreatorUserName = a.CreatorUserName,
                             CreatTime = a.CreatedTime
                         })
                        .WhereIf(c => c.FormName.Contains(entityName), !entityName.IsNullOrEmpty());
            var total = query.Count();
            if (request.PageCondition.SortConditions.Length > 0)
            {
                foreach (var item in request.PageCondition.SortConditions)
                {
                    query = query.OrderBy(item.SortField, item.ListSortDirection);
                }
            }
            else
                query = query.OrderBy("CreatTime", ListSortDirection.Descending);

            var list = query.Skip((request.PageCondition.PageIndex - 1) * request.PageCondition.PageSize).Take(request.PageCondition.PageSize).ToList();
            var data = new GridData<FlowFormDto>(list, total);

            return Json(data, JsonRequestBehavior.AllowGet);
        }

 public static GridData GetGridDataWithPagingBandejaNotificaciones(
     string colName, string sortOrder, int numPage, int numRows, string searchField, string searchString, string searchOper, bool isSearch)
 {
     GridData gridData = new GridData();
     gridData = _getListListConPaginacionServicios(numPage, numRows, numPage, isSearch, searchField, searchString, searchOper);
     return gridData;
 }

 public Map DataToMap(JsonData Data)
 {
     mapname = Data ["Name"].ToString ();
     PerfectMove = int.Parse (Data ["Step"].ToString ());
     width= int.Parse (Data ["Width"].ToString ());
     height= int.Parse (Data ["Height"].ToString ());
     for(int i=0;i<Data["Grid"].Count;i++) {
         JsonData jd=Data["Grid"][i];
         GridPos.Add (new Vector2(float.Parse (jd["x"].ToString ()),float.Parse (jd["y"].ToString ())));
         GridData d=new GridData(int.Parse(jd["data"][0].ToString ()),int.Parse(jd["data"][1].ToString ()),int.Parse(jd["data"][2].ToString ()));
         GData.Add (d);
     }
     for(int i=0;i<Data["Block"].Count;i++)
     {
         JsonData jd=Data["Block"][i];
         if(jd==null)
             break;
         AllBlock.Add (new Vector2(float.Parse (jd["x"].ToString ()),float.Parse (jd["y"].ToString ())));
     }
     GPD = new Dictionary<Vector2, GridData> ();
     for (int i=0; i<GridPos.Count; i++) {
         GPD.Add (GridPos[i],GData[i]);
     }
     return this;
 }

 public static GridData GetGridDataWithPagingHistorial(
     string colName, string sortOrder, int numPage, int numRows, string searchField, string searchString, string searchOper, bool isSearch, int Paciented)
 {
     GridData gridData = new GridData();
     gridData = _getListListConPaginacionHistorial(numPage, numRows, numPage, isSearch, searchField, searchString, searchOper);
     return gridData;
 }

 public ActionResult GridData()
 {
     GridRequest request = new GridRequest(Request);
     if (request.PageCondition.SortConditions.Length == 0)
     {
         request.PageCondition.SortConditions = new[]
         {
             new SortCondition("Area"),
             new SortCondition("Controller"), 
             new SortCondition("Name")
         };
     }
     Expression<Func<Function, bool>> predicate = FilterHelper.GetExpression<Function>(request.FilterGroup);
     var page = SecurityContract.Functions.ToPage(predicate,
         request.PageCondition,
         m => new
         {
             m.Id,
             m.Name,
             m.Url,
             m.FunctionType,
             m.OperateLogEnabled,
             m.DataLogEnabled,
             m.CacheExpirationSeconds,
             m.IsCacheSliding,
             m.Area,
             m.Controller,
             m.Action,
             m.IsController,
             m.IsAjax,
             m.IsChild,
             m.IsLocked,
             m.IsTypeChanged,
             m.IsCustom
         });
     GridData<object> gridData = new GridData<object>() { Total = page.Total };
     gridData.Rows = page.Data.Select(m => new
     {
         m.Id,
         m.Name,
         m.Url,
         m.FunctionType,
         m.OperateLogEnabled,
         m.DataLogEnabled,
         m.CacheExpirationSeconds,
         m.IsCacheSliding,
         m.Area,
         m.Controller,
         m.Action,
         ModuleName = m.Area + "-" + m.Controller,
         m.IsController,
         m.IsAjax,
         m.IsChild,
         m.IsLocked,
         m.IsTypeChanged,
         m.IsCustom
     }).ToArray();
     return Json(gridData, JsonRequestBehavior.AllowGet);
 }

 public static GridData GetGridDataWithPagingDocumentosAdjuntos(
     string colName, string sortOrder, int numPage, int numRows, string searchField,
     string searchString, string searchOper, bool isSearch, decimal idNotificacion)
 {
     GridData gridData = new GridData();
     gridData = _getLisAdjuntosPaginacion(numPage, numRows, numPage, isSearch, searchField, searchString, searchOper, idNotificacion);
     return gridData;
 }

        //Customer Visit Involved People
        public string CustomerVisitInvolvedPeople()
        {
            string VisitID = Request["VisitID"];
            DataTable dt = CustomerVisitManager.GetVisitInvolvedPeopleData(VisitID);

            GridData gd = new GridData();
            gd.Page = "0";
            gd.DataTable = dt;

            return gd.ToJson();
        }

 public byte CalculateMagnitudeDistance(GridData grid0, GridData grid1, bool isTwoCamp)
 {
     if (isTwoCamp)
     {
         return (byte)(Mathf.Pow(grid0.XGrid - grid1.XGrid, 2) + Mathf.Pow(grid0.ZGrid + grid1.ZGrid + 1, 2));
     }
     else
     {
         return (byte)(Mathf.Pow(grid0.XGrid - grid1.XGrid, 2) + Mathf.Pow(grid0.ZGrid - grid1.ZGrid, 2));
     }
 }

 public void registerObject(GameObject obj, float x, float y, float width, float height, int cost)
 {
     GridData d = new GridData();
     d.cost = cost;
     d.xOffset = obj.transform.position.x - x;
     d.yOffset = obj.transform.position.y - y;
     getGridCoords(x - width/2, y - height/2, out d.fromX, out d.fromY);
     getGridCoords(x + width/2, y + height/2, out d.toX, out d.toY);
     objectToGridData[obj.GetHashCode()] = d;
     this.updateGrid(d.fromX, d.fromY, d.toX, d.toY, cost);
     //Debug.Log(string.Format("Registered object: {0} at ({1},{2}) ({3}, {4})", obj.GetHashCode(), d.fromX, d.fromY, d.toX, d.toY));
 }

        public string GetFiles()
        {
            string FileID = Request["FileID"];
            DataTable dt = null;
            if (!String.IsNullOrWhiteSpace(FileID))
            {
                dt = FileHelper.GetFilesData(FileID, null);
            }
            GridData gd = new GridData();
            gd.Page = "0";
            gd.DataTable = dt;

            return gd.ToJson(new TableFormatString("CreateTime", "{0:yyyy-MM-dd hh:mm}"));
        }

 public void Should_map_the_constructor_parameters_to_the_right_properties()
 {
     var gridColumns = new List<IGridColumn>
                       {
                           new GridColumn(GridColumnType.Sortable, "Header", "Field", AlignAttribute.Left, false, true, "", ActionName, _rows)
                       };
     var filters = new List<DropDownListData>();
     var pagedGridData = new GridData(null, ControllerName, ".mvc", ActionName, gridColumns, gridColumns.Count, filters, _rows.Count);
     pagedGridData.PagedListParameters.ShouldBeEqualTo(null);
     pagedGridData.ControllerName.ShouldBeEqualTo(ControllerName);
     pagedGridData.ActionName.ShouldBeEqualTo(ActionName);
     Assert.AreSame(gridColumns, pagedGridData.GridColumns);
     pagedGridData.Total.ShouldBeEqualTo(gridColumns.Count);
     pagedGridData.Filters.ShouldBeEqualTo(filters);
     pagedGridData.RowCount.ShouldBeEqualTo(_rows.Count);
 }

	public void SaveMapToFile (string pmFileName)
	{
		BinaryFormatter lvFormater = new BinaryFormatter ();
		FileStream lvFile = File.Open (Application.persistentDataPath + "/" + pmFileName + ".dat", FileMode.OpenOrCreate);

		GridData lvData = new GridData ();
		lvData.x = GridDrawer.instance.gridWidth;
		lvData.z = GridDrawer.instance.gridHeight;
		lvData.graphicsStyle = FloorCreator.instance.GraphicsStyle;
		lvData.obstacles = CollectObstacleData ();
		lvData.players = CollectPlayersData ();
		lvData.enemies = CollectEnemiesData ();

		lvFormater.Serialize (lvFile, lvData);
		lvFile.Close ();
	}

 private ActorBevBase FindTarget(GridData gridData, List<ActorBevBase> actorList)
 {
     byte minDistance = FightMgr.Instance.GetMaxMagnitudeDistance();
     byte minIndex = FightMgr.Instance.GetMaxIndex();
     ActorBevBase target = null;
     foreach (ActorBevBase actor in actorList)
     {
         byte distance = FightMgr.Instance.CalculateMagnitudeDistance(gridData, actor.GridData, true);
         if (distance < minDistance ||
            (distance == minDistance && actor.Index < minIndex))
         {
             target = actor;
             minIndex = target.Index;
             minDistance = distance;
         }
     }
     return target;
 }

		Control createControl(Composite parent) {
			PixelConverter converter = new PixelConverter(parent);
			
			var composite = new Composite(parent, SWT.NONE);
			composite.setFont(parent.getFont());
			
			var layout = new GridLayout();
			layout.numColumns = 2;
			composite.setLayout(layout);

			//
			// Label
			//
			var label = new Label(composite, SWT.LEFT | SWT.WRAP);
			label.setFont(composite.getFont());
			label.setText(Messages.librariesPreferencesLabelText);
	
			var gd = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
			gd.horizontalSpan = 2;
			gd.verticalAlignment = GridData.BEGINNING;
			label.setLayoutData(gd);

			//
			// Table
			//
			var tableComposite = new Composite(composite, SWT.NONE);
			tableComposite.setFont(composite.getFont());
			var tableColumnLayout = new TableColumnLayout();
			tableComposite.setLayout(tableColumnLayout);
			
			var table = new Table(tableComposite, SWT.BORDER | SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL | SWT.CHECK);
			table.setFont(composite.getFont());
			table.setHeaderVisible(false);
			table.setLinesVisible(false);
			var column = new TableColumn(table, SWT.NONE);
			tableColumnLayout.setColumnData(column, new ColumnWeightData(100, false));
	
			// Table viewer
			tableViewer = new CheckboxTableViewer(table);
			tableViewer.setContentProvider(tableContentProvider);
			tableViewer.setCheckStateProvider(tableCheckStateProvider);
			tableViewer.setLabelProvider(tableLabelProvider);
			tableViewer.addCheckStateListener(tableCheckStateListener);
			tableViewer.addSelectionChangedListener(event => {

        /// <summary>
        /// Parse grid data from R host and return <see cref="GridData"/>
        /// </summary>
        /// <param name="input">serialized string from R host</param>
        /// <returns>parsed data</returns>
        public static GridData Parse(string input) {
            input = CleanEscape(input);

            //
            // the implementation here is virtually hard-coded
            // R routine uses dput of list that contains four children in order; dimnames, row.names, col.names, data
            // row.names is character vector, col.names is character vector, and data contains is list of columns, which is in turn a named character vector
            // This is for performance, as generic formatting such as json is too expensive
            //
            int current = 0;
            current = input.IndexOf("structure", current, StringComparison.OrdinalIgnoreCase);
            current = input.IndexOf('(', current);
            current = input.IndexOf("list", current, StringComparison.OrdinalIgnoreCase);
            current = input.IndexOf('(', current);

            current = input.IndexOf("dimnames", current, StringComparison.OrdinalIgnoreCase);
            current = input.IndexOf('=', current);
            string dimnamesValue;
            current = FirstQuotedString(input, current, out dimnamesValue);
            var validHeaderNames = (GridData.HeaderNames) Enum.Parse(typeof(GridData.HeaderNames), dimnamesValue);

            List<string> rowNames = new List<string>();
            current = NamedValue(input, "row.names", rowNames, current, true);
            current = input.IndexOf(',', current);

            List<string> columnNames = new List<string>();
            current = NamedValue(input, "col.names", columnNames, current, true);
            current = input.IndexOf(',', current);

            current = input.IndexOf("data", current, StringComparison.OrdinalIgnoreCase);
            current = input.IndexOf('=', current);

            current = input.IndexOf("structure", current, StringComparison.OrdinalIgnoreCase);
            current = input.IndexOf('(', current);


            List<string> values = new List<string>();
            current = Vector(input, values, current);

            GridData data = new GridData(rowNames, columnNames, values);
            data.ValidHeaderNames = validHeaderNames;

            return data;
        }

 public void InitGrid(GridData[,] grids)
 {
     this.m_GridDic = new Dictionary<FightUIGridCellComponent, GridData>();
     int zLength = grids.GetLength(0);
     int xLength = grids.GetLength(1);
     float cellLength = this.CellPrefab.CellLength;
     for (int z = 0; z < zLength; z++)
     {
         float positionY =((this.Type == ActorType.Player)?(zLength - z): z) * cellLength;
         //float positionY  = z * cellLength;
         for (int x = 0; x < xLength; x++)
         {
             FightUIGridCellComponent cell = Instantiate(this.CellPrefab);
             cell.MyTransform.SetParent(this.MyTransform);
             cell.MyTransform.localRotation = Quaternion.identity;
             float positionX = x * cellLength;
             cell.MyTransform.localPosition = new Vector3(positionX, positionY, 0);
             this.m_GridDic.Add(cell, grids[z, x]);
         }
     }
 }

        // GET /api/<controller>
        public GridData<Holding> Get()
        {
            GridData<Holding> result = new GridData<Holding>();

            result.data = Holdings.Data.AsQueryable();
            result.totalRows = 0;
            var totalRows = result.data.Count();

            string paging = this.Request.RequestUri.ParseQueryString()["paging"];

            if (!string.IsNullOrEmpty(this.Request.RequestUri.ParseQueryString()["sortproperty"]))
            {
                string sortProperty = this.Request.RequestUri.ParseQueryString()["sortProperty"];
                string sortDirection = this.Request.RequestUri.ParseQueryString()["sortDirection"];

                if (sortDirection.ToLower() == "desc")
                {
                    result.data = result.data.AsQueryable().OrderByDescending(sortProperty);
                }
                else
                {
                    result.data = result.data.AsQueryable().OrderBy(sortProperty);
                }
            }

            if (paging.ToLower() == "server")
            {
                int page = 0;
                int pageSize = 0;

                if (int.TryParse(this.Request.RequestUri.ParseQueryString()["page"], out page) &&
                    int.TryParse(this.Request.RequestUri.ParseQueryString()["pageSize"], out pageSize))
                {
                    result.data = result.data.Skip(page * pageSize).Take(pageSize);
                    result.totalRows = totalRows;
                }
            }

            return result;
        }

    public void CreateTiles(GridData gridData)
    {
        _width = gridData.GetWidth();
        _height = gridData.GetHeight();
        for(int column=0; column<_width; ++column)
        {
            for(int row=0; row<_height; ++row)
            {
                Vector3 tilePosition = new Vector3(CalculateTilePosition(column, _height), CalculateTilePosition(row, _width), 0.5f);
                GameObject tile = Instantiate(_tilePrefab, tilePosition, Quaternion.Euler(-90, 0, 0)) as GameObject;
                TileDisplay tileDisplay = tile.GetComponent<TileDisplay>();
                tileDisplay.SetCoordinates(column, row);

                // Don't display grid lines for the last column/row, so
                // that we get that traditional noughts and crosses grid.
                tileDisplay.EnableRightLine(column<_width-1);
                tileDisplay.EnableTopLine(row<_height-1);
                eState state = gridData.GetTileState(new Move(column, row));
                tileDisplay.UpdateDisplay(state);
                tile.name = CreateTileName(column, row);
            }
        }
    }

 public Map Init()
 {
     mapname = "1";
     PerfectMove = 10;
     width = 3;
     height = 3;
     GridData SData = new GridData (0, 0, 3);
     GridData EData = new GridData (1, 0, 3);
     GridData Mirror1 = new GridData (3, 0, 1);
     GridData Mirror2 = new GridData (3, 0, 2);
     GridData Change1 = new GridData (5, 1, 0);
     GridData Change2 = new GridData (5, 2, 0);
     GridData Cross1 = new GridData (4, 0, 1);
     GridPos.Add (new Vector2 (0, 2));
     GData.Add (SData);
     GridPos.Add (new Vector2 (2, 0));
     GData.Add (EData);
     GridPos.Add (new Vector2 (1, 1));
     GData.Add (Cross1);
     GridPos.Add (new Vector2 (0, 1));
     GData.Add (Change1);
     AllBlock.Add (new Vector2(0.5f,1f));
     return this;
 }

        void loadgriddata(GridData griddata)
        {
            list = griddata.poly;

            CMB_camera.Text = griddata.camera;
            NUM_altitude.Value = griddata.alt;
            NUM_angle.Value = griddata.angle;
            CHK_camdirection.Checked = griddata.camdir;
            CHK_usespeed.Checked = griddata.usespeed;
            NUM_UpDownFlySpeed.Value = griddata.speed;
            CHK_toandland.Checked = griddata.autotakeoff;
            CHK_toandland_RTL.Checked = griddata.autotakeoff_RTL;

            CHK_internals.Checked = griddata.internals;
            CHK_footprints.Checked = griddata.footprints;
            CHK_advanced.Checked = griddata.advanced;

            NUM_Distance.Value = griddata.dist;
            NUM_overshoot.Value = griddata.overshoot1;
            NUM_overshoot2.Value = griddata.overshoot2;
            NUM_leadin.Value = griddata.leadin;
            CMB_startfrom.Text = griddata.startfrom;
            num_overlap.Value = griddata.overlap;
            num_sidelap.Value = griddata.sidelap;
            NUM_spacing.Value = griddata.spacing;
            
            rad_trigdist.Checked = griddata.trigdist;
            rad_digicam.Checked = griddata.digicam;
            rad_repeatservo.Checked = griddata.repeatservo;
            chk_stopstart.Checked = griddata.breaktrigdist;

            NUM_reptservo.Value = griddata.repeatservo_no;
            num_reptpwm.Value = griddata.repeatservo_pwm;
            NUM_repttime.Value = griddata.repeatservo_cycle;

            // Copter Settings
            NUM_copter_delay.Value = griddata.copter_delay;
            CHK_copter_headinghold.Checked = griddata.copter_headinghold_chk;
            TXT_headinghold.Text = griddata.copter_headinghold.ToString();

            // Plane Settings
            NUM_Lane_Dist.Value = griddata.minlaneseparation;
        }