public void OnClickUpdate()
{
CheckString = (M4uUtil.Random(0, 2) == 0) ? CheckSuccess : CheckFail;
CheckEnum = (M4uUtil.Random(0, 2) == 0) ? CheckType.OK : CheckType.NG;
BoolBindingText = CheckString + "/" + CheckEnum.ToString();
var time = Time.time;
var src = Color;
var dst = new UnityEngine.Color(M4uUtil.Random(0f, 1f), M4uUtil.Random(0f, 1f), M4uUtil.Random(0f, 1f), 1f);
StartCoroutine(UpdateColor(time, src, dst));
FontStyle = (UnityEngine.FontStyle)M4uUtil.Random(0, 4);
FontSize = M4uUtil.Random(30, 50);
LineSpacing = M4uUtil.Random(1f, 2f);
SupportRichText = (M4uUtil.Random(0, 2) == 0);
Alignment = (TextAnchor)M4uUtil.Random(3, 6);
ResizeTextForBestFit = (M4uUtil.Random(0, 2) == 0);
Text = "[Special]\n";
Text += "FontStyle=" + FontStyle.ToString() + "\n";
Text += "LineSpacing=" + LineSpacing + "\n";
Text += "SupportRichText=" + SupportRichText + "\n";
Text += "Alignment=" + Alignment.ToString() + "\n";
Text += "ResizeTextForBestFit=" + ResizeTextForBestFit;
}
/// <summary>
/// Makes render object representing a check mark.
/// </summary>
/// <param name="chk">The check status (must not be None).</param>
/// <param name="name">The name for the created render object (may be null).</param>
/// <returns>The render object representing the check mark.</returns>
private RenderObject MakeCheckboxRO(CheckEnum chk, string name)
{
Debug.Assert(chk != CheckEnum.None);
RenderImage rimg = MakeGlyphRO(s_CheckToGlyph[chk]);
if (!string.IsNullOrEmpty(name))
{
rimg.Name = name;
}
return(rimg);
}
public void Demonstrate()
{
CheckEnum c = CheckEnum.Mode1 | CheckEnum.Mode2;
bool b = c.HasFlag(CheckEnum.Mode2);
Console.WriteLine(b);
b = c.HasFlag(CheckEnum.Mode3);
Console.WriteLine(b);
c = CheckEnum.Mode1 | CheckEnum.Mode2 | CheckEnum.Mode3;
b = (c & CheckEnum.Mode3) == CheckEnum.Mode3;
Console.WriteLine(b);
}
public static CheckEnum TagCheckEnumCheck(string tag)
{
CheckEnum result = CheckEnum.Ignore;
var tagSplit = ProcessTag(tag);
if (tagSplit.Length == 2)
{
if (CheckEnum.TryParse(tagSplit[1], out result) == false)
{
return(CheckEnum.Ignore);
}
}
return(result);
}
public TargetProfile()
{
UseCustomTargeting = false;
Target = TargetTypeEnum.None;
BlockTargets = new List <BlockTypeEnum>();
TimeUntilTargetAcquisition = 1;
UseTargetRefresh = false;
TimeUntilNextRefresh = 60;
TimeUntilNextEvaluation = 1;
MaxDistance = 12000;
MatchAllFilters = new List <TargetFilterEnum>();
MatchAnyFilters = new List <TargetFilterEnum>();
MatchNoneFilters = new List <TargetFilterEnum>();
GetTargetBy = TargetSortEnum.ClosestDistance;
Owners = OwnerTypeEnum.None;
Relations = RelationTypeEnum.None;
FactionTargets = new List <string>();
OnlyGetFromEntityOwner = false;
GetFromMinorityGridOwners = false;
PrioritizeSpecifiedFactions = false;
IsStatic = CheckEnum.Ignore;
MinAltitude = -100000;
MaxAltitude = 100000;
NonBroadcastVisualRange = 1500;
MinGravity = 0;
MaxGravity = 1.1;
MinSpeed = 0;
MaxSpeed = 110;
MinTargetValue = 0;
MaxTargetValue = 1;
ProfileSubtypeId = "";
BuiltUniqueFilterList = false;
AllUniqueFilters = new List <TargetFilterEnum>();
}
// Get the data in template cell
private object GetTempData(int col)
{
// special handling on check column
if (ShowValueAsCheck(col))
{
CheckEnum check = _flex.GetCellCheck(_row, col);
switch (check)
{
case CheckEnum.Checked:
case CheckEnum.TSChecked:
return(true);
case CheckEnum.Unchecked:
case CheckEnum.TSUnchecked:
return(false);
case CheckEnum.TSGrayed:
return(DBNull.Value);
}
}
return(_flex.GetData(_row, col));
}
/// <summary>
/// Makes render object representing the cell image.
/// </summary>
/// <param name="image">The cell image.</param>
/// <param name="chk">The cell check status.</param>
/// <param name="name">The name for the created render object (may be null).</param>
/// <returns>The render object representing the cell image.</returns>
private RenderObject MakeImageRO(Image image, CheckEnum chk, string name)
{
if (chk != CheckEnum.None)
{
return(MakeCheckboxRO(chk, name));
}
else
{
RenderImage rimg = new RenderImage(image);
if (!string.IsNullOrEmpty(name))
{
rimg.Name = name;
}
return(rimg);
}
// todo:
// In grid, ImageSpacing covers text if there's not enough space for both;
// to mimic that behavior, rimg must opaquely cover text - for that to work,
// we must set rimg.Style.BackColor to a non-transparent color (White IS transparent),
// e.g. with some off-white like 255,255,254.
// If we do that, we must also cache those styles (as main styles) to improve performance...
// rimg.Style.BackColor = Color.White;
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//UseCustomTargeting
if (tag.Contains("[UseCustomTargeting:") == true)
{
this.UseCustomTargeting = TagHelper.TagBoolCheck(tag);
}
//TimeUntilTargetAcquisition
if (tag.Contains("[TimeUntilTargetAcquisition:") == true)
{
this.TimeUntilTargetAcquisition = TagHelper.TagIntCheck(tag, this.TimeUntilTargetAcquisition);
}
//UseTargetRefresh
if (tag.Contains("[UseTargetRefresh:") == true)
{
this.UseTargetRefresh = TagHelper.TagBoolCheck(tag);
}
//TimeUntilNextRefresh
if (tag.Contains("[TimeUntilNextRefresh:") == true)
{
this.TimeUntilNextRefresh = TagHelper.TagIntCheck(tag, this.TimeUntilNextRefresh);
}
//UseTargetLastKnownPosition
if (tag.Contains("[UseTargetLastKnownPosition:") == true)
{
this.UseTargetLastKnownPosition = TagHelper.TagBoolCheck(tag);
}
//TimeUntilNextEvaluation
if (tag.Contains("[TimeUntilNextEvaluation:") == true)
{
this.TimeUntilNextEvaluation = TagHelper.TagIntCheck(tag, this.TimeUntilNextEvaluation);
}
//Target
if (tag.Contains("[Target:") == true)
{
this.Target = TagHelper.TagTargetTypeEnumCheck(tag);
}
//BlockTargets
if (tag.Contains("[BlockTargets:") == true)
{
var tempValue = TagHelper.TagBlockTargetTypesCheck(tag);
if (tempValue != BlockTypeEnum.None && this.BlockTargets.Contains(tempValue) == false)
{
this.BlockTargets.Add(tempValue);
}
}
//GetTargetBy
if (tag.Contains("[GetTargetBy:") == true)
{
this.GetTargetBy = TagHelper.TagTargetSortEnumCheck(tag);
}
//MaxDistance
if (tag.Contains("[MaxDistance:") == true)
{
this.MaxDistance = TagHelper.TagDoubleCheck(tag, this.MaxDistance);
}
//MatchAllFilters
if (tag.Contains("[MatchAllFilters:") == true)
{
var tempValue = TagHelper.TagTargetFilterEnumCheck(tag);
if (tempValue != TargetFilterEnum.None && !this.MatchAllFilters.Contains(tempValue))
{
this.MatchAllFilters.Add(tempValue);
}
}
//MatchAnyFilters
if (tag.Contains("[MatchAnyFilters:") == true)
{
var tempValue = TagHelper.TagTargetFilterEnumCheck(tag);
if (tempValue != TargetFilterEnum.None && !this.MatchAnyFilters.Contains(tempValue))
{
this.MatchAnyFilters.Add(tempValue);
}
}
//MatchNoneFilters
if (tag.Contains("[MatchNoneFilters:") == true)
{
var tempValue = TagHelper.TagTargetFilterEnumCheck(tag);
if (tempValue != TargetFilterEnum.None && !this.MatchNoneFilters.Contains(tempValue))
{
this.MatchNoneFilters.Add(tempValue);
}
}
//Owners
if (tag.Contains("[Owners:") == true)
{
var tempValue = TagHelper.TagTargetOwnerEnumCheck(tag);
if (!this.Owners.HasFlag(tempValue))
{
this.Owners |= tempValue;
}
}
//Relations
if (tag.Contains("[Relations:") == true)
{
var tempValue = TagHelper.TagTargetRelationEnumCheck(tag);
if (this.Relations.HasFlag(tempValue) == false)
{
this.Relations |= tempValue;
}
}
//FactionTargets
if (tag.Contains("[FactionTargets:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (!string.IsNullOrWhiteSpace(tempValue) && !this.FactionTargets.Contains(tempValue))
{
this.FactionTargets.Add(tempValue);
}
}
//OnlyGetFromEntityOwner
if (tag.Contains("[OnlyGetFromEntityOwner:") == true)
{
this.OnlyGetFromEntityOwner = TagHelper.TagBoolCheck(tag);
}
//GetFromMinorityGridOwners
if (tag.Contains("[GetFromMinorityGridOwners:") == true)
{
this.GetFromMinorityGridOwners = TagHelper.TagBoolCheck(tag);
}
//PrioritizeSpecifiedFactions
if (tag.Contains("[PrioritizeSpecifiedFactions:") == true)
{
this.PrioritizeSpecifiedFactions = TagHelper.TagBoolCheck(tag);
}
//IsStatic
if (tag.Contains("[IsStatic:") == true)
{
this.IsStatic = TagHelper.TagCheckEnumCheck(tag);
}
//MinAltitude
if (tag.Contains("[MinAltitude:") == true)
{
this.MinAltitude = TagHelper.TagDoubleCheck(tag, this.MinAltitude);
}
//MaxAltitude
if (tag.Contains("[MaxAltitude:") == true)
{
this.MaxAltitude = TagHelper.TagDoubleCheck(tag, this.MaxAltitude);
}
//NonBroadcastVisualRange
if (tag.Contains("[NonBroadcastVisualRange:") == true)
{
this.NonBroadcastVisualRange = TagHelper.TagDoubleCheck(tag, this.NonBroadcastVisualRange);
}
//MinGravity
if (tag.Contains("[MinGravity:") == true)
{
this.MinGravity = TagHelper.TagDoubleCheck(tag, this.MinGravity);
}
//MaxGravity
if (tag.Contains("[MaxGravity:") == true)
{
this.MaxGravity = TagHelper.TagDoubleCheck(tag, this.MaxGravity);
}
//MinSpeed
if (tag.Contains("[MinSpeed:") == true)
{
this.MinSpeed = TagHelper.TagDoubleCheck(tag, this.MinSpeed);
}
//MaxSpeed
if (tag.Contains("[MaxSpeed:") == true)
{
this.MaxSpeed = TagHelper.TagDoubleCheck(tag, this.MaxSpeed);
}
//MinTargetValue
if (tag.Contains("[MinTargetValue:") == true)
{
this.MinTargetValue = TagHelper.TagFloatCheck(tag, this.MinTargetValue);
}
//MaxTargetValue
if (tag.Contains("[MaxTargetValue:") == true)
{
this.MaxTargetValue = TagHelper.TagFloatCheck(tag, this.MaxTargetValue);
}
}
}
}
public void InitTags(string customData)
{
if (string.IsNullOrWhiteSpace(customData) == false)
{
var descSplit = customData.Split('\n');
foreach (var tag in descSplit)
{
//UseCustomTargeting
if (tag.Contains("[UseCustomTargeting:") == true)
{
UseCustomTargeting = TagHelper.TagBoolCheck(tag);
}
//TimeUntilTargetAcquisition
if (tag.Contains("[TimeUntilTargetAcquisition:") == true)
{
TimeUntilTargetAcquisition = TagHelper.TagIntCheck(tag, TimeUntilTargetAcquisition);
}
//UseTargetRefresh
if (tag.Contains("[UseTargetRefresh:") == true)
{
UseTargetRefresh = TagHelper.TagBoolCheck(tag);
}
//TimeUntilNextRefresh
if (tag.Contains("[TimeUntilNextRefresh:") == true)
{
TimeUntilNextRefresh = TagHelper.TagIntCheck(tag, TimeUntilNextRefresh);
}
//UseTargetLastKnownPosition
if (tag.Contains("[UseTargetLastKnownPosition:") == true)
{
UseTargetLastKnownPosition = TagHelper.TagBoolCheck(tag);
}
//TimeUntilNextEvaluation
if (tag.Contains("[TimeUntilNextEvaluation:") == true)
{
TimeUntilNextEvaluation = TagHelper.TagIntCheck(tag, TimeUntilNextEvaluation);
}
//Target
if (tag.Contains("[Target:") == true)
{
Target = TagHelper.TagTargetTypeEnumCheck(tag);
}
//BlockTargets
if (tag.Contains("[BlockTargets:") == true)
{
var tempValue = TagHelper.TagBlockTargetTypesCheck(tag);
if (tempValue != BlockTypeEnum.None && BlockTargets.Contains(tempValue) == false)
{
BlockTargets.Add(tempValue);
}
}
//GetTargetBy
if (tag.Contains("[GetTargetBy:") == true)
{
GetTargetBy = TagHelper.TagTargetSortEnumCheck(tag);
}
//MaxDistance
if (tag.Contains("[MaxDistance:") == true)
{
MaxDistance = TagHelper.TagDoubleCheck(tag, MaxDistance);
}
//MatchAllFilters
if (tag.Contains("[MatchAllFilters:") == true)
{
var tempValue = TagHelper.TagTargetFilterEnumCheck(tag);
if (tempValue != TargetFilterEnum.None && !MatchAllFilters.Contains(tempValue))
{
MatchAllFilters.Add(tempValue);
}
}
//MatchAnyFilters
if (tag.Contains("[MatchAnyFilters:") == true)
{
var tempValue = TagHelper.TagTargetFilterEnumCheck(tag);
if (tempValue != TargetFilterEnum.None && !MatchAnyFilters.Contains(tempValue))
{
MatchAnyFilters.Add(tempValue);
}
}
//MatchNoneFilters
if (tag.Contains("[MatchNoneFilters:") == true)
{
var tempValue = TagHelper.TagTargetFilterEnumCheck(tag);
if (tempValue != TargetFilterEnum.None && !MatchNoneFilters.Contains(tempValue))
{
MatchNoneFilters.Add(tempValue);
}
}
//Owners
if (tag.Contains("[Owners:") == true)
{
var tempValue = TagHelper.TagTargetOwnerEnumCheck(tag);
if (!Owners.HasFlag(tempValue))
{
Owners |= tempValue;
}
}
//Relations
if (tag.Contains("[Relations:") == true)
{
var tempValue = TagHelper.TagTargetRelationEnumCheck(tag);
if (Relations.HasFlag(tempValue) == false)
{
Relations |= tempValue;
}
}
//FactionTargets
if (tag.Contains("[FactionTargets:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (!string.IsNullOrWhiteSpace(tempValue) && !FactionTargets.Contains(tempValue))
{
FactionTargets.Add(tempValue);
}
}
//OnlyGetFromEntityOwner
if (tag.Contains("[OnlyGetFromEntityOwner:") == true)
{
OnlyGetFromEntityOwner = TagHelper.TagBoolCheck(tag);
}
//GetFromMinorityGridOwners
if (tag.Contains("[GetFromMinorityGridOwners:") == true)
{
GetFromMinorityGridOwners = TagHelper.TagBoolCheck(tag);
}
//PrioritizeSpecifiedFactions
if (tag.Contains("[PrioritizeSpecifiedFactions:") == true)
{
PrioritizeSpecifiedFactions = TagHelper.TagBoolCheck(tag);
}
//IsStatic
if (tag.Contains("[IsStatic:") == true)
{
IsStatic = TagHelper.TagCheckEnumCheck(tag);
}
//MinAltitude
if (tag.Contains("[MinAltitude:") == true)
{
MinAltitude = TagHelper.TagDoubleCheck(tag, MinAltitude);
}
//MaxAltitude
if (tag.Contains("[MaxAltitude:") == true)
{
MaxAltitude = TagHelper.TagDoubleCheck(tag, MaxAltitude);
}
//NonBroadcastVisualRange
if (tag.Contains("[NonBroadcastVisualRange:") == true)
{
NonBroadcastVisualRange = TagHelper.TagDoubleCheck(tag, NonBroadcastVisualRange);
}
//MinGravity
if (tag.Contains("[MinGravity:") == true)
{
MinGravity = TagHelper.TagDoubleCheck(tag, MinGravity);
}
//MaxGravity
if (tag.Contains("[MaxGravity:") == true)
{
MaxGravity = TagHelper.TagDoubleCheck(tag, MaxGravity);
}
//MinSpeed
if (tag.Contains("[MinSpeed:") == true)
{
MinSpeed = TagHelper.TagDoubleCheck(tag, MinSpeed);
}
//MaxSpeed
if (tag.Contains("[MaxSpeed:") == true)
{
MaxSpeed = TagHelper.TagDoubleCheck(tag, MaxSpeed);
}
//MinTargetValue
if (tag.Contains("[MinTargetValue:") == true)
{
MinTargetValue = TagHelper.TagFloatCheck(tag, MinTargetValue);
}
//MaxTargetValue
if (tag.Contains("[MaxTargetValue:") == true)
{
MaxTargetValue = TagHelper.TagFloatCheck(tag, MaxTargetValue);
}
//MinMovementScore
if (tag.Contains("[MinMovementScore:") == true)
{
MinMovementScore = TagHelper.TagFloatCheck(tag, MinMovementScore);
}
//MaxMovementScore
if (tag.Contains("[MaxMovementScore:") == true)
{
MaxMovementScore = TagHelper.TagFloatCheck(tag, MaxMovementScore);
}
//PrioritizePlayerControlled
if (tag.Contains("[PrioritizePlayerControlled:") == true)
{
PrioritizePlayerControlled = TagHelper.TagBoolCheck(tag);
}
//Names
if (tag.Contains("[Names:") == true)
{
var tempValue = TagHelper.TagStringCheck(tag);
if (!string.IsNullOrWhiteSpace(tempValue) && !Names.Contains(tempValue))
{
Names.Add(tempValue);
}
}
//UsePartialNameMatching
if (tag.Contains("[UsePartialNameMatching:") == true)
{
UsePartialNameMatching = TagHelper.TagBoolCheck(tag);
}
//MaxLineOfSight
if (tag.Contains("[MaxLineOfSight:") == true)
{
MaxLineOfSight = TagHelper.TagDoubleCheck(tag, MaxLineOfSight);
}
//MaxMovementDetectableDistance
if (tag.Contains("[MaxMovementDetectableDistance:") == true)
{
MaxMovementDetectableDistance = TagHelper.TagDoubleCheck(tag, MaxMovementDetectableDistance);
}
//BroadcastOnlyAntenna
if (tag.Contains("[BroadcastOnlyAntenna:") == true)
{
BroadcastOnlyAntenna = TagHelper.TagBoolCheck(tag);
}
//MinUnderWaterDepth
if (tag.Contains("[MinUnderWaterDepth:") == true)
{
MinUnderWaterDepth = TagHelper.TagDoubleCheck(tag, MinUnderWaterDepth);
}
//MaxUnderWaterDepth
if (tag.Contains("[MaxUnderWaterDepth:") == true)
{
MaxUnderWaterDepth = TagHelper.TagDoubleCheck(tag, MaxUnderWaterDepth);
}
//PlayerKnownLocationFactionOverride
if (tag.Contains("[PlayerKnownLocationFactionOverride:") == true)
{
PlayerKnownLocationFactionOverride = TagHelper.TagStringCheck(tag);
}
}
}
}
public TargetProfile()
{
UseCustomTargeting = false;
Target = TargetTypeEnum.None;
BlockTargets = new List <BlockTypeEnum>();
TimeUntilTargetAcquisition = 1;
UseTargetRefresh = false;
TimeUntilNextRefresh = 60;
TimeUntilNextEvaluation = 1;
MaxDistance = 12000;
MatchAllFilters = new List <TargetFilterEnum>();
MatchAnyFilters = new List <TargetFilterEnum>();
MatchNoneFilters = new List <TargetFilterEnum>();
GetTargetBy = TargetSortEnum.ClosestDistance;
Owners = OwnerTypeEnum.None;
Relations = RelationTypeEnum.None;
FactionTargets = new List <string>();
OnlyGetFromEntityOwner = false;
GetFromMinorityGridOwners = false;
PrioritizeSpecifiedFactions = false;
IsStatic = CheckEnum.Ignore;
MinAltitude = -100000;
MaxAltitude = 100000;
NonBroadcastVisualRange = 1500;
MinGravity = 0;
MaxGravity = 1.1;
MinSpeed = 0;
MaxSpeed = 110;
MinTargetValue = 0;
MaxTargetValue = 1;
MinMovementScore = -1;
MaxMovementScore = -1;
MaxLineOfSight = -1;
MaxMovementDetectableDistance = -1;
PrioritizePlayerControlled = false;
BroadcastOnlyAntenna = false;
Names = new List <string>();
UsePartialNameMatching = false;
MinUnderWaterDepth = -1;
MaxUnderWaterDepth = -1;
PlayerKnownLocationFactionOverride = "";
ProfileSubtypeId = "";
BuiltUniqueFilterList = false;
AllUniqueFilters = new List <TargetFilterEnum>();
}
public void TestSerializeValue()
{
bool boolValue = Rand.Default.Range(0, 2) > 0;
checkSerializeValue(boolValue);
byte byteValue = Rand.Default.RandByte();
checkSerializeValue(byteValue);
sbyte sbyteValue = (sbyte)Rand.Default.RandByte();
checkSerializeValue(sbyteValue);
char charValue = (char)Rand.Default.RandShort();
checkSerializeValue(charValue);
short shortValue = Rand.Default.RandShort();
checkSerializeValue(shortValue);
ushort ushortValue = (ushort)Rand.Default.RandShort();
checkSerializeValue(ushortValue);
int intValue = Rand.Default.RandInt();
checkSerializeValue(intValue);
uint uintValue = Rand.Default.RandUint();
checkSerializeValue(uintValue);
long longValue = Rand.Default.RandLong();
checkSerializeValue(longValue);
ulong ulongValue = (ulong)Rand.Default.RandLong();
checkSerializeValue(ulongValue);
float floatValue = Rand.Default.RandFloat();
checkSerializeValue(floatValue);
double doubleValue = Rand.Default.RandFloat();
checkSerializeValue(doubleValue);
string stringValue = Rand.Default.RandFloat().ToString();
checkSerializeValue(stringValue);
CheckEnum enumValue = (CheckEnum)Rand.Default.Range((int)CheckEnum.begin, (int)CheckEnum.end);
checkSerializeValue(enumValue);
object nullValue = null;
checkSerializeValue <object>(nullValue);
}
private static string GetMessage(CheckEnum @enum)
{
return(I18n.GetText(@enum));
}
private void FormatGrid(C1FlexGrid grid)
{
if (grid == null)
{
return;
}
ColumnCollection _cols = grid.Cols;
if (grid.Name == grdUsers.Name)
{
grid.AllowEditing = true;
for (int i = 0; i <= (_cols.Count - 1); i++)
{
_cols[i].AllowEditing = false;
}
_cols["AccountHolder"].AllowEditing = true;
for (int i = 0; i <= (grid.Rows.Count - 1); i++)
{
CheckEnum _checked = CheckEnum.Unchecked;
if (i == (_cols.Fixed - 1))
{
_checked = CheckEnum.Checked;
}
else
{
if (VisualBasic.CBool(grid[i, "Select"]))
{
_checked = CheckEnum.Checked;
}
}
grid.SetCellCheck(i, _cols["AccountHolder"].Index, _checked);
}
_cols["AccountHolder"].Caption = "Account Holder";
_cols["Username"].Visible = false;
_cols["Select"].Visible = false;
grid.ExtendLastCol = true;
_cols[_cols.Fixed - 1].Visible = false;
}
else if (grid == grdActions)
{
grid.AllowEditing = true;
for (int i = 0; i <= (_cols.Count - 1); i++)
{
_cols[i].AllowEditing = false;
}
_cols["Action"].AllowEditing = true;
for (int i = 0; i <= (grid.Rows.Count - 1); i++)
{
CheckEnum _checked = CheckEnum.Unchecked;
if (i == (_cols.Fixed - 1))
{
_checked = CheckEnum.Checked;
}
else
{
if (VisualBasic.CBool(grid[i, "Select"]))
{
_checked = CheckEnum.Checked;
}
}
grid.SetCellCheck(i, _cols["Action"].Index, _checked);
}
_cols["Id"].Visible = false;
_cols["Select"].Visible = false;
grid.ExtendLastCol = true;
_cols[_cols.Fixed - 1].Visible = false;
}
else if (grid == grdLogs)
{
_cols["DateAndTime"].Format = "dd-MMM-yyyy hh:mm:ss tt";
_cols["DateAndTime"].Caption = "Date and Time";
_cols["AccountHolder"].Caption = "Account Holder";
_cols["ReferenceNo"].Caption = "Reference No";
_cols["ComputerName"].Caption = "Computer Name";
_cols["IPAddress"].Caption = "IP Address";
_cols["Image"].Caption = "";
_cols["DetailId"].Visible = false;
grid.AutoSizeCols(); grid.ExtendLastCol = true;
_cols[_cols.Fixed - 1].Visible = false;
_cols["Image"].Width = 30;
}
else
{
}
}
private void grdActions_CellChecked(object sender, RowColEventArgs e)
{
if (!_shown)
{
return;
}
if (!grdActions.Redraw)
{
return;
}
if (grdActions.DataSource == null)
{
return;
}
ColumnCollection _cols = grdActions.Cols;
if (_cols[e.Col].Name == "Action")
{
if (e.Row == (grdActions.Rows.Fixed - 1))
{
if (grdActions.Redraw)
{
grdActions.BeginUpdate();
}
CheckEnum _checked = grdActions.GetCellCheck(e.Row, e.Col);
for (int i = grdActions.Rows.Fixed; i <= (grdActions.Rows.Count - 1); i++)
{
grdActions.SetCellCheck(i, e.Col, _checked);
grdActions[i, _cols["Select"].Index] = (_checked == CheckEnum.Checked);
}
while (!grdActions.Redraw)
{
grdActions.EndUpdate();
}
}
else
{
grdActions[e.Row, "Select"] = (grdActions.GetCellCheck(e.Row, e.Col) == CheckEnum.Checked);
CheckEnum _checked = CheckEnum.Checked;
bool _allchecked = true;
for (int i = grdActions.Rows.Fixed; i <= (grdActions.Rows.Count - 1); i++)
{
_allchecked = _allchecked && VisualBasic.CBool(grdActions[i, "Select"]);
if (!_allchecked)
{
break;
}
}
if (!_allchecked)
{
_checked = CheckEnum.Unchecked;
}
grdActions.SetCellCheck(grdActions.Rows.Fixed - 1, e.Col, _checked);
}
}
}
