Example #1
0
 /// <summary>
 /// Change the size of the virtual list so that it matches its data source
 /// </summary>
 public virtual void UpdateVirtualListSize()
 {
     if (VirtualListDataSource != null)
     {
         SetVirtualListSize(VirtualListDataSource.GetObjectCount());
     }
 }
Example #2
0
 /// <summary>
 /// Handle the CacheVirtualItems event
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 protected virtual void HandleCacheVirtualItems(object sender, CacheVirtualItemsEventArgs e)
 {
     if (VirtualListDataSource != null)
     {
         VirtualListDataSource.PrepareCache(e.StartIndex, e.EndIndex);
     }
 }
Example #3
0
        /// <summary>
        /// Remove all of the given objects from the control
        /// </summary>
        /// <param name="modelObjects">Collection of objects to be removed</param>
        /// <remarks>
        /// <para>Nulls and model objects that are not in the ListView are silently ignored.</para>
        /// <para>Due to problems in the underlying ListView, if you remove all the objects from
        /// the control using this method and the list scroll vertically when you do so,
        /// then when you subsequenially add more objects to the control,
        /// the vertical scroll bar will become confused and the control will draw one or more
        /// blank lines at the top of the list. </para>
        /// </remarks>
        public override void RemoveObjects(ICollection <object> modelObjects)
        {
            if (VirtualListDataSource == null)
            {
                return;
            }

            // Give the world a chance to cancel or change the removed objects
            ItemsRemovingEventArgs args = new ItemsRemovingEventArgs(modelObjects);

            OnItemsRemoving(args);
            if (args.Canceled)
            {
                return;
            }

            try
            {
                BeginUpdate();
                VirtualListDataSource.RemoveObjects(args.ObjectsToRemove);
                BuildList();
            }
            finally
            {
                EndUpdate();
            }
        }
Example #4
0
        /// <summary>
        /// Set the collection of objects that this control will show.
        /// </summary>
        /// <param name="collection"></param>
        /// <param name="preserveState">Should the state of the list be preserved as far as is possible.</param>
        public override void SetObjects(IEnumerable <object> collection, bool preserveState)
        {
            if (InvokeRequired)
            {
                Invoke((MethodInvoker) delegate { SetObjects(collection, preserveState); });
                return;
            }

            if (VirtualListDataSource == null)
            {
                return;
            }

            // Give the world a chance to cancel or change the assigned collection
            ItemsChangingEventArgs args = new ItemsChangingEventArgs(null, collection);

            OnItemsChanging(args);
            if (args.Canceled)
            {
                return;
            }

            BeginUpdate();
            try
            {
                VirtualListDataSource.SetObjects(args.NewObjects);
                BuildList();
            }
            finally
            {
                EndUpdate();
            }
        }
Example #5
0
        /// <summary>
        /// Select the row that is displaying the given model object. All other rows are deselected.
        /// </summary>
        /// <param name="modelObject">Model object to select</param>
        /// <param name="setFocus">Should the object be focused as well?</param>
        public override void SelectObject(object modelObject, bool setFocus)
        {
            // Without a data source, we can't do this.
            if (VirtualListDataSource == null)
            {
                return;
            }

            // Check that the object is in the list (plus not all data sources can locate objects)
            int index = VirtualListDataSource.GetObjectIndex(modelObject);

            if (index < 0 || index >= VirtualListSize)
            {
                return;
            }

            // If the given model is already selected, don't do anything else (prevents an flicker)
            if (SelectedIndices.Count == 1 && SelectedIndices[0] == index)
            {
                return;
            }

            // Finally, select the row
            SelectedIndices.Clear();
            SelectedIndices.Add(index);
            if (setFocus && SelectedItem != null)
            {
                SelectedItem.Focused = true;
            }
        }
Example #6
0
        /// <summary>
        /// Update the rows that are showing the given objects
        /// </summary>
        /// <remarks>This method does not resort the items.</remarks>
        public override void RefreshObjects(IList <object> modelObjects)
        {
            if (InvokeRequired)
            {
                Invoke((MethodInvoker) delegate { RefreshObjects(modelObjects); });
                return;
            }

            // Without a data source, we can't do this.
            if (VirtualListDataSource == null)
            {
                return;
            }

            try
            {
                BeginUpdate();
                ClearCachedInfo();
                foreach (object modelObject in modelObjects)
                {
                    int index = VirtualListDataSource.GetObjectIndex(modelObject);
                    if (index >= 0)
                    {
                        VirtualListDataSource.UpdateObject(index, modelObject);
                        RedrawItems(index, index, true);
                    }
                }
            }
            finally
            {
                EndUpdate();
            }
        }
Example #7
0
        /// <summary>
        /// Inserts the given collection of model objects to this control at hte given location
        /// </summary>
        /// <param name="modelObjects">A collection of model objects</param>
        /// <remarks>
        /// <para>The added objects will appear in their correct sort position, if sorting
        /// is active. Otherwise, they will appear at the given position of the list.</para>
        /// <para>No check is performed to see if any of the objects are already in the ListView.</para>
        /// <para>Null objects are silently ignored.</para>
        /// </remarks>
        public override void InsertObjects(int index, ICollection <object> modelObjects)
        {
            if (VirtualListDataSource == null)
            {
                return;
            }

            // Give the world a chance to cancel or change the added objects
            ItemsAddingEventArgs args = new ItemsAddingEventArgs(index, modelObjects);

            OnItemsAdding(args);
            if (args.Canceled)
            {
                return;
            }

            try
            {
                BeginUpdate();
                VirtualListDataSource.InsertObjects(index, args.ObjectsToAdd);
                BuildList();
            }
            finally
            {
                EndUpdate();
            }
        }
Example #8
0
        /// <summary>
        /// Find the given model object within the listview and return its index
        /// </summary>
        /// <param name="modelObject">The model object to be found</param>
        /// <returns>The index of the object. -1 means the object was not present</returns>
        public override int IndexOf(object modelObject)
        {
            if (VirtualListDataSource == null || modelObject == null)
            {
                return(-1);
            }

            return(VirtualListDataSource.GetObjectIndex(modelObject));
        }
Example #9
0
        /// <summary>
        /// Return the OLVListItem that displays the given model object
        /// </summary>
        /// <param name="modelObject">The modelObject whose item is to be found</param>
        /// <returns>The OLVListItem that displays the model, or null</returns>
        /// <remarks>This method has O(n) performance.</remarks>
        public override OLVListItem ModelToItem(object modelObject)
        {
            if (VirtualListDataSource == null || modelObject == null)
            {
                return(null);
            }

            int index = VirtualListDataSource.GetObjectIndex(modelObject);

            return(index >= 0 ? GetItem(index) : null);
        }
Example #10
0
 /// <summary>
 /// Return the model object at the given index
 /// </summary>
 /// <param name="index">Index of the model object to be returned</param>
 /// <returns>A model object</returns>
 public override object GetModelObject(int index)
 {
     if (VirtualListDataSource != null && index >= 0 && index < GetItemCount())
     {
         return(VirtualListDataSource.GetNthObject(index));
     }
     else
     {
         return(null);
     }
 }
Example #11
0
        /// <summary>
        /// Handle the SearchForVirtualList event, which is called when the user types into a virtual list
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected virtual void HandleSearchForVirtualItem(object sender, SearchForVirtualItemEventArgs e)
        {
            // The event has e.IsPrefixSearch, but as far as I can tell, this is always false (maybe that's different under Vista)
            // So we ignore IsPrefixSearch and IsTextSearch and always to a case insensitve prefix match.

            // We can't do anything if we don't have a data source
            if (VirtualListDataSource == null)
            {
                return;
            }

            // Where should we start searching? If the last row is focused, the SearchForVirtualItemEvent starts searching
            // from the next row, which is actually an invalidate index -- so we make sure we never go past the last object.
            int start = Math.Min(e.StartIndex, VirtualListDataSource.GetObjectCount() - 1);

            // Give the world a chance to fiddle with or completely avoid the searching process
            BeforeSearchingEventArgs args = new BeforeSearchingEventArgs(e.Text, start);

            OnBeforeSearching(args);
            if (args.Canceled)
            {
                return;
            }

            // Do the search
            int i = FindMatchingRow(args.StringToFind, args.StartSearchFrom, e.Direction);

            // Tell the world that a search has occurred
            AfterSearchingEventArgs args2 = new AfterSearchingEventArgs(args.StringToFind, i);

            OnAfterSearching(args2);

            // If we found a match, tell the event
            if (i != -1)
            {
                e.Index = i;
            }
        }
Example #12
0
        /// <summary>
        /// Select the rows that is displaying any of the given model object. All other rows are deselected.
        /// </summary>
        /// <param name="modelObjects">A collection of model objects</param>
        /// <remarks>This method has O(n) performance where n is the number of model objects passed.
        /// Do not use this to select all the rows in the list -- use SelectAll() for that.</remarks>
        public override void SelectObjects(IList <object> modelObjects)
        {
            // Without a data source, we can't do this.
            if (VirtualListDataSource == null)
            {
                return;
            }

            SelectedIndices.Clear();

            if (modelObjects == null)
            {
                return;
            }

            foreach (object modelObject in modelObjects)
            {
                int index = VirtualListDataSource.GetObjectIndex(modelObject);
                if (index >= 0 && index < VirtualListSize)
                {
                    SelectedIndices.Add(index);
                }
            }
        }
Example #13
0
 /// <summary>
 /// Find the first row in the given range of rows that prefix matches the string value of the given column.
 /// </summary>
 /// <param name="text"></param>
 /// <param name="first"></param>
 /// <param name="last"></param>
 /// <param name="column"></param>
 /// <returns>The index of the matched row, or -1</returns>
 protected override int FindMatchInRange(string text, int first, int last, OLVColumn column)
 {
     return(VirtualListDataSource.SearchText(text, first, last, column));
 }