IItemContainerGenerator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / WIN_WINDOWS / lh_tools_devdiv_wpf / Windows / wcp / Framework / System / Windows / Controls / Primitives / IItemContainerGenerator.cs / 1 / IItemContainerGenerator.cs
                        

                        
                            //---------------------------------------------------------------------------- 
//
// 
//    Copyright (C) Microsoft Corporation.  All rights reserved.
//  
//
// Description: IItemContainerGenerator interface 
// 
// Specs:       [....]/connecteddata/M5%20General%20Docs/Data%20Styling.mht
// 
//---------------------------------------------------------------------------

using System;
using MS.Internal.Data; 

namespace System.Windows.Controls.Primitives 
{ 
    /// 
    ///     Interface through which a layout element (such as a panel) marked 
    ///     as an ItemsHost communicates with the ItemContainerGenerator of its
    ///     items owner.
    /// 
    public interface IItemContainerGenerator 
    {
        ///  
        /// Return the ItemContainerGenerator appropriate for use by the given panel 
        /// 
        ItemContainerGenerator GetItemContainerGeneratorForPanel(Panel panel); 

        ///  Prepare the generator to generate, starting at the given position and direction 
        /// 
        /// This method must be called before calling GenerateNext.  It returns an 
        /// IDisposable object that tracks the lifetime of the generation loop.
        /// This method sets the generator's status to GeneratingContent;  when 
        /// the IDisposable is disposed, the status changes to ContentReady or 
        /// Error, as appropriate.
        ///  
        IDisposable StartAt(GeneratorPosition position, GeneratorDirection direction);

        ///  Prepare the generator to generate, starting at the given position and direction 
        ///  
        /// This method must be called before calling GenerateNext.  It returns an
        /// IDisposable object that tracks the lifetime of the generation loop. 
        /// This method sets the generator's status to GeneratingContent;  when 
        /// the IDisposable is disposed, the status changes to ContentReady or
        /// Error, as appropriate. 
        /// 
        IDisposable StartAt(GeneratorPosition position, GeneratorDirection direction, bool allowStartAtRealizedItem);

        ///  Return the container element used to display the next item.  
        /// 
        /// This method must be called in the scope of the IDisposable returned by 
        /// a previous call to StartAt. 
        /// 
        DependencyObject GenerateNext(); 

        ///  Return the container element used to display the next item.
        /// When the next item has not been realized, this method returns a container
        /// and sets isNewlyRealized to true.  When the next item has been realized, 
        /// this method returns the exisiting container and sets isNewlyRealized to
        /// false. 
        ///  
        /// 
        /// This method must be called in the scope of the IDisposable returned by 
        /// a previous call to StartAt.
        /// 
        DependencyObject GenerateNext(out bool isNewlyRealized);
 
        /// 
        /// Prepare the given element to act as the ItemUI for the 
        /// corresponding item.  This includes applying the ItemUI style, 
        /// forwarding information from the host control (ItemTemplate, etc.),
        /// and other small adjustments. 
        /// 
        /// 
        /// This method must be called after the element has been added to the
        /// visual tree, so that resource references and inherited properties 
        /// work correctly.
        ///  
        ///  The container to prepare. 
        /// Normally this is the result of the previous call to GenerateNext.
        ///  
        void PrepareItemContainer(DependencyObject container);

        /// 
        /// Remove all generated elements. 
        /// 
        void RemoveAll(); 
 
        /// 
        /// Remove generated elements. 
        /// 
        /// 
        /// The position must refer to a previously generated item, i.e. its
        /// Offset must be 0. 
        /// 
        void Remove(GeneratorPosition position, int count); 
 
        /// 
        /// Map an index into the items collection to a GeneratorPosition. 
        /// 
        GeneratorPosition GeneratorPositionFromIndex(int itemIndex);

        ///  
        /// Map a GeneratorPosition to an index into the items collection.
        ///  
        int IndexFromGeneratorPosition(GeneratorPosition position); 
    }
 
    /// 
    /// A user of the ItemContainerGenerator describes positions using this struct.
    /// Some examples:
    /// To start generating forward from the beginning of the item list, 
    /// specify position (-1, 0) and direction Forward.
    /// To start generating backward from the end of the list, 
    /// specify position (-1, 0) and direction Backward. 
    /// To generate the items after the element with index k, specify
    /// position (k, 0) and direction Forward. 
    /// 
    public struct GeneratorPosition
    {
        ///  
        /// Index, with respect to realized elements.  The special value -1
        /// refers to a fictitious element at the beginning or end of the 
        /// the list. 
        /// 
        public int Index  { get { return _index; }  set { _index = value; } } 

        /// 
        /// Offset, with respect to unrealized items near the indexed element.
        /// An offset of 0 refers to the indexed element itself, an offset 
        /// of 1 refers to the next (unrealized) item, and an offset of -1
        /// refers to the previous item. 
        ///  
        public int Offset { get { return _offset; } set { _offset = value; } }
 
        ///  Constructor 
        public GeneratorPosition(int index, int offset)
        {
            _index = index; 
            _offset = offset;
        } 
 
        ///  Return a hash code 
        // This is required by FxCop. 
        public override int GetHashCode()
        {
            return _index.GetHashCode() + _offset.GetHashCode();
        } 

        /// Returns a string representation of the GeneratorPosition 
        public override string ToString() 
        {
            return string.Concat("GeneratorPosition (", _index.ToString(DataBindEngine.EnglishUSCulture), ",", _offset.ToString(DataBindEngine.EnglishUSCulture), ")"); 
        }


        // The remaining methods are present only because they are required by FxCop. 

        ///  Equality test  
        // This is required by FxCop. 
        public override bool Equals(object o)
        { 
            if (o is GeneratorPosition)
            {
                GeneratorPosition that = (GeneratorPosition)o;
                return  this._index == that._index && 
                        this._offset == that._offset;
            } 
            return false; 
        }
 
        ///  Equality test 
        // This is required by FxCop.
        public static bool operator==(GeneratorPosition gp1, GeneratorPosition gp2)
        { 
            return  gp1._index == gp2._index &&
                    gp1._offset == gp2._offset; 
        } 

        ///  Inequality test  
        // This is required by FxCop.
        public static bool operator!=(GeneratorPosition gp1, GeneratorPosition gp2)
        {
            return  !(gp1 == gp2); 
        }
 
        private int _index; 
        private int _offset;
    } 

    /// 
    /// This enum is used by the ItemContainerGenerator and its client to specify
    /// the direction in which the generator produces UI. 
    /// 
    public enum GeneratorDirection 
    { 
        ///  generate forward through the item collection 
        Forward, 

        ///  generate backward through the item collection 
        Backward
    } 

    ///  
    /// This enum is used by the ItemContainerGenerator to indicate its status. 
    /// 
    public enum GeneratorStatus 
    {
        ///The generator has not tried to generate content
        NotStarted,
        ///The generator is generating containers 
        GeneratingContainers,
        ///The generator has finished generating containers 
        ContainersGenerated, 
        ///The generator has finished generating containers, but encountered one or more errors
        Error 
    }
}


// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK