tools/ddms/libs/ddmuilib/src/com/android/ddmuilib/logcat/LogFilter.java - platform/development - Gitiles

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.ddmuilib.logcat;

 import com.android.ddmlib.Log;
 import com.android.ddmlib.Log.LogLevel;
 import com.android.ddmuilib.annotation.UiThread;
 import com.android.ddmuilib.logcat.LogPanel.LogMessage;

 import org.eclipse.swt.SWT;
 import org.eclipse.swt.SWTException;
 import org.eclipse.swt.widgets.ScrollBar;
 import org.eclipse.swt.widgets.TabItem;
 import org.eclipse.swt.widgets.Table;
 import org.eclipse.swt.widgets.TableItem;

 import java.util.ArrayList;
 import java.util.regex.PatternSyntaxException;

 /** logcat output filter class */
 public class LogFilter {

     public final static int MODE_PID = 0x01;
     public final static int MODE_TAG = 0x02;
     public final static int MODE_LEVEL = 0x04;

     private String mName;

     /**
      * Filtering mode. Value can be a mix of MODE_PID, MODE_TAG, MODE_LEVEL
      */
     private int mMode = 0;

     /**
      * pid used for filtering. Only valid if mMode is MODE_PID.
      */
     private int mPid;

     /** Single level log level as defined in Log.mLevelChar. Only valid
      * if mMode is MODE_LEVEL */
     private int mLogLevel;

     /**
      * log tag filtering. Only valid if mMode is MODE_TAG
      */
     private String mTag;

     private Table mTable;
     private TabItem mTabItem;
     private boolean mIsCurrentTabItem = false;
     private int mUnreadCount = 0;

     /** Temp keyword filtering */
     private String[] mTempKeywordFilters;

     /** temp pid filtering */
     private int mTempPid = -1;

     /** temp tag filtering */
     private String mTempTag;

     /** temp log level filtering */
     private int mTempLogLevel = -1;

     private LogColors mColors;

     private boolean mTempFilteringStatus = false;

     private final ArrayList<LogMessage> mMessages = new ArrayList<LogMessage>();
     private final ArrayList<LogMessage> mNewMessages = new ArrayList<LogMessage>();

     private boolean mSupportsDelete = true;
     private boolean mSupportsEdit = true;
     private int mRemovedMessageCount = 0;

     /**
      * Creates a filter with a particular mode.
      * @param name The name to be displayed in the UI
      */
     public LogFilter(String name) {
         mName = name;
     }

     public LogFilter() {

     }

     @Override
     public String toString() {
         StringBuilder sb = new StringBuilder(mName);

         sb.append(':');
         sb.append(mMode);
         if ((mMode & MODE_PID) == MODE_PID) {
             sb.append(':');
             sb.append(mPid);
         }

         if ((mMode & MODE_LEVEL) == MODE_LEVEL) {
             sb.append(':');
             sb.append(mLogLevel);
         }

         if ((mMode & MODE_TAG) == MODE_TAG) {
             sb.append(':');
             sb.append(mTag);
         }

         return sb.toString();
     }

     public boolean loadFromString(String string) {
         String[] segments = string.split(":"); // $NON-NLS-1$
         int index = 0;

         // get the name
         mName = segments[index++];

         // get the mode
         mMode = Integer.parseInt(segments[index++]);

         if ((mMode & MODE_PID) == MODE_PID) {
             mPid = Integer.parseInt(segments[index++]);
         }

         if ((mMode & MODE_LEVEL) == MODE_LEVEL) {
             mLogLevel = Integer.parseInt(segments[index++]);
         }

         if ((mMode & MODE_TAG) == MODE_TAG) {
             mTag = segments[index++];
         }

         return true;
     }


     /** Sets the name of the filter. */
     void setName(String name) {
         mName = name;
     }

     /**
      * Returns the UI display name.
      */
     public String getName() {
         return mName;
     }

     /**
      * Set the Table ui widget associated with this filter.
      * @param tabItem The item in the TabFolder
      * @param table The Table object
      */
     public void setWidgets(TabItem tabItem, Table table) {
         mTable = table;
         mTabItem = tabItem;
     }

     /**
      * Returns true if the filter is ready for ui.
      */
     public boolean uiReady() {
         return (mTable != null && mTabItem != null);
     }

     /**
      * Returns the UI table object.
      * @return
      */
     public Table getTable() {
         return mTable;
     }

     public void dispose() {
         mTable.dispose();
         mTabItem.dispose();
         mTable = null;
         mTabItem = null;
     }

     /**
      * Resets the filtering mode to be 0 (i.e. no filter).
      */
     public void resetFilteringMode() {
         mMode = 0;
     }

     /**
      * Returns the current filtering mode.
      * @return A bitmask. Possible values are MODE_PID, MODE_TAG, MODE_LEVEL
      */
     public int getFilteringMode() {
         return mMode;
     }

     /**
      * Adds PID to the current filtering mode.
      * @param pid
      */
     public void setPidMode(int pid) {
         if (pid != -1) {
             mMode |= MODE_PID;
         } else {
             mMode &= ~MODE_PID;
         }
         mPid = pid;
     }

     /** Returns the pid filter if valid, otherwise -1 */
     public int getPidFilter() {
         if ((mMode & MODE_PID) == MODE_PID)
             return mPid;
         return -1;
     }

     public void setTagMode(String tag) {
         if (tag != null && tag.length() > 0) {
             mMode |= MODE_TAG;
         } else {
             mMode &= ~MODE_TAG;
         }
         mTag = tag;
     }

     public String getTagFilter() {
         if ((mMode & MODE_TAG) == MODE_TAG)
             return mTag;
         return null;
     }

     public void setLogLevel(int level) {
         if (level == -1) {
             mMode &= ~MODE_LEVEL;
         } else {
             mMode |= MODE_LEVEL;
             mLogLevel = level;
         }

     }

     public int getLogLevel() {
         if ((mMode & MODE_LEVEL) == MODE_LEVEL) {
             return mLogLevel;
         }

         return -1;
     }


     public boolean supportsDelete() {
         return mSupportsDelete ;
     }

     public boolean supportsEdit() {
         return mSupportsEdit;
     }

     /**
      * Sets the selected state of the filter.
      * @param selected selection state.
      */
     public void setSelectedState(boolean selected) {
         if (selected) {
             if (mTabItem != null) {
                 mTabItem.setText(mName);
             }
             mUnreadCount = 0;
         }
         mIsCurrentTabItem = selected;
     }

     /**
      * Adds a new message and optionally removes an old message.
      * <p/>The new message is filtered through {@link #accept(LogMessage)}.
      * Calls to {@link #flush()} from a UI thread will display it (and other
      * pending messages) to the associated {@link Table}.
      * @param logMessage the MessageData object to filter
      * @return true if the message was accepted.
      */
     public boolean addMessage(LogMessage newMessage, LogMessage oldMessage) {
         synchronized (mMessages) {
             if (oldMessage != null) {
                 int index = mMessages.indexOf(oldMessage);
                 if (index != -1) {
                     // TODO check that index will always be -1 or 0, as only the oldest message is ever removed.
                     mMessages.remove(index);
                     mRemovedMessageCount++;
                 }

                 // now we look for it in mNewMessages. This can happen if the new message is added
                 // and then removed because too many messages are added between calls to #flush()
                 index = mNewMessages.indexOf(oldMessage);
                 if (index != -1) {
                     // TODO check that index will always be -1 or 0, as only the oldest message is ever removed.
                     mNewMessages.remove(index);
                 }
             }

             boolean filter = accept(newMessage);

             if (filter) {
                 // at this point the message is accepted, we add it to the list
                 mMessages.add(newMessage);
                 mNewMessages.add(newMessage);
             }

             return filter;
         }
     }

     /**
      * Removes all the items in the filter and its {@link Table}.
      */
     public void clear() {
         mRemovedMessageCount = 0;
         mNewMessages.clear();
         mMessages.clear();
         mTable.removeAll();
     }

     /**
      * Filters a message.
      * @param logMessage the Message
      * @return true if the message is accepted by the filter.
      */
     boolean accept(LogMessage logMessage) {
         // do the regular filtering now
         if ((mMode & MODE_PID) == MODE_PID && mPid != logMessage.data.pid) {
             return false;
         }

         if ((mMode & MODE_TAG) == MODE_TAG && (
                 logMessage.data.tag == null ||
                 logMessage.data.tag.equals(mTag) == false)) {
             return false;
         }

         int msgLogLevel = logMessage.data.logLevel.getPriority();

         // test the temp log filtering first, as it replaces the old one
         if (mTempLogLevel != -1) {
             if (mTempLogLevel > msgLogLevel) {
                 return false;
             }
         } else if ((mMode & MODE_LEVEL) == MODE_LEVEL &&
                 mLogLevel > msgLogLevel) {
             return false;
         }

         // do the temp filtering now.
         if (mTempKeywordFilters != null) {
             String msg = logMessage.msg;

             for (String kw : mTempKeywordFilters) {
                 try {
                     if (msg.contains(kw) == false && msg.matches(kw) == false) {
                         return false;
                     }
                 } catch (PatternSyntaxException e) {
                     // if the string is not a valid regular expression,
                     // this exception is thrown.
                     return false;
                 }
             }
         }

         if (mTempPid != -1 && mTempPid != logMessage.data.pid) {
            return false;
         }

         if (mTempTag != null && mTempTag.length() > 0) {
             if (mTempTag.equals(logMessage.data.tag) == false) {
                 return false;
             }
         }

         return true;
     }

     /**
      * Takes all the accepted messages and display them.
      * This must be called from a UI thread.
      */
     @UiThread
     public void flush() {
         // if scroll bar is at the bottom, we will scroll
         ScrollBar bar = mTable.getVerticalBar();
         boolean scroll = bar.getMaximum() == bar.getSelection() + bar.getThumb();

         // if we are not going to scroll, get the current first item being shown.
         int topIndex = mTable.getTopIndex();

         // disable drawing
         mTable.setRedraw(false);

         int totalCount = mNewMessages.size();

         try {
             // remove the items of the old messages.
             for (int i = 0 ; i < mRemovedMessageCount && mTable.getItemCount() > 0 ; i++) {
                 mTable.remove(0);
             }

             if (mUnreadCount > mTable.getItemCount()) {
                 mUnreadCount = mTable.getItemCount();
             }

             // add the new items
             for (int i = 0  ; i < totalCount ; i++) {
                 LogMessage msg = mNewMessages.get(i);
                 addTableItem(msg);
             }
         } catch (SWTException e) {
             // log the error and keep going. Content of the logcat table maybe unexpected
             // but at least ddms won't crash.
             Log.e("LogFilter", e);
         }

         // redraw
         mTable.setRedraw(true);

         // scroll if needed, by showing the last item
         if (scroll) {
             totalCount = mTable.getItemCount();
             if (totalCount > 0) {
                 mTable.showItem(mTable.getItem(totalCount-1));
             }
         } else if (mRemovedMessageCount > 0) {
             // we need to make sure the topIndex is still visible.
             // Because really old items are removed from the list, this could make it disappear
             // if we don't change the scroll value at all.

             topIndex -= mRemovedMessageCount;
             if (topIndex < 0) {
                 // looks like it disappeared. Lets just show the first item
                 mTable.showItem(mTable.getItem(0));
             } else {
                 mTable.showItem(mTable.getItem(topIndex));
             }
         }

         // if this filter is not the current one, we update the tab text
         // with the amount of unread message
         if (mIsCurrentTabItem == false) {
             mUnreadCount += mNewMessages.size();
             totalCount = mTable.getItemCount();
             if (mUnreadCount > 0) {
                 mTabItem.setText(mName + " (" // $NON-NLS-1$
                         + (mUnreadCount > totalCount ? totalCount : mUnreadCount)
                         + ")");  // $NON-NLS-1$
             } else {
                 mTabItem.setText(mName);  // $NON-NLS-1$
             }
         }

         mNewMessages.clear();
     }

     void setColors(LogColors colors) {
         mColors = colors;
     }

     int getUnreadCount() {
         return mUnreadCount;
     }

     void setUnreadCount(int unreadCount) {
         mUnreadCount = unreadCount;
     }

     void setSupportsDelete(boolean support) {
         mSupportsDelete = support;
     }

     void setSupportsEdit(boolean support) {
         mSupportsEdit = support;
     }

     void setTempKeywordFiltering(String[] segments) {
         mTempKeywordFilters = segments;
         mTempFilteringStatus = true;
     }

     void setTempPidFiltering(int pid) {
         mTempPid = pid;
         mTempFilteringStatus = true;
     }

     void setTempTagFiltering(String tag) {
         mTempTag = tag;
         mTempFilteringStatus = true;
     }

     void resetTempFiltering() {
         if (mTempPid != -1 || mTempTag != null || mTempKeywordFilters != null) {
             mTempFilteringStatus = true;
         }

         mTempPid = -1;
         mTempTag = null;
         mTempKeywordFilters = null;
     }

     void resetTempFilteringStatus() {
         mTempFilteringStatus = false;
     }

     boolean getTempFilterStatus() {
         return mTempFilteringStatus;
     }


     /**
      * Add a TableItem for the index-th item of the buffer
      * @param filter The index of the table in which to insert the item.
      */
     private void addTableItem(LogMessage msg) {
         TableItem item = new TableItem(mTable, SWT.NONE);
         item.setText(0, msg.data.time);
         item.setText(1, new String(new char[] { msg.data.logLevel.getPriorityLetter() }));
         item.setText(2, msg.data.pidString);
         item.setText(3, msg.data.tag);
         item.setText(4, msg.msg);

         // add the buffer index as data
         item.setData(msg);

         if (msg.data.logLevel == LogLevel.INFO) {
             item.setForeground(mColors.infoColor);
         } else if (msg.data.logLevel == LogLevel.DEBUG) {
             item.setForeground(mColors.debugColor);
         } else if (msg.data.logLevel == LogLevel.ERROR) {
             item.setForeground(mColors.errorColor);
         } else if (msg.data.logLevel == LogLevel.WARN) {
             item.setForeground(mColors.warningColor);
         } else {
             item.setForeground(mColors.verboseColor);
         }
     }
 }
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.ddmuilib.logcat;

	import com.android.ddmlib.Log;
	import com.android.ddmlib.Log.LogLevel;
	import com.android.ddmuilib.annotation.UiThread;
	import com.android.ddmuilib.logcat.LogPanel.LogMessage;

	import org.eclipse.swt.SWT;
	import org.eclipse.swt.SWTException;
	import org.eclipse.swt.widgets.ScrollBar;
	import org.eclipse.swt.widgets.TabItem;
	import org.eclipse.swt.widgets.Table;
	import org.eclipse.swt.widgets.TableItem;

	import java.util.ArrayList;
	import java.util.regex.PatternSyntaxException;

	/** logcat output filter class */
	public class LogFilter {

	public final static int MODE_PID = 0x01;
	public final static int MODE_TAG = 0x02;
	public final static int MODE_LEVEL = 0x04;

	private String mName;

	/**
	* Filtering mode. Value can be a mix of MODE_PID, MODE_TAG, MODE_LEVEL
	*/
	private int mMode = 0;

	/**
	* pid used for filtering. Only valid if mMode is MODE_PID.
	*/
	private int mPid;

	/** Single level log level as defined in Log.mLevelChar. Only valid
	* if mMode is MODE_LEVEL */
	private int mLogLevel;

	/**
	* log tag filtering. Only valid if mMode is MODE_TAG
	*/
	private String mTag;

	private Table mTable;
	private TabItem mTabItem;
	private boolean mIsCurrentTabItem = false;
	private int mUnreadCount = 0;

	/** Temp keyword filtering */
	private String[] mTempKeywordFilters;

	/** temp pid filtering */
	private int mTempPid = -1;

	/** temp tag filtering */
	private String mTempTag;

	/** temp log level filtering */
	private int mTempLogLevel = -1;

	private LogColors mColors;

	private boolean mTempFilteringStatus = false;

	private final ArrayList<LogMessage> mMessages = new ArrayList<LogMessage>();
	private final ArrayList<LogMessage> mNewMessages = new ArrayList<LogMessage>();

	private boolean mSupportsDelete = true;
	private boolean mSupportsEdit = true;
	private int mRemovedMessageCount = 0;

	/**
	* Creates a filter with a particular mode.
	* @param name The name to be displayed in the UI
	*/
	public LogFilter(String name) {
	mName = name;
	}

	public LogFilter() {

	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder(mName);

	sb.append(':');
	sb.append(mMode);
	if ((mMode & MODE_PID) == MODE_PID) {
	sb.append(':');
	sb.append(mPid);
	}

	if ((mMode & MODE_LEVEL) == MODE_LEVEL) {
	sb.append(':');
	sb.append(mLogLevel);
	}

	if ((mMode & MODE_TAG) == MODE_TAG) {
	sb.append(':');
	sb.append(mTag);
	}

	return sb.toString();
	}

	public boolean loadFromString(String string) {
	String[] segments = string.split(":"); // $NON-NLS-1$
	int index = 0;

	// get the name
	mName = segments[index++];

	// get the mode
	mMode = Integer.parseInt(segments[index++]);

	if ((mMode & MODE_PID) == MODE_PID) {
	mPid = Integer.parseInt(segments[index++]);
	}

	if ((mMode & MODE_LEVEL) == MODE_LEVEL) {
	mLogLevel = Integer.parseInt(segments[index++]);
	}

	if ((mMode & MODE_TAG) == MODE_TAG) {
	mTag = segments[index++];
	}

	return true;
	}


	/** Sets the name of the filter. */
	void setName(String name) {
	mName = name;
	}

	/**
	* Returns the UI display name.
	*/
	public String getName() {
	return mName;
	}

	/**
	* Set the Table ui widget associated with this filter.
	* @param tabItem The item in the TabFolder
	* @param table The Table object
	*/
	public void setWidgets(TabItem tabItem, Table table) {
	mTable = table;
	mTabItem = tabItem;
	}

	/**
	* Returns true if the filter is ready for ui.
	*/
	public boolean uiReady() {
	return (mTable != null && mTabItem != null);
	}

	/**
	* Returns the UI table object.
	* @return
	*/
	public Table getTable() {
	return mTable;
	}

	public void dispose() {
	mTable.dispose();
	mTabItem.dispose();
	mTable = null;
	mTabItem = null;
	}

	/**
	* Resets the filtering mode to be 0 (i.e. no filter).
	*/
	public void resetFilteringMode() {
	mMode = 0;
	}

	/**
	* Returns the current filtering mode.
	* @return A bitmask. Possible values are MODE_PID, MODE_TAG, MODE_LEVEL
	*/
	public int getFilteringMode() {
	return mMode;
	}

	/**
	* Adds PID to the current filtering mode.
	* @param pid
	*/
	public void setPidMode(int pid) {
	if (pid != -1) {
	mMode \|= MODE_PID;
	} else {
	mMode &= ~MODE_PID;
	}
	mPid = pid;
	}

	/** Returns the pid filter if valid, otherwise -1 */
	public int getPidFilter() {
	if ((mMode & MODE_PID) == MODE_PID)
	return mPid;
	return -1;
	}

	public void setTagMode(String tag) {
	if (tag != null && tag.length() > 0) {
	mMode \|= MODE_TAG;
	} else {
	mMode &= ~MODE_TAG;
	}
	mTag = tag;
	}

	public String getTagFilter() {
	if ((mMode & MODE_TAG) == MODE_TAG)
	return mTag;
	return null;
	}

	public void setLogLevel(int level) {
	if (level == -1) {
	mMode &= ~MODE_LEVEL;
	} else {
	mMode \|= MODE_LEVEL;
	mLogLevel = level;
	}

	}

	public int getLogLevel() {
	if ((mMode & MODE_LEVEL) == MODE_LEVEL) {
	return mLogLevel;
	}

	return -1;
	}


	public boolean supportsDelete() {
	return mSupportsDelete ;
	}

	public boolean supportsEdit() {
	return mSupportsEdit;
	}

	/**
	* Sets the selected state of the filter.
	* @param selected selection state.
	*/
	public void setSelectedState(boolean selected) {
	if (selected) {
	if (mTabItem != null) {
	mTabItem.setText(mName);
	}
	mUnreadCount = 0;
	}
	mIsCurrentTabItem = selected;
	}

	/**
	* Adds a new message and optionally removes an old message.
	* <p/>The new message is filtered through {@link #accept(LogMessage)}.
	* Calls to {@link #flush()} from a UI thread will display it (and other
	* pending messages) to the associated {@link Table}.
	* @param logMessage the MessageData object to filter
	* @return true if the message was accepted.
	*/
	public boolean addMessage(LogMessage newMessage, LogMessage oldMessage) {
	synchronized (mMessages) {
	if (oldMessage != null) {
	int index = mMessages.indexOf(oldMessage);
	if (index != -1) {
	// TODO check that index will always be -1 or 0, as only the oldest message is ever removed.
	mMessages.remove(index);
	mRemovedMessageCount++;
	}

	// now we look for it in mNewMessages. This can happen if the new message is added
	// and then removed because too many messages are added between calls to #flush()
	index = mNewMessages.indexOf(oldMessage);
	if (index != -1) {
	// TODO check that index will always be -1 or 0, as only the oldest message is ever removed.
	mNewMessages.remove(index);
	}
	}

	boolean filter = accept(newMessage);

	if (filter) {
	// at this point the message is accepted, we add it to the list
	mMessages.add(newMessage);
	mNewMessages.add(newMessage);
	}

	return filter;
	}
	}

	/**
	* Removes all the items in the filter and its {@link Table}.
	*/
	public void clear() {
	mRemovedMessageCount = 0;
	mNewMessages.clear();
	mMessages.clear();
	mTable.removeAll();
	}

	/**
	* Filters a message.
	* @param logMessage the Message
	* @return true if the message is accepted by the filter.
	*/
	boolean accept(LogMessage logMessage) {
	// do the regular filtering now
	if ((mMode & MODE_PID) == MODE_PID && mPid != logMessage.data.pid) {
	return false;
	}

	if ((mMode & MODE_TAG) == MODE_TAG && (
	logMessage.data.tag == null \|\|
	logMessage.data.tag.equals(mTag) == false)) {
	return false;
	}

	int msgLogLevel = logMessage.data.logLevel.getPriority();

	// test the temp log filtering first, as it replaces the old one
	if (mTempLogLevel != -1) {
	if (mTempLogLevel > msgLogLevel) {
	return false;
	}
	} else if ((mMode & MODE_LEVEL) == MODE_LEVEL &&
	mLogLevel > msgLogLevel) {
	return false;
	}

	// do the temp filtering now.
	if (mTempKeywordFilters != null) {
	String msg = logMessage.msg;

	for (String kw : mTempKeywordFilters) {
	try {
	if (msg.contains(kw) == false && msg.matches(kw) == false) {
	return false;
	}
	} catch (PatternSyntaxException e) {
	// if the string is not a valid regular expression,
	// this exception is thrown.
	return false;
	}
	}
	}

	if (mTempPid != -1 && mTempPid != logMessage.data.pid) {
	return false;
	}

	if (mTempTag != null && mTempTag.length() > 0) {
	if (mTempTag.equals(logMessage.data.tag) == false) {
	return false;
	}
	}

	return true;
	}

	/**
	* Takes all the accepted messages and display them.
	* This must be called from a UI thread.
	*/
	@UiThread
	public void flush() {
	// if scroll bar is at the bottom, we will scroll
	ScrollBar bar = mTable.getVerticalBar();
	boolean scroll = bar.getMaximum() == bar.getSelection() + bar.getThumb();

	// if we are not going to scroll, get the current first item being shown.
	int topIndex = mTable.getTopIndex();

	// disable drawing
	mTable.setRedraw(false);

	int totalCount = mNewMessages.size();

	try {
	// remove the items of the old messages.
	for (int i = 0 ; i < mRemovedMessageCount && mTable.getItemCount() > 0 ; i++) {
	mTable.remove(0);
	}

	if (mUnreadCount > mTable.getItemCount()) {
	mUnreadCount = mTable.getItemCount();
	}

	// add the new items
	for (int i = 0 ; i < totalCount ; i++) {
	LogMessage msg = mNewMessages.get(i);
	addTableItem(msg);
	}
	} catch (SWTException e) {
	// log the error and keep going. Content of the logcat table maybe unexpected
	// but at least ddms won't crash.
	Log.e("LogFilter", e);
	}

	// redraw
	mTable.setRedraw(true);

	// scroll if needed, by showing the last item
	if (scroll) {
	totalCount = mTable.getItemCount();
	if (totalCount > 0) {
	mTable.showItem(mTable.getItem(totalCount-1));
	}
	} else if (mRemovedMessageCount > 0) {
	// we need to make sure the topIndex is still visible.
	// Because really old items are removed from the list, this could make it disappear
	// if we don't change the scroll value at all.

	topIndex -= mRemovedMessageCount;
	if (topIndex < 0) {
	// looks like it disappeared. Lets just show the first item
	mTable.showItem(mTable.getItem(0));
	} else {
	mTable.showItem(mTable.getItem(topIndex));
	}
	}

	// if this filter is not the current one, we update the tab text
	// with the amount of unread message
	if (mIsCurrentTabItem == false) {
	mUnreadCount += mNewMessages.size();
	totalCount = mTable.getItemCount();
	if (mUnreadCount > 0) {
	mTabItem.setText(mName + " (" // $NON-NLS-1$
	+ (mUnreadCount > totalCount ? totalCount : mUnreadCount)
	+ ")"); // $NON-NLS-1$
	} else {
	mTabItem.setText(mName); // $NON-NLS-1$
	}
	}

	mNewMessages.clear();
	}

	void setColors(LogColors colors) {
	mColors = colors;
	}

	int getUnreadCount() {
	return mUnreadCount;
	}

	void setUnreadCount(int unreadCount) {
	mUnreadCount = unreadCount;
	}

	void setSupportsDelete(boolean support) {
	mSupportsDelete = support;
	}

	void setSupportsEdit(boolean support) {
	mSupportsEdit = support;
	}

	void setTempKeywordFiltering(String[] segments) {
	mTempKeywordFilters = segments;
	mTempFilteringStatus = true;
	}

	void setTempPidFiltering(int pid) {
	mTempPid = pid;
	mTempFilteringStatus = true;
	}

	void setTempTagFiltering(String tag) {
	mTempTag = tag;
	mTempFilteringStatus = true;
	}

	void resetTempFiltering() {
	if (mTempPid != -1 \|\| mTempTag != null \|\| mTempKeywordFilters != null) {
	mTempFilteringStatus = true;
	}

	mTempPid = -1;
	mTempTag = null;
	mTempKeywordFilters = null;
	}

	void resetTempFilteringStatus() {
	mTempFilteringStatus = false;
	}

	boolean getTempFilterStatus() {
	return mTempFilteringStatus;
	}


	/**
	* Add a TableItem for the index-th item of the buffer
	* @param filter The index of the table in which to insert the item.
	*/
	private void addTableItem(LogMessage msg) {
	TableItem item = new TableItem(mTable, SWT.NONE);
	item.setText(0, msg.data.time);
	item.setText(1, new String(new char[] { msg.data.logLevel.getPriorityLetter() }));
	item.setText(2, msg.data.pidString);
	item.setText(3, msg.data.tag);
	item.setText(4, msg.msg);

	// add the buffer index as data
	item.setData(msg);

	if (msg.data.logLevel == LogLevel.INFO) {
	item.setForeground(mColors.infoColor);
	} else if (msg.data.logLevel == LogLevel.DEBUG) {
	item.setForeground(mColors.debugColor);
	} else if (msg.data.logLevel == LogLevel.ERROR) {
	item.setForeground(mColors.errorColor);
	} else if (msg.data.logLevel == LogLevel.WARN) {
	item.setForeground(mColors.warningColor);
	} else {
	item.setForeground(mColors.verboseColor);
	}
	}
	}