void OnLayoutUpdated(object sender, EventArgs e) {
			if(!IsLoaded) return;
			LayoutUpdated -= OnLayoutUpdated;
			Rows rows = new Rows(this);
			PrepareColumns(rows);
			CorrectColumnsWidth(rows);
		}

 public Move(Columns column, Rows row, Values value, int score = 0)
     : this()
 {
     Row = row;
     Column = column;
     Value = value;
     Score = score;
 }

        public GantChart()
        {
            InitializeComponent();
            items = new Rows();

            graphField1.SelectItem += new GraphField.ItemChanged(GraphFieldItemChanged);
            graphField1.SelectLostItem += new GraphField.ItemChanged(GraphFieldItemChangedLost);
        }

        /// <summary>
        /// Initializes a new instance of <see cref="Workspace"/> for a given <see cref="Token"/> with a given <see cref="ICommunication"/>
        /// </summary>
        /// <param name="token"><see cref="Token">Access token to use</see></param>
        /// <param name="communication"><see cref="ICommunication"/> to use</param>
        public Workspace(Token token, ICommunication communication)
        {
            _communication = communication;

            Groups = new Groups(token, communication);
            Datasets = new Datasets(token, communication);
            Tables = new Tables(token, communication);
            Rows = new Rows(token, communication);
            Dashboards = new Dashboards(token, communication);
            Reports = new Reports(token, communication);
            Tiles = new Tiles(token, communication);
        }

		Rows _Data;				// set dynamically when needed
	
		internal MatrixEntry(MatrixEntry p, int rowCount)
		{
			_HashData = new Hashtable();
			_ColumnGroup = null;
			_RowGroup = null;
			_SortedData = null;
			_Data = null;
			_rowCount = rowCount;
			_Rows = null;
			_Parent = p;
			_FirstRow = -1;
			_LastRow = -1;
		}

        internal Worksheet(XlsDocument doc)
        {
            _doc = doc;

            _visibility = WorksheetVisibilities.Default;
            _sheettype = WorksheetTypes.Default;
            _streamByteLength = 0;

            _dbCellOffsets = new int[0];

            _cells = new Cells(this);
            _rows = new Rows();
            _rowBlocks = new RowBlocks(this);

            _cachedBlockRow = CachedBlockRow.Empty;

            _columnInfos = new List<ColumnInfo>();
        }

		internal Rows GetFilteredData(Report rpt, Row row)
		{
			try
			{
				Rows data;
				if (this._Filters == null)
				{
					if (this._ParentDataRegion == null)
					{
						data = DataSetDefn.Query.GetMyData(rpt);
						return data == null? null: new Rows(rpt, data);	// We need to copy in case DataSet is shared by multiple DataRegions
					}
					else
						return GetNestedData(rpt, row);
				}

				if (this._ParentDataRegion == null)
				{
					data = DataSetDefn.Query.GetMyData(rpt);
					if (data != null)
						data = new Rows(rpt, data);
				}
				else
					data = GetNestedData(rpt, row);

				if (data == null)
					return null;

				List<Row> ar = new List<Row>();
				foreach (Row r in data.Data)
				{
					if (_Filters.Apply(rpt, r))
						ar.Add(r);
				}
                ar.TrimExcess();
				data.Data = ar;
				_Filters.ApplyFinalFilters(rpt, data, true);

				// Adjust the rowcount
				int rCount = 0;
				foreach (Row r in ar)
				{
					r.RowNumber = rCount++;
				}
				return data;
			}
			catch (Exception e)
			{
				this.OwnerReport.rl.LogError(8, e.Message);
				return null;
			}
		}

		internal bool AnyRows(IPresent ip, Rows data)
		{
			if (data == null || data.Data == null ||
				data.Data.Count <= 0)
			{
				string msg;
				if (this.NoRows != null)
					msg = this.NoRows.EvaluateString(ip.Report(), null);
				else
					msg = null;
				ip.DataRegionNoRows(this, msg);
				return false;
			}

			return true;
		}

		internal bool AnyRowsPage(Pages pgs, Rows data)
		{
			if (data != null && data.Data != null &&
				data.Data.Count > 0)
				return true;

			string msg;
			if (this.NoRows != null)
				msg = this.NoRows.EvaluateString(pgs.Report, null);
			else
				msg = null;

			if (msg == null)
				return false;

			// OK we have a message we need to put out
			RunPageRegionBegin(pgs);				// still perform page break if needed

			PageText pt = new PageText(msg);
			SetPagePositionAndStyle(pgs.Report, pt, null);

			if (pt.SI.BackgroundImage != null)
				pt.SI.BackgroundImage.H = pt.H;		//   and in the background image

			pgs.CurrentPage.AddObject(pt);

			RunPageRegionEnd(pgs);					// perform end page break if needed
			return false;
		}

		// Obtain the data from the XML
		internal void GetData(Report rpt, string xmlData, Fields flds, Filters f)
		{
			Rows uData = this.GetMyUserData(rpt);
			if (uData != null)
			{
				this.SetMyData(rpt, uData);
				return;
			}

			int fieldCount = flds.Items.Count;

			XmlDocument doc = new XmlDocument();
			doc.PreserveWhitespace = false;
			doc.LoadXml(xmlData);

			XmlNode xNode;
			xNode = doc.LastChild;
			if (xNode == null || !(xNode.Name == "Rows" || xNode.Name == "fyi:Rows"))
			{
				throw new Exception("Error: XML Data must contain top level rows.");
			}

			Rows _Data = new Rows(rpt, null,null,null);
            List<Row> ar = new List<Row>();
			_Data.Data = ar;

			int rowCount=0;
			foreach(XmlNode xNodeRow in xNode.ChildNodes)
			{
				if (xNodeRow.NodeType != XmlNodeType.Element)
					continue;
				if (xNodeRow.Name != "Row")
					continue;
				Row or = new Row(_Data, fieldCount);
				foreach (XmlNode xNodeColumn in xNodeRow.ChildNodes)
				{	
					Field fld = (Field) (flds.Items[xNodeColumn.Name]);	// Find the column
					if (fld == null)
						continue;			// Extraneous data is ignored
					TypeCode tc = fld.qColumn != null? fld.qColumn.colType: fld.Type;

					if (xNodeColumn.InnerText == null || xNodeColumn.InnerText.Length == 0)
						or.Data[fld.ColumnNumber] = null;
					else if (tc == TypeCode.String)
						or.Data[fld.ColumnNumber] = xNodeColumn.InnerText;
					else
					{
						try
						{
							or.Data[fld.ColumnNumber] = 
								Convert.ChangeType(xNodeColumn.InnerText, tc, NumberFormatInfo.InvariantInfo);
						}
						catch	// all conversion errors result in a null value
						{
							or.Data[fld.ColumnNumber] = null;
						}
					}
				}
				// Apply the filters 
				if (f == null || f.Apply(rpt, or))
				{
					or.RowNumber = rowCount;	// 
					rowCount++;
					ar.Add(or);
				}
			}

            ar.TrimExcess();		// free up any extraneous space; can be sizeable for large # rows
			if (f != null)
				f.ApplyFinalFilters(rpt, _Data, false);

			SetMyData(rpt, _Data);
		}

		internal void SetRows(Report rpt, Rows rows)
		{
			WorkClass wc = GetValue(rpt);
			wc.rows = rows;
			return;
		}

        private int NumberOfSquaresInRegionCouldUseValue(Columns column, Rows row, Values value)
        {
            int r = (int)row / 3;
            int c = (int)column / 3;
            var result = 0;
            for (int i = 0; i < 3; i++)
                for (int j = 0; j < 3; j ++ )
                {
                    Rows ro = (Rows)(r*3+i);
                    Columns co = (Columns)(c * 3 + i);
                    if (CouldPutValueInSquare(co, ro, value)) result++;
                }

            return result;
        }

		internal void SetData(Report rpt, IDataReader dr, Fields flds, Filters f)
		{
			if (dr == null)			// Does user want to remove user data?
			{	
				SetMyUserData(rpt, null);
				return;
			}

			Rows rows = new Rows(rpt,null,null,null);		// no sorting and grouping at base data

            List<Row> ar = new List<Row>();
			rows.Data = ar;
			int rowCount=0;
			int maxRows = _RowLimit > 0? _RowLimit: int.MaxValue;
			while (dr.Read())
			{
				Row or = new Row(rows, dr.FieldCount);
				dr.GetValues(or.Data);
				// Apply the filters 
				if (f == null || f.Apply(rpt, or))
				{
					or.RowNumber = rowCount;	// 
					rowCount++;
					ar.Add(or);
				}
				if (--maxRows <= 0)				// don't retrieve more than max
					break;
			}
            ar.TrimExcess();		// free up any extraneous space; can be sizeable for large # rows
			if (f != null)
				f.ApplyFinalFilters(rpt, rows, false);

			SetMyUserData(rpt, rows);
		}

        internal void Run(IPresent ip, Rows rs, int start, int end)
        {
            // if no rows output or rows just leave
            if (rs == null || rs.Data == null)
                return;
            if (this.Visibility != null && Visibility.IsHidden(ip.Report(), rs.Data[start]) && Visibility.ToggleItem == null)
                return;                 // not visible

            for (int r=start; r <= end; r++)
            {
                _TableRows.Run(ip, rs.Data[r]);
            }
            return;
        }

        internal void RunPage(Pages pgs, Rows rs, int start, int end, float footerHeight)
        {
            // if no rows output or rows just leave
            if (rs == null || rs.Data == null)
                return;

            if (this.Visibility != null && Visibility.IsHidden(pgs.Report, rs.Data[start]))
                return;                 // not visible

            Page p;

            Row row;
            for (int r=start; r <= end; r++)
            {
                p = pgs.CurrentPage;			// this can change after running a row
                row = rs.Data[r];
                float hrows = HeightOfRows(pgs, row);	// height of all the rows in the details
                float height = p.YOffset + hrows;
                if (r == end)
                    height += footerHeight;		// on last row; may need additional room for footer
                if (height > pgs.BottomOfPage)
                {
                    p = OwnerTable.RunPageNew(pgs, p);
                    OwnerTable.RunPageHeader(pgs, row, false, null);
                    _TableRows.RunPage(pgs, row, true);   // force checking since header + hrows might be > BottomOfPage
                }
                else
                    _TableRows.RunPage(pgs, row, hrows > pgs.BottomOfPage);
            }
            return;
        }

 internal Row(Rows r, int columnCount)
 {
     _R = r;
     _Data = new object[columnCount];
     _Level=0;
 }

		internal void AddPageExpressionRow(Report rpt, string exprname, Row r)
		{
			if (exprname == null || r == null)
				return;

			if (_PageExprReferences == null)
				_PageExprReferences = new Dictionary<string, Rows>();

			Rows rows=null;
            _PageExprReferences.TryGetValue(exprname, out rows);
            if (rows == null)
			{
				rows = new Rows(rpt);
				rows.Data = new List<Row>();
				_PageExprReferences.Add(exprname, rows);
			}
			Row row = new Row(rows, r);	// have to make a new copy
			row.RowNumber = rows.Data.Count;
			rows.Data.Add(row);			// add row to rows
			return;
		}

        public IEnumerable<Values> GetValueOptions(Columns column, Rows row)
        {
            var usedValues = GetDeniedValues(column, row);

            for (int i = 0; i < 9; i++)
            {
                Values candidate = (Values)(1 << i);
                if ((usedValues & candidate) == Values.None)
                    yield return candidate;
            }
        }

 public Values GetCellValue(Columns column, Rows row)
 {
     return this._BoardValues[(int)column, (int)row];
 }

 private bool CouldPutValueInSquare(Columns column, Rows row, Values value)
 {
     int r = (int)row;
     int c = (int)column;
     return (
         ((_RowValues[r] & value) == 0) &&
         ((_ColumnValues[c] & value) > 0) &&
         ((_RegionValues[c / 3, r / 3] & value) == 0)
         );
 }