public void TestCommands()
{
var target = new BoardViewModel();
var moveCommand = target.MoveCommand;
Assert.IsInstanceOfType(moveCommand, typeof(RelayCommand));
// Tests a valid move (knight moves)
moveCommand.Execute("B1C3");
//Assert.AreNotEqual("", target.Board.MBoard[5][2]);
// Tests invalid move
moveCommand.Execute("BB1C3");
// Sequence for a king take (will break when turn checking is implemented)
moveCommand.Execute("C3B5");
moveCommand.Execute("B5D6");
moveCommand.Execute("D6E8");
Assert.AreEqual(1, target.WonGame);
// Needs null handling
Assert.IsTrue(moveCommand.CanExecute(null));
}
public void RegularMove(BoardViewModel boardViewModel)
{
"establish board"._(() =>
{
boardViewModel = new BoardViewModel();
});
"establish two paragraph tokens of different players"._(() =>
{
boardViewModel.Fields[1][1].Token = new Token(TokenType.Paragraph, boardViewModel.Players[0]);
boardViewModel.Fields[1][2].Token = new Token(TokenType.Paragraph, boardViewModel.Players[1]);
});
"when first player does a paragraph move"._(() =>
{
boardViewModel.SelectField.Execute(boardViewModel.Fields[1][1]);
boardViewModel.SelectField.Execute(boardViewModel.Fields[1][3]);
});
"it should have moved the paragraph token to the destination field"._(() =>
{
boardViewModel.Fields[1][3].Token.Type.Should().Be(TokenType.Paragraph);
boardViewModel.Fields[1][3].Token.Player.Should().Be(boardViewModel.Players[0]);
});
"it should clear token on paragraph token's previous field"._(() =>
{
boardViewModel.Fields[1][1].Token.Should().BeNull();
});
"it should have removed the paragraph token of the second player"._(() =>
{
boardViewModel.Fields[1][2].Token.Should().BeNull();
});
}
public void InValidInput()
{
var target = new BoardViewModel();
// Paramaters must be (char,int,char,int)
Assert.IsFalse(target.ValidInputCheck("aaaa"));
Assert.IsFalse(target.ValidInputCheck("1234"));
Assert.IsFalse(target.ValidInputCheck("123d"));
Assert.IsFalse(target.ValidInputCheck("12d1"));
Assert.IsFalse(target.ValidInputCheck("1d11"));
Assert.IsFalse(target.ValidInputCheck("d111"));
Assert.IsFalse(target.ValidInputCheck("dd11"));
Assert.IsFalse(target.ValidInputCheck("1dd1"));
Assert.IsFalse(target.ValidInputCheck("11dd"));
// Valid.ValidInputCheck's chars can only consist of letters up to the letter "H"
Assert.IsFalse(target.ValidInputCheck("z1z2"));
Assert.IsFalse(target.ValidInputCheck("z1a2"));
Assert.IsFalse(target.ValidInputCheck("i1a2"));
// Valid.ValidInputCheck's ints can only consist of numbers from 1 to 8
Assert.IsFalse(target.ValidInputCheck("a1a9"));
Assert.IsFalse(target.ValidInputCheck("a9a1"));
Assert.IsFalse(target.ValidInputCheck("a9a9"));
Assert.IsFalse(target.ValidInputCheck("a9a0"));
Assert.IsFalse(target.ValidInputCheck("a0a9"));
Assert.IsFalse(target.ValidInputCheck("a0a0"));
// Valid.ValidInputCheck has a length of 4
Assert.IsFalse(target.ValidInputCheck("a1a"));
Assert.IsFalse(target.ValidInputCheck("a1a2a"));
}
public GameViewModel(IGameSettings gameSettings, IQuestsManager questsManager, IDialogService dialogService)
{
_gameSettings = gameSettings;
_questsManager = questsManager;
_dialogService = dialogService;
_game = Mvx.GetSingleton <IGame>();
BoardViewModel = new BoardViewModel(Game.Info.BoardSize);
BoardViewModel.BoardTapped += (s, e) => OnBoardTapped(e);
BoardViewModel.IsTouchInputOffsetEnabled = gameSettings.Display.AddTouchInputOffset;
// Set empty node (should be in the beginning of every gametree) as current node for board rendering
RefreshBoard(Game.Controller.GameTree.LastNode);
_uiConnector = new UiConnector(Game.Controller);
_phaseStartHandlers = new Dictionary <GamePhaseType, Action <IGamePhase> >();
_phaseEndHandlers = new Dictionary <GamePhaseType, Action <IGamePhase> >();
SetupPhaseChangeHandlers(_phaseStartHandlers, _phaseEndHandlers);
Game.Controller.RegisterConnector(_uiConnector);
Game.Controller.GameEnded += (s, e) => OnGameEnded(e);
Game.Controller.GameTree.LastNodeChanged += (s, e) => OnCurrentNodeChanged(e);
Game.Controller.TurnPlayerChanged += (s, e) => OnTurnPlayerChanged(e);
Game.Controller.GamePhaseChanged += (s, e) => OnGamePhaseChanged(e);
ObserveDebuggingMessages();
}
////////////////
// Game View Model Services
////////////////
protected void RefreshBoard(GameTreeNode boardState)
{
BoardViewModel.GameTreeNode = boardState;
BoardViewModel.BoardControlState.TEMP_MoveLegality = Game.Controller.Ruleset.GetMoveResult(boardState);
// TODO (future work) Petr: GameTree has now LastNodeChanged event - use it to fix this - for now make public and. Called from GameViewModel
BoardViewModel.Redraw();
}
public void RegularMove(BoardViewModel boardViewModel)
{
"establish board"._(() =>
{
boardViewModel = new BoardViewModel();
});
"when first player moves valid angle"._(() =>
{
boardViewModel.SelectField.Execute(boardViewModel.Fields[0][6]);
boardViewModel.SelectField.Execute(boardViewModel.Fields[7][6]);
});
"it should put current player token on new field"._(() =>
{
boardViewModel.Fields[7][6].Token.Type.Should().Be(TokenType.Advocate);
boardViewModel.Fields[7][6].Token.Player.Should().Be(boardViewModel.Players[0]);
});
"it should place paragraph token on first clicked field"._(() =>
{
boardViewModel.Fields[0][6].Token.Type.Should().Be(TokenType.Paragraph);
boardViewModel.Fields[0][6].Token.Player.Should().Be(boardViewModel.Players[0]);
});
"it should clear token on player's previous field"._(() =>
{
boardViewModel.Fields[0][0].Token.Should().BeNull();
});
"it should give turn to player 2"._(() =>
{
boardViewModel.CurrentPlayer.Should().Be(boardViewModel.Players[1]);
});
}
public ActionResult Edit(BoardViewModel viewModel)
{
if (ModelState.IsValid)
{
var board = _repository.Project <Board, bool>(boards => (from b in boards where b.BoardId == viewModel.BoardId select b).Any());
if (!board)
{
_logger.Warn(string.Format("Board not exists '{0}'.", viewModel.Name));
Danger(string.Format("Board not exists '{0}'.", viewModel.Name));
}
var result = _boardService.Update(new Board {
BoardId = viewModel.BoardId, Name = viewModel.Name
});
if (result.Success)
{
var roleUserId = User.Identity.GetUserId();
var roles = _aspNetRolesService.GetCurrentUserRole(roleUserId);
var bodySubject = "Web portal changes - Board update";
var message = "Board Updated Successfully";
SendMailToAdmin(roles, roleUserId, message, viewModel.Name, bodySubject);
Success(result.Results.FirstOrDefault().Message);
ModelState.Clear();
return(RedirectToAction("Index"));
}
else
{
_logger.Warn(result.Results.FirstOrDefault().Message);
Warning(result.Results.FirstOrDefault().Message, true);
}
}
return(View(viewModel));
}
public void TestTurtleSucceeds()
{
//arrange
var board = new BoardViewModel()
{
N = 10, M = 10
};
var turtle = new TurtleViewModel()
{
Direction = "North", X = 1, Y = 1
};
var exitPoint = new BoardItemViewModel()
{
X = 1, Y = 3
};
var mines = new List <BoardItemViewModel>();
mines.Add(new BoardItemViewModel()
{
X = 4, Y = 5
});
var moves = "mmmm";
var gameService = new GameService();
//act
var mockGame = gameService.Start(board, turtle, exitPoint, mines);
mockGame = gameService.Move(moves, mockGame);
//assert
Assert.IsTrue(mockGame.Outcome == "Success!");
Assert.IsTrue(mockGame.IsOver);
}
public MainWindow()
{
InitializeComponent();
_theBoard = new BoardViewModel();
DataContext = _theBoard;
SetRandomPuzzle();
}
/// <summary>
/// Queries the database for each board in tblBoards
/// and returns a collection of boards
/// </summary>
/// <returns>Collection of boards, of type BoardViewModel</returns>
public static ObservableCollection <BoardViewModel> GetBoards()
{
ObservableCollection <BoardViewModel> boards = new ObservableCollection <BoardViewModel>();
using (SqliteConnection db =
new SqliteConnection(DBName))
{
db.Open();
SqliteCommand selectCommand = new SqliteCommand
("SELECT Id,Name,Notes from tblBoards", db);
SqliteDataReader query = selectCommand.ExecuteReader();
while (query.Read())
{
BoardViewModel row = new BoardViewModel()
{
BoardId = query.GetString(0),
BoardName = query.GetString(1),
BoardNotes = query.GetString(2),
};
boards.Add(row);
}
db.Close();
}
return(boards);
}
public static ObservableCollection <BoardViewModel> GetBoards()
{
ObservableCollection <BoardViewModel> boards = new ObservableCollection <BoardViewModel>();
// Get tasks and return the collection
using (SqliteConnection db =
new SqliteConnection("Filename=ktdatabase.db"))
{
db.Open();
SqliteCommand selectCommand = new SqliteCommand
("SELECT Id,Name,Notes from tblBoards", db);
SqliteDataReader query = selectCommand.ExecuteReader();
// Query the db and get the tasks
while (query.Read())
{
BoardViewModel row = new BoardViewModel()
{
BoardId = query.GetString(0),
BoardName = query.GetString(1),
BoardNotes = query.GetString(2),
};
boards.Add(row);
}
db.Close();
}
return(boards);
}
public IActionResult Board()
{
var boards = _context.Boards.ToArray();
var viewModel = new BoardViewModel(boards);
return(View(viewModel));
}
//顯示主版內容
public ActionResult Board()
{
BoardViewModel board = new BoardViewModel();
board.article = db.Article.Where(a => a.IsDeleted != true).OrderByDescending(a => a.Number).Take(6);
return(View(board));
}
public MainWindow()
{
InitializeComponent();
DataContext = this;
Board = new BoardViewModel(BoardSize);
_canPlay = true;
}
public void RotateBoardCounterClockwise()
{
//Arrange
int?_ = null;
var board = new int?[9, 9]
{
{ _, _, 2, _, _, _, 8, _, _ },
{ 1, _, _, 2, _, _, _, 4, _ },
{ 3, _, 6, 8, _, _, 7, 2, _ },
{ _, _, 5, 3, _, _, _, _, 8 },
{ _, 2, _, _, _, _, _, 9, _ },
{ 6, _, _, _, _, 1, 5, _, _ },
{ _, 5, 7, _, _, 3, 2, _, 1 },
{ _, 1, _, _, _, 7, _, _, 6 },
{ _, _, 3, _, _, _, 4, _, _ }
};
var model = new BoardViewModel();
model.NewPuzzle(board);
//Act
model.Rotate(BoardViewModel.RotateDirection.CounterClockwise);
//Assert
Assert.AreEqual(null, model.Cells[0][0].Number);
Assert.AreEqual(8, model.Cells[0][3].Number);
Assert.AreEqual(4, model.Cells[1][1].Number);
Assert.AreEqual(7, model.Cells[6][6].Number);
Assert.AreEqual(5, model.Cells[7][6].Number);
Assert.AreEqual(3, model.Cells[6][8].Number);
}
public static void ShowBoard(BoardViewModel board)
{
Console.WriteLine();
ShowCharacterCoordinate(board);
Console.WriteLine();
string delimeter = "\t";
for (int i = board.GetBoardSize() - 1; i >= 0; i--)
{
Console.Write(i + 1 + delimeter);
for (int j = 0; j < board.GetBoardSize(); j++)
{
var figure = board.GetFigureAtPosition(board.GetPositionAt(i, j));
if (figure == null)
{
Console.Write('x' + delimeter);
}
else
{
ShowFigure(figure);
}
}
Console.WriteLine(i + 1);
}
Console.WriteLine();
ShowCharacterCoordinate(board);
}
internal void InitializeBoard()
{
// Bootstrapper
var boardService = new BoardService();
var gameModel = new GameModel(boardService);
var gameController = new GameController(gameModel);
var boardModel = new BoardModel(boardService);
var boardController = new BoardController(boardModel);
var boardViewModel = new BoardViewModel(BoardCanvas, gameModel, boardModel);
var userMessageController = new UserMessageController(boardViewModel);
var rendererController = new RendererController(boardViewModel);
boardModel.NewPieceAdded += rendererController.DrawNewPiece;
boardModel.NewPieceAdded += gameController.IncreasePieceCount;
boardModel.PieceRemoved += rendererController.DeletePiece;
boardModel.PieceRemoved += gameController.DecreaseOpponentPieceCount;
boardModel.PieceMoved += rendererController.MovePiece;
boardModel.SelectionChanged += rendererController.ChangeSelection;
gameModel.TurnTaken += rendererController.UpdateRendererModel;
rendererController.NotifyUser += userMessageController.SetUserMessage;
boardViewModel.NotifyUser += userMessageController.SetUserMessage;
boardViewModel.SelectPiece += boardController.ChangeSelection;
boardViewModel.RemovePiece += boardController.RemovePiece;
boardViewModel.TakeTurn += gameController.TakeTurn;
boardViewModel.AddPiece += boardController.AddNewPiece;
boardViewModel.MoveSelectedPiece += boardController.MoveSelectedPiece;
DataContext = boardViewModel;
gameController.StartGame();
}
public void Initialize(ViewRequest viewRequest)
{
HeaderPropertyViewRequest request = viewRequest as HeaderPropertyViewRequest;
if (request == null)
{
return;
}
Header = request.Header;
Box = request.Box;
board = request.Board;
if (Header == null)
{
return;
}
OldLimitSet = Header.LimitSet;
OldMaxNumberOfCards = HeaderMaxNumber;
OldName = Header.Name;
TitleText = Header is ColumnViewModel ? "Column Properties" : "Row Properties";
this.RaisePropertyChanged("TitleText");
this.RaisePropertyChanged("HeaderName");
this.RaisePropertyChanged("HeaderLimitSet");
this.RaisePropertyChanged("HeaderMaxNumber");
IsOpened = true;
}
public InputViewModel(Camera camera, BoardViewModel boardViewModel, BoardView boardView, GameConfig.InputSettings inputSetting)
{
_shootInterval = inputSetting.ShootInterval;
_camera = camera;
_boardViewModel = boardViewModel;
_boardView = boardView;
_isAiming = new ReactiveProperty <bool>().AddTo(Disposer);
_aimPosition = new ReactiveProperty <Vector2>().AddTo(Disposer);
_trajectoryPoints = new ReactiveProperty <IReadOnlyList <Vector3> >(_linePositions);
_hasValidTarget = new ReactiveProperty <bool>().AddTo(Disposer);
_targetGridPos = new ReactiveProperty <Vector2Int>().AddTo(Disposer);
_shootSubject = new Subject <Unit>().AddTo(Disposer);
_canShootTimerDisposable = new SerialDisposable().AddTo(Disposer);
Observable.EveryUpdate()
.Subscribe(_ => UpdateInput()).AddTo(Disposer);
AimPosition
.SkipLatestValueOnSubscribe()
.Subscribe(OnAimPositionChanged).AddTo(Disposer);
IsAiming
.SkipLatestValueOnSubscribe()
.IfFalse()
.Do(_ => Shoot())
.DelayFrame(1)
.Subscribe(_ => _hasValidTarget.Value = false).AddTo(Disposer);
}
public object GetBoard(int id)
{
var map = mapper.CreateMapper();
if (id != 0)
{
BoardDTO board = BoardService.Get(id);
BoardViewModel myboard = map.Map <BoardViewModel>(board);
return(JsonConvert.SerializeObject(myboard, Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}));
}
else
{
IEnumerable <BoardDTO> board = BoardService.GetAll(User.Identity.GetUserId());
IEnumerable <BoardViewModel> myboard = map.Map <IEnumerable <BoardViewModel> >(board);
return(JsonConvert.SerializeObject(myboard.FirstOrDefault(), Formatting.None, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}));
}
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
var window = new Board();
var viewModel = new BoardViewModel();
// When the ViewModel asks to be closed,
// close the window.
EventHandler handler = null;
handler = delegate
{
viewModel.RequestClose -= handler;
window.Close();
};
viewModel.RequestClose += handler;
// Allow all controls in the window to
// bind to the ViewModel by setting the
// DataContext, which propagates down
// the element tree.
window.DataContext = viewModel;
window.Show();
}
public void TestTurtleOffTheBoard()
{
//arrange
var board = new BoardViewModel()
{
N = 2, M = 2
};
var turtle = new TurtleViewModel()
{
Direction = "North", X = 1, Y = 1
};
var exitPoint = new BoardItemViewModel()
{
X = 4, Y = 5
};
var mines = new List <BoardItemViewModel>();
mines.Add(new BoardItemViewModel()
{
X = 2, Y = 2
});
var moves = "mmmmrrrmmmmmmm";
var gameService = new GameService();
//act
var mockGame = gameService.Start(board, turtle, exitPoint, mines);
mockGame = gameService.Move(moves, mockGame);
//assert
Assert.IsTrue(mockGame.Outcome == "Moved off the board!");
Assert.IsTrue(mockGame.IsOver);
}
public ActionResult Create(BoardViewModel viewModel)
{
if (ModelState.IsValid)
{
var result = _boardService.Save(new Board {
Name = viewModel.Name
});
if (result.Success)
{
var roleUserId = User.Identity.GetUserId();
var roles = _aspNetRolesService.GetCurrentUserRole(roleUserId);
var bodySubject = "Web portal changes - Board Create";
var message = "Board Created Successfully";
SendMailToAdmin(roles, roleUserId, message, viewModel.Name, bodySubject);
Success(result.Results.FirstOrDefault().Message);
ModelState.Clear();
viewModel = new BoardViewModel();
}
else
{
_logger.Warn(result.Results.FirstOrDefault().Message);
Warning(result.Results.FirstOrDefault().Message, true);
}
}
viewModel = new BoardViewModel();
return(View(viewModel));
}
// GET: Boards/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Board board = db.Boards.Find(id);
if (board == null)
{
return(HttpNotFound());
}
var detailViewModel = new BoardViewModel()
{
Board = board,
Replies = db.Replies.Where(s => s.BoardId == board.ID).ToList(),
Reply = new Reply()
{
BoardId = board.ID,
BoardKey = board.BoardKey
}
};
return(View(detailViewModel));
}
public MainWindow()
{
InitializeComponent();
Cvm = new ConnectionViewModel();
this.DataContext = Cvm;
Bvm = new BoardViewModel();
}
public ChartControl GetAbsencesByDateChartControl(BoardViewModel value)
{
// Create an empty chart.
var sideBySideBarChart = new ChartControl();
var data = CacheStats(value);
// Create the first side-by-side bar series and add points to it.
var series1 = new Series("Absences par date", ViewType.Bar);
foreach (var at in data)
{
series1.Points.Add(new SeriesPoint(at.Date, at.Count));
}
// Add the series to the chart.
sideBySideBarChart.Series.Add(series1);
// Hide the legend (if necessary).
sideBySideBarChart.Legend.Visibility = DefaultBoolean.False;
// Add a title to the chart (if necessary).
var chartTitle1 = new ChartTitle();
chartTitle1.Text = "Side-by-Side Bar Chart";
sideBySideBarChart.Titles.Add(chartTitle1);
// Add the chart to the form.
sideBySideBarChart.Dock = DockStyle.Fill;
return(sideBySideBarChart);
}
public ActionResult Index(string name)
{
if (string.IsNullOrEmpty(name))
{
return(View("Welcome"));
}
var user = RavenService.GetUser(RavenSession, name);
if (user == null)
{
return(View("NewUser", new User {
UserName = name
}));
}
var isAuthenticated = IsAuthenticated(user);
if (user.IsPublic || isAuthenticated)
{
var challenges = RavenService.GetAllChallenges(RavenSession);
var history = RavenService.GetHistory(RavenSession, user);
Thread.CurrentThread.CurrentCulture = new CultureInfo("sv-SE");
var boardViewModel = new BoardViewModel
{
Challenges = challenges.Where(m => m.Hide == false).ToList(),
TotalPoints = CalculatePoints(challenges, user),
CurrentUser = user,
IsAuthenticated = isAuthenticated,
History = history
};
return(View("Index", boardViewModel));
}
return(RedirectToAction("Index", "Authentication", new { name = user.UserName }));
}
public BoardView()
{
InitializeComponent();
var vm = new BoardViewModel();
var width = int.Parse(ConfigurationManager.AppSettings["width"]);
var height = int.Parse(ConfigurationManager.AppSettings["height"]);
for (var i = 0; i < width - 1; i++)
{
this.Main.ColumnDefinitions.Add(new ColumnDefinition());
}
for (var i = 0; i < height - 1; i++)
{
this.Main.RowDefinitions.Add(new RowDefinition());
}
for (var i = 0; i < width - 1; i++)
{
for (var j = 0; j < height - 1; j++)
{
var rec = new Rectangle()
{
Style = this.FindResource("CellStyle") as Style,
DataContext = vm.Cells[i][j]
};
this.Main.Children.Add(rec);
Grid.SetColumn(rec, i);
Grid.SetRow(rec, j);
}
}
vm.StartGame();
}
private async Task InitializeVM(BoardViewModel viewModel)
{
if (viewModel == null)
{
return;
}
ViewModel.NodeChanged += (sender, node) => _currentGameTreeNode = node;
_currentGameTreeNode = ViewModel.GameTreeNode;
_boardControlState = ViewModel.BoardControlState;
_renderService = new RenderService(_boardControlState);
_inputService = new InputService(_boardControlState);
await RenderService.AwaitResources();
canvas.Draw += canvas_Draw;
canvas.Update += canvas_Update;
canvas.PointerMoved += canvas_PointerMoved;
canvas.PointerPressed += canvas_PointerPressed;
canvas.PointerReleased += canvas_PointerReleased;
canvas.PointerExited += Canvas_PointerExited;
_inputService.PointerTapped += (sender, ev) => ViewModel.BoardTap(ev);
}
public async Task <IActionResult> Index(int id)
{
var project = await _projectService.GetByIdAsync(id);
if (project == null)
{
return(NotFound());
}
var taskList = _taskService.GetProjectTasksByProjectId(id).ToList();
if (taskList == null)
{
return(NotFound());
}
var model = new BoardViewModel
{
ProjectId = id,
ProjectName = project.ProjectName,
Tasks = taskList
};
model.EstimatedProjectDeadline = _taskBoardHelper.CalculateProjectDeadline(model.Tasks);
return(View(model));
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.NavigationMode == NavigationMode.Back && SetBoard != null)
{
_viewModel.All.Flush();
for (int i = 0; i < _viewModel.All.Count; i++)
{
if (_viewModel.All[i].Name == SetBoard.Name)
{
RootPivot.SelectedIndex = 3;
All.UpdateLayout();
All.ScrollTo(_viewModel.All[Math.Min(i - 2, _viewModel.All.Count - 1)]);
break;
}
}
SetBoard = null;
}
}
// GET: Tables/Draw/5
public async Task<ActionResult> Draw(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
Board board = await db.Boards.FindAsync(id);
if (board == null)
{
return HttpNotFound();
}
var user = UserManager.FindById(User.Identity.GetUserId());
if (board.ApplicationUserID != user.Id)
{
return new HttpStatusCodeResult(HttpStatusCode.Forbidden);
}
var vm = new BoardViewModel(board);
vm.Drawings = await db.Drawings.ToListAsync();
vm.Queue = await db.DrawingQueues.Where(q => q.BoardID == board.ID).ToListAsync();
return View(vm);
}
public MainPageViewModel()
{
BoardViewModel = new BoardViewModel();
}
private void NameChanged()
{
int pos = Math.Min(Name.Length, SelectionStart);
for (int i = 0; i < pos; i++)
{
if (!char.IsLetterOrDigit(Name[i]))
{
pos--;
}
}
string replace = Regex.Replace(Name.ToLower(), "[^a-z0-9]", "");
if (Name != replace)
{
Name = replace;
SelectionStart = pos;
}
if (BoardList.Boards.ContainsKey(Name))
{
Board = new BoardViewModel(ThreadCache.Current.EnforceBoard(BoardList.Boards[Name].Name));
NSFWText = Board.IsNSFW ? AppResources.AddBoardPage_NSFW : string.Empty;
HasBoard = true;
}
else
{
Board = null;
NSFWText = "";
HasBoard = false;
}
}
public BoardView(BoardViewModel viewModel)
{
InitializeComponent();
this.DataContext = viewModel;
}
