public RemoveSlideMenuItem(DeckTraversalModel traversal, PresenterModel model)
: base(Strings.DeleteSlide)
{
this.m_Deck = traversal.Deck;
this.m_WhereTheEntriesGo = traversal.Deck.TableOfContents.Entries;
traversal_ = traversal;
this.m_Model = model;
}
public PublicSlideMenuItem(DeckModel deck, TableOfContentsModel.EntryCollection bucket, DeckTraversalModel traversal, PresenterModel model)
: base(Strings.CopyToPublic)
{
this.m_Deck = deck;
this.m_WhereTheEntriesGo = bucket;
this.traversal_ = traversal;
this.m_Model = model;
if ((deck.Disposition & DeckDisposition.StudentSubmission) == 0) // Only enable for student submissions
this.Enabled = false;
}
public InsertSlidesFromFileMenuItem(DeckTraversalModel traversal, PresenterModel model)
: base(Strings.InsertSlidesFromDeck)
{
this.deck_ = traversal.Deck;
this.deck_traversal_ = traversal;
this.m_WhereTheEntriesGo = traversal.Deck.TableOfContents.Entries;
this.m_Model = model;
}
public InsertSlideMenuItem(DeckModel deck, TableOfContentsModel.EntryCollection bucket, DeckTraversalModel traversal, PresenterModel model)
: base(Strings.NewSlide)
{
this.m_Deck = deck;
this.m_WhereTheEntriesGo = bucket;
this.traversal_ = traversal;
this.m_Model = model;
// TODO: Disable this menu item if the deck is immutable (requires defining what sorts of decks are mutable or not).
}
/// <summary>
/// Finds the next entry, relative to the specified entry, which is accepted by the entry filter.
/// </summary>
/// <remarks>
/// The caller is required to hold a reader lock on the entry's <see cref="TableOfContentsModel"/>.
/// </remarks>
public TableOfContentsModel.Entry FindPrevious(TableOfContentsModel.Entry entry)
{
if (entry == null)
{
return(null);
}
// Pre-order traversal: we start with the last descendent of the entry's previous sibling.
using (Synchronizer.Lock(entry.SyncRoot)) {
TableOfContentsModel.Entry parent = entry.Parent;
TableOfContentsModel.EntryCollection siblings = (parent == null)
? entry.TableOfContents.Entries
: parent.Children;
int index = siblings.IndexOf(entry);
// If there exists a previous sibling, we're in good shape.
// (This also handles the case when the given entry is not a child of its parent,
// which can happen when entries are received over the network in a strange order.)
if (index > 0)
{
entry = siblings[index - 1];
// Find the *last* descendent of the sibling by going down as far as possible.
siblings = entry.Children;
while (siblings.Count > 0)
{
entry = siblings[siblings.Count - 1];
siblings = entry.Children;
}
// Now, we've either got the original sibling or the last descendent of it.
// Use this as the previous entry, or start here if it's not accepted by the filter.
if (this.m_Filter(entry))
{
return(entry);
}
else
{
return(this.FindPrevious(entry));
}
}
// If there's no previous sibling and no parent, we're screwed.
else if (parent == null)
{
return(null);
}
// Otherwise, if there's no previous sibling, use the parent.
else
{
if (this.m_Filter(parent))
{
return(parent);
}
else
{
return(this.FindPrevious(parent));
}
}
}
}
/// <summary>
/// Finds the next entry, in pre-order relative to the specified entry, which is accepted by the entry filter.
/// </summary>
/// <remarks>
/// The caller is required to hold a reader lock on the entry's <see cref="TableOfContentsModel"/>.
/// </remarks>
public TableOfContentsModel.Entry FindNext(TableOfContentsModel.Entry entry)
{
if (entry == null)
{
return(null);
}
using (Synchronizer.Lock(entry.SyncRoot)) {
// Pre-order traversal: we've already visited the "current" entry, so visit it's children next.
if (entry.Children.Count > 0)
{
TableOfContentsModel.Entry child = entry.Children[0];
if (this.m_Filter(child))
{
return(child);
}
else
{
return(this.FindNext(child));
}
}
// If there are no children, look for a next sibling, parent's sibling, etc.
else
{
TableOfContentsModel.Entry parent = entry.Parent;
TableOfContentsModel.EntryCollection siblings = (parent == null)
? entry.TableOfContents.Entries
: parent.Children;
while (siblings != null)
{
int index = siblings.IndexOf(entry);
// Use the entry's sibling within the parent, if possible.
if (index >= 0 && index < siblings.Count - 1)
{
TableOfContentsModel.Entry sibling = siblings[index + 1];
if (this.m_Filter(sibling))
{
return(sibling);
}
else
{
return(this.FindNext(sibling));
}
}
// If there is no sibling in the parent, go up another level.
// Do not consider parent nodes in the pre-order traversal.
else
{
entry = parent;
parent = (entry == null) ? null : entry.Parent;
siblings = (parent == null) ? null : parent.Children;
}
}
// If we get here, then we've run out of parents and there is no next entry!
return(null);
}
}
}