C# DataGridContext.GetChildContexts方法代码示例

    private void RecursiveSaveDataGridContextsState( DataGridContext dataGridContext )
    {
      SaveRestoreDataGridContextStateVisitor saveRestoreDataGridContextStateVisitor
        = new SaveRestoreDataGridContextStateVisitor( true, int.MaxValue, m_stopAtFirstCollapsedGroup );

      saveRestoreDataGridContextStateVisitor.SaveState( dataGridContext as IDataGridContextVisitable );

      m_dataGridContextsStateDictionary.Add( new WeakDataGridContextKey( dataGridContext ), saveRestoreDataGridContextStateVisitor );

      IEnumerable<DataGridContext> subDataGridContexts = dataGridContext.GetChildContexts();

      foreach( DataGridContext subDataGridContext in subDataGridContexts )
      {
        this.RecursiveSaveDataGridContextsState( subDataGridContext );
      }
    }

    private void EnsureNodeTreeCreatedOnAllSubContext( DataGridContext context )
    {
      // context.GetChildContexts() do a EnsureNodeTreeCreated(), no need to do one before calling it

      foreach( var subContext in context.GetChildContexts() )
      {
        this.EnsureNodeTreeCreatedOnAllSubContext( subContext );
      }
    }

      // Parse all the expanded details recursively
      private void GetVisiblePositionsForContextDetailLevel( DataGridContext dataGridContext, int desiredDetailLevel, HashSet<int> exportedColumnPositions )
      {
        int dataGridContextDetailLevel = dataGridContext.DetailLevel;

        // The detail level is too deep, return immediately
        if( dataGridContextDetailLevel > desiredDetailLevel )
          return;

        // The desired detail level is reached get the exportedColumnPositions
        if( dataGridContextDetailLevel == desiredDetailLevel )
        {
          DataGridContext parentDataGridContext = dataGridContext.ParentDataGridContext;

          if( parentDataGridContext == null )
          {
            this.GetVisibleColumnsVisiblePositionForDataGridContext( dataGridContext, exportedColumnPositions );
          }
          else
          {
            foreach( DataGridContext childContext in parentDataGridContext.GetChildContexts() )
            {
              if( this.GetVisibleColumnsVisiblePositionForDataGridContext( childContext, exportedColumnPositions ) )
              {
                // All columns need to be exported, stop parsing child DataGridContexts
                break;
              }
            }
          }
        }
        else
        {
          // The detail level differs, parse the child contexts recursively
          foreach( DataGridContext childContext in dataGridContext.GetChildContexts() )
          {
            this.GetVisiblePositionsForContextDetailLevel( childContext, desiredDetailLevel, exportedColumnPositions );
          }
        }
      }

    private static DataGridContext GetDataGridContextFromDetailConfiguration(
    DetailConfiguration configuration,
    DataGridContext parentDataGridContext )
    {
      if( ( configuration == null ) || ( parentDataGridContext == null ) )
        return null;

      if( parentDataGridContext.SourceDetailConfiguration == configuration )
        return parentDataGridContext;

      foreach( DataGridContext childContext in parentDataGridContext.GetChildContexts() )
      {
        DataGridContext foundContext =
          HierarchicalGroupByControlNode.GetDataGridContextFromDetailConfiguration( configuration,
            childContext );

        if( foundContext != null )
          return foundContext;
      }

      return null;
    }

    private DataGridContext UpdateCurrentContextRecursive(
      DataGridContext parentDataGridContext,
      DataGridContext oldCurrentDataGridContext,
      out object newCurrentItem )
    {
      if( parentDataGridContext == null )
      {
        newCurrentItem = null;
        return null;
      }

      foreach( DataGridContext childContext in parentDataGridContext.GetChildContexts() )
      {
        if( childContext.SourceDetailConfiguration == oldCurrentDataGridContext.SourceDetailConfiguration )
        {
          object oldCurrentItem = oldCurrentDataGridContext.CurrentItem;

          System.Data.DataView dataView =
            ItemsSourceHelper.TryGetDataViewFromDataGridContext( childContext );

          System.Data.DataRowView oldCurrentDataRowView = oldCurrentItem as System.Data.DataRowView;

          if( ( dataView != null ) && ( oldCurrentDataRowView != null ) )
          {
            System.Data.DataRow oldDataRow = oldCurrentDataRowView.Row;

            foreach( System.Data.DataRowView dataRowView in dataView )
            {
              if( dataRowView.Row == oldDataRow )
              {
                newCurrentItem = dataRowView;
                return childContext;
              }
            }
          }
          else
          {
            if( childContext.Items.Contains( oldCurrentItem ) )
            {
              newCurrentItem = oldCurrentItem;
              return childContext;
            }
          }
        }

        DataGridContext foundContext = this.UpdateCurrentContextRecursive( childContext, oldCurrentDataGridContext, out newCurrentItem );

        if( foundContext != null )
          return foundContext;
      }

      newCurrentItem = null;
      return null;
    }

    public void ProcessVisit(
      DataGridContext sourceContext,
      int minIndex,
      int maxIndex,
      IDataGridContextVisitor visitor,
      DataGridContextVisitorType visitorType,
      bool visitDetails,
      out bool visitWasStopped )
    {
      visitWasStopped = false;

      // This is used only for DataGridContextVisitorType.ItemsBlock
      int startSourceDataItemIndex = -1;
      int endSourceDataItemIndex = -1;

      if( minIndex < 0 )
      {
        DataGridException.ThrowSystemException( "The minimum index must be greater than or equal to zero.",
                                                typeof( ArgumentException ), sourceContext.DataGridControl.Name, "minIndex" );
      }

      if( ( visitorType & DataGridContextVisitorType.DataGridContext ) == DataGridContextVisitorType.DataGridContext )
      {
        visitor.Visit( sourceContext, ref visitWasStopped );

        if( visitWasStopped )
          return;
      }

      //Take a shortcut, if the visit is made only for contexts, and there is no child contexts
      //return right away.
      bool containsDetails = false;

      foreach( DataGridContext childContext in sourceContext.GetChildContexts() )
      {
        containsDetails = true;
        break;
      }

      bool processed = false;

      do
      {
        //resets the flag that indicates if the node was already processed
        processed = false;

        int itemCount = this.CurrentNode.ItemCount;

        //If the whole current node is below the minIndex, jump over it.
        if( ( this.Index + ( itemCount - 1 ) ) < minIndex )
        {
          processed = true;
        }

        //when the index to visit exceeds the range defined, exit the loop.
        if( this.Index > maxIndex )
          break;

        int minForNode = Math.Max( 0, minIndex - this.Index ); // this will give the base offset within the node where to start the visitating!
        int maxForNode = Math.Min( itemCount - 1, maxIndex - this.Index ); //this will five the max offset within this node to visit (protected against overlfow )

        if( !processed )
        {
          HeadersFootersGeneratorNode headersNode = this.CurrentNode as HeadersFootersGeneratorNode;

          if( headersNode != null )
          {
            bool isHeaderFooter = ( headersNode.Parent == null );

            //If the node is a Headers or Footers node AND the visitorType does not contain HeadersFooters
            if( ( isHeaderFooter ) && ( ( visitorType & DataGridContextVisitorType.HeadersFooters ) == DataGridContextVisitorType.HeadersFooters ) )
            {
              GeneratorNodeHelper.ProcessHeadersNodeVisit( headersNode, sourceContext, minForNode, maxForNode, visitor, ref visitWasStopped );
            }
            else if( ( !isHeaderFooter ) && ( ( visitorType & DataGridContextVisitorType.GroupHeadersFooters ) == DataGridContextVisitorType.GroupHeadersFooters ) )
            {
              GeneratorNodeHelper.ProcessHeadersNodeVisit( headersNode, sourceContext, minForNode, maxForNode, visitor, ref visitWasStopped );
            }

            processed = true;
          }
        }

        if( !processed )
        {
          ItemsGeneratorNode itemsNode = this.CurrentNode as ItemsGeneratorNode;

          if( itemsNode != null )
          {
            if( ( visitorType & DataGridContextVisitorType.ItemsBlock ) == DataGridContextVisitorType.ItemsBlock )
            {
              GeneratorNodeHelper.ProcessItemsNodeBlockVisit(
                itemsNode, sourceContext,
                minForNode, maxForNode,
                visitor, visitorType, visitDetails, containsDetails, m_sourceDataIndex,
                ref startSourceDataItemIndex, ref endSourceDataItemIndex, ref visitWasStopped );
            }
            else if( ( ( visitDetails ) && ( containsDetails ) )
              || ( ( visitorType & DataGridContextVisitorType.Items ) == DataGridContextVisitorType.Items ) )
            {
//.........这里部分代码省略.........

    private void RecursiveRestoreDataGridContextsState( DataGridContext dataGridContext )
    {
      WeakDataGridContextKey weakDataGridContextKey = new WeakDataGridContextKey( dataGridContext );

      SaveRestoreDataGridContextStateVisitor saveRestoreDataGridContextStateVisitor;

      if( m_dataGridContextsStateDictionary.TryGetValue( weakDataGridContextKey, out saveRestoreDataGridContextStateVisitor ) )
      {
        try
        {
          saveRestoreDataGridContextStateVisitor.RestoreState( dataGridContext as IDataGridContextVisitable );
        }
        finally
        {
          m_dataGridContextsStateDictionary.Remove( weakDataGridContextKey );
        }
      }

      IEnumerable<DataGridContext> subDataGridContexts = dataGridContext.GetChildContexts();
      foreach( DataGridContext subDataGridContext in subDataGridContexts )
      {
        this.RecursiveRestoreDataGridContextsState( subDataGridContext );
      }
    }