TaskBoard

Creates an empty board: empty, watched Tasks, Links and Holidays collections, no Columns (so the tasks' own statuses are the columns), no lanes, on the system's window colours.

Gets or sets the fill of a card.

In Windows high-contrast mode the system colours are used instead.

Gets or sets the border of a card.

In Windows high-contrast mode the system colours are used instead.

Gets or sets the height of a card.

A card shows up to two lines of its task's name; a taller card leaves more room around them but no more lines.

Gets or sets the fill of a column, the band behind its cards that runs down every lane.

In Windows high-contrast mode the system colours are used instead.

Gets or sets the width of a column, and so of its cards.

Gets the board's columns – its workflow – in the order they appear.

Adding, removing or replacing a column redraws the board at once. A column's own properties are plain values: after changing one in place, call Reschedule. Columns with no BoardColumn.Status, and any after the first with the same status, are ignored.

A task whose status matches no column is shown in the first column, so that no card is ever off the board; moving it sets its status to the column it is dropped in.

board.Columns.Add(new BoardColumn("Backlog"));
board.Columns.Add(new BoardColumn("Doing", 4));
board.Columns.Add(new BoardColumn("Done"));

Gets or sets the colour of the stripe down the side of a card whose task is on the critical path.

Used only while ShowCriticalPath is on. Setting Color.Empty returns to the default. In Windows high-contrast mode the system colours are used instead.

Gets or sets the dates that are not worked, such as public holidays.

Durations and lags skip these dates, which moves the finish dates on the cards. An observable collection is watched; after changing a plain list, call Reschedule.

Gets or sets what the board's rows – its lanes – are split by.

Lanes are made from the values the tasks have: a lane per assignee or category in the order they first appear, or a lane per phase in plan order. Tasks with no value share a lane, placed last and labelled "Unassigned", "Uncategorised" or "No phase". Dropping a card in another lane sets the task's ProjectTask.Assignee, ProjectTask.Category or ProjectTask.ParentId.

Changing it puts back a card that is being carried.

Gets or sets the dependencies between the tasks, which decide each card's finish date and whether it is on the critical path.

Watched in the same way as Tasks. The board never changes the list.

Gets or sets the colour of the count of a column holding more cards than its BoardColumn.Limit, and of the mark over its heading.

Setting Color.Empty returns to the default. In Windows high-contrast mode the system colours are used instead.

Gets or sets the colour of the thin bar along the bottom of a card that shows how far its task has got, and of a milestone's diamond.

Setting Color.Empty returns to the default. In Windows high-contrast mode the system colours are used instead.

Gets or sets the first day work can happen. No task is scheduled before it, except one that must start on an earlier date.

Give every chart showing a plan the same value, so that they schedule the same dates.

Gets or sets whether the reader is stopped from moving cards.

Selecting, navigating and TaskActivated still work, and so does MoveCard, which is the application's own call. Turning it on puts back a card that is being carried.

Gets or sets the task whose card is selected.

Setting a task scrolls its card into view, and raises SelectedTaskChanged when the selection changes. Setting a task that has no card – a summary, or a task not in the plan – clears the selection. When the selected task leaves the board, the selection is cleared and SelectedTaskChanged is raised from the message loop.

Gets or sets whether a card whose task is on the critical path carries a stripe down its side in CriticalColor.

Gets or sets whether a column that already holds as many cards as its BoardColumn.Limit refuses another.

It applies to moves into a column from another one, by the reader and by MoveCard alike; reordering cards within a column is always allowed. A card carried over a full column is drawn as refused, and dropping it there puts it back.

Gets or sets the tasks of the plan, as a flat list with parent references. Every task that is work, not a summary, is a card.

An ObservableCollection or a BindingList is watched, and so is every task in it. A plain list is read when it is assigned; call Reschedule after changing one. The order of the list is the order of cards that have no ProjectTask.Rank. Setting a new list scrolls back to the first column.

Gets or sets the date the charts treat as today.

The Gantt chart draws its today line from this. A board has no time axis, so it draws nothing from it, and changing it does not redraw the board; it is here so that one set of plan settings can be given to all three charts alike.

Gets or sets the days of the week that are worked. Durations and lags count only these days.

Creates the accessible object that presents the board to screen readers and other assistive technology as a list: each column heading, saying its count and limit, followed by its cards in reading order.

The board's accessible object.

Stops watching the plan and releases the fonts, the timer and the tooltip the board created.

The application's tasks, links and holidays are not touched: they can be given to another chart.

Gets the plan as the board has scheduled it: every task's dates and float, the critical path, and anything in the plan that could not be used.

Scheduled again first when anything has changed. The board reads each card's finish date and critical mark from it. The schedule returned is a snapshot; read the property again after a change.

Claims the keys the board uses for itself, so that the form does not take them for moving the focus or pressing a button.

true for the arrows, Home, End, Page Up and Page Down; for Enter without modifiers while a card is selected or carried; and for Esc while a card is carried – so that a dialog's default and cancel buttons keep those keys otherwise. Otherwise what the base class answers.

Moves a card as though the reader had dropped it: to a column, optionally to another lane, at a position in that cell.

true when the card moved; false when the move was refused by StrictLimits, cancelled in CardMoving, would change nothing, or named a task or column that is not on the board.

The move follows the same path as the reader's: refused by a full column when StrictLimits is on, offered through CardMoving with a CardMovingEventArgs.Source of TaskEditSource.Application, written to the task, and announced by CardMoved. It works even when ReadOnly is set, which only stops the reader.

// A build server reports that the API is deployed: move its card to the top of Review.
ProjectTask api = tasks.First(task => task.Id == "api");
if (!board.MoveCard(api, "Review", null, 0))
{
    statusLabel.Text = "Review is full - the API card stays where it is.";
}

Raises the CardMoved event.

A derived board that overrides this should call the base method, or the event is not raised.

Raises the CardMoving event.

The board reads CancelEventArgs.Cancel after this returns. A derived board can refuse a move here, before or instead of calling the base method.

Rebuilds everything measured in device pixels when the board moves to a display with a different scale: the fonts, the scroll bars and the scroll range.

Raises Control.FontChanged and rebuilds the fonts the cards are written in.

Draws the focus cue and announces the selected card to screen readers.

Fits the scroll bars once the window exists and the display's scale is known for certain, and schedules any changes made before then.

Forgets a refresh posted to a window that is going away; the next window posts again.

Raises Control.KeyDown, then, unless a handler has handled the key, carries out the board's keyboard commands: the arrows move between cards, Space picks the selected card up, Enter raises TaskActivated; while a card is carried, the arrows move it (Shift with Up or Down to the next lane), Space or Enter drops it and Esc puts it back.

Puts back a card that is being carried – the keys that would drop it are going elsewhere – and removes the focus cue.

Puts a dragged card back when the mouse is taken away part way through, by a message box or a switch of window.

Raises Control.MouseDoubleClick, then raises TaskActivated when the double-click was on a card.

Raises Control.MouseDown, takes the focus, and with the left button selects the card under the pointer, ready to drag it once the pointer moves far enough. A press while a card is carried from the keyboard puts that card back.

Raises Control.MouseLeave and hides the tooltip.

Raises Control.MouseMove, then carries a dragged card, showing where it would land; otherwise shows the tooltip for the card under the pointer.

Raises Control.MouseUp, then drops a dragged card, offering the move through CardMoving.

Raises Control.MouseWheel, then scrolls the lanes up and down, or sideways with Shift. A card being dragged follows the pointer as the board scrolls.

Raises Control.Paint, then draws the column bands, the lanes, the cards, a card being moved and the header row. A fault while drawing is absorbed rather than leaving the control crossed out, and the next paint tries again.

Raises Control.Resize and fits the scroll bars and the view to the new size.

Raises Control.RightToLeftChanged and lays the board out again mirrored, with the first column on the right, scrolled to it.

Raises the ScheduleChanged event.

A derived board that overrides this should call the base method, or the event is not raised.

Raises the SelectedTaskChanged event.

A derived board that overrides this should call the base method, or the event is not raised.

Raises the TaskActivated event.

A derived board that overrides this should call the base method, or the event is not raised.

Schedules the plan and lays the board out again now, and raises ScheduleChanged.

Needed only after changing a plain list given to Tasks, Links or Holidays, which the board cannot watch, or after changing a BoardColumn's properties in place.

Scrolls the board until a task's card is in view.

The selection is left as it is; set SelectedTask to select the task as well, which scrolls to it too.

Occurs after a card has moved and its task's status, lane field and rank have been written: the moment to save the task.

The ranks of the other cards in the cell it landed in may have changed too.

Occurs before a card moves – by a drag, a keyboard drop or MoveCard – so that the application can refuse the move.

Set CancelEventArgs.Cancel to true to refuse it: the card goes back where it was and nothing is written. A move into a full column while StrictLimits is on is refused before this event, and a drop where the card already is raises nothing.

Occurs after the plan has been scheduled again because something changed: a task, a link, a collection, a calendar setting, or a call to Reschedule.

Raised from the message loop, once for any number of changes made together – moving one card can re-rank a whole column – and never from inside a paint, so a handler is free to change the plan again. Not raised for the board's first schedule.

Occurs when the selected card changes: by the reader, by setting SelectedTask, or because the selected task left the board.

Occurs when the reader double-clicks a card or presses Enter with a card selected: the moment to open the application's own view of the task.