internal override bool IsNodeSelected(IViewNode node)
{
lock ( _selectedNodes )
{
return(_selectedNodes.Contains(node));
}
}
private void OnFocusStateChanged(IViewNode node, bool isFocused)
{
if (FocusStateChanged != null)
{
FocusStateChanged(this, new ViewNodeStateChangeEventArgs(node, isFocused));
}
}
internal MouseHandleResult HandleMouseDown(IViewNode itemNode, Keys modifiers)
{
MouseHandleResult result = 0;
_processedMouseDown = false;
if (itemNode == null)
{
return(result);
}
if ((modifiers & Keys.Shift) != 0)
{
ProcessShiftClick(itemNode, ((modifiers & Keys.Control) != 0));
}
else if ((modifiers & Keys.Control) != 0)
{
ProcessControlClick(itemNode);
}
else
{
if (IsSingleNodeSelected(itemNode) && FocusNode == itemNode)
{
result |= MouseHandleResult.MayInPlaceEdit;
}
ProcessClick(itemNode);
}
if (itemNode != null)
{
SetFocusNode(itemNode);
}
return(result);
}
public MouseHandleResult HandleMouseDown(int x, int y, MouseButtons button, Keys modifiers)
{
MouseHandleResult rrResult = 0;
int deltaY;
IViewNode row = GetRowAndDelta(y, out deltaY);
if (row is JetListViewNode)
{
rrResult = _rowRenderer.HandleMouseDown(row as JetListViewNode, x, deltaY, button, modifiers);
if ((rrResult & MouseHandleResult.Handled) != 0)
{
return(rrResult);
}
}
else if (row is GroupHeaderNode)
{
if (_groupRenderer.HandleMouseDown(row as GroupHeaderNode, x, deltaY, button, modifiers))
{
return(MouseHandleResult.Handled);
}
}
if (button == MouseButtons.Left && row != null)
{
MouseHandleResult selResult = _selection.HandleMouseDown(row, modifiers);
if ((rrResult & MouseHandleResult.MayInPlaceEdit) == 0)
{
selResult = rrResult & ~MouseHandleResult.MayInPlaceEdit;
}
return(selResult);
}
return(0);
}
public IVisibleNodeEnumerator GetDirectionalEnumerator(IViewNode startNode, MoveDirection direction)
{
Guard.NullArgument(startNode, "startNode");
JetListViewNode startLvNode = startNode as JetListViewNode;
if (startLvNode != null)
{
return(new GroupedItemEnumerator(this,
_nodeCollection.GetDirectionalEnumerator(startLvNode, direction), direction,
(direction == MoveDirection.Down)));
}
GroupHeaderNode startHeaderNode = startNode as GroupHeaderNode;
Debug.Assert(startHeaderNode.TopNode != null);
if (startHeaderNode.TopNode == null)
{
return(new GroupedItemEnumerator(this, new EmptyEnumerator(), direction, false));
}
GroupedItemEnumerator enumerator = new GroupedItemEnumerator(this,
_nodeCollection.GetDirectionalEnumerator(startHeaderNode.TopNode, direction),
direction, false);
if (direction == MoveDirection.Up)
{
// move from first node of current group to last node of previous group
enumerator.MoveNext();
}
return(enumerator);
}
public IViewNode GetRowAndDelta(int y, out int deltaY)
{
lock ( _nodeCollection )
{
if (_topNode != null)
{
int curY = -_topNodeOffset + _borderSize;
IEnumerator enumerator = GetRowEnumerator();
while (enumerator.MoveNext())
{
IViewNode viewNode = (IViewNode)enumerator.Current;
int itemHeight = GetRowHeight(viewNode);
if (y >= curY && y < curY + itemHeight)
{
deltaY = y - curY;
return(viewNode);
}
curY += itemHeight;
if (curY >= _visibleHeight + _borderSize)
{
break;
}
}
}
}
deltaY = 0;
return(null);
}
public bool GetRowBounds(IViewNode node, out int startY, out int endY)
{
if (_rowRenderer != null && _topNode != null)
{
lock ( _nodeCollection )
{
if (_topNode != null)
{
int curY = -_topNodeOffset + _borderSize;
IEnumerator enumerator = GetRowEnumerator();
while (enumerator.MoveNext())
{
IViewNode itemNode = (IViewNode)enumerator.Current;
int itemHeight = GetRowHeight(itemNode);
if (itemNode == node)
{
startY = curY;
endY = curY + itemHeight;
return(endY > 0);
}
curY += itemHeight;
if (curY > _visibleHeight + _borderSize)
{
break;
}
}
}
}
}
startY = -1;
endY = -1;
return(false);
}
private void HandleVisibleNodeAdded(object sender, JetListViewNodeEventArgs e)
{
Guard.NullArgument(e.Node, "e.Node");
if (_topNode == null) // first node added to the view
{
_topNode = e.Node;
}
UpdateScrollRange();
IViewNode topNode = _topNode;
if (topNode == null)
{
topNode = e.Node;
}
if (_visibleNodeCollection.GetMoveDirection(e.Node, topNode) == MoveDirection.Down)
{
// If we were scrolled so that the top item in the list was visible,
// add the new item to the visible area. If the top item in the list was
// not visible, scroll down so that the visible area remains the same and
// the new item does not appear in it.
if (_scrollOffset == 0)
{
UpdateTopNode();
}
else
{
OnRequestVerticalScroll(_scrollOffset + GetRowHeight(e.Node));
}
}
InvalidateBelow(e.Node);
}
private void OnActiveNodeChanged(IViewNode node)
{
if (ActiveNodeChanged != null)
{
ActiveNodeChanged(this, new ViewNodeEventArgs(node));
}
}
public void ScrollInView(IViewNode node)
{
if (_rowRenderer == null)
{
return;
}
int curY = 0;
IEnumerator enumerator = _visibleNodeCollection.GetFullEnumerator();
while (enumerator.MoveNext())
{
IViewNode itemNode = (IViewNode)enumerator.Current;
int itemHeight = GetRowHeight(itemNode);
if (itemNode == node)
{
if (curY < _scrollOffset)
{
OnRequestVerticalScroll(curY);
}
else if (itemHeight > _visibleHeight && curY >= _scrollOffset + _visibleHeight)
{
OnRequestVerticalScroll(curY);
}
else if (itemHeight < _visibleHeight && curY + itemHeight > _scrollOffset + _visibleHeight)
{
OnRequestVerticalScroll(curY + itemHeight - _visibleHeight);
}
return;
}
curY += itemHeight;
}
}
private void UpdateTopNode()
{
if (!inUpdateTopNode)
{
inUpdateTopNode = true;
try
{
lock ( _nodeCollection )
{
_topNode = null;
int delta = _scrollOffset;
IVisibleNodeEnumerator enumerator = _visibleNodeCollection.GetFullEnumerator();
while (enumerator.MoveNext())
{
int height = GetRowHeight(enumerator.CurrentNode);
if (delta < height)
{
_topNode = enumerator.CurrentNode;
_topNodeOffset = delta;
break;
}
delta -= height;
}
}
}
finally
{
inUpdateTopNode = false;
}
}
}
public MoveDirection GetMoveDirection(IViewNode startNode, IViewNode endNode)
{
JetListViewNode startLvNode = startNode as JetListViewNode;
if (startLvNode == null)
{
GroupHeaderNode startHeaderNode = (GroupHeaderNode)startNode;
startLvNode = startHeaderNode.TopNode;
}
JetListViewNode endLvNode = endNode as JetListViewNode;
if (endLvNode == null)
{
GroupHeaderNode endHeaderNode = (GroupHeaderNode)endNode;
endLvNode = endHeaderNode.TopNode;
}
int orderDiff = _nodeCollection.CompareVisibleOrder(startLvNode, endLvNode);
if (orderDiff == 0 && startNode is GroupHeaderNode && !(endNode is GroupHeaderNode))
{
return(MoveDirection.Down);
}
return((orderDiff < 0)
? MoveDirection.Down
: MoveDirection.Up);
}
public bool HandleKeyDown(KeyEventArgs e)
{
IViewNode viewNode = _selection.FocusViewNode;
if (viewNode is JetListViewNode)
{
if (_rowRenderer.HandleKeyDown(viewNode as JetListViewNode, e))
{
return(true);
}
}
if (viewNode is GroupHeaderNode)
{
if (_groupRenderer.HandleGroupKeyDown(viewNode as GroupHeaderNode, e))
{
return(true);
}
}
if (viewNode is JetListViewNode && _groupRenderer != null)
{
if (_groupRenderer.HandleNodeKeyDown(viewNode as JetListViewNode, e))
{
return(true);
}
}
return(_selection.HandleKeyDown(e.KeyData));
}
public int GetWheelScrollDistance(int lines)
{
// the wheel scroll can be requested between BeginUpdate() and EndUpdate(),
// when the node which was _topNode has already been removed from the collection
// but UpdateTopNode() was not yet called (OM-10633)
int result = 0;
lock ( _nodeCollection )
{
IViewNode topNode = _topNode; // avoid race condition (OM-11963)
if (topNode != null && _visibleNodeCollection.IsNodeVisible(topNode))
{
IVisibleNodeEnumerator enumerator = _visibleNodeCollection.GetDirectionalEnumerator(topNode,
(lines < 0) ? MoveDirection.Up : MoveDirection.Down);
while (enumerator.MoveNext() && lines != 0)
{
int rowHeight = GetRowHeight(enumerator.CurrentNode);
if (lines > 0)
{
result += rowHeight;
lines--;
}
else
{
result -= rowHeight;
lines++;
}
}
}
}
return(result);
}
public void OnSelectionStateChanged(IViewNode node, bool isSelected)
{
if (SelectionStateChanged != null)
{
SelectionStateChanged(this, new ViewNodeStateChangeEventArgs(node, isSelected));
}
}
private void OnViewNodeRemoving(IViewNode viewNode)
{
if (ViewNodeRemoving != null)
{
ViewNodeRemoving(this, new ViewNodeEventArgs(viewNode));
}
}
IVisibleNodeEnumerator IVisibleNodeCollection.GetDirectionalEnumerator(IViewNode startNode, MoveDirection direction)
{
if (startNode is JetListViewNode)
{
return(GetDirectionalEnumerator((JetListViewNode)startNode, direction));
}
return(new EmptyVisibleNodeEnumerator());
}
private void HandleNodeRemoving(object sender, ViewNodeEventArgs e)
{
if (_selectionStartNode == e.ViewNode)
{
_selectionStartNode = null;
}
RemoveNodeFromSelection(e.ViewNode);
}
private void ProcessControlClick(IViewNode itemNode)
{
_selectionStartNode = itemNode;
if (!IsNodeSelected(itemNode))
{
SelectNode(itemNode);
_processedMouseDown = true;
}
}
internal void InvalidateRow(IViewNode node)
{
int startY, endY;
if (GetRowBounds(node, out startY, out endY))
{
OnInvalidate(startY, endY);
}
}
internal override void ClearSelection()
{
if (_selectedNode != null)
{
IViewNode oldSelectedNode = _selectedNode;
_selectedNode = null;
OnSelectionStateChanged(oldSelectedNode, false);
}
}
private void InvalidateBelow(IViewNode node)
{
int startY, endY;
if (GetRowBounds(node, out startY, out endY))
{
InvalidateBelow(startY);
}
}
internal void SelectAndFocusNode(IViewNode destNode)
{
if (!IsSingleNodeSelected(destNode))
{
ClearSelection();
SelectNode(destNode);
SetFocusNode(destNode);
}
_selectionStartNode = destNode;
}
IViewNode IVisibleNodeCollection.GetVisibleParent(IViewNode node)
{
JetListViewNode lvNode = node as JetListViewNode;
if (lvNode == null)
{
return(null);
}
return(GetVisibleParent(lvNode));
}
private void ProcessShiftClick(IViewNode itemNode, bool ctrlPressed)
{
if (_selectionStartNode == null || _selectionStartNode == itemNode)
{
ProcessClick(itemNode);
return;
}
SelectItemRange(_selectionStartNode, itemNode, !ctrlPressed);
}
internal override bool UnselectNode(IViewNode node)
{
if (_selectedNode == node)
{
_selectedNode = null;
OnSelectionStateChanged(node, false);
return(true);
}
return(false);
}
private void TreeView_MouseDoubleClick(object sender, MouseEventArgs e)
{
ExtTreeView etv = sender as ExtTreeView;
IViewNode ivn = etv.SelectedNode as IViewNode;
if (ivn != null)
{
ivn.ShowView();
}
}
internal bool HandleKeyDown(Keys keys)
{
Keys modifiers = Keys.None;
if ((keys & Keys.Shift) != 0)
{
modifiers |= Keys.Shift;
keys &= ~Keys.Shift;
}
if ((keys & Keys.Control) != 0)
{
modifiers |= Keys.Control;
keys &= ~Keys.Control;
}
switch (keys)
{
case Keys.Down:
MoveSelection(MoveDirection.Down, modifiers);
return(true);
case Keys.Up:
MoveSelection(MoveDirection.Up, modifiers);
return(true);
case Keys.PageDown:
MoveSelectionByPage(MoveDirection.Down, modifiers);
return(true);
case Keys.PageUp:
MoveSelectionByPage(MoveDirection.Up, modifiers);
return(true);
case Keys.End:
IViewNode lastVisibleNode = _visibleNodeCollection.LastVisibleViewNode;
if (lastVisibleNode != null)
{
MoveSelectionTo(lastVisibleNode, modifiers & ~Keys.Control);
}
return(true);
case Keys.Home:
IViewNode firstVisibleNode = _visibleNodeCollection.FirstVisibleViewNode;
if (firstVisibleNode != null)
{
MoveSelectionTo(firstVisibleNode, modifiers & ~Keys.Control);
}
return(true);
case Keys.Space:
ProcessSpaceKey();
return(true);
}
return(false);
}
public void EnsureNodeVisible(IViewNode node)
{
JetListViewNode lvNode = node as JetListViewNode;
if (lvNode != null)
{
_nodeCollection.ExpandParents(lvNode);
GroupHeaderNode group = GetNodeGroupHeader(lvNode);
group.Expanded = true;
}
}
private void MoveSelectionByPage(MoveDirection direction, Keys modifiers)
{
if (_focusNode == null || _pagingProvider == null)
{
MoveSelection(direction, Keys.None);
return;
}
IViewNode destNode = _pagingProvider.MoveByPage(_focusNode, direction);
MoveSelectionTo(destNode, modifiers);
}
