public DataTable GetDataTable(IUIGrid uiGrid)
{
if (uiGrid == null)
{
throw new ArgumentNullException("uiGrid");
}
_table = new DataTable();
this.InitialiseLocalData();
_uiGridProperties = uiGrid;
DataColumn column = _table.Columns.Add();
column.Caption = _idColumnName;
column.ColumnName = _idColumnName;
IClassDef classDef = _collection.ClassDef;
foreach (UIGridColumn uiProperty in _uiGridProperties)
{
AddColumn(uiProperty, classDef);
}
var copiedBoCollection = new List <BusinessObject>((IEnumerable <BusinessObject>)_collection);
foreach (BusinessObject businessObject in copiedBoCollection)
{
LoadBusinessObject(businessObject);
}
this.RegisterForEvents();
return(_table);
}
public IUIGrid CreateUIGrid(IClassDef classDef)
{
IUIGrid uiGrid = _factory.CreateUIGridDef();
//The Properties are loaded in the ordinal position order
// that they occur in the XML ClassDef so this will be the
// correct order they should be shown in the UI.
foreach (var propDef in classDef.PropDefcol)
{
if (propDef.IsPartOfObjectIdentity())
{
continue;
}
if (propDef.IsPropForeignKey())
{
continue;
}
uiGrid.Add(GetUIGridColumn(propDef));
}
var uiFilterCreator = new UIFilterCreator(_factory);
uiGrid.FilterDef = uiFilterCreator.CreateUIFilter(classDef);
return(uiGrid);
}
public virtual void TestInitGrid_LoadsDataGridViewDateTimeColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithDateTimeParameterFormat();
IEditableGridControl grid = GetControlFactory().CreateEditableGridControl();
DisposeOnTearDown(grid);
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
IUIGridColumn uiDTColDef = uiGridDef[2];
uiDTColDef.GridControlTypeName = "DataGridViewDateTimeColumn";
AddControlToForm(grid);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
Assert.AreEqual(6, grid.Grid.Columns.Count);
IDataGridViewColumn column3 = grid.Grid.Columns[3];
Assert.AreEqual("TestDateTime", column3.Name);
Assert.AreEqual(uiDTColDef.Heading, column3.HeaderText);
Assert.IsInstanceOf(typeof(IDataGridViewColumn), column3);
AssertGridColumnTypeAfterCast(column3, GetDateTimeGridColumnType());
}
public virtual void TestInitGrid_LoadsDataGridViewComboBoxColumn_WhenPropDefMissing()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWith_Grid_1ComboBoxColumn();
IEditableGridControl grid = GetControlFactory().CreateEditableGridControl();
DisposeOnTearDown(grid);
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
IUIGridColumn uiComboColDef = uiGridDef[0];
uiComboColDef.GridControlTypeName = "DataGridViewComboBoxColumn";
uiComboColDef.PropertyName = "OtherProp";
AddControlToForm(grid);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
Assert.AreEqual(2, grid.Grid.Columns.Count);
IDataGridViewColumn column1 = grid.Grid.Columns[1];
Assert.AreEqual("OtherProp", column1.Name);
Assert.AreEqual(uiComboColDef.Heading, column1.HeaderText);
Assert.IsInstanceOf(typeof(IDataGridViewComboBoxColumn), column1);
AssertGridColumnTypeAfterCast(column1, GetComboBoxGridColumnType());
}
/// <summary>
/// Loads grid definition data from the reader
/// </summary>
protected override void LoadFromReader()
{
_uiGrid = _defClassFactory.CreateUIGridDef();
_reader.Read();
_uiGrid.SortColumn = _reader.GetAttribute("sortColumn");
_reader.Read();
if (_reader.Name == "filter")
{
XmlFilterLoader filterLoader = new XmlFilterLoader(DtdLoader, _defClassFactory);
_uiGrid.FilterDef = filterLoader.LoadFilterDef(_reader.ReadOuterXml());
}
while (_reader.Name == "column")
{
XmlUIGridColumnLoader propLoader = new XmlUIGridColumnLoader(DtdLoader, _defClassFactory);
_uiGrid.Add(propLoader.LoadUIProperty(_reader.ReadOuterXml()));
}
if (_uiGrid.Count == 0)
{
throw new InvalidXmlDefinitionException("No 'column' " +
"elements were specified in a 'grid' element. Ensure " +
"that the element " +
"contains one or more 'column' elements, which " +
"specify the columns to appear in the grid.");
}
}
public void TestInitGrid_With_GridDef()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIGrid uiGridDef = classDef.UIDefCol["default"].UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
IUIGridColumn columnDef1 = uiGridDef[0];
Assert.AreEqual("TestProp", columnDef1.PropertyName);
IUIGridColumn columnDef2 = uiGridDef[1];
Assert.AreEqual("TestProp2", columnDef2.PropertyName);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef, uiGridDef, "test");
//---------------Test Result -----------------------
IDataGridViewColumn idColumn = grid.Grid.Columns[0];
AssertVerifyIDFieldSetUpCorrectly(idColumn);
IDataGridViewColumn dataColumn1 = grid.Grid.Columns[1];
AssertThatDataColumnSetupCorrectly(classDef, columnDef1, dataColumn1);
IDataGridViewColumn dataColumn2 = grid.Grid.Columns[2];
AssertThatDataColumnSetupCorrectly(classDef, columnDef2, dataColumn2);
//---------------Tear Down -------------------------
}
public void TestInitGrid_UIDef_ZeroWidthColumn_HidesColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWith_Grid_2Columns_1stHasZeroWidth();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
IUIGridColumn columnDef1 = uiGridDef[0];
Assert.AreEqual("TestProp", columnDef1.PropertyName);
Assert.AreEqual(0, columnDef1.Width);
IUIGridColumn columnDef2 = uiGridDef[1];
Assert.AreEqual("TestProp2", columnDef2.PropertyName);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
IDataGridViewColumn dataColumn1 = grid.Grid.Columns[1];
AssertThatDataColumnSetupCorrectly(classDef, columnDef1, dataColumn1);
IDataGridViewColumn dataColumn2 = grid.Grid.Columns[2];
AssertThatDataColumnSetupCorrectly(classDef, columnDef2, dataColumn2);
//---------------Tear Down -------------------------
}
public void TestSetupColumnAsCheckBoxType()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWith_Grid_1CheckBoxColumn();
IBusinessObjectCollection colBOs = GetCol_BO_1CheckboxItem(classDef);
IEditableGrid grid = GetControlFactory().CreateEditableGrid();
IDataGridViewColumn dataGridViewColumnSetup = GetControlFactory().CreateDataGridViewCheckBoxColumn();
SetupGridColumnsForMyBo(grid, dataGridViewColumnSetup);
//--------------Assert PreConditions----------------
Assert.AreEqual(1, grid.Columns.Count);
Assert.AreEqual(1, classDef.UIDefCol.Count);
IUIGrid uiGridDef = classDef.UIDefCol["default"].UIGrid;
Assert.IsNotNull(uiGridDef);
Assert.AreEqual(1, uiGridDef.Count);
//---------------Execute Test ----------------------
#pragma warning disable 618,612// maintained test for backward compatibility testing
grid.SetBusinessObjectCollection(colBOs);
#pragma warning restore 618,612
//---------------Test Result -----------------------
IDataGridViewColumn dataGridViewColumn = grid.Columns[0];
AssertIsCheckBoxColumnType(dataGridViewColumn);
//---------------Tear Down -------------------------
}
public void Test_Set_BusinessObjectCollection_SetupColumnAsCheckBoxType()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWith_Grid_1CheckBoxColumn();
IBusinessObjectCollection colBOs = GetCol_BO_1CheckboxItem(classDef);
IEditableGrid grid = GetControlFactory().CreateEditableGrid();
IDataGridViewColumn dataGridViewColumnSetup = GetControlFactory().CreateDataGridViewCheckBoxColumn();
SetupGridColumnsForMyBo(grid, dataGridViewColumnSetup);
//--------------Assert PreConditions----------------
Assert.AreEqual(1, grid.Columns.Count);
Assert.AreEqual(1, classDef.UIDefCol.Count);
IUIGrid uiGridDef = classDef.UIDefCol["default"].UIGrid;
Assert.IsNotNull(uiGridDef);
Assert.AreEqual(1, uiGridDef.Count);
//---------------Execute Test ----------------------
grid.BusinessObjectCollection = colBOs;
//---------------Test Result -----------------------
IDataGridViewColumn dataGridViewColumn = grid.Columns[0];
AssertIsCheckBoxColumnType(dataGridViewColumn);
//---------------Tear Down -------------------------
}
public void TestInitialiseGrid()
{
//---------------Set up test pack-------------------
IClassDef classDef = LoadMyBoDefaultClassDef();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
//---------------Assert Preconditions---------------
Assert.AreEqual(2, uiGridDef.Count, "2 defined columns in the defaultDef");
// Assert.AreEqual("", grid.UiDefName);
Assert.IsNull(grid.ClassDef);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
Assert.AreEqual("default", grid.UiDefName);
Assert.AreEqual(classDef, grid.ClassDef);
Assert.AreEqual
(uiGridDef.Count + 1, grid.Grid.Columns.Count,
"There should be 1 ID column and 2 defined columns in the defaultDef");
Assert.IsTrue(initialiser.IsInitialised);
// Assert.IsTrue(grid.IsInitialised);
}
/// <summary>
/// Initialises the grid with a given alternate UI definition for the class
/// </summary>
/// <param name="classDef">The Classdef used to initialise the grid</param>
/// <param name="uiGridDef">The <see cref="IUIGrid"/> that specifies the grid </param>
/// <param name="uiDefName">The name of the <see cref="IUIGrid"/></param>
public void InitialiseGrid(IClassDef classDef, IUIGrid uiGridDef, string uiDefName)
{
if (classDef == null)
{
throw new ArgumentNullException("classDef");
}
if (uiDefName == null)
{
throw new ArgumentNullException("uiDefName");
}
if (uiGridDef == null)
{
throw new ArgumentNullException("uiGridDef");
}
if (uiGridDef.FilterDef != null)
{
FilterControlBuilder builder = new FilterControlBuilder(_controlFactory);
builder.BuildFilterControl(uiGridDef.FilterDef, Grid.FilterControl);
ShowFilterControl();
}
else if (!FilterControlSetupProgramatically())
{
HideFilterControl();
}
_gridBaseInitialiser.InitialiseGrid(classDef, uiGridDef, uiDefName);
}
/// <summary>
/// Loads grid definition data from the reader
/// </summary>
protected override void LoadFromReader()
{
_uiGrid = _defClassFactory.CreateUIGridDef();
_reader.Read();
_uiGrid.SortColumn = _reader.GetAttribute("sortColumn");
_reader.Read();
if (_reader.Name == "filter")
{
XmlFilterLoader filterLoader = new XmlFilterLoader(DtdLoader, _defClassFactory);
_uiGrid.FilterDef = filterLoader.LoadFilterDef(_reader.ReadOuterXml());
}
while (_reader.Name == "column")
{
XmlUIGridColumnLoader propLoader = new XmlUIGridColumnLoader(DtdLoader, _defClassFactory);
_uiGrid.Add(propLoader.LoadUIProperty(_reader.ReadOuterXml()));
}
if (_uiGrid.Count == 0)
{
throw new InvalidXmlDefinitionException("No 'column' " +
"elements were specified in a 'grid' element. Ensure " +
"that the element " +
"contains one or more 'column' elements, which " +
"specify the columns to appear in the grid.");
}
}
public void TestSetupColumnAsCheckBoxType_FromClassDef()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWith_Grid_1CheckBoxColumn();
IEditableGridControl gridControl = GetControlFactory().CreateEditableGridControl();
GridInitialiser gridInitialiser = new GridInitialiser(gridControl, GetControlFactory());
//--------------Assert PreConditions----------------
Assert.AreEqual(0, gridControl.Grid.Columns.Count);
Assert.AreEqual(1, classDef.UIDefCol.Count);
const string uiDefName = "default";
IUIGrid uiGridDef = classDef.UIDefCol[uiDefName].UIGrid;
Assert.IsNotNull(uiGridDef);
Assert.AreEqual(1, uiGridDef.Count);
//---------------Execute Test ----------------------
gridInitialiser.InitialiseGrid(classDef, uiDefName);
//---------------Test Result -----------------------
Assert.AreEqual(2, gridControl.Grid.Columns.Count, "Should have ID column and should have checkBoxColumn");
IDataGridViewColumn dataGridViewColumn = gridControl.Grid.Columns[1];
AssertIsCheckBoxColumnType(dataGridViewColumn);
//---------------Tear Down -------------------------
}
public void TestInitGrid_LoadsCustomColumnType()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithDateTimeParameterFormat();
IEditableGridControl grid = GetControlFactory().CreateEditableGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
Type customColumnType = typeof(CustomDataGridViewColumnVWG);
uiGridDef[2].GridControlTypeName = customColumnType.Name; //"CustomDataGridViewColumn";
uiGridDef[2].GridControlAssemblyName = "Habanero.Faces.Test.VWG";
AddControlToForm(grid);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
//---------------Test Result -----------------------
Assert.AreEqual(6, grid.Grid.Columns.Count);
IDataGridViewColumn column3 = grid.Grid.Columns[3];
Assert.AreEqual("TestDateTime", column3.Name);
Assert.IsInstanceOf(typeof(IDataGridViewColumn), column3);
AssertGridColumnTypeAfterCast(column3, customColumnType);
}
///<summary>
/// Clones the collection of ui columns this performs a copy of all uicolumns but does not copy the uiFormFields.
///</summary>
///<returns>a new collection that is a shallow copy of this collection</returns>
public IUIDef Clone()
{
IUIForm clonedForm = this.UIForm != null? ((UIForm)this.UIForm).Clone(): null;
IUIGrid clonedGrid = this.UIGrid != null ? ((UIGrid)this.UIGrid).Clone() : null;
UIDef newUIForm = new UIDef(this.Name, clonedForm, clonedGrid);
return(newUIForm);
}
/// <summary>
/// Initialises the grid with a given alternate UI definition for the class
/// </summary>
/// <param name="classDef">The Classdef used to initialise the grid</param>
/// <param name="uiGridDef">The <see cref="IUIGrid"/> that specifies the grid </param>
/// <param name="uiDefName">The name of the <see cref="IUIGrid"/></param>
public void InitialiseGrid(IClassDef classDef, IUIGrid uiGridDef, string uiDefName)
{
SetUpGridColumns(classDef, uiGridDef);
GridBase.UiDefName = uiDefName;
GridBase.ClassDef = classDef;
IsInitialised = true;
}
/// <summary>
/// Initialises the grid structure using the given UI class definition
/// </summary>
/// <param name="classDef">The class definition of the business objects shown in the grid</param>
/// <param name="gridDef">The grid definition to use in setting up the structure</param>
/// <param name="uiDefName">The name of the grid definition.</param>
public void Initialise(IClassDef classDef, IUIGrid gridDef, string uiDefName)
{
if (gridDef == null)
{
throw new ArgumentNullException("gridDef");
}
_editableGridManager.Initialise(classDef, gridDef, uiDefName);
}
public void TestSortColumn()
{
IUIGrid def =
loader.LoadUIGridDef(
@"
<grid sortColumn=""testpropname1 desc"">
<column heading=""testheading1"" property=""testpropname1"" />
</grid>" );
Assert.AreEqual("testpropname1 desc", def.SortColumn);
}
public void Test_CreateUIGrid_ShouldReturnNewUIDef()
{
//---------------Set up test pack-------------------
var gridCreator = new UIGridCreator(GetFactory());
IClassDef classDef = typeof(FakeBo).MapClass();
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IUIGrid returnedUIGrid = gridCreator.CreateUIGrid(classDef);
//---------------Test Result -----------------------
Assert.IsNotNull(returnedUIGrid);
}
/// <summary>
/// Determines whether this object is equal to obj.
/// </summary>
/// <param name="obj">The object being compared to</param>
/// <returns></returns>
public bool Equals(IUIGrid obj)
{
if (ReferenceEquals(null, obj))
{
return(false);
}
if (ReferenceEquals(this, obj))
{
return(true);
}
return(this.Equals((object)obj));
}
public void Test_UIGrid_WhenSet_ShouldSetUIDef()
{
//---------------Set up test pack-------------------
IUIGrid uiGrid = MockRepository.GenerateStub <IUIGrid>();
UIDef uiDef = new UIDef("test", null, null);
//---------------Assert Precondition----------------
Assert.IsNull(uiGrid.UIDef);
//---------------Execute Test ----------------------
uiDef.UIGrid = uiGrid;
//---------------Test Result -----------------------
Assert.AreSame(uiDef, uiGrid.UIDef);
}
/// <summary>
/// Constructor to initialise a new definition with the name, form
/// and grid definitions provided
/// </summary>
/// <param name="name">The name</param>
/// <param name="uiForm">The form definition</param>
/// <param name="uiGrid">The grid definition</param>
public UIDef(string name, IUIForm uiForm, IUIGrid uiGrid)
{
_name = name;
_uiForm = uiForm;
if (_uiForm != null)
{
_uiForm.UIDef = this;
}
_uiGrid = uiGrid;
if (_uiGrid != null)
{
_uiGrid.UIDef = this;
}
}
public void TestInitGrid_UIDef_DateFormat_FormatsDateColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithDateTimeParameterFormat();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
AddControlToForm(grid);
GlobalUIRegistry.DateDisplaySettings = new DateDisplaySettings();
GlobalUIRegistry.DateDisplaySettings.GridDateFormat = "dd MMM yyyy";
//--------------Assert PreConditions----------------
const string formattedPropertyName = "TestDateTimeFormat";
Assert.IsNotNull(uiGridDef[formattedPropertyName]);
Assert.IsNotNull(uiGridDef["TestDateTimeNoFormat"]);
Assert.IsNotNull(uiGridDef["TestDateTime"]);
Assert.IsNull(uiGridDef["TestDateTimeNoFormat"].GetParameterValue("dateFormat"));
Assert.IsNull(uiGridDef["TestDateTime"].GetParameterValue("dateFormat"));
object dateFormatObject = uiGridDef[formattedPropertyName].GetParameterValue("dateFormat");
string dateFormatParameter = dateFormatObject.ToString();
const string expectedFormat = "dd.MMM.yyyy";
Assert.AreEqual(expectedFormat, dateFormatParameter);
MyBO myBo = new MyBO();
DateTime currentDateTime = DateTime.Now;
myBo.SetPropertyValue(formattedPropertyName, currentDateTime);
BusinessObjectCollection <MyBO> col = new BusinessObjectCollection <MyBO>();
col.Add(myBo);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
grid.BusinessObjectCollection = col;
//---------------Test Result -----------------------
Assert.AreEqual(1, col.Count);
Assert.AreEqual(1, grid.Grid.Rows.Count);
IDataGridViewCell dataGridViewCell = grid.Grid.Rows[0].Cells[formattedPropertyName];
//((DataGridViewCellVWG) dataGridViewCell).DataGridViewCell.HasStyle = false;
Assert.AreSame(typeof(DateTime), dataGridViewCell.ValueType);
Assert.AreEqual(currentDateTime.ToString(expectedFormat), dataGridViewCell.FormattedValue);
//---------------Tear Down -------------------------
}
/// <summary>
/// Initialises the grid with a specified alternate UI definition for the class,
/// as provided in the ClassDef
/// </summary>
/// <param name="classDef">The Classdef used to initialise the grid</param>
/// <param name="uiDefName">The name of the UI definition</param>
public void InitialiseGrid(IClassDef classDef, string uiDefName)
{
if (classDef == null)
{
throw new ArgumentNullException("classDef");
}
if (uiDefName == null)
{
throw new ArgumentNullException("uiDefName");
}
IUIGrid gridDef = GetGridDef((ClassDef)classDef, uiDefName);
InitialiseGrid(classDef, gridDef, uiDefName);
}
public void Test_UIGrid_WhenChanged_ShouldResetUIDefOnOld()
{
//---------------Set up test pack-------------------
IUIGrid uiGridOld = MockRepository.GenerateStub <IUIGrid>();
IUIGrid uiGridNew = MockRepository.GenerateStub <IUIGrid>();
UIDef uiDef = new UIDef("test", null, uiGridOld);
//---------------Assert Precondition----------------
Assert.AreSame(uiDef, uiGridOld.UIDef);
//---------------Execute Test ----------------------
uiDef.UIGrid = uiGridNew;
//---------------Test Result -----------------------
Assert.IsNull(uiGridOld.UIDef);
}
public void Test_CreateUIGrid_ShouldCreateFilterDefForGrid()
{
//---------------Set up test pack-------------------
var gridCreator = new UIGridCreator(GetFactory());
IClassDef classDef = typeof(FakeBo).MapClass();
//---------------Assert Precondition----------------
Assert.AreEqual(0, classDef.UIDefCol.Count);
//---------------Execute Test ----------------------
IUIGrid returnedUIGrid = gridCreator.CreateUIGrid(classDef);
//---------------Test Result -----------------------
Assert.IsNotNull(returnedUIGrid.FilterDef);
}
public void TestInitGrid_UIDef_CurrencyFormat_WhenVirtualProp_ShouldFormatColumn()
{
//---------------Set up test pack-------------------
IClassDef classDef = MyBO.LoadClassDefWithCurrencyParameterFormat();
IReadOnlyGridControl grid = CreateReadOnlyGridControl();
IGridInitialiser initialiser = new GridInitialiser(grid, GetControlFactory());
IUIDef uiDef = classDef.UIDefCol["default"];
IUIGrid uiGridDef = uiDef.UIGrid;
AddControlToForm(grid);
//--------------Assert PreConditions----------------
const string formattedPropertyName = "TestCurrencyFormat";
Assert.IsNotNull(uiGridDef[formattedPropertyName]);
Assert.IsNotNull(uiGridDef[formattedPropertyName].GetParameterValue("currencyFormat"));
const string unformattedPropName = "TestCurrencyNoFormat";
Assert.IsNotNull(uiGridDef[unformattedPropName]);
Assert.IsNull(uiGridDef[unformattedPropName].GetParameterValue("currencyFormat"));
object currencyFormat = uiGridDef[formattedPropertyName].GetParameterValue("currencyFormat");
string currencyFormatParameter = currencyFormat.ToString();
const string expectedFormat = "### ###.##";
Assert.AreEqual(expectedFormat, currencyFormatParameter);
MyBO myBo = new MyBO();
const double currencyValue = 222222.55555d;
myBo.SetPropertyValue(formattedPropertyName, currencyValue);
BusinessObjectCollection <MyBO> col = new BusinessObjectCollection <MyBO>();
col.Add(myBo);
//---------------Execute Test ----------------------
initialiser.InitialiseGrid(classDef);
grid.BusinessObjectCollection = col;
//---------------Test Result -----------------------
Assert.AreEqual(1, col.Count);
Assert.AreEqual(1, grid.Grid.Rows.Count);
IDataGridViewCell dataGridViewCell = grid.Grid.Rows[0].Cells[formattedPropertyName];
//((DataGridViewCellVWG) dataGridViewCell).DataGridViewCell.HasStyle = false;
Assert.AreSame(typeof(Double), dataGridViewCell.ValueType);
Assert.AreEqual(currencyValue.ToString(expectedFormat), dataGridViewCell.FormattedValue);
}
protected static IClassDef GetCustomClassDef()
{
ClassDef.ClassDefs.Clear();
ContactPersonTestBO.LoadClassDef_NoOrganisationRelationship();
IClassDef classDef = OrganisationTestBO.LoadDefaultClassDef();
IUIGrid originalGridDef = classDef.UIDefCol["default"].UIGrid;
UIGrid extraGridDef = ((UIGrid)originalGridDef).Clone();
extraGridDef.Remove(extraGridDef[extraGridDef.Count - 1]);
UIDef extraUIDef = new UIDef(CUSTOM_UIDEF_NAME, new UIForm(), extraGridDef);
UIDef gridWithNoForm = new UIDef(GRID_WITHNOFORM, null, extraGridDef);
classDef.UIDefCol.Add(extraUIDef);
return(classDef);
}
public void TestLoadPropertyCollection()
{
IUIGrid def =
loader.LoadUIGridDef(
@"
<grid>
<column heading=""testheading1"" property=""testpropname1"" />
<column heading=""testheading2"" property=""testpropname2"" />
</grid>" );
Assert.AreEqual(2, def.Count);
Assert.AreEqual("testheading1", def[0].Heading);
Assert.AreEqual("testheading2", def[1].Heading);
Assert.IsTrue(String.IsNullOrEmpty(def.SortColumn));
}
/// <summary>
/// Loads UI definition data from the reader
/// </summary>
protected override void LoadFromReader()
{
_reader.Read();
_name = _reader.GetAttribute("name");
_reader.Read();
if (_reader.Name == "grid")
{
var loader = new XmlUIGridLoader(DtdLoader, _defClassFactory);
_uiGrid = loader.LoadUIGridDef(_reader.ReadOuterXml());
}
if (_reader.Name == "form")
{
var loader = new XmlUIFormLoader(DtdLoader, _defClassFactory);
_uiForm = loader.LoadUIFormDef(_reader.ReadOuterXml());
}
}
public void Test_CreateUIGrid_WhenClassDefHasOnePropAndOnePKProp_ShouldCreateFilterDefWithOneFilterPropertyDef()
{
//---------------Set up test pack-------------------
var gridCreator = new UIGridCreator(GetFactory());
IClassDef classDef = typeof(FakeBo).MapClass();
//---------------Assert Precondition----------------
Assert.AreEqual(0, classDef.UIDefCol.Count);
//---------------Execute Test ----------------------
IUIGrid returnedUIGrid = gridCreator.CreateUIGrid(classDef);
//---------------Test Result -----------------------
Assert.AreEqual(1, returnedUIGrid.FilterDef.FilterPropertyDefs.Count);
Assert.AreEqual("Fake Bo Name", returnedUIGrid.FilterDef.FilterPropertyDefs[0].Label);
Assert.AreEqual("FakeBoName", returnedUIGrid.FilterDef.FilterPropertyDefs[0].PropertyName);
}
public DataTable GetDataTable(IUIGrid uiGrid)
{
if (uiGrid == null) throw new ArgumentNullException("uiGrid");
_table = new DataTable();
this.InitialiseLocalData();
_uiGridProperties = uiGrid;
DataColumn column = _table.Columns.Add();
column.Caption = _idColumnName;
column.ColumnName = _idColumnName;
IClassDef classDef = _collection.ClassDef;
foreach (UIGridColumn uiProperty in _uiGridProperties)
{
AddColumn(uiProperty, classDef);
}
var copiedBoCollection = new List<BusinessObject>( (IEnumerable<BusinessObject>) _collection);
foreach (BusinessObject businessObject in copiedBoCollection)
{
LoadBusinessObject(businessObject);
}
this.RegisterForEvents();
return _table;
}
private void CreateColumnForUIDef(IClassDef classDef, IUIGrid gridDef)
{
foreach (IUIGridColumn gridColDef in gridDef)
{
IDataGridViewColumn col;
if (gridColDef.GridControlTypeName == "DataGridViewComboBoxColumn")
{
IDataGridViewComboBoxColumn comboBoxCol = _controlFactory.CreateDataGridViewComboBoxColumn();
IPropDef propDef = GetPropDef(classDef, gridColDef);
ILookupList source = null;
if (propDef != null) source = propDef.LookupList;
if (source != null)
{
DataTable table = new DataTable();
table.Columns.Add("id");
table.Columns.Add("str");
table.LoadDataRow(new object[] {"", ""}, true);
foreach (KeyValuePair<string, string> pair in source.GetLookupList())
{
table.LoadDataRow(new object[] {pair.Value, pair.Key}, true);
}
comboBoxCol.DataSource = table;
// ReSharper disable ConditionIsAlwaysTrueOrFalse
//Hack_: This null check has been placed because of a Gizmox bug_
// We posted this at: http://www.visualwebgui.com/Forums/tabid/364/forumid/29/threadid/12420/scope/posts/Default.aspx
// It is causing a StackOverflowException on ValueMember because the DataSource is still null
if (comboBoxCol.DataSource != null)
{
comboBoxCol.ValueMember = "str";
comboBoxCol.DisplayMember = "str";
}
// ReSharper restore ConditionIsAlwaysTrueOrFalse
}
comboBoxCol.DataPropertyName = gridColDef.PropertyName;
col = comboBoxCol;
this.GridBase.Columns.Add(col);
}
else if (gridColDef.GridControlTypeName == "DataGridViewCheckBoxColumn")
{
col = _controlFactory.CreateDataGridViewCheckBoxColumn();
this.GridBase.Columns.Add(col);
}
else
{
col = CreateCustomColumn(gridColDef);
}
col.HeaderText = gridColDef.GetHeading();
col.Name = gridColDef.PropertyName;
col.DataPropertyName = gridColDef.PropertyName;
col.Width = gridColDef.Width;
col.Visible = gridColDef.Width != 0;
col.SortMode = DataGridViewColumnSortMode.Automatic;
col.ReadOnly = !gridColDef.Editable;
Type propertyType = GetPropertyType(classDef, gridColDef.PropertyName);
if (propertyType != typeof (object))
{
col.ValueType = propertyType;
}
SetupColumnWithDefParameters(col, gridColDef, propertyType);
}
}
private void SetUpGridColumns(IClassDef classDef, IUIGrid gridDef)
{
this.GridBase.Columns.Clear();
CreateIDColumn();
CreateColumnForUIDef(classDef, gridDef);
}
/// <summary>
/// Initialises the grid with a given alternate UI definition for the class
/// </summary>
/// <param name="classDef">The Classdef used to initialise the grid</param>
/// <param name="uiGridDef">The <see cref="IUIGrid"/> that specifies the grid </param>
/// <param name="uiDefName">The name of the <see cref="IUIGrid"/></param>
public void InitialiseGrid(IClassDef classDef, IUIGrid uiGridDef, string uiDefName)
{
SetUpGridColumns(classDef, uiGridDef);
GridBase.UiDefName = uiDefName;
GridBase.ClassDef = classDef;
IsInitialised = true;
}
/// <summary>
/// Initialises the grid structure using the given UI class definition
/// </summary>
/// <param name="classDef">The class definition of the business objects shown in the grid</param>
/// <param name="gridDef">The grid definition to use in setting up the structure</param>
/// <param name="uiDefName">The name of the grid definition.</param>
public void Initialise(IClassDef classDef, IUIGrid gridDef, string uiDefName)
{
if (gridDef == null) throw new ArgumentNullException("gridDef");
_editableGridManager.Initialise(classDef, gridDef, uiDefName);
}
/// <summary>
/// Loads UI definition data from the reader
/// </summary>
protected override void LoadFromReader()
{
_reader.Read();
_name = _reader.GetAttribute("name");
_reader.Read();
if (_reader.Name == "grid")
{
var loader = new XmlUIGridLoader(DtdLoader, _defClassFactory);
_uiGrid = loader.LoadUIGridDef(_reader.ReadOuterXml());
}
if (_reader.Name == "form")
{
var loader = new XmlUIFormLoader(DtdLoader, _defClassFactory);
_uiForm = loader.LoadUIFormDef(_reader.ReadOuterXml());
}
}
///<summary>
///</summary>
///<param name="name"></param>
///<param name="uiForm"></param>
///<param name="uiGrid"></param>
///<returns></returns>
public IUIDef CreateUIDef(string name, IUIForm uiForm, IUIGrid uiGrid)
{
return new UIDef(name, uiForm, uiGrid);
}
#pragma warning disable 612,618
//This should be moved to a private method when this method is removed from UI.
/// <summary>
/// Returns a data view for the UIGridDef provided
/// </summary>
/// <param name="uiGrid">The UIGridDef</param>
/// <returns>Returns a DataTable object</returns>
public IBindingListView GetDataView(IUIGrid uiGrid)
{
var dataTable = GetDataTable(uiGrid);
return dataTable == null ? null : dataTable.DefaultView;
}
/// <summary>
/// See <see cref="IGridControl.Initialise(IClassDef,IUIGrid,string)"/>
/// </summary>
public void Initialise(IClassDef classDef, IUIGrid uiGridDef, string uiDefName)
{
_gridInitialiser.InitialiseGrid(classDef, uiGridDef, uiDefName);
}
/// <summary>
/// Initialises the grid with a given alternate UI definition for the class
/// </summary>
/// <param name="classDef">The Classdef used to initialise the grid</param>
/// <param name="uiGridDef">The <see cref="IUIGrid"/> that specifies the grid </param>
/// <param name="uiDefName">The name of the <see cref="IUIGrid"/></param>
public void InitialiseGrid(IClassDef classDef, IUIGrid uiGridDef, string uiDefName)
{
if (classDef == null) throw new ArgumentNullException("classDef");
if (uiDefName == null) throw new ArgumentNullException("uiDefName");
if (uiGridDef == null) throw new ArgumentNullException("uiGridDef");
if (uiGridDef.FilterDef != null)
{
FilterControlBuilder builder = new FilterControlBuilder(_controlFactory);
builder.BuildFilterControl(uiGridDef.FilterDef, Grid.FilterControl);
ShowFilterControl();
}
else if (!FilterControlSetupProgramatically())
{
HideFilterControl();
}
_gridBaseInitialiser.InitialiseGrid(classDef, uiGridDef, uiDefName);
}
/// <summary>
/// Initialises the grid structure using the given UI class definition
/// </summary>
/// <param name="classDef">The class definition of the business objects shown in the grid</param>
/// <param name="gridDef">The grid definition to use</param>
/// <param name="uiDefName">The name of the grid definition.</param>
public void Initialise(IClassDef classDef, IUIGrid gridDef, string uiDefName) {
_editableGridManager.Initialise(classDef, gridDef, uiDefName);
}
