datagrid.cs

一种.net实现ajax方法的类库

            }
            columnTemplateFormat += "}}";

            if (columns == null) columns = new List<DataGridColumn>();

            if ((options & DataGridOptions.Deletable) == DataGridOptions.Deletable)
            {
                DataGridColumn col = new DataGridColumn();
                col.Name = "Delete";
                Label l = root.CreateWidget<Label>();
                l.Text = col.Name;
                l.id = string.Format("{0}_deleteHeader", ClientId, col.Name);
                l.rendered = true;
                col.HeaderTemplate = l;
                LinkButton lb = root.CreateWidget<LinkButton>();
                lb.id = "delete";
                lb.Label = "Delete";
                lb.ClientArguments["evt"] = "'OnDelete'";
                col.ViewTemplate = lb;
                columns.Add(col);
            }

            if ((options & DataGridOptions.AutoGenerateColumns) == DataGridOptions.AutoGenerateColumns)
            {
                ColumnInfo[] fields = ColumnInfoManager.RequestColumns(DataSource,typeof(T));
                foreach (ColumnInfo fi in fields )
                {
                    if (autogeneratFieldNames != null && !autogeneratFieldNames.Contains(fi.Name))
                        continue;
                    if (fi.DataType == DataType.RecordList)
                        continue;
                    DataGridColumn col = new DataGridColumn();
                    col.Name = fi.Name;
                    col.ViewTemplate = DataTypeFieldBuilder.GetViewWidget(fi);
                    col.EditTemplate = (IDataBindable)DataTypeFieldBuilder.GetEditWidget(fi,FieldLayout.Terse);
                    Label l = root.CreateWidget<Label>();
                    l.Text = col.Name;
                    l.id = string.Format("{0}_{1}Header", ClientId, col.Name);
                    l.rendered = true;
                    col.HeaderTemplate = l;
                    columns.Add(col);
                }
            }

            for( int i = 0; i < columns.Count; i++ )
            {
                DataGridColumn col = columns[i];
                string editTemplateCommand = "null";
                if (col.EditTemplate != null)
                {
                    Widget editTemplate = col.EditTemplate as Widget;
                    editTemplateCommand = (col.EditTemplate as Widget).GetClientCommand(true);
                    recurseSetwidgetRendered(editTemplate);
                }
                
                cols.Add(string.Format(
                       columnTemplateFormat,
                       col.Name,
                       col.ViewTemplate.GetClientCommand(true),
                       col.HeaderTemplate.GetClientCommand(true),
                       editTemplateCommand));

                recurseSetwidgetRendered(col.ViewTemplate);
            }
            ClientArguments["rowTemplate"] = JSON.ArrayToJSON(cols);
        }

        private void recurseSetwidgetRendered( Widget c )
        {
            c.rendered = true;
            if( c.Widgets != null )
                foreach (Widget c2 in c.Widgets)
                    recurseSetwidgetRendered(c2);
        }

        bool dataBound = false;
        public void DataBind()
        {
            if (!columnsBuilt) buildColumns();
            if (DataSource == null)
            {
                DataSource = new RecordList<T>();
            }
            ClientArguments["rows"] = DataSource.toJSON(JSON.Type.Array, columns, pageIndex, pageSize);
            if (rendered)
            {
                InvokeClientMethod("DataBind", ClientArguments["rows"]);
            }
            dataBound = true;
        }

        private string currentwidgetType;
        public override void HandleEvents(string evt, string args)
        {
            if (OnCustomEvent != null)
            {
                //if( !OnCustomEvent(this, ) ) return;
            }

            string[] parts = null;
            int rowIndex = -1, cellIndex = -1;
            if (ClientArguments.ContainsKey("widgetKey"))
            {
                ClientArguments["widgetKey"] = ClientArguments["widgetKey"].Substring(
                    ClientArguments["widgetKey"].IndexOf(this.id));
                parts = ClientArguments["widgetKey"].Split('_');
                SelectedRowIndex = rowIndex = Convert.ToInt32(parts[1]);
                SelectedCellIndex = cellIndex = Convert.ToInt32(parts[2]);
            }

            switch( evt )
            {
                case "Next >>":
                    PageIndex++;                        
                    break;
                case "<< Prev":
                    PageIndex--;
                    break;
                case "OnDelete":
                    DataSource.DeleteAt(DataRowIndex);
                    InvokeClientMethod("RemoveRow", rowIndex.ToString());
                    break;
                case "OnFilter":
                    break;
                case "OnHeaderClick":
                    SortInfo si = null;
                    if (dataSource.Sorts.Count > 0)
                    {
                        si = dataSource.Sorts[0];
                        if (si.ColumnName == args)
                        {
                            si.Direction = (SortDirection)((int)si.Direction * -1);
                        }
                        else
                        {
                            si = null;
                            dataSource.Sorts.Clear();
                        }
                    }
                    if (si == null)
                        dataSource.Sorts.Add( new SortInfo(args) );
                    dataSource.Sort();
                    DataBind();
                    pagesSent.Clear();
                    break;
                case "OnRowSelect":
                    if (args == null)
                    {
                        this.selectedRowIndex = 0;
                        return;
                    }
                    if (rowToSave > -1)
                    {
                        try
                        {
                            DataSource[DataRowIndex].Save(false);
                        }
                        catch (Exception e)
                        {
                            Debug.Trace("Error saving record: {0} {1}", e.Message, e.InnerException != null ? e.InnerException.Message : "");
                        }
                        rowToSave = -1;
                    }
                    int rowOnPageIndex = int.Parse(args);
                    if (rowOnPageIndex < pageSize)
                        selectedRowIndex = int.Parse(args) + (pageIndex * pageSize);
                    else
                        selectedRowIndex = dataSource.Count - 1;
                    break;
                case "New Row":
                    DataSource.NewRow();
                    InvokeClientMethod("NewRow", (DataSource.Count-1).ToString());
                    break;
                case "OnEdit":
                    editCell(args, rowIndex, cellIndex, true, parts);
                    break;
                default:
                    if (cellIndex > -1)
                    {
                        Widget widget = null, sub = null;
                        currentwidgetType = "view";
                        if (parts[3] == "edit" && columns[cellIndex].EditTemplate != null)
                        {
                            currentwidgetType = "edit";
                            widget = columns[cellIndex].EditTemplate as Widget;
                            if (parts.Length >= 5)
                            {
                                string fullId = Util.Join(parts, "_", false, 4);
                                sub = widget.Find(fullId);
                            }
                        }
                        else
                        {
                            widget = columns[cellIndex].ViewTemplate as Widget;
                            if (parts.Length >= 5)
                                sub = widget.Find(parts[4]);
                        }

                        widget.GetDynamicId = new DynamicIdDelegate(getDataGridId);
                       
                        if (sub != null)
                            sub.HandleEvents(evt, args);
                        else
                            widget.HandleEvents(evt, args);

                        root.RecurseRender(widget, new HtmlSurface(root.HttpContext));
                        
                        if (currentwidgetType == "edit")
                        {
                            IDataBindable db = widget as IDataBindable;
                            editCell(db.Value, rowIndex, cellIndex, false, parts);
                        }

                        widget.GetDynamicId = null;
                    }
                    break;
            }

            base.HandleEvents(evt, args);
        }

        public string getDataGridId(Widget c)
        {
            return string.Format("{0}_{1}_{2}_{3}_{4}", ClientId, selectedRowIndex, selectedCellIndex, currentwidgetType, c.id);
        }

        int rowToSave = -1;
        private void editCell(object value, int rowIndex, int cellIndex, bool editCell, string[] parts )
        {
            int dataSourceIndex = DataRowIndex;
            if (parts.Length >= 6 && parts[4] == "newId") dataSourceIndex = int.Parse(parts[5]);
            DataGridColumn col = columns[cellIndex];
            DataSource[dataSourceIndex][col.Name] = value;
            rowToSave = rowIndex;
            if( editCell ) col.EditTemplate.Value = value;
            SendCommand("{0}.rows[{1}].rowElem.cells[{2}].viewWidget.SetValue({3});",
                ClientId, rowIndex, cellIndex, JSON.PrepareValueForJSON( col.EditTemplate.Value));
        }

        #region IDataSourced Members

        IRecordList IDataSourced.DataSource
        {
            get
            {
                return DataSource as IRecordList;
            }
            set
            {
                DataSource = value as IRecordList<T>;
            }
        }

        #endregion
    }
}