public override void removeTabAt(int position)
{
if (mTabScrollView == null)
{
// No tabs around to remove
return;
}
int selectedTabPosition = mSelectedTab != null?mSelectedTab.getPosition() : mSavedTabPosition;
mTabScrollView.removeTabAt(position);
[email protected] removedTab = mTabs.remove(position);
if (removedTab != null)
{
removedTab.setPosition(-1);
}
int newTabCount = mTabs.size();
{
for (int i = position; i < newTabCount; i++)
{
mTabs.get(i).setPosition(i);
}
}
if (selectedTabPosition == position)
{
selectTab(mTabs.isEmpty() ? null : mTabs.get(System.Math.Max(0, position - 1)));
}
}
/**
* Removes a collection from the those being decorated in this composite.
*
* @param coll collection to be removed
*/
public virtual void removeComposited(java.util.Collection <Object> coll)
{
java.util.ArrayList <Object> list = new java.util.ArrayList <Object>(this.all.Length);
list.addAll(java.util.Arrays <Object> .asList <Object>(this.all));
list.remove(coll);
this.all = (java.util.Collection <Object>[])list.toArray(new java.util.Collection <Object> [list.size()]);
}
public virtual void unregisterActivityLifecycleCallbacks(android.app.Application.
ActivityLifecycleCallbacks callback)
{
lock (mActivityLifecycleCallbacks)
{
mActivityLifecycleCallbacks.remove(callback);
}
}
public override void unregisterComponentCallbacks(android.content.ComponentCallbacks
callback)
{
lock (mComponentCallbacks)
{
mComponentCallbacks.remove(callback);
}
}
protected virtual java.util.MapNS.Entry <Object, Object> nextEntry()
{
if (!hasNext())
{
throw new java.util.NoSuchElementException();
}
last = (java.util.MapNS.Entry <Object, Object>)current.remove(current.size() - 1);
return(last);
}
/// <summary>Remove a previously installed pre-draw callback</summary>
/// <param name="victim">The callback to remove</param>
/// <exception cref="System.InvalidOperationException">
/// If
/// <see cref="isAlive()">isAlive()</see>
/// returns false
/// </exception>
/// <seealso cref="addOnPreDrawListener(OnPreDrawListener)">addOnPreDrawListener(OnPreDrawListener)
/// </seealso>
public void removeOnPreDrawListener(android.view.ViewTreeObserver.OnPreDrawListener
victim)
{
checkIsAlive();
if (mOnPreDrawListeners == null)
{
return;
}
mOnPreDrawListeners.remove(victim);
}
/**
* Subtracts all elements in the second list from the first list,
* placing the results in a new list.
* <p>
* This differs from {@link List#removeAll(Collection)} in that
* cardinality is respected; if <Code>list1</Code> contains two
* occurrences of <Code>null</Code> and <Code>list2</Code> only
* contains one occurrence, then the returned list will still contain
* one occurrence.
*
* @param list1 the list to subtract from
* @param list2 the list to subtract
* @return a new list containing the results
* @throws NullPointerException if either list is null
*/
public static java.util.List <Object> subtract(java.util.List <Object> list1, java.util.List <Object> list2)
{
java.util.ArrayList <Object> result = new java.util.ArrayList <Object>(list1);
java.util.Iterator <Object> iterator = list2.iterator();
while (iterator.hasNext())
{
result.remove(iterator.next());
}
return(result);
}
/// <summary>Removes a listener from the set listening to this animation.</summary>
/// <remarks>Removes a listener from the set listening to this animation.</remarks>
/// <param name="listener">
/// the listener to be removed from the current set of listeners for this
/// animation.
/// </param>
public virtual void removeListener(android.animation.Animator.AnimatorListener listener
)
{
if (mListeners == null)
{
return;
}
mListeners.remove(listener);
if (mListeners.size() == 0)
{
mListeners = null;
}
}
internal void reset()
{
levelObjVal = null;
levelIntVal = Level.INFO.intValue();
foreach (Handler handler in handlers)
{
try {
if (handlers.remove(handler))
{
handler.close();
}
} catch (Exception) {
}
}
}
public virtual bool removeHeader(android.view.View v)
{
{
for (int i = 0; i < mHeaderViewInfos.size(); i++)
{
android.widget.ListView.FixedViewInfo info = mHeaderViewInfos.get(i);
if (info.view == v)
{
mHeaderViewInfos.remove(i);
mAreAllFixedViewsSelectable = areAllListInfosSelectable(mHeaderViewInfos) && areAllListInfosSelectable
(mFooterViewInfos);
return(true);
}
}
}
return(false);
}
internal static android.widget.ExpandableListPosition getRecycledOrCreate()
{
android.widget.ExpandableListPosition elp;
lock (sPool)
{
if (sPool.size() > 0)
{
elp = sPool.remove(0);
}
else
{
return(new android.widget.ExpandableListPosition());
}
}
elp.resetState();
return(elp);
}
/// <summary>Removes a previously registered observer.</summary>
/// <remarks>
/// Removes a previously registered observer. The observer must not be null and it
/// must already have been registered.
/// </remarks>
/// <param name="observer">the observer to unregister</param>
/// <exception cref="System.ArgumentException">the observer is null</exception>
/// <exception cref="System.InvalidOperationException">the observer is not yet registered
/// </exception>
public virtual void unregisterObserver(T observer)
{
if ((object)observer == null)
{
throw new System.ArgumentException("The observer is null.");
}
lock (mObservers)
{
int index = mObservers.indexOf(observer);
if (index == -1)
{
throw new System.InvalidOperationException("Observer " + observer + " was not registered."
);
}
mObservers.remove(index);
}
}
private static android.widget.ExpandableListConnector.PositionMetadata getRecycledOrCreate
()
{
android.widget.ExpandableListConnector.PositionMetadata pm;
lock (sPool)
{
if (sPool.size() > 0)
{
pm = sPool.remove(0);
}
else
{
return(new android.widget.ExpandableListConnector.PositionMetadata());
}
}
pm.resetState();
return(pm);
}
/**
* Removes user (public) listener to this list.
*
* @param listener - listener to be removed.
*/
public void removeUserListener(Object listener)
{
if (listener == null)
{
return;
}
// transactionally replace old list
lock (this)
{
if (userList == null || !userList.contains(listener))
{
return;
}
java.util.ArrayList <T> newList = new java.util.ArrayList <T>(userList);
newList.remove(listener);
userList = (newList.size() > 0 ? newList : null);
}
}
public virtual void removeGroup(int groupId)
{
java.util.ArrayList <*****@*****.**> items = mItems;
int itemCount = items.size();
int i = 0;
while (i < itemCount)
{
if (items.get(i).getGroupId() == groupId)
{
items.remove(i);
itemCount--;
}
else
{
i++;
}
}
}
/**
* Removes a driver from the {@code DriverManager}'s registered driver list.
* This will only succeed when the caller's class loader loaded the driver
* that is to be removed. If the driver was loaded by a different class
* loader, the removal of the driver fails silently.
* <p>
* If the removal succeeds, the {@code DriverManager} will not use this
* driver in the future when asked to get a {@code Connection}.
*
* @param driver
* the JDBC driver to remove.
* @throws SQLException
* if there is a problem interfering with accessing the
* database.
*/
public static void deregisterDriver(Driver driver)
{//throws SQLException {
if (driver == null)
{
return;
}
java.lang.ClassLoader callerClassLoader = java.lang.Runtime.getRuntime().getClass().getClassLoader();// Basties note: sometime do the same as VM.callerClassLoader();
if (!DriverManager.isClassFromClassLoader(driver, callerClassLoader))
{
// sql.1=DriverManager: calling class not authorized to deregister
// JDBC driver
throw new java.lang.SecurityException("DriverManager: calling class not authorized to deregister JDBC driver"); //$NON-NLS-1$
} // end if
lock (theDrivers)
{
theDrivers.remove(driver);
}
}
/**
* Remove the element at the specified position in the list, and shift
* any subsequent elements down one position.
*
* @param index Index of the element to be removed
*
* @exception IndexOutOfBoundsException if the index is out of range
*/
public override Object remove(int index)
{
if (fast)
{
lock (this)
{
java.util.ArrayList <Object> temp = (java.util.ArrayList <Object>)list.clone();
Object result = temp.remove(index);
list = temp;
return(result);
}
}
else
{
lock (list)
{
return(list.remove(index));
}
}
}
/**
* Remove the first occurrence of the specified element from the list,
* and shift any subsequent elements down one position.
*
* @param element Element to be removed
*/
public override bool remove(Object element)
{
if (fast)
{
lock (this)
{
java.util.ArrayList <Object> temp = (java.util.ArrayList <Object>)list.clone();
bool result = temp.remove(element);
list = temp;
return(result);
}
}
else
{
lock (list)
{
return(list.remove(element));
}
}
}
//
// DiscardInstance
//
public static void DiscardInstance(SoundEffectInstance discardInstance, SoundEffect discardEffect)
{
if (instancesLock.isHeldByCurrentThread())
{
return;
}
try
{
instancesLock.@lock();
for (int idx = instancesList.size(); idx-- > 0;)
{
var instRef = ([email protected])instancesList.get(idx);
var inst = (SoundEffectInstance)instRef.get();
if (inst == discardInstance || inst == null || inst.ShouldDiscard(discardEffect))
{
instancesList.remove(idx);
}
}
}
finally
{
instancesLock.unlock();
}
}
public virtual void onAnimationEnd(android.animation.Animator animation)
{
mAnimators.remove(animation);
}
/**
* Returns a new {@link Collection} containing <tt><i>a</i> - <i>b</i></tt>.
* The cardinality of each element <i>e</i> in the returned {@link Collection}
* will be the cardinality of <i>e</i> in <i>a</i> minus the cardinality
* of <i>e</i> in <i>b</i>, or zero, whichever is greater.
*
* @param a the collection to subtract from, must not be null
* @param b the collection to subtract, must not be null
* @return a new collection with the results
* @see Collection#removeAll
*/
public static java.util.Collection<Object> subtract(java.util.Collection<Object> a, java.util.Collection<Object> b)
{
java.util.ArrayList<Object> list = new java.util.ArrayList<Object>(a);
for (java.util.Iterator<Object> it = b.iterator(); it.hasNext(); )
{
list.remove(it.next());
}
return list;
}
/// <summary>
/// Traverses the expanded group metadata list and fills in the flat list
/// positions.
/// </summary>
/// <remarks>
/// Traverses the expanded group metadata list and fills in the flat list
/// positions.
/// </remarks>
/// <param name="forceChildrenCountRefresh">
/// Forces refreshing of the children count
/// for all expanded groups.
/// </param>
/// <param name="syncGroupPositions">
/// Whether to search for the group positions
/// based on the group IDs. This should only be needed when calling
/// this from an onChanged callback.
/// </param>
private void refreshExpGroupMetadataList(bool forceChildrenCountRefresh, bool syncGroupPositions
)
{
java.util.ArrayList <android.widget.ExpandableListConnector.GroupMetadata> egml =
mExpGroupMetadataList;
int egmlSize = egml.size();
int curFlPos = 0;
mTotalExpChildrenCount = 0;
if (syncGroupPositions)
{
// We need to check whether any groups have moved positions
bool positionsChanged = false;
{
for (int i = egmlSize - 1; i >= 0; i--)
{
android.widget.ExpandableListConnector.GroupMetadata curGm = egml.get(i);
int newGPos = findGroupPosition(curGm.gId, curGm.gPos);
if (newGPos != curGm.gPos)
{
if (newGPos == android.widget.AdapterView.INVALID_POSITION)
{
// Doh, just remove it from the list of expanded groups
egml.remove(i);
egmlSize--;
}
curGm.gPos = newGPos;
if (!positionsChanged)
{
positionsChanged = true;
}
}
}
}
if (positionsChanged)
{
// At least one group changed positions, so re-sort
java.util.Collections.sort(egml);
}
}
int gChildrenCount;
int lastGPos = 0;
{
for (int i_1 = 0; i_1 < egmlSize; i_1++)
{
android.widget.ExpandableListConnector.GroupMetadata curGm = egml.get(i_1);
if ((curGm.lastChildFlPos == android.widget.ExpandableListConnector.GroupMetadata
.REFRESH) || forceChildrenCountRefresh)
{
gChildrenCount = mExpandableListAdapter.getChildrenCount(curGm.gPos);
}
else
{
gChildrenCount = curGm.lastChildFlPos - curGm.flPos;
}
mTotalExpChildrenCount += gChildrenCount;
curFlPos += (curGm.gPos - lastGPos);
lastGPos = curGm.gPos;
curGm.flPos = curFlPos;
curFlPos += gChildrenCount;
curGm.lastChildFlPos = curFlPos;
}
}
}
/**
* Subtracts all elements in the second list from the first list,
* placing the results in a new list.
* <p>
* This differs from {@link List#removeAll(Collection)} in that
* cardinality is respected; if <Code>list1</Code> contains two
* occurrences of <Code>null</Code> and <Code>list2</Code> only
* contains one occurrence, then the returned list will still contain
* one occurrence.
*
* @param list1 the list to subtract from
* @param list2 the list to subtract
* @return a new list containing the results
* @throws NullPointerException if either list is null
*/
public static java.util.List<Object> subtract(java.util.List<Object> list1, java.util.List<Object> list2)
{
java.util.ArrayList<Object> result = new java.util.ArrayList<Object>(list1);
java.util.Iterator<Object> iterator = list2.iterator();
while (iterator.hasNext())
{
result.remove(iterator.next());
}
return result;
}
public virtual void removeItem(int id)
{
mItems.remove(findItemIndex(id));
}
/*
* Removes the provider
*
* @param providerNumber
*/
public static void removeProvider(int providerNumber)
{
java.security.Provider p = providers.remove(providerNumber - 1);
providersNames.remove(p.getName());
setNeedRefresh();
}
public override void removeOnMenuVisibilityListener(android.app.ActionBar.OnMenuVisibilityListener
listener)
{
mMenuVisibilityListeners.remove(listener);
}
