protected void createdynamiccontrols_decimal()
{
int i = DataTypeIndex.GetValueOrDefault();
++i;
TableRow row = new TableRow();
row.ID = "TableRow_";
TableCell cell1 = new TableCell();
cell1.ID = "TableCell_";
DropDownList Range_DDL_Decimal = new DropDownList();
Range_DDL_Decimal.ID = "RandeDDL_Decimal" + i.ToString();
Range_DDL_Decimal.Items.Insert(0, new ListItem("--Select--", "--Select--"));
Range_DDL_Decimal.Items.Insert(1, new ListItem("Equal", "Equal"));
Range_DDL_Decimal.Items.Insert(2, new ListItem("NotEqual", "NotEqual"));
Range_DDL_Decimal.Items.Insert(3, new ListItem("greater than", "greater than"));
Range_DDL_Decimal.Items.Insert(4, new ListItem("lesser than", "lesser than"));
Range_DDL_Decimal.Items.Insert(5, new ListItem("greater than or equal to", "greater than or equal to"));
Range_DDL_Decimal.Items.Insert(6, new ListItem("lesser than or equal to", "lesser than or equal to"));
Range_DDL_Decimal.Items.Insert(7, new ListItem("Contains", "Contains"));
Range_DDL_Decimal.Items.Insert(8, new ListItem("Is Null", "Is Null"));
Range_DDL_Decimal.Items.Insert(9, new ListItem("Is Not Null", "Is Not Null"));
Range_DDL_Decimal.Items.Insert(10, new ListItem("Between", "Between"));
Range_DDL_Decimal.SelectedIndexChanged += new System.EventHandler(Range_DDL_Decimal_SelectedIndexChanged);
Range_DDL_Decimal.AutoPostBack = true;
cell1.Controls.Add(Range_DDL_Decimal);
//// Add the TableCell to the TableRow
row.Cells.Add(cell1);
dynamic_filter_table.Rows.Add(row);
dynamic_filter_table.EnableViewState = true;
ViewState["dynamic_filter_table"] = true;
}
private void CreateIndex(string tableName, DataTypeIndex index)
{
string indexName = GetIndexName(index);
var fields = new StringBuilder();
foreach (var field in index.Fields)
{
if (fields.Length > 0)
{
fields.Append(", ");
}
fields.Append('[').Append(field.Item1).Append(']');
if (field.Item2 == IndexDirection.Descending)
{
fields.Append(" DESC");
}
}
var sql = string.Format("CREATE {0}CLUSTERED INDEX [{1}] ON [{2}] ({3})",
!index.Clustered ? "NON" : "",
indexName,
tableName,
fields);
ExecuteNonQuery(sql);
}
protected void CreateRangeTextBoxes()
{
int j = DataTypeIndex.GetValueOrDefault();
++j;
TableCell cell2 = new TableCell();
cell2.ID = "Range";
TextBox tb1 = new TextBox();
TextBox tb2 = new TextBox();
Label lbl1 = new Label();
Label lbl2 = new Label();
// Set a unique ID for each TextBox added
tb1.ID = "lowerbound_" + j.ToString();
tb2.ID = "upperbound_" + j.ToString();
lbl1.Text = "LowerBound:";
lbl1.Font.Size = FontUnit.Point(10);
lbl1.Font.Bold = true;
lbl1.Font.Name = "Arial";
lbl2.Text = "UpperBound:";
lbl2.Font.Size = FontUnit.Point(10);
lbl2.Font.Bold = true;
lbl2.Font.Name = "Arial";
cell2.Controls.Add(lbl1);
cell2.Controls.Add(tb1);
cell2.Controls.Add(lbl2);
cell2.Controls.Add(tb2);
TableRow rowtwo = dynamic_filter_table.FindControl("TableRow_") as TableRow;
rowtwo.Cells.Add(cell2);
dynamic_filter_table.Rows.Add(rowtwo);
dynamic_filter_table.EnableViewState = true;
ViewState["dynamic_filter_table"] = true;
}
virtual public void InitializeMoreInfo(DataSet BigTable)
{
int count = 0;
foreach (DataRow dr in SchemaDataTypes.Rows)
{
MySQL_TableDataT dt = new MySQL_TableDataT(dr);
DataTypeIndex.Add(dt.TypeName);
data_types.Add(count, dt);
count++;
}
// count=0;
// foreach (DataRow dr in SchemaFK.Rows)
// {
// fk_info fk = new fk_info(dr);
// fk_names.Add(fk.constraint_name);
// count++;
// }
// count=0;
// foreach (DataRow dr in SchemaFKCols.Rows)
// {
// fk_columns fvk = new fk_columns(dr);
// fk_col_names.Add(fvk.CONSTRAINT_NAME);
// count++;
// }
}
private void DropIndex(string tableName, DataTypeIndex index)
{
string indexName = GetIndexName(index);
var sql = string.Format("DROP INDEX [{0}] ON [{1}]", indexName, tableName);
ExecuteNonQuery(sql);
}
private string GetIndexName(DataTypeIndex index)
{
var result = new StringBuilder().Append("IX_");
foreach (var field in index.Fields)
{
result.Append('_').Append(field.Item1);
}
return(result.ToString());
}
public StructuredDataElement ReadElement()
{
DataTypeIndex type = ReadDataTypeIndex();
if ((int)type == -1)
{
return(null);
}
int count = ReadInteger();
object[] values = new object[count];
for (int i = 0; i < count; i++)
{
values[i] = ReadValue(type);
}
return(new StructuredDataElement(type, values));
}
private object ReadValue(DataTypeIndex type)
{
switch (type)
{
case DataTypeIndex.Name:
case DataTypeIndex.String:
case DataTypeIndex.StringFixed:
return(ReadToken());
case DataTypeIndex.ColorIndex:
case DataTypeIndex.Integer:
case DataTypeIndex.SignedInteger8bit:
case DataTypeIndex.SignedInteger16bit:
case DataTypeIndex.SignedInteger32bit:
case DataTypeIndex.Index:
case DataTypeIndex.UnsignedInteger8bit:
case DataTypeIndex.UnsignedInteger16bit:
case DataTypeIndex.UnsignedInteger32Bit:
return(ReadInteger());
case DataTypeIndex.Real:
case DataTypeIndex.VDC:
return(ReadReal());
case DataTypeIndex.Reserved:
// TODO: what exactly does reserved mean in terms of advancing position?
return(null);
case DataTypeIndex.StructuredDataRecord:
case DataTypeIndex.ColorDirect:
case DataTypeIndex.Enumerated:
case DataTypeIndex.ViewportCoordinate:
case DataTypeIndex.ColorComponent:
case DataTypeIndex.BitStream:
case DataTypeIndex.ColorList:
default:
// FIXME: implement the other types; at least as soon as they appear somewhere.
// they seem to be rare enough to get away with this...
return(_sdr);
}
}
public static StructuredDataRecord ReadStructuredDataRecord(MetafileReader reader)
{
// overall length seems to be encoded similar to the string length [ISO/IEC 8632-3 7, Table 1, Note 12]
// (ie. one byte, followed by one word if its 255).
int length = reader.ReadByte();
if (length == 255)
{
// FIXME: does an SDR also have a long form similar to a string?
length = reader.ReadWord();
}
var elements = new List <StructuredDataElement>();
long startPosition = reader.Position;
// require at least the number of bytes for the enum and the count; which depends on integer/index precision:
// > The integer of the "data count" and the index of the "data type index" are represented respectively at the current
// > Integer Precision and the current Index Precision of the metafile. [ISO/IEC 8632-1 H.2.2]
// some files seem to include padding or similar, which throws this off by having an extra byte available at the end
while (reader.HasMoreData((reader.Descriptor.IndexPrecision + reader.Descriptor.IntegerPrecision) / 8))
{
// enum is an index at the current index precision for SDR [ISO/IEC 8632-1 H.2.2]
DataTypeIndex type = (DataTypeIndex)Enum.ToObject(typeof(DataTypeIndex), reader.ReadIndex());
// count is an interger at the current integer precision for SDR [ISO/IEC 8632-1 H.2.2]
int count = reader.ReadInteger();
object[] values = new object[count];
for (int i = 0; i < count; i++)
{
values[i] = ReadValue(reader, type);
}
elements.Add(new StructuredDataElement(type, values));
// only read as much as specified by length
if (reader.Position - startPosition >= length)
{
break;
}
}
return(new StructuredDataRecord(elements));
}
private static object ReadValue(MetafileReader reader, DataTypeIndex type)
{
switch (type)
{
case DataTypeIndex.StructuredDataRecord:
return(ReadStructuredDataRecord(reader));
case DataTypeIndex.ColorIndex:
return(reader.ReadIndexedColor());
case DataTypeIndex.ColorDirect:
return(reader.ReadDirectColor());
case DataTypeIndex.Name:
return(reader.ReadName());
case DataTypeIndex.Enumerated:
return(reader.ReadEnum());
case DataTypeIndex.Integer:
return(reader.ReadInteger());
case DataTypeIndex.Reserved:
// TODO: what exactly does reserved mean in terms of advancing position?
return(null);
case DataTypeIndex.SignedInteger8bit:
return(reader.ReadInteger(1, false));
case DataTypeIndex.SignedInteger16bit:
return(reader.ReadInteger(2, false));
case DataTypeIndex.SignedInteger32bit:
return(reader.ReadInteger(4, false));
case DataTypeIndex.Index:
return(reader.ReadIndex());
case DataTypeIndex.Real:
return(reader.ReadReal());
case DataTypeIndex.String:
case DataTypeIndex.StringFixed:
// TODO: difference between S and SF? charset/escape code handling?
return(reader.ReadString());
case DataTypeIndex.ViewportCoordinate:
return(reader.ReadViewportCoordinate());
case DataTypeIndex.VDC:
return(reader.ReadVdc());
case DataTypeIndex.ColorComponent:
return(reader.ReadColorValue());
case DataTypeIndex.UnsignedInteger8bit:
return(reader.ReadInteger(1, true));
case DataTypeIndex.UnsignedInteger32Bit:
return(reader.ReadInteger(4, true));
case DataTypeIndex.UnsignedInteger16bit:
return(reader.ReadInteger(2, true));
case DataTypeIndex.BitStream:
case DataTypeIndex.ColorList:
default:
// FIXME: how are those implemented?
return(null);
}
}
public bool Equals(DataTypeIndex index)
{
return(value == index.value);
}
public StructuredDataElement(DataTypeIndex type, object[] values)
{
Type = type;
Values = values;
}