public void SetHoverItem(ISelectable item)
{
var prevHoverItem = HoverItem;
HoverItem = item;
if (HoverItem != null) HoverItem.AddHighlightColor(HoverColor);
if (prevHoverItem != null && item != prevHoverItem) prevHoverItem.RemoveHighlightColor(HoverColor);
}
internal void AddToSelection(ISelectable item)
{
var x = item as DesignerItem;
if (x != null)
{
CurrentSelection.Add(item);
x.IsSelected = true;
//_diagramControl.SelectedItems.Add(x);
//_diagramControl.SelectedItems.Clear();
//foreach (var designerItem in CurrentSelection.Cast<DesignerItem>())
//{
// _diagramControl.SelectedItems.Add(designerItem);
//}
//if (item is IGroupable)
//{
// List<IGroupable> groupItems = GetGroupMembers(item as IGroupable);
//foreach (ISelectable groupItem in groupItems)
//{
// groupItem.IsSelected = true;
// CurrentSelection.Add(groupItem);
//}
//}
//else
//{
// item.IsSelected = true;
// CurrentSelection.Add(item);
//}
}
}
public void ToggleSelection(ISelectable item)
{
if (ActiveItems.Contains(item))
RemoveActive(item);
else
AddActive(item);
}
public void AddItem(ISelectable selectable, int rowIndex, int columnIndex)
{
if (Destroyed)
throw new InvalidOperationException("Cannot add a control to a destroyed group");
if (selectable == null)
throw new ArgumentNullException("selectable");
if (rowIndex < 0)
throw new ArgumentException("Cannot add an item to a row index less than 0");
if (columnIndex < 0)
throw new ArgumentException("Cannot add an item to a column index less than 0");
// Make sure this item doesn't already exist or an item doesn't exist in this row/column
if (_items.Contains(selectable))
throw new InvalidOperationException("Selectable item already exists in the GridSelectableGroup");
// Make sure the row/column index is available
if (_items[rowIndex, columnIndex] != null)
throw new InvalidOperationException(
string.Format("An item already exists at row {0} column {1} in the GridSelectableGroup", rowIndex, columnIndex));
// If we got here, the specified spot in the grid is free
_items.Add(selectable, null, rowIndex, columnIndex);
}
protected override bool IsSelectedItemMenuOperator(ISelectable selected) {
if (_universeCenterMenuOperator.IsSelected) {
D.AssertEqual(_universeCenterMenuOperator, selected as UniverseCenterItem);
return true;
}
return false;
}
protected override bool IsSelectedItemMenuOperator(ISelectable selected) {
if (_fleetMenuOperator.IsSelected) {
D.AssertEqual(_fleetMenuOperator, selected as FleetCmdItem);
return true;
}
return false;
}
/// <summary>
/// 添加设计组件
/// </summary>
/// <param name="item"></param>
public void AddToSelection(ISelectable item)
{
if (item is IGroupable)
{
IEnumerable<IGroupable> list = designerCanvas.Children.OfType<IGroupable>();
List<IGroupable> groupItems = new List<IGroupable>();
foreach (IGroupable groupitem in list)
{
if (groupitem.CurrentSerialNumber == (item as IGroupable).CurrentSerialNumber)
{
groupItems.Add(groupitem);
break;
}
}
foreach (ISelectable groupItem in groupItems)
{
groupItem.IsSelected = true;
CurrentSelection.Add(groupItem);
}
}
else
{
item.IsSelected = true;
CurrentSelection.Add(item);
}
}
public void select(ISelectable select)
{
currentSelection.Selected = false;
currentSelection = select;
currentSelection.Selected = true;
panel1.Invalidate();
}
protected override bool IsSelectedItemMenuOperator(ISelectable selected) {
if (_baseMenuOperator.IsSelected) {
D.AssertEqual(_baseMenuOperator, selected as AUnitBaseCmdItem);
return true;
}
return false;
}
protected sealed override bool IsSelectedItemMenuOperator(ISelectable selected) {
if (_planetoidMenuOperator.IsSelected) {
D.AssertEqual(_planetoidMenuOperator, selected as APlanetoidItem);
return true;
}
return false;
}
/// <summary>
/// Selects an object an unselects all other
/// </summary>
private void selectSingle(ISelectable selected)
{
foreach (var item in selectables) {
if (item == selected) {
if (!item.IsSelected) item.OnSelect();
} else item.OnDeselect();
}
}
public override bool CheckInteraction(ISelectable[] selectedObjects, IInteractable obj)
{
if (selectedObjects[0].GetType() == typeof(Unit) && obj.GetType() == typeof(Map)) {
return true;
}
return false;
}
public void AddItem(ISelectable item) {
if (!items.Contains(item)) {
items.Add(item);
item.SetSelected(false);
item.SetSelectable(true);
item.OnSelected += SetSelected;
}
}
//protected override CtxObject ValidateAndAcquireCtxObject() {
// // the system's CtxObject, not the system's base's CtxObject - provides proper menu positioning
// return UnityUtility.ValidateMonoBehaviourPresence<CtxObject>(_system.gameObject);
//}
//public override void OnRightPressRelease() { // must override to test for the system being selected
// if (_system.IsSelected) {
// D.Assert(_system.Owner.IsPlayer);
// _accessSource = AccessSource.Local;
// _playerRemoteAccessItem = null;
// Show(true);
// return;
// }
// var selected = SelectionManager.Instance.CurrentSelection;
// var selectedFleet = selected as FleetCommandItem;
// if (selectedFleet != null && selectedFleet.Owner.IsPlayer) {
// // a remote player owned fleet is selected
// _accessSource = AccessSource.RemoteFleet;
// _playerRemoteAccessItem = selectedFleet;
// Show(true);
// return;
// }
// var selectedShip = selected as ShipItem;
// if (selectedShip != null && selectedShip.Owner.IsPlayer) {
// // a remote player owned ship is selected
// _accessSource = AccessSource.RemoteShip;
// _playerRemoteAccessItem = selectedShip;
// Show(true);
// return;
// }
// _accessSource = AccessSource.None;
// _playerRemoteAccessItem = null;
//}
protected override bool TryIsSelectedItemAccessAttempted(ISelectable selected) {
if (_system.IsSelected) {
D.Assert(_system == selected as SystemItem);
D.Assert(_system.Owner.IsPlayer);
return true;
}
return false;
}
private void mainCanvas_SelectedItemChangedEvent(object sender, ISelectable item)
{
DesignerItem designerItem = item as DesignerItem;
if (designerItem != null)
{
designerItem.ContextMenu=(ContextMenu)MenuService.ContextMenuResource["item"];
}
CustomProperty property = new CustomProperty(designerItem.EuipType);
((Window1)App.Current.MainWindow).PropertyBrowser.SelectedObject = designerItem.EuipType;
}
public void SetSelected(ISelectable item) {
if ( !items.Contains(item)) return;
selectedItem = item;
foreach(ISelectable i in items) {
if (i != item) {
i.SetSelected(false);
}
}
Debug.Log(string.Format("ISelectable `{0}' was selected.",item.ToString()));
}
public override void LoadContent()
{
base.LoadContent();
Play.LoadContent();
Exit.LoadContent();
Play.UpdatePosition(50, ScreenManager.Instance.Dimensions.Y - 50);
Exit.UpdatePosition(100 + Play.Widht, ScreenManager.Instance.Dimensions.Y - 50);
SelectedItem = Play;
}
/// <summary>
/// Adds an item to selection.
/// </summary>
/// <param name="item">Item to add to selection.</param>
/// <param name="bNotify">True to notify of this selection change. False otherwise.</param>
public void AddToSelection(ISelectable item, bool bNotify)
{
if (item is ISelectable)
{
if (!ContainsInSelection(item))
CurrentSelection.Add(item);
item.IsSelected = true;
}
if (bNotify)
Notify();
}
public override void LoadContent()
{
base.LoadContent();
Play.LoadContent();
Back.LoadContent();
Selector.LoadContent();
Play.UpdatePosition(110, ScreenManager.Instance.Dimensions.Y - 50);
Back.UpdatePosition(75 + Play.Position.X + Play.Widht, ScreenManager.Instance.Dimensions.Y - 50);
SelectedItem = Play;
}
public void Select(GameObject toSelect)
{
if (toSelect.GetComponent<ISelectable>() != null)
{
Deselect();
CurrentSelected = toSelect;
moveableSelection = CurrentSelected.GetComponent<IMoveable>();
selection = CurrentSelected.GetComponent<ISelectable>();
UIPortrait.sprite = selection.GetSelectionPortrait();
UIPortraitText.text = selection.GetName();
}
}
public static bool Contains(ISelectable item, object[] dataCriteria)
{
return dataCriteria.Any(o =>
{
if (o is string)
return item.Contains((string) o);
if (o is DateTime)
return item.Contains((DateTime) o);
return true;
});
}
public void ExternalSelect(ISelectable o)
{
if (o == null)
{
o = robot;
}
robotGraphPanel1.select(o);
Select(o);
if (this.Visible != true)
{
this.Show();
}
}
public void Select(ISelectable selectable)
{
if (selectable == null)
throw new ArgumentNullException(nameof(selectable));
selectable.IsSelected = true;
if (!_selected.Contains(selectable))
{
_selected.Add(selectable);
OnSelectionChanged();
}
}
public ListBoxItem(ISelectable target)
{
this.target = target;
var attr = target.GetType().GetCustomAttributes(typeof(CustomSelectedTypeNameAttribute), false);
if(attr.Length > 0)
{
Name = (attr[0] as CustomSelectedTypeNameAttribute).TypeName;
}
else
{
Name = target.GetType().Name;
}
Name = string.Format("{0,-20} {1}", Name, target.NameInObjectList);
}
public void Deselect()
{
// Removing parents means this object (and children) will no longer follow any object
transform.parent = null;
// Reset position
transform.position = Vector3.zero;
// Turn off visual effects
visualEffect.SetActive(false);
if (selected != null)
{
selected.OnDeselect();
}
selected = null;
}
public void SetProxy(IAopProxy target)
{
Shape2D shape = target as Shape2D;
if (shape == null)
throw new ArgumentException("target is not an IShape2D");
this.shape = shape;
this.selectable = (ISelectable)shape;
IMouseHandler mouseShape = (IMouseHandler)shape;
mouseShape.MouseDownHandlers.Add(MouseDown);
mouseShape.MouseUpHandlers.Add(MouseUp);
mouseShape.MouseMoveHandlers.Add(MouseMove);
}
public Ga(int generationNumber, int populationSize, double crossRate, double mutationRate, ICrossible crossover, ISelectable selection)
{
if (mutationRate < 0 || mutationRate > 1) throw new ArgumentOutOfRangeException("mutationRate [0;1]");
if (crossRate < 0 || crossRate > 1) throw new ArgumentOutOfRangeException("crossRate [0;1]");
if (generationNumber == 0) throw new ArgumentException("Количество поколений должно быть больше нуля");
if (populationSize % 2 == 1) throw new ArgumentException("Размер популяции должен быть четным");
MutationRate = mutationRate;
CrossRate = crossRate;
PopulationSize = populationSize;
GenerationNumber = generationNumber;
Crossover = crossover;
Selection = selection;
Population = new Population(PopulationSize);
bests = new List<IIndividual>();
}
public void Setup(ISelectable component) {
if (this.IsChanged(ParameterFlag.P1) == true) component.SetEnabledState(this.interactableByDefault);
if (this.IsChanged(ParameterFlag.P2) == true) {
component.SetCallback(() => this.callback.Invoke());
}
if (this.IsChanged(ParameterFlag.P3) == true) component.SetHoverState(this.hoverIsActive);
if (this.IsChanged(ParameterFlag.P4) == true) component.SetHoverOnAnyPointerState(this.hoverOnAnyPointerState);
if (this.IsChanged(ParameterFlag.P5) == true) {
component.SetCallbackHover((state) => {
if (state == true) {
this.hoverInCallback.Invoke();
}
});
}
if (this.IsChanged(ParameterFlag.P6) == true) {
component.SetCallbackHover((state) => {
if (state == false) {
this.hoverOutCallback.Invoke();
}
});
}
if (this.IsChanged(ParameterFlag.P7) == true) component.SetSFX(PointerEventState.Click, this.sfxOnClick);
if (this.IsChanged(ParameterFlag.P8) == true) component.SetSFX(PointerEventState.Enter, this.sfxOnEnter);
if (this.IsChanged(ParameterFlag.P9) == true) component.SetSFX(PointerEventState.Leave, this.sfxOnLeave);
if (this.IsChanged(ParameterFlag.P10) == true) component.SetHoverOnAnyButtonState(this.hoverOnAnyButtonState);
}
public void Unselect(ISelectable selectable)
{
if (selectable == null)
throw new ArgumentNullException(nameof(selectable));
if (_selected.Contains(selectable))
{
//Unselect the item
selectable.IsSelected = false;
//Remove it from the list of selections
_selected.Remove(selectable);
//Raise the event
OnSelectionChanged();
}
}
public void Awake()
{
switch (searchType)
{
case SearchForSelectable.InCurrent:
selectable = transform.GetInterface<ISelectable>();
break;
case SearchForSelectable.InParent:
selectable = transform.GetInterfaceInParentAndChildren<ISelectable>();
break;
case SearchForSelectable.InChildren:
selectable = transform.GetInterfaceInChildren<ISelectable>();
break;
default:
break;
}
}
public void OnSelectInvoke(ISelectable selectableObject)
{
OnSelect?.Invoke(this, new OnSelectEventArgs {
selectableObject = selectableObject
});
}
public EventArgs(ISelectable currentSelectedElement)
{
CurrentSelectedElement = currentSelectedElement;
}
public void SelectSelectable(ISelectable selectable)
{
_targetSelectable = selectable;
SelectObj();
}
internal void SelectItem(ISelectable item)
{
this.ClearSelection();
this.AddToSelection(item);
}
private void SelectModel(ISelectable model)
{
DynamoSelection.Instance.Selection.Add(model);
}
/// <summary>
/// Meant to called when the Object Selector has stopped being used.
/// </summary>
public void CleanUp()
{
_previousSelection.OnDeselected();
_previousSelection = null;
}
public static void DrawInspectGizmoGridFor(IEnumerable <object> selectedObjects, out Gizmo mouseoverGizmo)
{
mouseoverGizmo = null;
try
{
InspectGizmoGrid.objList.Clear();
InspectGizmoGrid.objList.AddRange(selectedObjects);
InspectGizmoGrid.gizmoList.Clear();
for (int i = 0; i < InspectGizmoGrid.objList.Count; i++)
{
ISelectable selectable = InspectGizmoGrid.objList[i] as ISelectable;
if (selectable != null)
{
InspectGizmoGrid.gizmoList.AddRange(selectable.GetGizmos());
}
}
for (int j = 0; j < InspectGizmoGrid.objList.Count; j++)
{
Thing t = InspectGizmoGrid.objList[j] as Thing;
if (t != null)
{
List <Designator> allDesignators = Find.ReverseDesignatorDatabase.AllDesignators;
for (int k = 0; k < allDesignators.Count; k++)
{
Designator des = allDesignators[k];
if (des.CanDesignateThing(t).Accepted)
{
Command_Action command_Action = new Command_Action();
command_Action.defaultLabel = des.LabelCapReverseDesignating(t);
float iconAngle;
Vector2 iconOffset;
command_Action.icon = des.IconReverseDesignating(t, out iconAngle, out iconOffset);
command_Action.iconAngle = iconAngle;
command_Action.iconOffset = iconOffset;
command_Action.defaultDesc = des.DescReverseDesignating(t);
command_Action.order = ((!(des is Designator_Uninstall)) ? -20f : -11f);
command_Action.action = delegate()
{
if (!TutorSystem.AllowAction(des.TutorTagDesignate))
{
return;
}
des.DesignateThing(t);
des.Finalize(true);
};
command_Action.hotKey = des.hotKey;
command_Action.groupKey = des.groupKey;
InspectGizmoGrid.gizmoList.Add(command_Action);
}
}
}
}
InspectGizmoGrid.objList.Clear();
GizmoGridDrawer.DrawGizmoGrid(InspectGizmoGrid.gizmoList, InspectPaneUtility.PaneWidthFor(Find.WindowStack.WindowOfType <IInspectPane>()) + 20f, out mouseoverGizmo);
InspectGizmoGrid.gizmoList.Clear();
}
catch (Exception ex)
{
Log.ErrorOnce(ex.ToString(), 3427734, false);
}
}
private dynamic ExtractField(ISelectable item, Page page, DataToken field, int index)
{
ISelector selector = SelectorUtil.Parse(field.Selector);
if (selector == null)
{
return(null);
}
var f = field as Field;
bool isEntity = field is Entity;
if (!isEntity)
{
string tmpValue;
if (selector is EnviromentSelector)
{
var enviromentSelector = selector as EnviromentSelector;
tmpValue = GetEnviromentValue(enviromentSelector.Field, page, index);
if (f != null)
{
foreach (var formatter in f.Formatters)
{
tmpValue = formatter.Formate(tmpValue);
}
}
return(tmpValue);
}
else
{
bool needPlainText = ((Field)field).Option == PropertySelector.ValueOption.PlainText;
if (field.Multi)
{
var propertyValues = item.SelectList(selector).Nodes();
List <string> results = new List <string>();
foreach (var propertyValue in propertyValues)
{
string tmp = propertyValue.GetValue(needPlainText);
if (f != null)
{
foreach (var formatter in f.Formatters)
{
tmp = formatter.Formate(tmp);
}
}
results.Add(tmp);
}
return(new JArray(results));
}
else
{
bool needCount = (((Field)field).Option == PropertySelector.ValueOption.Count);
if (needCount)
{
var propertyValues = item.SelectList(selector).Nodes();
return(propertyValues?.Count.ToString() ?? "-1");
}
else
{
tmpValue = item.Select(selector)?.GetValue(needPlainText);
if (f != null)
{
foreach (var formatter in f.Formatters)
{
tmpValue = formatter.Formate(tmpValue);
}
}
return(tmpValue);
}
}
}
}
else
{
if (field.Multi)
{
JArray objs = new JArray();
var selectables = item.SelectList(selector).Nodes();
foreach (var selectable in selectables)
{
JObject obj = new JObject();
foreach (var child in ((Entity)field).Fields)
{
obj.Add(child.Name, ExtractField(selectable, page, child, 0));
}
objs.Add(obj);
}
return(objs);
}
else
{
JObject obj = new JObject();
var selectable = item.Select(selector);
foreach (var child in ((Entity)field).Fields)
{
obj.Add(child.Name, ExtractField(selectable, page, field, 0));
}
return(obj);
}
}
}
public string GetSelectQuery(DatabaseBase database, QueryBuilderBase queryBuilder, Parameters parameters)
{
StringBuilder stringBuilder = new StringBuilder();
if (queryBuilder.UnionQuery != null)
{
stringBuilder.Append(GetSelectQuery(database, queryBuilder.UnionQuery, parameters));
if (queryBuilder.UnionType == UnionType.UNION)
{
stringBuilder.Append(" UNION ");
}
else if (queryBuilder.UnionType == UnionType.UNION_ALL)
{
stringBuilder.Append(" UNION ALL ");
}
else if (queryBuilder.UnionType == UnionType.INTERSECT)
{
stringBuilder.Append(" INTERSECT ");
}
else
{
if (queryBuilder.UnionType != UnionType.EXCEPT)
{
throw new Exception("Unknown union type: " + queryBuilder.UnionType.ToString());
}
stringBuilder.Append(" EXCEPT ");
}
}
stringBuilder.Append("SELECT ");
if (queryBuilder.IsDistinct)
{
stringBuilder.Append("DISTINCT ");
}
if (queryBuilder.TopRows.HasValue)
{
stringBuilder.Append("TOP ").Append(queryBuilder.TopRows.Value.ToString());
}
bool useAlias = queryBuilder.JoinList.Count > 0 && !queryBuilder.FromTable.IsTemporaryTable;
int index1 = 0;
while (index1 < queryBuilder.SelectColumns.Length)
{
ISelectable selectable = queryBuilder.SelectColumns[index1];
if (index1 > 0)
{
stringBuilder.Append(',');
}
if (selectable is ColumnBase)
{
stringBuilder.Append(GetColumnSql((ColumnBase)selectable, useAlias));
}
else
{
if (!(selectable is IFunction))
{
throw new Exception("Field type not supported yet");
}
stringBuilder.Append(((IFunction)selectable).GetFunctionSql(database, useAlias));
}
checked { ++index1; }
}
if (queryBuilder.IntoTable != null)
{
stringBuilder.Append(" INTO ");
if (queryBuilder.IntoTable.IsTemporaryTable)
{
stringBuilder.Append("#");
}
stringBuilder.Append(queryBuilder.IntoTable.Name);
}
stringBuilder.Append(" FROM ");
if (queryBuilder.FromTable.IsTemporaryTable)
{
stringBuilder.Append("#");
}
stringBuilder.Append(queryBuilder.FromTable.Name);
stringBuilder.Append(" AS ").Append(queryBuilder.FromTable.Alias);
if (queryBuilder.FromHints != null && queryBuilder.FromHints.Length > 0)
{
stringBuilder.Append(" WITH(");
int index2 = 0;
while (index2 < queryBuilder.FromHints.Length)
{
string str = queryBuilder.FromHints[index2];
if (index2 > 0)
{
stringBuilder.Append(",");
}
stringBuilder.Append(str);
checked { ++index2; }
}
stringBuilder.Append(")");
}
if (queryBuilder.JoinList.Count > 0)
{
stringBuilder.Append(" ");
int index2 = 0;
while (index2 < queryBuilder.JoinList.Count)
{
Join join = queryBuilder.JoinList[index2];
if (join.JoinType == JoinType.JOIN)
{
stringBuilder.Append("JOIN ");
}
else if (join.JoinType == JoinType.LEFT)
{
stringBuilder.Append("LEFT JOIN ");
}
else
{
if (join.JoinType != JoinType.RIGHT)
{
throw new Exception("Unknown join type: " + join.JoinType.ToString());
}
stringBuilder.Append("RIGHT JOIN ");
}
if (join.Table.IsTemporaryTable)
{
stringBuilder.Append("#");
}
stringBuilder.Append(join.Table.Name).Append(" AS ").Append(join.Table.Alias).Append(" ON ").Append(GetConditionSql(database, join.Condition, parameters, true));
if (join.Hints != null && join.Hints.Length > 0)
{
stringBuilder.Append(" WITH(");
int index3 = 0;
while (index3 < join.Hints.Length)
{
string str = join.Hints[index3];
if (index3 > 0)
{
stringBuilder.Append(",");
}
stringBuilder.Append(str);
checked { ++index3; }
}
stringBuilder.Append(")");
}
checked { ++index2; }
}
}
if (queryBuilder.WhereCondition != null)
{
stringBuilder.Append(" WHERE ").Append(GetConditionSql(database, queryBuilder.WhereCondition, parameters, useAlias));
}
if (queryBuilder.GroupByColumns != null && queryBuilder.GroupByColumns.Length > 0)
{
stringBuilder.Append(" GROUP BY ");
int index2 = 0;
while (index2 < queryBuilder.GroupByColumns.Length)
{
ISelectable selectable = queryBuilder.GroupByColumns[index2];
if (index2 > 0)
{
stringBuilder.Append(',');
}
if (selectable is ColumnBase)
{
ColumnBase ColumnBase = (ColumnBase)selectable;
if (useAlias)
{
stringBuilder.Append(ColumnBase.Table.Alias).Append('.');
}
stringBuilder.Append(ColumnBase.Name);
}
else
{
if (!(selectable is IFunction))
{
throw new Exception("column type not supported yet");
}
stringBuilder.Append(((IFunction)selectable).GetFunctionSql(database, useAlias));
}
checked { ++index2; }
}
}
if (queryBuilder.HavingCondition != null)
{
stringBuilder.Append(" HAVING ").Append(GetConditionSql(database, queryBuilder.HavingCondition, parameters, useAlias));
}
if (queryBuilder.OrderByColumns != null && queryBuilder.OrderByColumns.Length > 0)
{
stringBuilder.Append(" ORDER BY ");
int index2 = 0;
while (index2 < queryBuilder.OrderByColumns.Length)
{
IOrderByColumn orderByColumn = queryBuilder.OrderByColumns[index2];
if (index2 > 0)
{
stringBuilder.Append(',');
}
ISelectable column = orderByColumn.GetOrderByColumn.Column;
if (column is ColumnBase)
{
stringBuilder.Append(GetColumnSql((ColumnBase)column, useAlias));
}
else
{
if (!(column is IFunction))
{
throw new Exception("Field type not supported yet");
}
stringBuilder.Append(((IFunction)column).GetFunctionSql(database, useAlias));
}
switch (orderByColumn.GetOrderByColumn.OrderBy)
{
case OrderByType.ASC:
stringBuilder.Append(" ASC");
goto case OrderByType.Default;
case OrderByType.DESC:
stringBuilder.Append(" DESC");
goto case OrderByType.Default;
case OrderByType.Default:
checked { ++index2; }
continue;
default:
throw new CooqDataException.CooqPreconditionException("Unknown OrderBy type: " + orderByColumn.GetOrderByColumn.OrderBy.ToString());
}
}
}
if (!string.IsNullOrEmpty(queryBuilder.CustomSql))
{
stringBuilder.Append(" ").Append(queryBuilder.CustomSql);
}
return(stringBuilder.ToString());
}
public bool IsSelected(ISelectable selectable, int channel)
{
return(selectedEntities[channel].Contains(selectable));
}
public bool IsSelected(ISelectable selectable)
{
return(IsSelected(selectable, 0));
}
public List <JObject> Process(Page page)
{
List <JObject> result = new List <JObject>();
bool isTarget = true;
foreach (var targetUrlExtractor in EntityMetadata.TargetUrlExtractors)
{
foreach (var regex in targetUrlExtractor.Regexes)
{
isTarget = regex.IsMatch(page.Url);
if (isTarget)
{
break;
}
}
}
if (!isTarget)
{
return(null);
}
if (_globalValues != null && _globalValues.Count > 0)
{
foreach (var enviromentValue in _globalValues)
{
string name = enviromentValue.Name;
var value = page.Selectable.Select(SelectorUtil.Parse(enviromentValue)).GetValue();
page.Request.PutExtra(name, value);
}
}
ISelector selector = SelectorUtil.Parse(EntityMetadata.Entity.Selector);
if (selector != null && EntityMetadata.Entity.Multi)
{
var list = page.Selectable.SelectList(selector).Nodes();
if (list == null || list.Count == 0)
{
result = null;
}
else
{
var countToken = EntityMetadata.Limit;
if (countToken != null)
{
list = list.Take(countToken.Value).ToList();
}
int index = 0;
foreach (var item in list)
{
JObject obj = ProcessSingle(page, item, index);
if (obj != null)
{
result.Add(obj);
}
index++;
}
}
}
else
{
ISelectable select = selector == null ? page.Selectable : page.Selectable.Select(selector);
if (select != null)
{
var singleResult = ProcessSingle(page, select, 0);
result = new List <JObject> {
singleResult
};
}
else
{
result = null;
}
}
//if (EntityMetadata.TargetUrlsCreators != null && EntityMetadata.TargetUrlExtractors.Count > 0)
//{
// foreach (var targetUrlsCreator in EntityMetadata.TargetUrlsCreators)
// {
// page.AddTargetRequests(targetUrlsCreator.Handle(page));
// }
//}
if (!page.MissExtractTargetUrls)
{
ExtractLinks(page, EntityMetadata.TargetUrlExtractors);
}
return(result);
}
public bool IsPreselected(ISelectable selectable)
{
return(preselectedEntities.Contains(selectable));
}
public SingleTableEntityPersister(PersistentClass persistentClass, ICacheConcurrencyStrategy cache,
ISessionFactoryImplementor factory, IMapping mapping)
: base(persistentClass, cache, factory)
{
#region CLASS + TABLE
joinSpan = persistentClass.JoinClosureSpan + 1;
identifierTypes = new IType[joinSpan];
qualifiedTableNames = new string[joinSpan];
isInverseTable = new bool[joinSpan];
isNullableTable = new bool[joinSpan];
keyColumnNames = new string[joinSpan][];
Table table = persistentClass.RootTable;
identifierTypes[0] = IdentifierType;
qualifiedTableNames[0] = table.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName);
isInverseTable[0] = false;
isNullableTable[0] = false;
keyColumnNames[0] = IdentifierColumnNames;
cascadeDeleteEnabled = new bool[joinSpan];
// Custom sql
customSQLInsert = new SqlString[joinSpan];
customSQLUpdate = new SqlString[joinSpan];
customSQLDelete = new SqlString[joinSpan];
insertCallable = new bool[joinSpan];
updateCallable = new bool[joinSpan];
deleteCallable = new bool[joinSpan];
insertResultCheckStyles = new ExecuteUpdateResultCheckStyle[joinSpan];
updateResultCheckStyles = new ExecuteUpdateResultCheckStyle[joinSpan];
deleteResultCheckStyles = new ExecuteUpdateResultCheckStyle[joinSpan];
customSQLInsert[0] = persistentClass.CustomSQLInsert;
insertCallable[0] = customSQLInsert[0] != null && persistentClass.IsCustomInsertCallable;
insertResultCheckStyles[0] = persistentClass.CustomSQLInsertCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(customSQLInsert[0], insertCallable[0]);
customSQLUpdate[0] = persistentClass.CustomSQLUpdate;
updateCallable[0] = customSQLUpdate[0] != null && persistentClass.IsCustomUpdateCallable;
updateResultCheckStyles[0] = persistentClass.CustomSQLUpdateCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(customSQLUpdate[0], updateCallable[0]);
customSQLDelete[0] = persistentClass.CustomSQLDelete;
deleteCallable[0] = customSQLDelete[0] != null && persistentClass.IsCustomDeleteCallable;
deleteResultCheckStyles[0] = persistentClass.CustomSQLDeleteCheckStyle
?? ExecuteUpdateResultCheckStyle.DetermineDefault(customSQLDelete[0], deleteCallable[0]);
#endregion
#region JOINS
int j = 1;
foreach (Join join in persistentClass.JoinClosureIterator)
{
identifierTypes[j] = join.Key.Type;
qualifiedTableNames[j] = join.Table.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName);
isInverseTable[j] = join.IsInverse;
isNullableTable[j] = join.IsOptional;
cascadeDeleteEnabled[j] = join.Key.IsCascadeDeleteEnabled && factory.Dialect.SupportsCascadeDelete;
customSQLInsert[j] = join.CustomSQLInsert;
insertCallable[j] = customSQLInsert[j] != null && join.IsCustomInsertCallable;
insertResultCheckStyles[j] = join.CustomSQLInsertCheckStyle
??
ExecuteUpdateResultCheckStyle.DetermineDefault(customSQLInsert[j], insertCallable[j]);
customSQLUpdate[j] = join.CustomSQLUpdate;
updateCallable[j] = customSQLUpdate[j] != null && join.IsCustomUpdateCallable;
updateResultCheckStyles[j] = join.CustomSQLUpdateCheckStyle
??
ExecuteUpdateResultCheckStyle.DetermineDefault(customSQLUpdate[j], updateCallable[j]);
customSQLDelete[j] = join.CustomSQLDelete;
deleteCallable[j] = customSQLDelete[j] != null && join.IsCustomDeleteCallable;
deleteResultCheckStyles[j] = join.CustomSQLDeleteCheckStyle
??
ExecuteUpdateResultCheckStyle.DetermineDefault(customSQLDelete[j], deleteCallable[j]);
keyColumnNames[j] = join.Key.ColumnIterator.OfType <Column>().Select(col => col.GetQuotedName(factory.Dialect)).ToArray();
j++;
}
constraintOrderedTableNames = new string[qualifiedTableNames.Length];
constraintOrderedKeyColumnNames = new string[qualifiedTableNames.Length][];
for (int i = qualifiedTableNames.Length - 1, position = 0; i >= 0; i--, position++)
{
constraintOrderedTableNames[position] = qualifiedTableNames[i];
constraintOrderedKeyColumnNames[position] = keyColumnNames[i];
}
spaces = qualifiedTableNames.Concat(persistentClass.SynchronizedTables).ToArray();
bool lazyAvailable = IsInstrumented(EntityMode.Poco);
bool hasDeferred = false;
List <string> subclassTables = new List <string>();
List <string[]> joinKeyColumns = new List <string[]>();
//provided so we can join to keys other than the primary key
joinToKeyColumns = new Dictionary <int, string[]>();
//Columns that also function as Id's
List <Column> idColumns = new List <Column>();
tableIdPropertyNumbers = new Dictionary <int, int>();
List <bool> isConcretes = new List <bool>();
List <bool> isDeferreds = new List <bool>();
List <bool> isInverses = new List <bool>();
List <bool> isNullables = new List <bool>();
List <bool> isLazies = new List <bool>();
subclassTables.Add(qualifiedTableNames[0]);
joinKeyColumns.Add(IdentifierColumnNames);
isConcretes.Add(true);
isDeferreds.Add(false);
isInverses.Add(false);
isNullables.Add(false);
isLazies.Add(false);
foreach (Join join in persistentClass.SubclassJoinClosureIterator)
{
isConcretes.Add(persistentClass.IsClassOrSuperclassJoin(join));
isDeferreds.Add(join.IsSequentialSelect);
isInverses.Add(join.IsInverse);
isNullables.Add(join.IsOptional);
isLazies.Add(lazyAvailable && join.IsLazy);
if (join.IsSequentialSelect && !persistentClass.IsClassOrSuperclassJoin(join))
{
hasDeferred = true;
}
subclassTables.Add(join.Table.GetQualifiedName(factory.Dialect, factory.Settings.DefaultCatalogName, factory.Settings.DefaultSchemaName));
var keyCols = join.Key.ColumnIterator.OfType <Column>().Select(col => col.GetQuotedName(factory.Dialect)).ToArray();
joinKeyColumns.Add(keyCols);
//are we joining to other than the primary key?
if (join.RefIdProperty != null)
{
var curTableIndex = joinKeyColumns.Count - 1;
//there should only ever be one key
var toKeyCols = new List <string>(join.RefIdProperty.ColumnSpan);
foreach (Column col in join.RefIdProperty.ColumnIterator)
{
toKeyCols.Add(col.GetQuotedName(factory.Dialect));
//find out what property index this is
int i = 0;
foreach (var prop in persistentClass.PropertyClosureIterator)
{
if (prop == @join.RefIdProperty)
{
tableIdPropertyNumbers.Add(curTableIndex, i);
break;
}
i++;
}
idColumns.Add(col);
}
joinToKeyColumns.Add(curTableIndex, toKeyCols.ToArray());
}
}
subclassTableSequentialSelect = isDeferreds.ToArray();
subclassTableNameClosure = subclassTables.ToArray();
subclassTableIsLazyClosure = isLazies.ToArray();
subclassTableKeyColumnClosure = joinKeyColumns.ToArray();
isClassOrSuperclassTable = isConcretes.ToArray();
isInverseSubclassTable = isInverses.ToArray();
isNullableSubclassTable = isNullables.ToArray();
hasSequentialSelects = hasDeferred;
#endregion
#region DISCRIMINATOR
if (persistentClass.IsPolymorphic)
{
IValue discrimValue = persistentClass.Discriminator;
if (discrimValue == null)
{
throw new MappingException("Discriminator mapping required for single table polymorphic persistence");
}
forceDiscriminator = persistentClass.IsForceDiscriminator;
IEnumerator <ISelectable> iSel = discrimValue.ColumnIterator.GetEnumerator();
iSel.MoveNext();
ISelectable selectable = iSel.Current;
if (discrimValue.HasFormula)
{
Formula formula = (Formula)selectable;
discriminatorFormula = formula.FormulaString;
discriminatorFormulaTemplate = formula.GetTemplate(factory.Dialect, factory.SQLFunctionRegistry);
discriminatorColumnName = null;
discriminatorAlias = Discriminator_Alias;
}
else
{
Column column = (Column)selectable;
discriminatorColumnName = column.GetQuotedName(factory.Dialect);
discriminatorAlias = column.GetAlias(factory.Dialect, persistentClass.RootTable);
discriminatorFormula = null;
discriminatorFormulaTemplate = null;
}
discriminatorType = persistentClass.Discriminator.Type;
if (persistentClass.IsDiscriminatorValueNull)
{
discriminatorValue = NullDiscriminator;
discriminatorSQLValue = InFragment.Null;
discriminatorInsertable = false;
}
else if (persistentClass.IsDiscriminatorValueNotNull)
{
discriminatorValue = NotNullDiscriminator;
discriminatorSQLValue = InFragment.NotNull;
discriminatorInsertable = false;
}
else
{
discriminatorInsertable = persistentClass.IsDiscriminatorInsertable && !discrimValue.HasFormula;
try
{
IDiscriminatorType dtype = (IDiscriminatorType)discriminatorType;
discriminatorValue = dtype.StringToObject(persistentClass.DiscriminatorValue);
discriminatorSQLValue = dtype.ObjectToSQLString(discriminatorValue, factory.Dialect);
}
catch (InvalidCastException cce)
{
throw new MappingException(
string.Format("Illegal discriminator type: {0} of entity {1}", discriminatorType.Name, persistentClass.EntityName), cce);
}
catch (Exception e)
{
throw new MappingException("Could not format discriminator value to SQL string of entity " + persistentClass.EntityName, e);
}
}
}
else
{
forceDiscriminator = false;
discriminatorInsertable = false;
discriminatorColumnName = null;
discriminatorAlias = null;
discriminatorType = null;
discriminatorValue = null;
discriminatorSQLValue = null;
discriminatorFormula = null;
discriminatorFormulaTemplate = null;
}
#endregion
#region PROPERTIES
propertyTableNumbers = new int[PropertySpan];
int i2 = 0;
foreach (Property prop in persistentClass.PropertyClosureIterator)
{
propertyTableNumbers[i2++] = persistentClass.GetJoinNumber(prop);
}
List <int> columnJoinNumbers = new List <int>();
List <int> formulaJoinedNumbers = new List <int>();
List <int> propertyJoinNumbers = new List <int>();
foreach (Property prop in persistentClass.SubclassPropertyClosureIterator)
{
int join = persistentClass.GetJoinNumber(prop);
propertyJoinNumbers.Add(join);
propertyTableNumbersByNameAndSubclass[prop.PersistentClass.EntityName + '.' + prop.Name] = join;
foreach (ISelectable thing in prop.ColumnIterator)
{
if (thing.IsFormula)
{
formulaJoinedNumbers.Add(join);
}
else
{
columnJoinNumbers.Add(join);
}
}
}
subclassColumnTableNumberClosure = columnJoinNumbers.ToArray();
subclassFormulaTableNumberClosure = formulaJoinedNumbers.ToArray();
subclassPropertyTableNumberClosure = propertyJoinNumbers.ToArray();
int subclassSpan = persistentClass.SubclassSpan + 1;
subclassClosure = new string[subclassSpan];
subclassClosure[0] = EntityName;
if (persistentClass.IsPolymorphic)
{
subclassesByDiscriminatorValue[discriminatorValue] = EntityName;
}
#endregion
#region SUBCLASSES
if (persistentClass.IsPolymorphic)
{
int k = 1;
foreach (Subclass sc in persistentClass.SubclassIterator)
{
subclassClosure[k++] = sc.EntityName;
if (sc.IsDiscriminatorValueNull)
{
subclassesByDiscriminatorValue[NullDiscriminator] = sc.EntityName;
}
else if (sc.IsDiscriminatorValueNotNull)
{
subclassesByDiscriminatorValue[NotNullDiscriminator] = sc.EntityName;
}
else
{
if (discriminatorType == null)
{
throw new MappingException("Not available discriminator type of entity " + persistentClass.EntityName);
}
try
{
IDiscriminatorType dtype = (IDiscriminatorType)discriminatorType;
subclassesByDiscriminatorValue[dtype.StringToObject(sc.DiscriminatorValue)] = sc.EntityName;
}
catch (InvalidCastException cce)
{
throw new MappingException(
string.Format("Illegal discriminator type: {0} of entity {1}", discriminatorType.Name, persistentClass.EntityName), cce);
}
catch (Exception e)
{
throw new MappingException("Error parsing discriminator value of entity " + persistentClass.EntityName, e);
}
}
}
}
#endregion
InitLockers();
InitSubclassPropertyAliasesMap(persistentClass);
PostConstruct(mapping);
}
private void SaveAsNewInstance(ISelectable targetInterface)
{
_targetSelectable = targetInterface;
targetInterface.StartHover();
SetDebugConsole(targetInterface.GetDebugInformation());
}
private void Hover(ISelectable selected, bool toDisplay) // Display health bar and other information UI elements
{
Debug.LogError(selected);
}
private void Clicked(ISelectable selected)
{
lastHovered = selected;
lastSelected = selected;
}
/// <summary>
/// 解析成爬虫实体对象
/// </summary>
/// <param name="page">页面数据</param>
/// <returns>爬虫实体对象</returns>
public override IEnumerable <T> Extract(Page page)
{
List <T> result = new List <T>();
if (EntityDefine.SharedValues != null && EntityDefine.SharedValues.Count > 0)
{
foreach (var enviromentValue in EntityDefine.SharedValues)
{
string name = enviromentValue.Name;
var value = page.Selectable.Select(enviromentValue.ToSelector()).GetValue();
page.Request.PutExtra(name, value);
}
}
ISelector selector = EntityDefine.SelectorAttribute.ToSelector();
if (selector != null && EntityDefine.Multi)
{
var list = page.Selectable.SelectList(selector).Nodes();
if (list == null || list.Count() == 0)
{
result = null;
}
else
{
if (EntityDefine.Take > 0 && list.Count() > EntityDefine.Take)
{
if (EntityDefine.TakeFromHead)
{
list = list.Take(EntityDefine.Take).ToList();
}
else
{
list = list.Skip(list.Count() - EntityDefine.Take).ToList();
}
}
for (int i = 0; i < list.Count(); ++i)
{
var item = list.ElementAt(i);
var obj = ExtractSingle(page, item, i);
if (obj != null)
{
result.Add(obj);
}
}
}
}
else
{
ISelectable select = selector == null ? page.Selectable : page.Selectable.Select(selector);
if (select != null)
{
var item = ExtractSingle(page, select, 0);
result = item != null ? new List <T> {
item
} : null;
}
else
{
result = null;
}
}
return(result);
}
public void DeselectEntity(ISelectable selectable)
{
DeselectEntity(selectable, 0);
}
private string ExtractField(Field field, ISelectable item, Selectable root, int index)
{
if (field == null)
{
return(null);
}
var selector = field.ToSelector();
if (selector == null)
{
return(null);
}
object value;
if (selector is EnviromentSelector)
{
var enviromentSelector = selector as EnviromentSelector;
switch (enviromentSelector.Field)
{
case EnviromentFields.Index:
{
value = index;
break;
}
default:
{
value = root.Enviroment(enviromentSelector.Field);
break;
}
}
}
else
{
value = field.Option == FieldOptions.Count
? item.SelectList(selector).Nodes().Count().ToString()
: item.Select(selector)?.GetValue(ConvertToValueOption(field.Option));
}
if (field.Formatters != null && field.Formatters.Count() > 0)
{
foreach (var formatter in field.Formatters)
{
#if DEBUG
try
{
#endif
value = formatter.Formate(value);
#if DEBUG
}
catch (Exception e)
{
Debugger.Log(0, "ERROR", $"ModelExtractor execute formatter failed: {e}");
}
#endif
}
}
return(value?.ToString());
}
public void AddToSelectables(ISelectable selectable)
{
allSelectables.Add(selectable);
}
/// <summary>
/// Metodo per l'aggiunta nella lista locale degli elementi da gestire dal behavior
/// </summary>
/// <param name="item"></param>
private void addItem(ISelectable item)
{
//se l'oggetto non è nullo e non è contenuto della lista locale
if (item != null && !elements.Contains(item))
{
//se il patch per il selettore del gruppo non è nullo
if (groupSel != null)
{
//un po' di reflection per recuperare le property che decide di quale gruppo farà parte l'oggetto
//per far funzionare la property changed su quella particolare proprietà dovremo agganciarci ad ogni
//istanza degli oggetti nel path
//
// esempio: Model1.Model2.Model3.Name
// Name è la property sulla base della quale viene gestito il raggruppamento degli oggetti
// per poter però sapere se il valore è cambiato dovrò agganciarmi al property changed degli oggetti
// Model1, Model2, Model3
Type type;
PropertyInfo info;
object obj = item;
List <INotifyPropertyChanged> objs = new List <INotifyPropertyChanged>();
//per ogni elemento diviso dal . nel Path del gruppo ad esclusione dell'ultimo che verrà gestito dopo il ciclo
for (int i = 0; i < groupSel.Length - 1; i++)
{
//a partire dall'oggetto da aggiungere recupero il tipo
type = obj.GetType();
//dal tipo recupero la property usando il primo delemento del path di selezione del gruppo
//nell'esempio sarebbe Model1
info = type.GetProperty(groupSel[i]);
//dalle info sulla Property recupero il valore della property
//la assengo a obj quindi dal prossimo giro il riferimento sarà il valore di questa peroperty
obj = info.GetValue(obj, null);
//se l'oggetto della property implementa l'INotifyPropertyChanged
//aggiungo questo oggetto alla lista di oggetti u cui registrare l'evento
if (obj as INotifyPropertyChanged != null)
{
objs.Add(obj as INotifyPropertyChanged);
}
}
//gestione dell'ultimo elemento del Path
//nell'esempio Name
//recupero il tipo dell'ultimo oggetto recuperato nel ciclo
//nell'esempio Model3
type = obj.GetType();
//recupero le info sulla proprietà indicata dall'ultima voce del Path
//nell'esempio Name
info = type.GetProperty(groupSel.Last());
//recupero il valore della property
var groupValue = info.GetValue(obj, null);
//se il valore della property equivale al valore del Gruppo che devo gestire
if (groupValue.Equals(Group))
{
//aggiungo l'elemento alla lista locale degli elementi che devo gestire
elements.Add(item);
//mi aggancio al property changed della proprietà
foreach (INotifyPropertyChanged o in objs)
{
o.PropertyChanged += item_subPropertyChanged;
}
//aggiungo una chiave nel dictionary che contiene la lista degli oggetti a cui ho agganciato l'evento property changed
//per l'oggetto passato
subElementWatch.Add(item, objs);
//mi aggancio anche al property chagned dell'oggetto passato
(item as INotifyPropertyChanged).PropertyChanged
+= new PropertyChangedEventHandler(item_PropertyChanged);
}
}
else
{
//se non ho la selezione dei gruppi da gestire
//aggiungo l'oggetto passato alla lista degli oggetti da gestire
elements.Add(item);
//mi aggancio al suo property changed
(item as INotifyPropertyChanged).PropertyChanged
+= new PropertyChangedEventHandler(item_PropertyChanged);
}
}
}
private object ExtractField(ISelectable item, Page page, Column field, int index)
{
if (field == null)
{
return(null);
}
ISelector selector = field.SelectorAttribute.ToSelector();
if (selector == null)
{
return(null);
}
if (selector is EnviromentSelector)
{
var enviromentSelector = selector as EnviromentSelector;
var value = SelectorUtil.GetEnviromentValue(enviromentSelector.Field, page, index);
foreach (var formatter in field.Formatters)
{
#if DEBUG
try
{
#endif
value = formatter.Formate(value);
#if DEBUG
}
catch (Exception e)
{
Log.Logger.Error(e.ToString());
}
#endif
}
return(TryConvert(value, field.DataType));
}
else
{
bool needCount = field.Option == PropertyDefineOptions.Count;
if (needCount)
{
var values = item.SelectList(selector).Nodes();
return(values.Count());
}
else
{
var value = (object)item.Select(selector)?.GetValue(ConvertToValueOption(field.Option));
foreach (var formatter in field.Formatters)
{
#if DEBUG
try
{
#endif
value = formatter.Formate(value);
#if DEBUG
}
catch (Exception e)
{
Log.Logger.Error(e.ToString());
}
#endif
}
return(TryConvert(value, field.DataType));
}
}
}
private dynamic ExtractField(ISelectable item, Page page, Column field, int index)
{
if (field == null)
{
return(null);
}
ISelector selector = SelectorUtils.Parse(field.Selector);
if (selector == null)
{
return(null);
}
string tmpValue;
if (selector is EnviromentSelector)
{
var enviromentSelector = selector as EnviromentSelector;
tmpValue = GetEnviromentValue(enviromentSelector.Field, page, index);
foreach (var formatter in field.Formatters)
{
#if DEBUG
try
{
#endif
tmpValue = formatter.Formate(tmpValue);
#if DEBUG
}
catch (Exception e)
{
}
#endif
}
return(tmpValue);
}
else
{
bool needPlainText = field.Option == PropertyDefine.Options.PlainText;
if (field.Multi)
{
var propertyValues = item.SelectList(selector).Nodes();
List <string> results = new List <string>();
foreach (var propertyValue in propertyValues)
{
results.Add(propertyValue.GetValue(needPlainText));
}
foreach (var formatter in field.Formatters)
{
#if DEBUG
try
{
#endif
results = formatter.Formate(results);
#if DEBUG
}
catch (Exception e)
{
}
#endif
}
return(new JArray(results));
}
else
{
bool needCount = field.Option == PropertyDefine.Options.Count;
if (needCount)
{
var propertyValues = item.SelectList(selector).Nodes();
string count = propertyValues?.Count.ToString();
count = string.IsNullOrEmpty(count) ? "-1" : count;
return(count);
}
else
{
tmpValue = item.Select(selector)?.GetValue(needPlainText);
foreach (var formatter in field.Formatters)
{
#if DEBUG
try
{
#endif
tmpValue = formatter.Formate(tmpValue);
#if DEBUG
}
catch (Exception e)
{
}
#endif
}
return(tmpValue);
}
}
}
}
// Update is called once per frame
void Update()
{
//TODO: this can be improved. I'm sure.
// Get Mouse Mouse Position
Ray mousePositionRay = Camera.main.ScreenPointToRay(Input.mousePosition);
//Cast a Ray through all Objects to shoot through Indicator Plane of Nodes. If Ray hits "Tile"-Layer, get the coresponding node
RaycastHit[] hits = Physics.RaycastAll(mousePositionRay, Mathf.Infinity).OrderBy(h => h.distance).ToArray();
SetMovement(mousePositionRay);
for (int i = 0; i < hits.Length; i++)
{
RaycastHit hit = hits[i];
//If mouse is over a Tile
if (hit.collider.gameObject.layer == LayerMask.NameToLayer("Tile"))
{
//Check which side of the tile was hit
Transform objectHit = hit.transform;
Ray objectSideRay = new Ray(objectHit.transform.position, hit.normal);
//Debug.DrawRay(objectSideRay.origin, objectSideRay.direction * 1.5f, Color.red, 5f);
// Get the node that is in that direction
RaycastHit objectSideHit;
if (Physics.Raycast(objectSideRay, out objectSideHit, 1f))
{
Node hitNode = objectSideHit.collider.gameObject.GetComponent <Node>();
if (hitNode != null && selectedPlayerUnit != null)
{
selectedPlayerUnit.PrecalculatePathTo(hitNode);
selectedPlayerUnit.Shoot(hitNode);
}
}
break;
}
}
if (Input.GetMouseButtonUp(0))
{
RaycastHit leftClickHit;
if (Physics.Raycast(mousePositionRay, out leftClickHit))
{
//A Selectable is clicked
ISelectable selectable = leftClickHit.collider.GetComponentInParent <ISelectable>();
if (selectable != null)
{
selectable.OnSelect();
}
}
// TileMap.Instance.selectedUnit.Move();
}
void SetMovement(Ray navigateRay)
{
if (Input.GetMouseButtonDown(0))
{
if (selectedPlayerUnit != null &&
selectedPlayerUnit.currentPath != null)
{
RaycastHit navigateToHit;
if (Physics.Raycast(navigateRay, out navigateToHit))
{
selectedPlayerUnit.Move();
}
}
}
}
// Draw Debug Path
if (selectedPlayerUnit != null &&
selectedPlayerUnit.actionState == PlayerUnit.PlayerActionState.MoveSelection &&
selectedPlayerUnit.currentPath != null &&
selectedPlayerUnit.actionState != PlayerUnit.PlayerActionState.Moving)
{
int currentNode = 0;
while (currentNode < selectedPlayerUnit.currentPath.Count - 1)
{
Vector3 start = selectedPlayerUnit.currentPath[currentNode].transform.position;
Vector3 end = selectedPlayerUnit.currentPath[currentNode + 1].transform.position;
Debug.DrawLine(start, end, Color.cyan);
currentNode++;
}
DrawPath();
}
}
static bool MainCanAcceptDrop(ISelectable selected)
{
return(!(selected is BlackboardThisField));
}
private bool IsPointed(ISelectable selectable, Vector3 selectablePosition, Vector3 pointedPosition, float thresholdPosDiff)
{
bool b = (pointedPosition - selectablePosition).magnitude < thresholdPosDiff;
return(b);
}
private DataObject ExtractSingle(Page page, ISelectable item, int index)
{
DataObject dataObject = new DataObject();
bool skip = false;
foreach (var field in EntityDefine.Columns)
{
var fieldValue = ExtractField(item, page, field, index);
if (fieldValue == null)
{
if (field.NotNull)
{
skip = true;
break;
}
}
else
{
dataObject.Add(field.Name, fieldValue);
}
}
if (EntityDefine.TableInfo != null && EntityDefine.TableInfo.Primary == Env.IdColumn)
{
var id = GetEnviromentValue(Env.IdColumn, page, index);
if (!string.IsNullOrEmpty(id))
{
dataObject.Add(Env.IdColumn, id);
}
}
if (skip)
{
return(null);
}
var result = dataObject.Count > 0 ? dataObject : null;
if (result != null && EntityDefine.LinkToNexts != null)
{
foreach (var targetUrl in EntityDefine.LinkToNexts)
{
Dictionary <string, dynamic> extras = new Dictionary <string, dynamic>();
if (targetUrl.Extras != null)
{
foreach (var extra in targetUrl.Extras)
{
extras.Add(extra, result[extra]);
}
}
Dictionary <string, dynamic> allExtras = new Dictionary <string, dynamic>();
foreach (var extra in page.Request.Extras.Union(extras))
{
allExtras.Add(extra.Key, extra.Value);
}
var value = result[targetUrl.PropertyName];
if (value != null)
{
page.AddTargetRequest(new Request(value.ToString(), allExtras));
}
}
}
return(result);
}
void Selection()
{
if (Input.GetMouseButtonDown(0))
{
RaycastHit hit;
if (Physics.Raycast(Camera.main.ScreenPointToRay(Input.mousePosition), out hit))
{
ISelectable selectable = hit.transform.GetComponent <ISelectable>();
if (selectable != null)
{
if (Input.GetKey(KeyCode.LeftControl))
{
if (currentSelection.Contains(selectable))
{
selectable.Deselect();
currentSelection.Remove(selectable);
}
//if (currentSelection == selectable)
//{
// selectable.Deselect();
// currentSelection = null;
//}
else
{
selectable.Select();
currentSelection.Add(selectable);
//if (currentSelection != null)
//{
// currentSelection.Deselect();
// currentSelection = null;
//}
//selectable.Select();
//currentSelection = selectable;
}
}
else
{
if (currentSelection.Count == 1 && currentSelection[0] == selectable)
{
selectable.Deselect();
currentSelection.Clear();
}
else
{
foreach (ISelectable s in currentSelection)
{
s.Deselect();
}
currentSelection.Clear();
selectable.Select();
currentSelection.Add(selectable);
}
}
}
else
{
foreach (ISelectable s in currentSelection)
{
s.Deselect();
}
currentSelection.Clear();
//if (currentSelection != null)
//{
// currentSelection.Deselect();
// currentSelection = null;
//}
}
}
else
{
foreach (ISelectable s in currentSelection)
{
s.Deselect();
}
currentSelection.Clear();
//if (currentSelection != null)
//{
// currentSelection.Deselect();
// currentSelection = null;
//}
}
}
}
public void OnControllerDisconnected()
{
_selected = null;
}
