public void Select(short tile)
{
if (tile < -1 || tile >= Tileset.Tiles.Count)
{
return;
}
if (tile == -1)
{
Selected.Clear();
Selected.Add(-1);
_selection.Start = _selection.End;
}
else
{
_selected_index = tile;
int x = (tile % (Width / _tile_w_zoom));
int y = (tile / (Height / _tile_h_zoom));
_selection.Start = new Point(x, y);
_selection.End = _selection.Start;
Selected.Clear();
Selected.Add(tile);
}
Invalidate();
}
private bool CheckMultiSelection(int xNew, int yNew)
{
if (!(MultiSelection = Input.GetKey(KeyCode.LeftShift)))
{
return(false);
}
var xDelta = xNew - _xCurrent;
var yDelta = yNew - _yCurrent;
var signX = Math.Sign(xDelta);
var signY = Math.Sign(yDelta);
for (var y = 0; y <= Math.Abs(yDelta); y++)
{
for (var x = 0; x <= Math.Abs(xDelta); x++)
{
Selected.Add(new Pair
{
X = _xCurrent + x * signX,
Y = _yCurrent + y * signY
});
_buttonsFrameGameObjectsArray[_yCurrent + y * signY, _xCurrent + x * signX].SetActive(true);
}
}
return(true);
}
public async Task <IActionResult> OnPostAddAsync(int add)
{
Selected.Add(add);
await GetMembers();
return(Page());
}
private void OnTick(object sender, EventArgs e)
{
string filename;
PreviousSelected.Clear();
Selected.ForEach(s => PreviousSelected.Add(s));
Selected.Clear();
try {
var sw = new SHDocVw.ShellWindows();
foreach (SHDocVw.InternetExplorer window in sw)
{
filename = System.IO.Path.GetFileNameWithoutExtension(window.FullName).ToLower();
if (filename.ToLowerInvariant() == "explorer")
{
Shell32.FolderItems items;
try {
var doc = ((Shell32.IShellFolderViewDual2)window.Document);
items = doc.SelectedItems();
foreach (Shell32.FolderItem item in items)
{
Selected.Add(item.Path);
}
} catch (Exception) {
}
}
}
if (Selected.Count != PreviousSelected.Count || !Selected.TrueForAll(s => PreviousSelected.Contains(s)))
{
RaiseUpdated();
}
} catch (Exception ex) {
throw;
}
}
public void set_up_selected(int evopop)
{
for (int i = 0; i < evopop; i++)
{
Selected.Add(i);
}
}
///<summary>
///Place in selected parameters list the selected parameter and remove it of the unselected parameter list
///</summary>
///<param name="parameterName"></param>
public void Select(string parameterName)
{
if (NotSelected.Contains(parameterName))
{
Selected.Add(parameterName);
NotSelected.Remove(parameterName);
}
}
public object Clone()
{
var list = new Selected();
foreach (var rect in this)
{
list.Add(rect);
}
return(list);
}
private void AddChoice(object obj)
{
if (!string.IsNullOrEmpty(ChoiceItem) && !Selected.Contains(ChoiceItem))
{
Selected.Add(ChoiceItem);
Selected = new ObservableCollection <string>(Selected.OrderBy(s => s));
Choices.Remove(ChoiceItem);
}
ToggleActivatation();
}
private void cmdOK_Click(object sender, EventArgs e)
{
Selected.Clear();
foreach (AliasTable s in lstSelectedTables.Items)
{
if (!Selected.Contains(s))
{
Selected.Add(s);
}
}
this.Hide();
}
public static void GetSelection()
{
if (MouseState == MouseStates.DragReleased)
{
IEnumerable <SpaceObject> inSelection = GameManager.Instance.Objects.Where(o =>
o is SpaceShip &&
o.Active &&
o.Location.X > SelectionRectangle.x &&
o.Location.Y > SelectionRectangle.y &&
o.Location.X < SelectionRectangle.x + SelectionRectangle.width &&
o.Location.Y < SelectionRectangle.y + SelectionRectangle.height
);
if (!inSelection.Any())
{
return;
}
if (!IsKeyDown(KeyboardKey.KEY_LEFT_SHIFT))
{
ClearSelection();
}
foreach (SpaceObject o in inSelection)
{
o.Selected = true;
Selected.Add(o);
}
UpdateSelectedUnits();
}
else if (MouseState == MouseStates.Idle)
{
IEnumerable <SpaceObject> inSelection = GameManager.Instance.Objects.Where(o =>
o is SpaceShip &&
o.Active &&
Vector2.Distance(o.Location, UpLocation) < MathF.Max(o.TextureOffset.X, o.TextureOffset.Y)
);
if (!inSelection.Any())
{
ClearSelection();
return;
}
if (!IsKeyDown(KeyboardKey.KEY_LEFT_SHIFT))
{
ClearSelection();
}
SpaceObject ob = inSelection.First();
ob.Selected = true;
Selected.Add(ob);
UpdateSelectedUnits();
}
}
private async void Button_OnClicked(object sender, EventArgs e)
{
foreach (var item in viewModel.Items)
{
if (item.Checked)
{
Selected.Add(item);
}
}
foreach (var item in Selected)
{
viewModel.Items.Remove(item);
}
}
public void AddToInterface(PredictionResult predictionResult)
{
if (SelectedItem != null && predictionResult.Prediction == SelectedItem)
{
Selected.Add(new OutputPrediction {
Prediction = predictionResult.Prediction, Image = new BitmapImage(new Uri(predictionResult.Path))
});
}
foreach (var i in Number)
{
if (i.Label == predictionResult.Prediction)
{
i.Number++;
}
}
All.Add(new OutputPrediction {
Prediction = predictionResult.Prediction, Image = new BitmapImage(new Uri(predictionResult.Path))
});
}
private void SelectTiles()
{
Rectangle r = Selection;
int w = Width / _tile_w_zoom;
Selected.Clear();
for (int y = 0; y < r.Height; ++y)
{
for (int x = 0; x < r.Width; ++x)
{
short tile = (short)((r.X + x) + (r.Y + y) * w);
if (tile < 0 || tile > Tileset.Tiles.Count - 1)
{
tile = -1;
}
Selected.Add(tile);
}
}
}
private async void Button_OnClicked(object sender, EventArgs e)
{
UploadBtn.IsEnabled = false;
await ProgressBar.ProgressTo(1, 1000, Easing.Linear);
ProgressBar.Progress = 0;
UploadBtn.IsEnabled = true;
foreach (var item in viewModel.Items)
{
if (item.Checked)
{
Selected.Add(item);
}
}
foreach (var item in Selected)
{
viewModel.Items.Remove(item);
}
}
private async Task ItemSelected(TModel item)
{
// Reset term
Term = string.Empty;
// Change state
_listVisible = false;
// Add to selected items
Selected ??= new List <TModel>();
if (!Multiselect)
{
Selected.Clear();
}
Selected.Add(item);
// Invoke events
await SelectedChanged.InvokeAsync(Selected);
await OnItemSelect.InvokeAsync(item);
}
private void UpdateResult(PredictionResult predictionResult)
{
CurDispatcher.Invoke(() =>
{
if (SelectedItem != null && predictionResult.Prediction == SelectedItem)
{
Selected.Add(new OutputPrediction {
Prediction = predictionResult.Prediction, Image = new BitmapImage(new Uri(predictionResult.Path))
});
}
foreach (var i in Number)
{
if (i.Label == predictionResult.Prediction)
{
i.Number++;
}
}
All.Add(new OutputPrediction {
Prediction = predictionResult.Prediction, Image = new BitmapImage(new Uri(predictionResult.Path))
});
}, DispatcherPriority.Render);
}
public void VoxelDragged(List <Voxel> refs)
{
if (CurrentVoxelType == null)
{
return;
}
verified = Verify(refs, CurrentVoxelType.ResourceToRelease);
if (!verified)
{
World.ShowToolPopup("Can't build this! Need at least " + refs.Count + " " + ResourceLibrary.Resources[CurrentVoxelType.ResourceToRelease].ResourceName + ".");
}
else
{
World.ShowToolPopup("Release to build.");
}
Selected.Clear();
foreach (Voxel voxel in refs)
{
Selected.Add(new Voxel(voxel));
}
}
public void SetSelect(IAreaContents areaItem, bool value)
{
if (!string.IsNullOrEmpty(areaItem.Group))
{
Debug.Assert(Grouped.ContainsKey(areaItem.Group));
Grouped[areaItem.Group].ForEach(item =>
{
if (item.Select != value)
{
item.Select = value;
}
if (value)
{
Selected.Add(item);
AreaItemSelectOperator.Add(item);
}
else
{
AreaItemSelectOperator.Remove(item);
Selected.Remove(item);
}
});
}
else
{
if (value)
{
Selected.Add(areaItem);
AreaItemSelectOperator.Add(areaItem);
}
else
{
AreaItemSelectOperator.Remove(areaItem);
Selected.Remove(areaItem);
}
}
}
internal void SelectShape(IShape shape, bool clearSelection)
{
if (shape == null)
{
return;
}
if (clearSelection)
{
DeselectAllShapes();
Selected.Add(shape);
shape.IsSelected = true;
DeleteSelectedShapesCommand.RaiseCanExecuteChanged();
CopyCommand.RaiseCanExecuteChanged();
CutCommand.RaiseCanExecuteChanged();
}
else
{
Selected.Add(shape);
shape.IsSelected = true;
DeleteSelectedShapesCommand.RaiseCanExecuteChanged();
CopyCommand.RaiseCanExecuteChanged();
CutCommand.RaiseCanExecuteChanged();
}
}
public void Select(Viz viz, bool ShiftKey)
{
if (viz.IsSelectable)
{
if (ShiftKey ||
(!viz.IsMultiSelectable) ||
((Selected.Count > 0) && (viz.GetType() != Selected[0].GetType())))
{
Selected.Clear();
}
if (Selected.Contains(viz))
{
Selected.Remove(viz);
}
else
{
Selected.Add(viz);
}
}
else
{
Selected.Clear();
}
}
protected override void OnPreviewKeyDown(KeyEventArgs e)
{
base.OnKeyDown(e);
if ((Table == null) || (Table.NumColumns == 0))
{
return;
}
e.Handled = true;
switch (e.Key)
{
case Key.A:
if ((!controlDown) || (!Selectable))
{
e.Handled = false;
}
else
{
for (var ctr = 0; ctr < Table.NumColumns; ++ctr)
{
if (!Selected.Contains(ctr))
{
Selected.Add(ctr);
}
}
}
break;
case Key.N:
if ((!controlDown) || (!Selectable))
{
e.Handled = false;
}
else
{
Selected.Clear();
}
break;
case Key.Left: --SelectedColumn; break;
case Key.Right: ++SelectedColumn; break;
case Key.Home: SelectedColumn = 0; break;
case Key.End: SelectedColumn = Table.NumColumns - 1; break;
case Key.Up:
case Key.Down: break;
case Key.Space:
if (Selectable)
{
if (Selected.Contains(SelectedColumn))
{
Selected.Remove(SelectedColumn);
}
else
{
Selected.Add(SelectedColumn);
}
}
else
{
e.Handled = false;
}
break;
default: e.Handled = false; break;
}
}
internal void AddItem(object obj, bool selected)
{
Items.Add(obj);
Selected.Add(selected);
}
private void SelectItem(MultipleSelectorModel item)
{
NotSelected.Remove(item);
Selected.Add(item);
}
// --------------------------------------------------------------------
public static void Add(SceneObject obj)
{
Selected.Remove(obj);
Selected.Add(obj);
OnSelectionChanged?.Invoke(Selected);
}
private void Add(IUserSort Sort, DataGridViewRow Row)
{
Selected.Add(Sort.Guid);
Commands.CommandUserSort.Instance.AddSort(Sort);
SetBackColor(Row, SelectedSort);
}
void Select(object obj, int depth)
{
// item not found?
if (obj == null)
{
return;
}
// if we're at the end of the query path then select
if (depth == SearchPath.Length)
{
Selected.Add(obj);
return;
}
// if we are a leaf node but still have a remaining path, then we can go no futher
var type = obj.GetType();
if (type.IsPrimitive)
{
return;
}
// get interpreter for current node
var interpreter = Interpreters.Get(type);
// get next path section
var segment = SearchPath[depth];
// select children
if (segment.NodeType == Path.Segment.Type.Children)
{
// get children from node
var child_nodes = interpreter.Children(obj);
// exit if node has no children
if (child_nodes == null || child_nodes.Length == 0)
{
return;
}
// recurse?
if (segment.RecursiveFind)
{
foreach (var node in child_nodes)
{
Select(node.Value, depth);
}
}
// filter by name
var filtered_children = from child in child_nodes where MatchName(segment, child) select child.Value;
// apply where clause
++depth;
if (segment.Where != null)
{
segment.Where.ForEach(filtered_children, Select, depth);
}
else
{
foreach (var child in filtered_children)
{
Select(child, depth);
}
}
}
// otherwise select attribute
else
{
var attr = interpreter.Attr(obj, segment.Select);
if (attr == null)
{
return;
}
++depth;
if (segment.Where == null)
{
Select(attr, depth);
}
else
{
if (attr is IDictionary)
{
segment.Where.ForEach(attr as IDictionary, Select, depth);
}
else if (attr.GetType().IsArray || attr is IEnumerable)
{
segment.Where.ForEach((attr as IEnumerable).Cast <object>(), Select, depth);
}
else if (segment.Where.Apply(attr))
{
Select(attr, depth);
}
}
}
}
/// <summary>
/// checks if to add it
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void CheckBox_Checked(object sender, RoutedEventArgs e)
{
Selected.Add(((CheckBox)sender).DataContext as BO.Station);
btnOk.IsEnabled = Selected.Count > 0;
}
