public static Html Table <Data>(this Html html, ObservableArray <Header <Data> > metadata, ObservableArray <Data> rowData)
{
var table = new Table <Data>(metadata, rowData);
table.Render();
return(html);
}
public Person(string name, string[] children)
{
Name = Knockout.Observable(name);
Children = Knockout.ObservableArray(children);
var self = this;
AddChild = () => self.Children.Push("New Child");
}
public ControlTypesViewModel()
{
StringValue = Knockout.Observable("Hello");
PasswordValue = Knockout.Observable("mypass");
BooleanValue = Knockout.Observable(true);
OptionValues = Knockout.ObservableArray(new[] { "Alpha", "Beta", "Gamma" });
SelectedOptionValue = Knockout.Observable("Gamma");
MultipleSelectedOptionValues = Knockout.ObservableArray(new[] { "Alpha" });
RadioSelectedOptionValue = Knockout.Observable("Beta");
}
/// <summary>
/// Constructs the observable sprite selection and sets the group part Ids to nothing.
/// </summary>
public ObservableSpriteSelection()
{
GameId = string.Empty;
CharacterId = string.Empty;
GroupPartIds = new ObservableArray <int>(SpriteSelection.PartCount);
for (int i = 0; i < SpriteSelection.PartCount; i++)
{
GroupPartIds[i] = SpriteSelection.NoPart;
}
GroupPartFrames = new ObservableArray <int>(SpriteSelection.PartCount);
}
private GridContainerContent([NotNull] Drawable[][] drawables)
: base(new ObservableArray <Drawable> [drawables.Length])
{
for (int i = 0; i < drawables.Length; i++)
{
if (drawables[i] != null)
{
var observableArray = new ObservableArray <Drawable>(drawables[i]);
this[i] = observableArray;
}
}
}
/// <summary>
/// Constructs the an observable copy of the sprite selection.
/// </summary>
/// <param name="spriteSelection">The sprite selection to make a copy of.</param>
public ObservableSpriteSelection(IReadOnlySpriteSelection spriteSelection)
{
GameId = spriteSelection.GameId;
CharacterId = spriteSelection.CharacterId;
Lighting = spriteSelection.Lighting;
Distance = spriteSelection.Distance;
Pose = spriteSelection.Pose;
Blush = spriteSelection.Blush;
GroupPartIds = new ObservableArray <int>(spriteSelection.GroupPartIds);
GroupPartFrames = new ObservableArray <int>(spriteSelection.GroupPartFrames);
}
public void InitViewModel()
{
CurrentTweets = Knockout.ObservableArray<Tweet>();
refreshTimer = -1;
LastID = -1;
String maxDistance = Utils.GetCookieValue("Max-Distance");
if (!String.IsNullOrEmpty(maxDistance))
{
jQuery.Select("#max-distance-field").Value(maxDistance);
Script.Literal("$('#max-distance-field').trigger('refresh')");
}
jQuery.Select("#max-distance-field").Change(new jQueryEventHandler(DistanceChangeHandler));
}
public SimpleListViewModel(string[] items)
{
this.Items = Knockout.ObservableArray(items);
this.ItemToAdd = Knockout.Observable("");
var self = this;
this.AddItem = () => {
if (self.ItemToAdd.Value != "") {
// Adds the item. Writing to the "items" observableArray
// causes any associated UI to update.
self.Items.Push(self.ItemToAdd.Value);
// Clears the text box, because it's bound to the
// "itemToAdd" observable
self.ItemToAdd.Value = "";
}
};
}
public PagedGridViewModel(Data[] items)
{
var self = this;
Items = Knockout.ObservableArray(items);
AddItem = () => self.Items.Push(new Data("New Item", 0, 100));
SortByName = () => self.Items.Sort((a, b) => a.Name.CompareTo(b.Name));
JumpToFirstPage = () => { self.GridViewModel.CurrentPageIndex.Value = 0; };
GridViewModel = new ViewModel<Data>(new Configuration<Data> (
pageSize: 4,
data: self.Items,
columns: Knockout.ObservableArray(new[] {
new Column<Data>("Item Name", "name"),
new Column<Data>("Sales Count", "sales"),
new Column<Data>("Price", item => "R " + item.Price.ToFixed(2))
}
)));
}
public SudokuViewModel()
{
_board = new string[81];
_arr = new ObservableArray(81);
_sudoku = new Sudoku();
_sudoku.WhenAnyValue(x => x.BoardIndex).Subscribe(x =>
{
int r = x / 9;
int c = x % 9;
_arr[x] = _sudoku.Board[r, c] + "";
this.RaisePropertyChanged("Board");
Debug.WriteLine("BoardIndex event, raising Board");
});
this.WhenAnyValue(x => x.Board.Index).Subscribe(x =>
{
int r = x / 9;
int c = x % 9;
int val;
if (Int32.TryParse(_arr[x], out val))
{
if (val < 1 || val > 9)
{
return;
}
_sudoku.SetBoard(r, c, val);
return;
}
_sudoku.SetBoard(r, c, 0);
});
SolveCommand = ReactiveCommand.CreateFromTask(() =>
{
return(Task.Run(() =>
{
_sudoku.Solve();
return true;
}));
});
}
/*/// <summary>
* /// Initializes a new instance of the MainViewModel class.
* /// </summary>
* public MainViewModel() {
* Collection = new ObservableCollection<int>();
* Categories = new ObservableCollection<ComboItem> {
* new ComboItem(0, 5),
* };
* for (int i = 0; i < 4; i++) {
* Categories.Add(Categories[i].Items[0]);
* }
* Action = new RelayCommand(ActionExecute);
* for (int i = 0; i < 4; i++) {
* Collection.Add(i);
* }
* Categories.CollectionChanged += Categories_CollectionChanged;
* }
*
* private void Categories_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e) {
* Console.WriteLine($"{e.Action} Start={e.NewStartingIndex} Count={e.NewItems.Count}");
* }
*
* private Random random = new Random();
*
* public ObservableCollection<ComboItem> Categories { get; }
* public ObservableCollection<int> Collection { get; }
* public RelayCommand Action { get; }
*
* private void ActionExecute() {
* Collection[random.Next(Collection.Count)]++;
* }*/
/// <summary>
/// Initializes a new instance of the MainViewModel class.
/// </summary>
public MainViewModel()
{
Collection = new ObservableCollection <int>();
Categories = new ObservableArray <ComboItem>(5);
this[0] = new ComboItem(0, 5);
for (int i = 0; i < 4; i++)
{
this[i + 1] = this[i].Items[0];
}
ComboItem.TotalItems = 0;
Categories[0] = new ComboItem(0, 5);
for (int i = 0; i < 4; i++)
{
Categories[i + 1] = Categories[i].Items[0];
}
Action = new RelayCommand(ActionExecute);
for (int i = 0; i < 4; i++)
{
Collection.Add(i);
}
Categories.CollectionChanged += Categories_CollectionChanged;
}
public BetterListViewModel()
{
var self = this;
ItemToAdd = Knockout.Observable("");
// Initial items
AllItems = Knockout.ObservableArray(new[] { "Fries", "Eggs Benedict", "Ham", "Cheese" });
// Initial selection
SelectedItems = Knockout.ObservableArray(new[] { "Ham" });
AddItem = () => {
// Prevent blanks and duplicates
if (self.ItemToAdd.Value != "" && (self.AllItems.IndexOf(self.ItemToAdd.Value) < 0)) {
self.AllItems.Push(self.ItemToAdd.Value);
// Clear the text box
self.ItemToAdd.Value = "";
}
};
RemoveSelected = () => {
self.AllItems.RemoveAll(self.SelectedItems.Value);
// Clear selection
self.SelectedItems.Value = new string[] { };
};
SortItems = () => self.AllItems.Sort();
}
public TableViewModel()
{
Datafields = new List<ColumnModel>();
Columns = new List<ColumnModel>();
Datafields.Add(new ColumnModel
{
Name = "z",
type = "number"
});
Datafields.Add(new ColumnModel
{
Name = "a",
type = "number"
});
Datafields.Add(new ColumnModel
{
Name = "MD",
type = "number"
});
Columns.Add(new ColumnModel
{
Text = "Zenith",
Datafield = "z",
Width = 80
});
Columns.Add(new ColumnModel
{
Text = "Azimuth",
Datafield = "a",
Width = 80
});
Columns.Add(new ColumnModel
{
Text = "Measured Depth",
Datafield = "MD",
Width = 120
});
Data = new ObservableArray<WellSurveyItemViewModel>();
Data.Push(new WellSurveyItemViewModel
{
Z = 0,
A = 0,
MD = 0,
});
Data.Push(new WellSurveyItemViewModel
{
Z = 10,
A = 10,
MD = 10
});
Data.Push(new WellSurveyItemViewModel
{
Z = 25,
A = 20,
MD = 30
});
Data.Push(new WellSurveyItemViewModel
{
Z = 40,
A = 30,
MD = -40
});
Data.Push(new WellSurveyItemViewModel
{
Z = 80,
A = 110,
MD = 70
});
}
public ObservableArray<WellSurveyItemViewModel> GetCartesianArray()
{
var cartesianarray = new ObservableArray<WellSurveyItemViewModel>();
double md = 0;
int i = 0;
double x = 0;
double y = 0;
double z = 0;
while (i < Data.Value.Length)
{
md = Data.Value[i]._MD - md;
cartesianarray.Push(new WellSurveyItemViewModel
{
X = md * Math.Sin( (Math.PI / 180) * Data.Value[i]._Z) * Math.Cos((Math.PI / 180) *Data.Value[i]._A),
Y = md * Math.Sin( (Math.PI / 180) * Data.Value[i]._Z) * Math.Sin((Math.PI / 180) * Data.Value[i]._A),
Z = md * Math.Cos( (Math.PI / 180) * Data.Value[i]._Z),
});
x += cartesianarray.Value[i].X;
y -= cartesianarray.Value[i].Y;
z += cartesianarray.Value[i].Z;
cartesianarray.Value[i].X = x;
cartesianarray.Value[i].Y = y;
cartesianarray.Value[i].Z = z;
md = Data.Value[i]._MD;
i++;
}
return cartesianarray;
}
public ObservableArray<WellSurveyItemViewModel> ConvertToCartesian(ObservableArray<WellSurveyItemViewModel> Cartesian, ObservableArray<WellSurveyItemViewModel> Spherical, int i)
{
Cartesian.Value[i].X = Spherical.Value[i]._MD * Math.Sin(Spherical.Value[i]._Z) * Math.Cos(Spherical.Value[i]._A);
Cartesian.Value[i].Y = Spherical.Value[i]._MD * Math.Sin(Spherical.Value[i]._Z) * Math.Sin(Spherical.Value[i]._A);
Cartesian.Value[i].Z = Spherical.Value[i]._MD * Math.Cos(Spherical.Value[i]._Z);
return Cartesian;
}
public TableViewModel()
{
Datafields = new List<ColumnModel>();
Columns = new List<ColumnModel>();
Datafields.Add(new ColumnModel
{
Name = "_Z",
type = "number"
});
Datafields.Add(new ColumnModel
{
Name = "_A",
type = "number"
});
Datafields.Add(new ColumnModel
{
Name = "_MD",
type = "number"
});
Columns.Add(new ColumnModel
{
Text = "Zenith",
Datafield = "_Z",
Width = 80
});
Columns.Add(new ColumnModel
{
Text = "Azimuth",
Datafield = "_A",
Width = 80
});
Columns.Add(new ColumnModel
{
Text = "Measured Depth",
Datafield = "_MD",
Width = 120
});
Data = new ObservableArray<WellSurveyItemViewModel>();
Data.Push(new WellSurveyItemViewModel
{
_Z = 0,
_A = 0,
_MD = 0,
});
Data.Push(new WellSurveyItemViewModel
{
_Z = 10,
_A = 50,
_MD = 10
});
Data.Push(new WellSurveyItemViewModel
{
_Z = 30,
_A = 60,
_MD = 30
});
Data.Push(new WellSurveyItemViewModel
{
_Z = 30,
_A = 40,
_MD = 40
});
Data.Push(new WellSurveyItemViewModel
{
_Z = 50,
_A = 50,
_MD = 70
});
}
/*
private IEnumerable<WellSurveyItemViewModel> GetCoords(double startAngle)
{
var points = new List<WellSurveyItemViewModel>();
var x = 0d;
var y = 0d;
var z = 0d;
var measuredDepth = 0.0;
foreach (var item in Data)
{
var vector;
}
}
*/
public TableViewModel()
{
Columns = new List<ColumnModel>();
Columns.Add(new ColumnModel
{
Name = "z",
type = "number"
});
Columns.Add(new ColumnModel
{
Name = "a",
type = "number"
});
Columns.Add(new ColumnModel
{
Name = "MD",
type = "number"
});
Data = new ObservableArray<WellSurveyItemViewModel>();
Data.Push(new WellSurveyItemViewModel
{
Z = 0,
A = 0,
MD = 0,
});
Data.Push(new WellSurveyItemViewModel
{
Z = 10,
A = 10,
MD = 10
});
Data.Push(new WellSurveyItemViewModel
{
Z = 20,
A = 15,
MD = 30
});
Data.Push(new WellSurveyItemViewModel
{
Z = 10,
A = 30,
MD = 60
});
Data.Push(new WellSurveyItemViewModel
{
Z = 10,
A = 60,
MD = 70
});
//Data2.Splice(0, 4);
}
public TwitterViewModel(List<TweetGroup> lists, string selectedList)
{
var self = this;
this.SavedLists = Knockout.ObservableArray(lists);
this.EditingList = new TweetGroup(
name: Knockout.Observable(selectedList),
userNames: Knockout.ObservableArray<string>()
);
this.UserNameToAdd = Knockout.Observable("");
this.CurrentTweets = Knockout.ObservableArray(new object[0]);
this.FindSavedList = name => KnockoutUtils.ArrayFirst(self.SavedLists.Value, grp => grp.Name.Value == name, self);
this.AddUser = () => {
if (self.UserNameToAdd.Value != null && self.UserNameToAddIsValid.Value) {
self.EditingList.UserNames.Push(self.UserNameToAdd.Value);
self.UserNameToAdd.Value = "";
}
};
this.RemoveUser = userName => self.EditingList.UserNames.Remove(userName);
this.SaveChanges = new Action(OnSaveChanges);
this.DeleteList = () => {
var nameToDelete = self.EditingList.Name.Value;
var savedListsExceptOneToDelete = self.SavedLists.Value.Filter(grp => grp.Name.Value != nameToDelete);
self.EditingList.Name.Value =
savedListsExceptOneToDelete.Length == 0
? null
: savedListsExceptOneToDelete[0].Name.Value;
self.SavedLists.Value = savedListsExceptOneToDelete;
};
Knockout.Computed(() => {
// Observe viewModel.editingList.name(), so when it changes
// (i.e., user selects a different list) we know to copy the
// saved list into the editing list
var savedList = self.FindSavedList(self.EditingList.Name.Value);
if (savedList != null) {
var userNamesCopy = savedList.UserNames.Slice(0);
self.EditingList.UserNames.Value = userNamesCopy;
} else {
self.EditingList.UserNames.Value = new string[0];
}
});
this.HasUnsavedChanges = Knockout.Computed(() => {
if (self.EditingList.Name.Value == null) {
return self.EditingList.UserNames.Value.Length > 0;
}
var savedData = self.FindSavedList(self.EditingList.Name.Value).UserNames;
var editingData = self.EditingList.UserNames.Value;
return savedData.Value.Join("|") != editingData.Join("|");
});
this.UserNameToAddIsValid = Knockout.Computed(() => {
var pattern = @"^\s*[a-zA-Z0-9_]{1,15}\s*$";
return self.UserNameToAdd.Value == "" ||
self.UserNameToAdd.Value.Match(new Regex(pattern, "g")) != null;
});
this.CanAddUserName = Knockout.Computed(() => {
return self.UserNameToAddIsValid.Value && self.UserNameToAdd.Value != "";
});
// The active user tweets are (asynchronously) computed from editingList.userNames
Knockout.Computed(() => {
TwitterApi.GetTweetsForUsers<object[]>(
self.EditingList.UserNames.Value,
result => {
self.CurrentTweets.Value = result;
});
});
}
public Table(ObservableArray <Header <Data> > metadata, ObservableArray <Data> rowData)
{
Headers = metadata;
RowData = rowData;
}
public TweetGroup(Observable <string> name, ObservableArray <string> userNames)
{
this.Name = name;
this.UserNames = userNames;
}
public Configuration(ObservableArray <T> data, ObservableArray <Column <T> > columns, int pageSize)
{
this.PageSize = pageSize;
this.Data = data;
this.Columns = columns;
}
public Configuration(ObservableArray <T> data, ObservableArray <Column <T> > columns)
{
this.Data = data;
this.Columns = columns;
}
public void Setup()
{
array = Global.ObservableArray <int>(new object[] { 1, 2, 3, 4 });
}
public ObservableArray<WellSurveyItemViewModel> AddLine(ObservableArray<WellSurveyItemViewModel> array)
{
array.Push(new WellSurveyItemViewModel
{
Z = 0,
A = 0,
MD = 0
});
return array;
}
public ObservableArray<WellSurveyItemViewModel> GetCartesianArray()
{
var Data2 = new ObservableArray<WellSurveyItemViewModel>();
double md = 0.0;
int i = 0;
double x = 0;
double y = 0;
double z = 0;
while (i < Data.Value.Length)
{
Data2.Push(new WellSurveyItemViewModel
{
Z = md + Data.Value[i].MD * Math.Sin(Data.Value[i].Z) * Math.Cos(Data.Value[i].A),
A = md + Data.Value[i].MD * Math.Sin(Data.Value[i].Z) * Math.Sin(Data.Value[i].A),
MD = md + Data.Value[i].MD * Math.Cos(Data.Value[i].Z),
});
md += Data.Value[i].MD;
i++;
}
i = 0;
while (i < Data2.Value.Length)
{
x += Data2.Value[i].Z;
y += Data2.Value[i].A;
z += Data2.Value[i].MD;
Data2.Value[i].Z = x;
Data2.Value[i].A = y;
Data2.Value[i].MD = z;
i++;
}
return Data2;
}
public NetworkViewModel(Guid id, string logicalName, GraphOptions config)
{
UsersAndTeams = Knockout.ObservableArray<UserOrTeam>();
HighlightedEntities = Knockout.ObservableArray<EntityReference>();
SelectedUserId = Knockout.Observable<string>();
RootEntityId = id;
RootEntityLogicalName = logicalName;
Config = config;
GetDefaultConfig();
if (Type.GetScriptType(Config) == "undefined")
{
// Config is not supplied
CancelRequested = true;
Window.SetTimeout(delegate()
{
ReportError(new Exception(ResourceStrings.NoConfigurationError));
}, 100);
return;
}
// Get default demo mode
if ((Type.GetScriptType(Config.DemoModeInitialState) != "undefined"))
{
DemoMode.SetValue(config.DemoModeInitialState.Value);
}
// Get default max iterations
if ((Type.GetScriptType(Config.IterationCountPerLoad) == "undefined"))
{
Config.IterationCountPerLoad = MaxIterations;
}
// Queue the root load
if (Config.Entities != null && Config.Entities.Count > 0)
{
Queue.Enqueue(new QueuedLoad(new List<string>(new string[] { id.Value }), Config.Entities[logicalName], null));
}
DemoTick();
}
public Contact(string firstName, string lastName, ObservableArray<Phone> phones)
{
this.FirstName = firstName;
this.LastName = lastName;
this.Phones = phones;
}
public Contact(string firstName, string lastName, ObservableArray <Phone> phones)
{
this.FirstName = firstName;
this.LastName = lastName;
this.Phones = phones;
}
public AnimatedTransitionsViewModel()
{
var self = this;
Planets = Knockout.ObservableArray(new[]{
new Planet( name: "Mercury", type: "rock"),
new Planet( name: "Venus", type: "rock"),
new Planet( name: "Earth", type: "rock"),
new Planet( name: "Mars", type: "rock"),
new Planet( name: "Jupiter", type: "gasgiant"),
new Planet( name: "Saturn", type: "gasgiant"),
new Planet( name: "Uranus", type: "gasgiant"),
new Planet( name: "Neptune", type: "gasgiant"),
new Planet( name: "Pluto", type: "rock")
});
TypeToShow = Knockout.Observable("all");
DisplayAdvancedOptions = Knockout.Observable(false);
AddPlanet = type => self.Planets.Push(new Planet("New planet", type));
PlanetsToShow = Knockout.Computed(() =>
{
// Represents a filtered list of planets
// i.e., only those matching the "typeToShow" condition
var desiredType = self.TypeToShow.Value;
if (desiredType == "all") return self.Planets.Value;
return KnockoutUtils.ArrayFilter(self.Planets.Value, planet => planet.Type == desiredType);
});
// Animation callbacks for the planets list
ShowPlanetElement = elem => {
if (elem.NodeType == ElementType.Element)
jQuery.FromElement(elem).Hide().SlideDown();
};
HidePlanetElement = elem => {
if (elem.NodeType == ElementType.Element)
jQuery.FromElement(elem).SlideUp(EffectDuration.Slow, () => jQuery.FromElement(elem).Remove());
};
// Here's a custom Knockout binding that makes elements
// shown/hidden via jQuery's fadeIn()/fadeOut() methods
//Could be stored in a separate utility library
Knockout.BindingHandlers["fadeVisible"] = new InlineBindingHandler<Observable<bool>>(
init: (element, valueAccessor, allBindingsAccessor, model) => {
// Initially set the element to be instantly visible/hidden
// depending on the value
var value = valueAccessor.Invoke();
// Use "unwrapObservable" so we can handle values that may
// or may not be observable
jQuery.FromElement(element).Toggle(KnockoutUtils.UnwrapObservable(value));
},
update: (element, valueAccessor, allBindingsAccessor, model) => {
// Whenever the value subsequently changes, slowly fade the
// element in or out
var value = valueAccessor.Invoke();
if (KnockoutUtils.UnwrapObservable(value)) jQuery.FromElement(element).FadeIn();
else jQuery.FromElement(element).FadeOut();
}
);
}
public TweetGroup(Observable<string> name, ObservableArray<string> userNames)
{
this.Name = name;
this.UserNames = userNames;
}
