Attachment #22100 for bug #81795

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.adapters;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.team.bugzilla.BugzillaImages;
import org.eclipse.team.bugzilla.browser.IWebContentAdapter;
import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
import org.eclipse.team.bugzilla.model.BugzillaAttachment;
import org.eclipse.team.bugzilla.view.BugzillaModelPresenter;
import org.eclipse.team.bugzilla.view.IPresentableAdapter;

/**
 * 
 */
public class BugzillaAttachmentAdapter extends ModelElementAdapter implements IPresentableAdapter, IWebContentAdapter {

    public BugzillaAttachmentAdapter() {
        super();
    }

    public void present(Object presentable, StyledText styledText) {

        if (!(presentable instanceof BugzillaAttachment)) 
            return;
        
        new BugzillaModelPresenter().present((BugzillaAttachment)presentable, styledText);
    }

    protected ImageDescriptor doGetImageDescriptor(Object object) {
        final BugzillaAttachment attachment= (BugzillaAttachment)object;
        return attachment.getData() != null ? BugzillaImages.ATTACHMENT: BugzillaImages.INCOMPLETE_ATTACHMENT;
    }

    public String getLabel(Object o) {
        final BugzillaAttachment attachment= (BugzillaAttachment)o;
        return attachment.isRefreshing() ? getRefreshingLabel("attachment " + attachment.getID()) : getStandardLabel(attachment); 
    }

    /**
     * @param attachment
     * @return String
     */
    private String getStandardLabel(final BugzillaAttachment attachment) {
        final StringBuffer label= new StringBuffer();
        
        if (attachment.getDescription().getBoolean(AttachmentDescription.OBSOLETE)) 
            label.append("[OBSOLETE]  ");
        
        label.append("[").append(attachment.getDescription().getString(AttachmentDescription.ID)).append("]  ");
        
        if (attachment.hasLocalContent())
            label.append(attachment.getDescription().getString(AttachmentDescription.DESCRIPTION));
        
        return label.toString();
    }

    public String getURL(Object o) {
        return null;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.team.bugzilla.adapters.ModelElementAdapter#getFont(java.lang.Object)
     */
    public FontData getFont(Object element) {
        final BugzillaAttachment attachment= (BugzillaAttachment)element;
        if (attachment.isRefreshing())
            return getRefreshingFont();
        return super.getFont(element);
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.adapters;


/**
 * 
 */
public class BugzillaFolderAdapter extends ContainerAdapter /*implements IPresentableAdapter*/ {
   
    public BugzillaFolderAdapter() {
    }
    /*
    public void present(Object presentable, StyledText styledText) {
    	
    	if (!(presentable instanceof BugzillaFolder)) 
            return;
    	
        new BugzillaModelPresenter().present((BugzillaFolder)presentable, styledText);
     }
     */
}
        new BugzillaModelPresenter().present((BugzillaFolder)presentable, styledText);
     }
     */
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.bugzilla.adapters;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.team.bugzilla.BugzillaImages;
import org.eclipse.team.bugzilla.browser.IWebContentAdapter;
import org.eclipse.team.bugzilla.model.BugzillaQuery;
import org.eclipse.team.bugzilla.view.BugzillaModelPresenter;
import org.eclipse.team.bugzilla.view.IPresentableAdapter;

public class BugzillaQueryAdapter extends ContainerAdapter implements IWebContentAdapter, IPresentableAdapter {

    /* (non-Javadoc)
     * @see org.eclipse.ui.model.IWorkbenchAdapter#getImageDescriptor(java.lang.Object)
     */
    protected ImageDescriptor doGetImageDescriptor(Object object) {
        return BugzillaImages.QUERY;
    }

    /* (non-Javadoc)
     * @see org.eclipse.team.bugzilla.browser.IWebContentAdapter#getURL(java.lang.Object)
     */
    public String getURL(Object o) {
        if (o instanceof BugzillaQuery) {
            return ((BugzillaQuery)o).getQueryUrl().toUrlString();
        }
        return null;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.team.bugzilla.adapters.ContainerAdapter#getLabel(java.lang.Object)
     */
    public String getLabel(Object o) {
       final BugzillaQuery query= (BugzillaQuery)o;
       return query.isRefreshing() ? getRefreshingLabel("query " + query.getName()) : getStandardLabel(query);
    }

    /**
     * @param query
     * @return String
     */
    private String getStandardLabel(final BugzillaQuery query) {
        final StringBuffer label= new StringBuffer();
           if (query.hasLocalContent()) {
               label.append("(");
               final int size= query.getChildren().length;
               label.append(size).append(size == 1 ? " result" : " results").append(") ");
           }
           return label.append(query.getName()).toString();
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.team.bugzilla.adapters.ModelElementAdapter#getFont(java.lang.Object)
     */
    public FontData getFont(Object element) {
        final BugzillaQuery query= (BugzillaQuery)element;
        if (query.isRefreshing())
            return getRefreshingFont();
        return super.getFont(element);
    }
    
    public void present(Object presentable, StyledText styledText) {
    	
    	if (!(presentable instanceof BugzillaQuery)) 
            return;
    	
    	new BugzillaModelPresenter().present((BugzillaQuery)presentable, styledText);
     }
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.adapters;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.RGB;
import org.eclipse.team.bugzilla.BugzillaImages;
import org.eclipse.team.bugzilla.browser.IWebContentAdapter;
import org.eclipse.team.bugzilla.datatypes.ReportData;
import org.eclipse.team.bugzilla.model.BugzillaProvider;
import org.eclipse.team.bugzilla.model.BugzillaReport;
import org.eclipse.team.bugzilla.operations.CachedOperations;
import org.eclipse.team.bugzilla.view.BugzillaModelPresenter;
import org.eclipse.team.bugzilla.view.IPresentableAdapter;

/**
 * 
 */
public class BugzillaReportAdapter extends ModelElementAdapter implements IPresentableAdapter, IWebContentAdapter {


    public void present(Object presentable, StyledText styledText) {

        if (!(presentable instanceof BugzillaReport)) 
            return;
        
        new BugzillaModelPresenter().present((BugzillaReport)presentable, styledText);
    }

    public Object[] getChildren(Object o) {
        return ((BugzillaReport)o).getComments().toArray();
    }

    protected ImageDescriptor doGetImageDescriptor(Object object) {
        final BugzillaReport report= (BugzillaReport)object;
        final ReportData data= report.getReportData();
        return data != null ? BugzillaImages.BUG : BugzillaImages.INCOMPLETE_BUG;
    }

    public String getLabel(Object o) {
        final BugzillaReport report= (BugzillaReport)o;
        return report.isRefreshing() ? getRefreshingLabel("bug " + report.getID()) : getStandardLabel(report);
    }
    
    /**
     * @param report
     * @return String
     */
    private String getStandardLabel(final BugzillaReport report) {
        final StringBuffer name= new StringBuffer();
        name.append(report.getID());
        
        final ReportData data= report.getReportData();
        
        if (data != null) {
            final String priority= data.getString(ReportData.PRIORITY);
            final String status= data.getString(ReportData.STATUS);
            final String milestone= data.getString(ReportData.TARGETMILESTONE);
            final String title= data.getString(ReportData.TITLE);
            
            name.append(" [");
            if (priority != null) name.append(priority);
            if (status != null) name.append(" ").append(status);
            if (milestone != null) name.append(" ").append(milestone);
            name.append("]");
            if (title != null) name.append(" ").append(title);
        }
        return name.toString();
    }

    public String getURL(Object o) {
        final BugzillaReport report= (BugzillaReport)o;
        final BugzillaProvider provider= (BugzillaProvider)report.getProvider();
        final CachedOperations operations= provider.getOperations();
        if (operations.isCached()) {
            return operations.getOperations().getReportURL(provider.getConfiguration(), report.getID());
        }
        return null;
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.model.IWorkbenchAdapter2#getForeground(java.lang.Object)
     */
    public RGB getForeground(Object element) {
        final ReportData data= ((BugzillaReport)element).getReportData();
        
        if (data == null)
            return super.getForeground(element);
        
        final String severity= data.getString(ReportData.SEVERITY);
        
        if ("blocker".equals(severity) || "critical".equals(severity)) {
            return RED;
        }
        return super.getForeground(element);
    }

    /* (non-Javadoc)
     * @see org.eclipse.ui.model.IWorkbenchAdapter2#getFont(java.lang.Object)
     */
    public FontData getFont(Object element) {
        
        final BugzillaReport report= (BugzillaReport)element;
        if (report.isRefreshing())
            return getRefreshingFont();
        
        final ReportData data= report.getReportData();
        
        if (data == null)
            return super.getFont(element);

        final String severity= data.getString(ReportData.SEVERITY);
        
        if ("enhancement".equals(severity)) {
            return ITALIC_FONT;
        }
        
        if ("blocker".equals(severity)) {
            return BOLD_FONT;
        }
        
        return super.getFont(element);
    }
    
}
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.bugzilla.datatypes;

import org.eclipse.team.bugzilla.BugzillaFactory;



public class BugzillaConfiguration {
    
    private String fName;
    private String fBaseURL;
    private String fCookie;
    private int version;
    
    public BugzillaConfiguration(String name, String baseURL) {
        fName= name;
        fBaseURL= baseURL;
        version = BugzillaFactory.VERSION_UNKNOWN;
    }
    
    public void setBaseURL(String baseURL) {
        fBaseURL = baseURL;
    }
    
    public String getBaseURL() {
        return fBaseURL;
    }
    
    public String getName() {
        return fName;
    }
    
    public void setName(String name) {
        fName = name;
    }

    public void setLoginCookie(String cookie) {
        this.fCookie = cookie;
    }

    public String getLoginCookie() {
        return fCookie;
    }
    
    
	public int getVersion() {
		return version;
	}
	
	public void setVersion(int version) {
		this.version = version;
	}
}
	}
	
	public void setVersion(int version) {
		this.version = version;
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.datatypes;

import java.util.Collection;
import java.util.LinkedHashSet;



public class CommentData extends Data implements Comparable {
    
    public final static String AUTHOR= "0";
    public final static String DATE= "1";
    public final static String TEXT= "2";
    
    private final static LinkedHashSet sSet;
    
    static {
        sSet= new LinkedHashSet();
        sSet.add(AUTHOR);
        sSet.add(DATE);
        sSet.add(TEXT);
    }
    
    public AttachmentDescription attachmentDesc;
    
    public CommentData() {
        attachmentDesc= null;
    }
    
    public String toString() {
        final StringBuffer buffer= new StringBuffer();
        final String nl= System.getProperty("line.separator"); //$NON-NLS-1$
        buffer.append("Author: ").append(getString(AUTHOR)).append(nl); //$NON-NLS-1$
        buffer.append("Date: ").append(getString(DATE)).append(nl); //$NON-NLS-1$
        buffer.append("Text: ").append(getString(TEXT)).append(nl); //$NON-NLS-1$
        return buffer.toString();
    }

    public int compareTo(Object o) {
        return getDate(DATE).compareTo(((CommentData)o).getDate(DATE));
    }

    public boolean equals(Object obj) {
        if (!(obj instanceof CommentData))
            return false;
        final CommentData other = (CommentData)obj;
        return getString(TEXT).equals(other.getString(TEXT)) && getString(AUTHOR).equals(other.getString(AUTHOR)) && getDate(DATE).equals(other.getDate(DATE)); 
    }

    protected Collection getKeys() {
        return sSet;
    }

    public String getId() {
        return getDate(DATE).toString();
    }
}
        return getDate(DATE).toString();
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.datatypes;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.HashMap;

/**
 * 
 */
public abstract class Data {
    
    private final static DateFormat sDateFormat= new SimpleDateFormat("yyyy-MM-dd HH:mm"); //$NON-NLS-1$
    
    private final HashMap fValues;
    private final HashMap fChangedValues;

    public Data() {
        fValues= new HashMap();
        fChangedValues= new HashMap();
    }

    public void set(String key, String value) {
        if (!getKeys().contains(key))
            return;
        
        final String oldValue= (String)fValues.get(key);
        if (oldValue == null) {
            fValues.put(key, value);
            fChangedValues.remove(key);
        } else if (!oldValue.equals(value)) {
            fChangedValues.put(key, value);
        }
    }

    public void set(String key, Date date) {
        set(key, sDateFormat.format(date));
    }
    
    public void set(String key, boolean state) {
        set(key, Boolean.valueOf(state).toString());
    }
    
    public String getString(String key) {
        if (fChangedValues.containsKey(key))
            return (String)fChangedValues.get(key);
        return (String)fValues.get(key);
    }
    
    public Date getDate(String key) {
        try {
            return sDateFormat.parse((String)fValues.get(key));
        } catch (ParseException e) {
            return null; // should not happen!
        }
    }
    
    public boolean getBoolean(String key) {
        return Boolean.valueOf(getString(key)).booleanValue();
    }
    
    public boolean hasChanged(String key) {
        return fChangedValues.containsKey(key);        
    }
    
    public boolean exists(String key) {
        return fValues.containsKey(key);
    }
    
    public void commitChanged() {
        fValues.putAll(fChangedValues);
    }
    
    public void commitChanged(String key) {
        if (fChangedValues.containsKey(key)) {
            fValues.put(key, fChangedValues.get(key));
        }
    }
    
    /**
     * Clients must implement this to define the set of keys which are allowed. Iteration and lookup 
     * should be fast, so a LinkedHashSet may be a good choice. 
     * @return Collection
     */
    protected abstract Collection getKeys();
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.bugzilla.datatypes;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ISafeRunnable;
import org.eclipse.core.runtime.MultiStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.util.ListenerList;
import org.eclipse.team.bugs.extension.BugsException;
import org.eclipse.team.bugzilla.BugzillaException;
import org.eclipse.team.bugzilla.BugzillaPlugin;
import org.eclipse.team.bugzilla.model.BugzillaProvider;
import org.eclipse.team.bugzilla.model.BugzillaQueryOptions;
import org.eclipse.team.bugzilla.model.IRemoteModel;
import org.eclipse.team.bugzilla.operations.RefreshOperation;

/**
 * Caches any data fetched from a bugzilla server
 */
public class DataCache {
    
    protected final BugzillaProvider fProvider; 
    private final Map fReports;
    private final Map fAttachments;
    private final Map fQueries;
    
    private final Set fReportErrors;
    private final Set fAttachmentErrors;
    private final Set fQueryErrors;
    
    private final BugzillaQueryOptions queryOptions;
    
    private ListenerList fListeners = new ListenerList();
    
    public DataCache(BugzillaProvider provider) {
        fProvider = provider;
        
        fReports= Collections.synchronizedMap(new HashMap());
        fAttachments= Collections.synchronizedMap(new HashMap());
        fQueries= Collections.synchronizedMap(new HashMap());
        
        fReportErrors= Collections.synchronizedSet(new HashSet());
        fAttachmentErrors = Collections.synchronizedSet(new HashSet());
        fQueryErrors= Collections.synchronizedSet(new HashSet());
        
        /* TODO: jpound - cache query options */
        queryOptions = new BugzillaQueryOptions(provider.getBaseURL());
    }

    /**
     * Return the cached report data for the given bug id.
     * If no data is cached, <code>null</code> is returned.
     * @param id the bug id
     * @return the cached ReportData or <code>null</code>
     */
    public ReportData getReport(String id) {
        return (ReportData)fReports.get(id);
    }

    /**
     * Return the cached attachment for the given id.
     * If no attachment is cached, <code>null</code> is returned.
     * @param desc the attachment id
     * @return the cached attachment or <code>null</code>
     */
    public AttachmentData getAttachment(AttachmentDescription desc) {
        return (AttachmentData)fAttachments.get(desc);
    }
    
    public void refreshReports(String[] reportIds, IProgressMonitor monitor) throws BugzillaException {
        List errors = new ArrayList();
        for (int i = 0; i < reportIds.length; i++) {
            String id = reportIds[i];
            try {
                ReportData data = fProvider.getOperations().getReportData(monitor, id);
                add(data);
                fReportErrors.remove(id);
            } catch (BugzillaException e) {
                errors.add(e);
                fReportErrors.add(id);
            }
        }
        fireReportDataChanged(reportIds);
        handleErrors(errors);
    }
    
    private void handleErrors(List errors) throws BugzillaException {
        if (errors.size() == 1) {
            throw (BugzillaException)errors.get(0);
        } else if (!errors.isEmpty()) {
            MultiStatus status = new MultiStatus(BugzillaPlugin.ID, 0, "Errors occured during refresh", null);
            for (Iterator iter = errors.iterator(); iter.hasNext();) {
                BugsException e = (BugsException) iter.next();
                status.add(e.getStatus());
                throw new BugzillaException(status);
            }
        }
        
    }

    public void refreshAttachments(AttachmentDescription[] descs, IProgressMonitor monitor) throws BugzillaException {
        List errors = new ArrayList();
        for (int i = 0; i < descs.length; i++) {
            AttachmentDescription desc = descs[i];
            try {
                AttachmentData data = fProvider.getOperations().getAttachment(monitor, desc);
                add(desc, data);
                fAttachmentErrors.remove(desc);
            } catch (BugzillaException e) {
                errors.add(e);
                fAttachmentErrors.add(desc);
            }
        }
        fireAttachmentDataChanged(descs);
        handleErrors(errors);
    }
    
    private void add(AttachmentDescription desc, AttachmentData data) {
        fAttachments.put(desc, data);     
    }

    private void fireAttachmentDataChanged(final AttachmentDescription[] descs) {
        Object[] allListeners = fListeners.getListeners();
        for (int i = 0; i < allListeners.length; i++) {
            final IBugRefreshListener listener = (IBugRefreshListener)allListeners[i];
            Platform.run(new ISafeRunnable() {
                public void handleException(Throwable exception) {
                }
                public void run() throws Exception {
                    listener.attachmentsChanged(fProvider, descs);
                }
            });
        }
    }

    private void fireReportDataChanged(final String[] reportIds) {
        Object[] allListeners = fListeners.getListeners();
        for (int i = 0; i < allListeners.length; i++) {
            final IBugRefreshListener listener = (IBugRefreshListener)allListeners[i];
            Platform.run(new ISafeRunnable() {
                public void handleException(Throwable exception) {
                    // Logged by Core
                }
                public void run() throws Exception {
                    listener.reportDataChange(fProvider, reportIds);
                }
            });
        }
    }

    private void add(ReportData data) {
        fReports.put(data.getString(ReportData.ID), data);
    }
    
	public void addRefreshListener(IBugRefreshListener listener) {
		fListeners.add(listener);
	}

	public void removeRefreshListener(IBugRefreshListener listener) {
		fListeners.remove(listener);
	}

    /**
     * @param datas
     * @param monitor
     */
    public void refreshQuery(QueryURL[] datas, IProgressMonitor monitor) throws BugzillaException {
        List errors = new ArrayList();
        for (int i = 0; i < datas.length; i++) {
            QueryURL url = datas[i];
            try {
                QueryData data = fProvider.getOperations().getQueryData(monitor, url);
                if (data == null) {
                	return;
                }
                add(url, data);
                fQueryErrors.remove(url);
            } catch (BugzillaException e) {
                errors.add(e);
                fQueryErrors.add(url);
            }
        }
        fireQueryChanged(datas);
        handleErrors(errors);
    }

    private void fireQueryChanged(final QueryURL[] datas) {
        Object[] allListeners = fListeners.getListeners();
        for (int i = 0; i < allListeners.length; i++) {
            final IBugRefreshListener listener = (IBugRefreshListener)allListeners[i];
            Platform.run(new ISafeRunnable() {
                public void handleException(Throwable exception) {
                    // Logged by Core
                }
                public void run() throws Exception {
                    listener.queryChange(fProvider, datas);
                }
            });
        }
    }

    private void add(QueryURL url, QueryData data) {
        fQueries.put(url, data);
        ReportData[] datas = data.getReportDatas();
        for (int i = 0; i < datas.length; i++) {
            ReportData report = datas[i];
            if (getReport(report.getString(ReportData.ID)) == null) {
                add(report);
            }
        }
    }

    public QueryData getQueryData(QueryURL queryUrl) {
        return (QueryData)fQueries.get(queryUrl);
    }
    
    public boolean hadErrorsForReport(String id) {
        return fReportErrors.contains(id);
    }
    
    public boolean hadErrorsForQuery(QueryURL url) {
        return fQueryErrors.contains(url);
    }
    
    public boolean hadErrorsForAttachment(AttachmentDescription desc) {
        return fAttachmentErrors.contains(desc);
    }
    
    /**
     * 
     * @return The query options for this bugzilla database.
     */
    public BugzillaQueryOptions getQueryOptions() {
    	return queryOptions;
    }

	/**
	 * 
	 */
	public void refreshQueryOptions() {
		try {
			new RefreshOperation(null, new IRemoteModel[] { getQueryOptions() }).run();
		} catch (InvocationTargetException e) {
			System.err.println("InvocationTargetException");
			//handleError(e);
		} catch (InterruptedException e) {
			System.err.println("InterruptedException");
			// Ignore
		}
	}
}
			// Ignore
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.bugzilla.datatypes;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

import org.eclipse.team.bugzilla.Util;


/**
 * Wrapper for a bugzilla query URL
 */
public class QueryURL extends BugzillaTransactionURL {
	
	public QueryURL(String baseUrl) {
		super(baseUrl);
		
		script = "buglist.cgi?";
		
		// initiallize default parameter settings
		addTransactionParam("format", "rdf");
		addTransactionParam("search", "Search");
	}
	
	
	/* (non-Javadoc)
	 * @see java.lang.Object#equals(java.lang.Object)
	 */
	public boolean equals(Object obj) {
		if (obj instanceof QueryURL) {
			return toUrlString().equals(((QueryURL)obj).toUrlString());
		}
		return super.equals(obj);
	}
	
	/* (non-Javadoc)
	 * @see java.lang.Object#hashCode()
	 */
	public int hashCode() {
		return toUrlString().hashCode();
	}
	
	// generate the query string (.cgi) from the parameter set
	protected String generateTransactionString() {
		
		if (url.equals("")) {
			System.err.println("BugzillaAction: No URL defined for action");
			return url;
		}
		/* A QueryURL object is being created from an already existing query url */
		int index;
		if ( (index = url.indexOf(script)) >= 0) {
			transUrl = url;
			if (transUrl.endsWith("/")) {
				transUrl = transUrl.substring(0, transUrl.lastIndexOf("/"));
			}
			url = url.substring(0, index);
			return transUrl;
		}
		
		transUrl = url + script;
		Iterator fieldIter = ((Set)params.keySet()).iterator();
		
		try {
			while (fieldIter.hasNext()) {
				String field = (String)fieldIter.next();
				Iterator paramIter = ((List)params.get(field)).iterator();
				
				while(paramIter.hasNext()) {
					String value = URLEncoder.encode((String)paramIter.next(), "UTF-8");
					transUrl += "&" + field + "=" + value;
				}
			}
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		
		return transUrl;
	}
	
	// add the specified 'param' to the list mapped to by 'field'
	public void addTransactionParam(String field, String param) {
		if (param == null) {
			return;
		}

		List parameters = (List)params.get(field);
		
		if(parameters == null) {
			parameters = new LinkedList();
			params.put(field, parameters);
		}
		
		parameters.add(param.trim());
	}
	
	// set param fields. These fields can map to ONLY 1 value.
	public void setFormatType(String type) {
		params.put("format", null);     	 	// clear any previous value
		addTransactionParam("format", type); 	// set the new value (only one value allowed for this type)
	}
	
	public void setSearchType(String type) {
		params.put("search", null);     		// clear any previous value
		addTransactionParam("search", type); 	// set the new value (only one value allowed for this type)
	}
	
	public void setShorDescType(String type) {
		params.put("short_desc_type", null);     		// clear any previous value
		addTransactionParam("short_desc_type", type); 	// set the new value (only one value allowed for this type)
	}
	
	public void setLongDescType(String type) { 
		params.put("long_desc_type", null);     		// clear any previous value
		addTransactionParam("long_desc_type", type); 	// set the new value (only one value allowed for this type)
	}
	
	public String getFormatType() {
		return (String)((List)params.get("format")).get(0);
	}
	
	public String toUrlString() {
		return (transUrl.equals("")) ? generateTransactionString() : transUrl;
	}
	
	/**
	 * Return the url that will execute the query and return XML
	 * @param configuration the configuration which identifies the bugzilla server
	 * @return the URL that executes this query
	 */
	public final String getUrl(BugzillaConfiguration configuration) {
		return getUrlString(configuration);
	}
	
	/**
	 * Build the string that is the URL to perform the query
	 * @param configuration the configuration which identifies the bugzilla server
	 * @return a String that is a valid URL
	 */
	protected String getUrlString(BugzillaConfiguration configuration) {
		String urlString = Util.appendPath(configuration.getBaseURL(), toUrlString());
		return urlString;
	}
	
	/**
	 * Returns the base url of the bugzilla database
	 * @return The base url of the bugzilla database
	 */
	public String getBaseUrl() {
		return url;
	}
	
	/**
	 * Return whether the query is a named query which requires
	 * a login.
	 * @return whether the query is a named query
	 */
	public boolean isNamedQuery() {
		return transUrl.indexOf("cmdtype=runnamed") != -1;
	}
	
	/**
	 * @return login cookie
	 */
	public String getLoginCookie() {
		// TODO Auto-generated method stub
		return null;
	}
	
	/**
	 * Return an appropriate name for the query
	 * @return an appropriate name for the query
	 */
	public String getName() {
		if (isNamedQuery()) {
			String key = "namedcmd="; //$NON-NLS-1$
			int start = transUrl.indexOf(key);
			if (start != -1) {
				start += key.length();
			}
			String name = transUrl.substring(start);
			try {
				return URLDecoder.decode(name, "UTF-8"); //$NON-NLS-1$
			} catch (UnsupportedEncodingException e) {
				// Ignore
			}
		}
		return transUrl;
	}
}
		return transUrl;
	}
}




	}
	
	/**
	 * @param group
	 * @return
	 */
	private Combo createSearchTypeCombo(Composite group) {
		Combo combo = new Combo(group, SWT.READ_ONLY);

	}
	
	/**
	 * 
	 * @param group
	 * @return
	 */
	private List createList(Composite group) {
		GridData smallVertData = new GridData(SWT.FILL, SWT.FILL, true, true);




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.model;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.team.bugzilla.BugzillaException;

/**
 * A generic model element container
 */
public abstract class BugzillaContainer extends BugzillaModel {

    private Map fChildren;
    
    public BugzillaContainer() {
        super();
        fChildren= new LinkedHashMap();
    }

    public BugzillaModel[] getChildren() {
        return (BugzillaModel[]) fChildren.values().toArray(new BugzillaModel[fChildren.size()]);
    }
    
    /**
     * Add a child to this container and set the child's path correctly. If this
     * container already contains a child with the same ID, the existing child
     * is removed and replaced by the new one. This method assumes that
     * <code>isReadOnly()</code> has been checked before, if applicable, and
     * thus inserts new children regardless of this property. A <code>childAdded</code> event
     * is fired after the child has been inserted.
     * 
     * @param children The children to be added.
     */
    public void addChildren(BugzillaModel [] children) {
        
        if (children.length == 0)
            return;
        
        final List existing= new ArrayList();
        for (int i = 0; i < children.length; i++) {
            final BugzillaModel child= children[i];
            if (contains(child)) {
                existing.add(fChildren.get(child.getID()));
            }
        }
        removeChildren((BugzillaModel [])existing.toArray(new BugzillaModel [existing.size()]));
        
        for (int i = 0; i < children.length; i++) {
            final BugzillaModel child= children[i];
            child.setParent(this);
            fChildren.put(child.getID(), child);
        }
        fireChildrenAdded(children);
    }
    
    public boolean contains(String id) {
        return fChildren.containsKey(id);
    }
    
    public boolean contains(BugzillaModel child) {
        return contains(child.getID()) && getChild(child.getID()) == child;
    }

    /**
     * Remove a child from this container. The child's parent is set to null
     * and a <code>childRemoved</code> event is fired.
     * @param children The childrem to be removed.
     */
    public void removeChildren(BugzillaModel [] children) {
        
        if (children.length == 0)
            return;
        
        final List removed= new ArrayList();
        for (int i = 0; i < children.length; i++) {
            final BugzillaModel child = children[i];
            if (!contains(child)) 
                continue;
            fChildren.remove(child.getID());
            child.setParent(null);
            removed.add(child);
        }
        fireChildrenRemoved((BugzillaModel [])removed.toArray(new BugzillaModel [removed.size()]));
    }
    
    public void setRefreshing(boolean refreshing) {
        if (isRefreshing() == refreshing) 
            return;
        super.setRefreshing(refreshing);
        setChildrenRefreshing(refreshing);
    }
    
    /**
     * @param refreshing
     */
    protected void setChildrenRefreshing(boolean refreshing) {
        for (final Iterator iter = fChildren.values().iterator(); iter.hasNext();) {
            ((BugzillaModel)iter.next()).setRefreshing(refreshing);
        }
    }

    public boolean hasParent(Object candiate) {
        
        final BugzillaContainer parent= (BugzillaContainer)getParent();
        if (parent == null)
            return false;
                
        return this == candiate || parent.hasParent(candiate);
    }
    
    public void accept(IBugzillaModelVisitor visitor) throws BugzillaException {
        if (visitor.visit(this)) {
            BugzillaModel[] children = getChildren();
            for (int i = 0; i < children.length; i++) {
                BugzillaModel model = children[i];
                model.accept(visitor);
            }
        }
    }

    /**
     * Get the name of the container as it would appear in any lists or trees.
     * This name is used to ensure a unique name within a parent container.
     * @return the name of the container
     */
    public abstract String getName();
  
    /**
     * Return the child with the given id or <code>null</code>
     * if one does not exist.
     * @param id the id of a child
     * @return the child with the given id or <code>null</code>
     */
    public BugzillaModel getChild(String id) {
        return (BugzillaModel)fChildren.get(id);
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.team.bugzilla.model.BugzillaModel#resetPath()
     */
    protected void resetPath() {
        super.resetPath();
        for (Iterator iter = fChildren.values().iterator(); iter.hasNext();) {
            final BugzillaModel child = (BugzillaModel) iter.next();
            child.resetPath();
        }
    }
    
    /**
     * This method indicates whether a user should be able to add or delete any children
     * of this container.
     * @return True if a user can modify the children, false otherwise.
     */
    public abstract boolean canModifyChildren();
}

Lines 187-197 Link Here

(-)src/org/eclipse/team/bugzilla/model/BugzillaQueryOptions.java (-2 / +2 lines)
187		187
188	private static final String URL_SUFFIX_QUERY = "query.cgi?format=advanced";	188	private static final String URL_SUFFIX_QUERY = "query.cgi?format=advanced";
189	private static final String URL_SUFFIX_KEYWORDS = "describekeywords.cgi?";	189	private static final String URL_SUFFIX_KEYWORDS = "describekeywords.cgi?";
190	private BugzillaQueryOptions queryOption;	190	//private BugzillaQueryOptions queryOption;
191		191
192	public BugzillaQueryOptionParser(BugzillaQueryOptions qo, String queryPage) {	192	public BugzillaQueryOptionParser(BugzillaQueryOptions qo, String queryPage) {
193	setUrl(queryPage);	193	setUrl(queryPage);
194	queryOption = qo;	194	//queryOption = qo;
195	}	195	}
196		196
197	public void setUrl(String queryPage) {	197	public void setUrl(String queryPage) {




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.model;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.bugs.model.IGenericModel;
import org.eclipse.team.bugzilla.BugzillaException;


/**
 * An interface for elements which have remote content.
 */
public interface IRemoteModel extends IGenericModel {
    
    /**
     * Re-fetch data from the BTS.
     * 
     * @param monitor a progress monitor
     */
	public void refresh(IProgressMonitor monitor) throws BugzillaException;

	/**
	 * Update this element with the new data.
	 */
	public void update();
	
	
	public boolean needsRefresh();

}
}




/*******************************************************************************
 * Copyright (c) 2000, 2003 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.team.bugzilla.operations;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.team.bugzilla.BugzillaException;
import org.eclipse.team.bugzilla.BugzillaFactory;
import org.eclipse.team.bugzilla.datatypes.AttachmentData;
import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
import org.eclipse.team.bugzilla.datatypes.BugzillaConfiguration;
import org.eclipse.team.bugzilla.datatypes.QueryData;
import org.eclipse.team.bugzilla.datatypes.QueryURL;
import org.eclipse.team.bugzilla.datatypes.ReportData;
import org.eclipse.team.bugzilla.xml.Parser;
import org.eclipse.team.bugzilla.xml.VersionHandler;


public abstract class BugzillaOperations {

	protected static String bugScript; /* TODO: jpound - part of redirect workaround for gcj */
	//TODO:private static final String BAD_XML_HEADER = "<?xml version=\"1.0\" ?>";
    public static BugzillaOperations getOperations(IProgressMonitor monitor, BugzillaConfiguration configuration) throws BugzillaException {
		int version = configuration.getVersion();
    	if (version < 0) {
    		version = getVersion(monitor, configuration);
    		configuration.setVersion(version);
    	}
		return create(version);
	}
       
    public static BugzillaOperations create(int version) {
        switch (version) {
        case BugzillaFactory.VERSION_2_16:
        	return new BugzillaOperations_2_16();
        case BugzillaFactory.VERSION_2_18:
        	return new BugzillaOperations_2_18();
            
        }
        return null;
    }
	
    public static int getVersion(IProgressMonitor monitor, BugzillaConfiguration configuration) throws BugzillaException {
        // find the version by requesting an invalid bug.
		String url = configuration.getBaseURL();
		if (!url.endsWith("/")) {
			url += "/";
		}
		try {
			final HTTPConnection connection= new HTTPConnection(url + "xml.cgi?id=1");
			final String xml= connection.getString(monitor);
			final Parser parser= new Parser(false, false);
			final VersionHandler handler= new VersionHandler();
			parser.parse(xml, handler);
			bugScript = "xml.cgi?id=";
			return handler.getVersion();
		} catch (Exception e) {
			/* FIXME: jpound - work around for gcj not handling the xml.cgi redirect in bugilla 2.18 */
			bugScript = "show_bug.cgi?ctype=xml&id=";
			final HTTPConnection connection= new HTTPConnection(url + bugScript + "1");
			final String xml= connection.getString(monitor);
			final Parser parser= new Parser(false, false);
			final VersionHandler handler= new VersionHandler();
			parser.parse(xml, handler);
			return handler.getVersion();
		}
    }
	
	public static ImageDescriptor getBugzillaIcon(String url) {
		try {
			BufferedReader read = new BufferedReader(new InputStreamReader(new URL(url).openStream()));
			String line;
			String image;
			url = url.endsWith("/") ? url : url + "/";	
			Pattern iconFlag = Pattern.compile(".*rel=\".*icon\".*");
			
			while ((line = read.readLine()) != null) {
				
				Matcher m = iconFlag.matcher(line);
				if (m.matches()) {
					image = parseUrl(read, line, url);
					read.close();
					return (image == null) ? null : ImageDescriptor.createFromURL(new URL(image));
				}
			}
			read.close();
			/* Attempt to find the default icon */
			URL base = new URL(url);
			URL iconUrl = new URL(base.getProtocol() + "://" + base.getHost() + "/" + "favicon.ico");
			
			URLConnection con = iconUrl.openConnection();
			int len = con.getContentLength();
			
			if (len <= 0) {
				return null;
			}
			
			
			ImageDescriptor defaultIcon = ImageDescriptor.createFromURL(new URL(iconUrl.toString()));
			
			if (defaultIcon.getImageData() != null) {
				return defaultIcon;
			}
			
		} catch (MalformedURLException e) {
			System.err.println("BugzillaOperations: Malformed URL when fetching icon");
		} catch (IOException e) {
			System.err.println("BugzillaOperations: IOException exception when fetching icon");
		}
		return null;
	}
	
	private static String parseUrl(BufferedReader read, String line, String url) throws IOException {
		String hrefFlag = "href=\"";
		int index;
		do {
			if ((index = line.indexOf(hrefFlag)) >= 0) {
				/* keep breaking off begining part of string to get icon url */
				line = line.substring(index + hrefFlag.length());
				url += line.substring(0, line.indexOf("\""));
				
				return url;
			}
		} while ((line = read.readLine()) != null);
		
		return null;
	}
        
    public abstract ReportData getReportData(IProgressMonitor monitor, BugzillaConfiguration configuration, String id) throws BugzillaException;
    
    public abstract QueryData getQueryData(IProgressMonitor monitor, BugzillaConfiguration configuration, QueryURL queryURL) throws BugzillaException;

	public abstract AttachmentData getAttachment(IProgressMonitor monitor, BugzillaConfiguration configuration, AttachmentDescription desc) throws BugzillaException;
	
	public abstract String getReportURL(BugzillaConfiguration configuration, String reportID);

	public abstract String getCommentURL(BugzillaConfiguration configuration, String reportID, int commentNbr);
	
	public abstract String getAttachmentURL(BugzillaConfiguration configuration, String attachmentID);
	
	public abstract String getReportIDFromURL(BugzillaConfiguration configuration, String url);
	
	public abstract String getQueryURL(BugzillaConfiguration configuration, String url);
	public abstract String getQueryURL(BugzillaConfiguration configuration, String url);
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.operations;

import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.team.bugzilla.BugzillaException;
import org.eclipse.team.bugzilla.datatypes.AttachmentData;
import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
import org.eclipse.team.bugzilla.datatypes.BugzillaConfiguration;
import org.eclipse.team.bugzilla.datatypes.QueryData;
import org.eclipse.team.bugzilla.datatypes.QueryURL;
import org.eclipse.team.bugzilla.datatypes.ReportData;
import org.eclipse.team.bugzilla.xml.Parser;
import org.eclipse.team.bugzilla.xml.QueryHandler;
import org.eclipse.team.bugzilla.xml.ReportHandler;
import org.eclipse.team.bugzilla.xml.ReportHandler_2_16;

/**
 * 
 */
public class BugzillaOperations_2_16 extends BugzillaOperations {
    
    private final static class Reader {
        
        private final String fSource;
        private int fIndex;
        
        public Reader(String source) {
            fSource= source;
            fIndex= 0;
        }
        
        public char read() {
            return fSource.charAt(fIndex++);
        }
        
        public boolean isFinished() {
            return fIndex == fSource.length();
        }
        
        public void consume(String string) throws BugzillaException {
            if (!fSource.startsWith(string, fIndex)) {
                throw new BugzillaException(BugzillaException.XML_ERROR, "Parse error consuming " + string);
            }
            fIndex += string.length();
        }
    }
    
    public ReportData getReportData(IProgressMonitor monitor, BugzillaConfiguration configuration, String id) throws BugzillaException {
        
        monitor.subTask("Fetching report data");
        try {
			String url = configuration.getBaseURL();
			if (!url.endsWith("/")) {
				url += "/";
			}
            url += bugScript + id.trim(); //$NON-NLS-1$
            final HTTPConnection connection= new HTTPConnection(url);
            final String xml= connection.getString(monitor);
            final ReportHandler handler= new ReportHandler_2_16();
            new Parser(false, false).parse(xml, handler);
            return handler.getReportData();
        } finally {
            monitor.done();
        }
    }
    
    public AttachmentData getAttachment(IProgressMonitor monitor, BugzillaConfiguration configuration, AttachmentDescription desc) throws BugzillaException {
        
        monitor.subTask("Fetching attachment data");
        try {
            final String id= desc.getString(AttachmentDescription.ID).trim();
            final String url= getAttachmentURL(configuration, id);
            final HTTPConnection connection= new HTTPConnection(url);
            final AttachmentData attachment= new AttachmentData();
            attachment.data= connection.getBytes(monitor);
            parse(connection.getContentType(), attachment);
            return attachment;
        } finally {
            monitor.done();
        }
    }
    
    private void parse(String contentType, AttachmentData data) throws BugzillaException {
        
        /**
         * The format we parse is like:
         *   text/plain; name="bug36204-1.txt"; charset=ISO-8859-1
         * or
         *   image/jpeg; name="text_editor_bug.jpg"
         *
         */
        final StringBuffer mimeType= new StringBuffer();
        final StringBuffer filename= new StringBuffer();
        final StringBuffer charset= new StringBuffer();
        
        final Reader reader= new Reader(contentType);
        
        /**
         * Read the MIME type.
         */
        char ch;
        while ((ch= reader.read()) != ';') {
            mimeType.append(ch);
        }
        
        reader.consume(" name=\"");
        
        /**
         * Read the file name
         */
        while ((ch= reader.read()) != '"') {
            filename.append(ch);
        }
        
        /**
         * Read the encoding if specified.
         */
        if (!reader.isFinished()) {
            reader.consume("; charset=");
            
            while (!reader.isFinished()) {
                charset.append(reader.read());
            }
        }
        data.set(AttachmentData.FILENAME, filename.toString());
        data.set(AttachmentData.MIMETYPE, mimeType.toString());
        data.set(AttachmentData.ENCODING, charset.toString());
    }
    
    public String getReportURL(BugzillaConfiguration configuration, String reportID) {
        return configuration.getBaseURL() + "/show_bug.cgi?id=" + reportID.trim();
    }
    
    public String getCommentURL(BugzillaConfiguration configuration, String reportID, int commentNbr) {
        return getReportURL(configuration, reportID) + "#c" + commentNbr;
    }
    
    public String getAttachmentURL(BugzillaConfiguration configuration, String attachmentID) {
        return configuration.getBaseURL() + "/attachment.cgi?id=" + attachmentID; //$NON-NLS-1$
    }
    
    public String getReportIDFromURL(BugzillaConfiguration configuration, String url) {
        if (!url.startsWith(configuration.getBaseURL() + "/show_bug.cgi?id="))
            return null;
        
        final int hashIndex = url.indexOf("#");
        final int equalsIndex = url.indexOf("=");
        try {
            if(hashIndex == -1)
                return url.substring(equalsIndex + 1);
            return url.substring(equalsIndex + 1, hashIndex);
        } catch (ArrayIndexOutOfBoundsException e) {
            return null;
        }
    }
    
    
    public String getQueryURL(BugzillaConfiguration configuration, String url) {
        if (!url.startsWith(configuration.getBaseURL() + "/buglist.cgi?"))
            return null;
        
        if (url.indexOf("regetlastlist") != -1)
            return null;
        return url;
    }

    /**
     * Fetch the query data for the given query from the server identified by the supplied
     * configuration. This method uses the query handler returned from <code>getQueryHandler</code>
     * to perform the parsing.
     * @param monitor a progress monitor
     * @param configuration the configuration which identified the bugzilla server
     * @param queryURL the query to be fetched
     * @return the data retrieved for the given query
     * @throws BugzillaException
     */
    public QueryData getQueryData(IProgressMonitor monitor, BugzillaConfiguration configuration, QueryURL queryURL) throws BugzillaException {
        final QueryHandler handler= new QueryHandler();
    
        String url= queryURL.getUrl(configuration); //$NON-NLS-1$
        // catch query data triggered by the browser (non-xml)
        // this also prevents queries from being added to the history
        if (url.indexOf("format=rdf") < 0) {
        	return null;
        }
        final String loginCookie = configuration.getLoginCookie();
        if (queryURL.isNamedQuery() && loginCookie == null) {
            throw new BugzillaException(BugzillaException.REQUIRES_LOGIN, "Please login to Bugzilla.");
        }
        final HTTPConnection connection= new HTTPConnection(url, loginCookie);
        final String xml= connection.getString(monitor);
        if (isLoginFailure(xml)) {
            throw new BugzillaException(BugzillaException.REQUIRES_LOGIN, "Bugzilla user authentication failed.");
        }
        new Parser(false, false).parse(xml, handler);
        return handler.getQueryData();
    }

    public boolean isLoginFailure(String xml) {
        return xml.indexOf("<html>") != -1 && xml.indexOf("Login") != -1; //$NON-NLS-1$ //$NON-NLS-2$
    }
}
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.persistence;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.team.bugs.extension.BugsException;
import org.eclipse.team.bugs.model.IBugProvider;
import org.eclipse.team.bugs.model.IGenericModel;
import org.eclipse.team.bugs.model.IProviderListener;
import org.eclipse.team.bugzilla.BugzillaException;
import org.eclipse.team.bugzilla.BugzillaPlugin;
import org.eclipse.team.bugzilla.adapters.BugzillaAdapterFactory;
import org.eclipse.team.bugzilla.model.BugzillaContainer;
import org.eclipse.team.bugzilla.model.BugzillaFolder;
import org.eclipse.team.bugzilla.model.BugzillaHistoryFolder;
import org.eclipse.team.bugzilla.model.BugzillaModel;
import org.eclipse.team.bugzilla.model.BugzillaProvider;
import org.eclipse.team.bugzilla.model.BugzillaQuery;
import org.eclipse.team.bugzilla.model.BugzillaReport;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;

/**
 * 
 */
public class PersistenceManager {
    
    /*
     * The preference node in the instance scope where the providers are persisted
     */
    private static final String PROVIDER_STORE_ID = "providers";  //$NON-NLS-1$
    
    protected static final BugzillaModel [] EMPTY_ARRAY= new BugzillaModel[0];
    
    /**
     * The key for the model type preference.
     */
    public final static String MODEL_TYPE= "org.eclipse.team.bugzilla.modelType"; //$NON-NLS-1$
    
    public final static String ELEMENT_ID = "org.eclipse.team.bugzilla.elementId"; //$NON-NLS-1$

    /**
     * IDs for the different persistent model types.
     */
    public final static String PROVIDER= "provider"; //$NON-NLS-1$
    public final static String FOLDER= "folder"; //$NON-NLS-1$
    public final static String HISTORY= "history"; //$NON-NLS-1$
    public final static String REPORT= "report"; //$NON-NLS-1$
    public final static String QUERY= "query"; //$NON-NLS-1$

    private final static Map type2classMap;

    /*
     * Listener that is registered with each provider to update 
     * the store when the model changes
     */
    private static IProviderListener listener = new IProviderListener() {
        /* (non-Javadoc)
         * @see org.eclipse.team.bugs.model.IProviderListener#modelAdded(org.eclipse.team.bugs.model.IGenericModel, org.eclipse.team.bugs.model.IGenericModel)
         */
        public void elementsAdded(IGenericModel parent, IGenericModel[] children) {
            elementsChanged(children);
        }

        /* (non-Javadoc)
         * @see org.eclipse.team.bugs.model.IProviderListener#modelChanged(org.eclipse.team.bugs.model.IGenericModel)
         */
        public void elementsChanged(IGenericModel[] elements) {
            for (int i = 0; i < elements.length; i++) {
                final BugzillaModel model = (BugzillaModel)elements[i];
                final IPersistenceAdapter adapter = getPersistenceAdapter(elements[i]);
                if (adapter != null)
                    adapter.storeElement(model, false);
            }
            final BugzillaProvider provider= ((BugzillaModel)elements[0]).getBugzillaProvider();
            try {
                AbstractPersistenceAdapter.getPreferences(provider).flush();
            } catch (BackingStoreException e) {
                BugzillaPlugin.log(BugzillaException.asBugsException(e));
            }
        }

        /* (non-Javadoc)
         * @see org.eclipse.team.bugs.model.IProviderListener#modelRemoved(org.eclipse.team.bugs.model.IGenericModel, org.eclipse.team.bugs.model.IGenericModel)
         */
        public void elementsRemoved(IGenericModel parent, IGenericModel[] children) {
            for (int i = 0; i < children.length; i++) {
                final BugzillaModel model = (BugzillaModel)children[i];
                final IPersistenceAdapter adapter = getPersistenceAdapter(parent);
                if (adapter != null)
                    adapter.purgeChild((BugzillaModel)parent, model, false);
            }
            try {
                AbstractPersistenceAdapter.getPreferences(parent).flush();
            } catch (BackingStoreException e) {
                BugzillaPlugin.log(BugzillaException.asBugsException(e));
            }
        }
    };

    
    static {
        type2classMap = new HashMap();
        type2classMap.put(PROVIDER, BugzillaProvider.class);
        type2classMap.put(FOLDER, BugzillaFolder.class);
        type2classMap.put(HISTORY, BugzillaHistoryFolder.class);
        type2classMap.put(REPORT, BugzillaReport.class);
        type2classMap.put(QUERY, BugzillaQuery.class);
    }
    
    /**
     * Return the root preferences node whose children are providers
     * @return the root preferences node whose children are providers
     */
    /* package */ static Preferences getRootNode() {
        return new InstanceScope().getNode(BugzillaPlugin.ID).node(PROVIDER_STORE_ID);
    }
    
    /**
     * Restore the providers from the preference store and return the restored providers
     * @return the restored providers
     */
    public static IBugProvider[] restoreProviders() {
        BugzillaModel[] providers = restoreChildren(null /* no parent */, getRootNode());
        IBugProvider[] result = new IBugProvider[providers.length];
        System.arraycopy(providers, 0, result, 0, providers.length);
        return result;
    }
    
    /**
     * Return the persistence adapter for the given element 
     * or <code>null</code> if there isn't one.
     * @param element the element
     * @return the persistence adapter for the given element 
     * or <code>null</code>
     */
    public static IPersistenceAdapter getPersistenceAdapter(Object element) {
        if (element instanceof IAdaptable) {
	        Object adapter = ((IAdaptable)element).getAdapter(IPersistenceAdapter.class);
	        if (adapter instanceof IPersistenceAdapter)
	            return (IPersistenceAdapter)adapter;
        }
        return null;
    }
    
    /*
     * Method used by persistence adapters to restore a bugzilla model
     */
    /* package */ static BugzillaModel restoreChild(BugzillaContainer parent, Preferences node) {
        final String type= node.get(MODEL_TYPE, ""); //$NON-NLS-1$
        final String id = node.get(ELEMENT_ID, ""); //$NON-NLS-1$
        IPersistenceAdapter adapter = getPersistenceAdapter(type);
        if (adapter != null) {
            try {
                BugzillaModel element = adapter.restoreElement(parent, node, id);
	            return element;
            } catch (BugzillaException e) {
                BugzillaPlugin.log(e);
            }
        }
        return null;
    }
    
    /**
     * Restore the childen of the given element.
     * @param parent the element
     * @param node the node for the element that may contain child nodes
     * representing children of the element
     * @return the restored children
     */
    /* package */ static final BugzillaModel[] restoreChildren(BugzillaContainer parent, Preferences node) {
        final String [] childrenNames;
        try {
            childrenNames= node.childrenNames();
        } catch (BackingStoreException e) {
            BugzillaPlugin.log(BugsException.asBugsException(e));
            return EMPTY_ARRAY;
        }
        final ArrayList children= new ArrayList();
        for (int i = 0; i < childrenNames.length; i++) {
            final String childName= childrenNames[i];
            final Preferences childNode= node.node(childName);
            final BugzillaModel child= restoreChild(parent, childNode);
            if (child != null)
                children.add(child);
        }
        return (BugzillaModel[]) children.toArray(new BugzillaModel[children.size()]);
    }
    
    private static IPersistenceAdapter getPersistenceAdapter(String type) {
        Class typeClass = (Class)type2classMap.get(type);
        if (typeClass != null) {
            Object adapter = BugzillaAdapterFactory.getPersistenceAdapter(typeClass);
            if (adapter instanceof IPersistenceAdapter)
                return (IPersistenceAdapter)adapter;
        }
        return null;
    }

    /**
     * The provider has been added so persist it's state
     * @param provider
     */
    public static void providerAdded(BugzillaProvider provider) {
        IPersistenceAdapter adapter = getPersistenceAdapter(provider);
        if (adapter != null) {
            adapter.storeElement(provider, true /* flush to disk */);
        }
        provider.getEventHandler().addProviderListener(listener );
    }

    /**
     * The provider has been removed so purge any persisted state
     * @param provider
     */
    public static void providerRemoved(BugzillaProvider provider) {
        IPersistenceAdapter adapter = getPersistenceAdapter(provider);
        if (adapter != null) {
            adapter.purgeChild(null, provider, true /* flush to disk */);
        }
        provider.getEventHandler().removeProviderListener(listener);
    }

    /**
     * @param container
     */
    public static Preferences getPreferenceNode(BugzillaContainer container) {
        return AbstractPersistenceAdapter.getPreferences(container);
    }
    
    /*
     * Do not allow instantiation
     */
    private PersistenceManager() {
    }

}
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.tools;

/**
 * 
 */
public interface IBugzillaSelectionProvider {

    BugzillaSelection getSelection();
    
    void addListener(IBugzillaSelectionListener listener);
    
    void removeListener(IBugzillaSelectionListener listener);

}
    void removeListener(IBugzillaSelectionListener listener);

}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.view;

import org.eclipse.jface.action.*;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.events.FocusAdapter;
import org.eclipse.swt.events.FocusEvent;
import org.eclipse.team.bugs.extension.IViewerProxy;
import org.eclipse.team.bugzilla.actions.*;
import org.eclipse.team.bugzilla.tools.IBugzillaSelectionProvider;
import org.eclipse.ui.IWorkbenchActionConstants;
import org.eclipse.ui.actions.ActionFactory;

/**
 * 
 */
class ActionManager extends FocusAdapter {
    
    private final BugzillaDeleteAction fDeleteAction;
    private final BugzillaCopyAction fCopyAction;
    private final BugzillaPasteAction fPasteAction;
    private final BugzillaMoveAction fMoveAction;
    private final BugzillaRenameAction fRenameAction;
    private final RefreshAction fRefreshAction;

    private final ShowInBrowserAction fShowInBrowserAction;
    private final ClearHistoryAction fClearHistoryAction;
    
    private final TextSelectAllAction fTextSelectAllAction;
    
    //private final BugzillaViewExtension fExtension;
    
    public ActionManager(BugzillaViewExtension extension) {
        
        //fExtension= extension;
        final IViewerProxy proxy= extension.getProxy();
        final IBugzillaSelectionProvider provider = extension.getBugzillaSelectionProvider();
        fDeleteAction= new BugzillaDeleteAction(proxy, provider);
        fPasteAction= new BugzillaPasteAction(proxy, provider);
        fCopyAction= new BugzillaCopyAction(proxy, extension, fPasteAction);
        fMoveAction= new BugzillaMoveAction(proxy, provider);
        fRenameAction= new BugzillaRenameAction(proxy, provider);
        fClearHistoryAction= new ClearHistoryAction(proxy, provider);
        fShowInBrowserAction= new ShowInBrowserAction(proxy, provider);
        fRefreshAction= new RefreshAction(proxy, provider);
        fTextSelectAllAction= new TextSelectAllAction(extension);
        
        proxy.registerGlobalAction(ActionFactory.DELETE.getId(), fDeleteAction);
        proxy.registerGlobalAction(ActionFactory.COPY.getId(), fCopyAction);
        proxy.registerGlobalAction(ActionFactory.PASTE.getId(), fPasteAction);
        proxy.registerGlobalAction(ActionFactory.MOVE.getId(), fMoveAction);
        proxy.registerGlobalAction(ActionFactory.RENAME.getId(), fRenameAction);
        proxy.registerGlobalAction(ActionFactory.REFRESH.getId(), fRefreshAction);
        proxy.registerGlobalAction(ActionFactory.SELECT_ALL.getId(), fTextSelectAllAction);
    }
    
    public void fillContextMenu(IMenuManager menu) {
        if (fShowInBrowserAction.isEnabled())
            menu.add(fShowInBrowserAction);
        if (fClearHistoryAction.isEnabled())
            menu.add(fClearHistoryAction);
    }

    public void updateActionEnablements() {
        fShowInBrowserAction.setEnablement();
        fDeleteAction.setEnablement();
        fCopyAction.setEnablement();
        fPasteAction.setEnablement();
        fMoveAction.setEnablement();
        fRefreshAction.setEnablement();
        fRenameAction.setEnablement();
        fClearHistoryAction.setEnablement();
        fTextSelectAllAction.setEnablement();
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.swt.events.FocusAdapter#focusGained(org.eclipse.swt.events.FocusEvent)
     */
    public void focusGained(FocusEvent e) {
        updateActionEnablements();
    }

    /**
     * @param styledText
     */
    public void createTextContextMenu(StyledText styledText) {
        final MenuManager menu= new MenuManager(null);
        menu.add(fCopyAction);
        menu.add(fTextSelectAllAction);
        menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
        styledText.setMenu(menu.createContextMenu(styledText));
    }
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.view;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.text.DateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;

import org.eclipse.jface.text.TextPresentation;
import org.eclipse.swt.SWT;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.custom.StyleRange;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.team.bugzilla.datatypes.AttachmentData;
import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
import org.eclipse.team.bugzilla.datatypes.CommentData;
import org.eclipse.team.bugzilla.datatypes.ReportData;
import org.eclipse.team.bugzilla.model.BugzillaAttachment;
import org.eclipse.team.bugzilla.model.BugzillaComment;
import org.eclipse.team.bugzilla.model.BugzillaModel;
import org.eclipse.team.bugzilla.model.BugzillaQuery;
import org.eclipse.team.bugzilla.model.BugzillaReport;

public class BugzillaModelPresenter {
    
    protected TextPresentation fPresentation;
    protected StringBuffer fBuffer;
    protected StyledText fStyledText;

    public BugzillaModelPresenter() {
        fStyledText= null;
        fPresentation= null;
        fBuffer= null;
    }
    
    private void begin(StyledText styledText) {
        fPresentation= new TextPresentation();
        fBuffer= new StringBuffer();
        fStyledText= styledText;
        
    }
    
    private void end(final boolean wordWrap) {
        BusyIndicator.showWhile(fStyledText.getDisplay(), new Runnable() {
            public void run() {
                fStyledText.setRedraw(false);
                fStyledText.setText("");
                fStyledText.setWordWrap(wordWrap);
                fStyledText.setText(fBuffer.toString());
                TextPresentation.applyTextPresentation(fPresentation, fStyledText);
                fStyledText.setRedraw(true);
            }
        });

        fBuffer= null;
        fPresentation= null;
        fStyledText= null;
    }
    
//    public void present(BugzillaProvider provider, StyledText styledText) {
//        begin(styledText);
//        end(true);
//    }

    public void present(BugzillaQuery query, StyledText styledText) {
        begin(styledText);
        append(query);
        end(true);        
    }
    
    public void present(BugzillaReport report, StyledText styledText) {
        begin(styledText);
        append(report);
        end(true);        
    }
    
    public void present(BugzillaComment comment, StyledText styledText) {
        begin(styledText);
        append(comment);
        end(true);
    }
    
    public void present(BugzillaAttachment bugzillaAttachment, StyledText styledText) {
        
        final AttachmentData attachment= bugzillaAttachment.getData();
        
        boolean wordWrap= false;
        begin(styledText);
        
        if (attachment != null) { 
            final String data= bugzillaAttachment.getDataAsString();
            final String mimeType= bugzillaAttachment.getData().getString(AttachmentData.MIMETYPE);
            if (mimeType.startsWith("text/")) {
                append(data);
                wordWrap= false;
            } else {
                append(attachment.getString(AttachmentData.FILENAME)).space().append("[").append(mimeType).append("]");
                wordWrap= true;
            }
        }
        end(wordWrap);
    }
    
//	/**
//	 * @param folder
//	 * @param styledText
//	 */
//	public void present(BugzillaFolder folder, StyledText styledText) {
//		begin(styledText);
//		append(folder);
//		end(true);
//	}
    
//    /**
//	 * @param folder
//	 */
//	private void append(BugzillaFolder folder) {
//		/* TODO: jpound - implement folder presentation */
//		bold(folder.getName()).endl().endl();
//		
//		BugzillaModel[] children = folder.getChildren();
//		int numQueries = 0;
//		int numBugs = 0;
//		if (children != null) {
//			for (int i = 0; i < children.length; i++) {
//				if (children[i] instanceof BugzillaQuery) {
//					numQueries++;
//				}
//				else {
//					numBugs++;
//				}
//			}
//		}
//		else {
//			italic("Empty Folder");
//			return;
//		}
//				
//		if (numQueries > 0) {
//			append("Queries:\t" + numQueries).endl();
//		}
//		if (numBugs > 0) {
//			append("Bugs:\t\t" + numBugs);
//		}
//	}

	private BugzillaModelPresenter append(BugzillaQuery query) {
        
    	String queryUrl = query.getQueryUrl().toUrlString();
        String summary = null;
        String comment = null;
        
        int summaryIndex = queryUrl.indexOf("short_desc=");
        if (summaryIndex >= 0) {
        	summary = queryUrl.substring(summaryIndex, queryUrl.length());
        	int ampIndex = summary.indexOf('&');
        	if (ampIndex < 0) {
        		ampIndex = summary.length();
        	}
        	try {
				summary = URLDecoder.decode(summary.substring(summary.indexOf('=') + 1, ampIndex), "UTF-8");
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
        }
        
        int commentIndex = queryUrl.indexOf("long_desc=");
        if (commentIndex >= 0) {
        	comment = queryUrl.substring(commentIndex,  queryUrl.length());
        	int ampIndex = comment.indexOf('&');
        	if (ampIndex < 0) {
        		ampIndex = comment.length();
        	}
        	try {
				comment = URLDecoder.decode(comment.substring(comment.indexOf('=') + 1, ampIndex), "UTF-8");
			} catch (UnsupportedEncodingException e) {
				e.printStackTrace();
			}
        }
        
        BugzillaModel[] children = query.getChildren();
        HashMap bugFreqs = new HashMap(7); // 7 bugzilla status'
        int criticalBugs = 0;
        
        for (int i = 0; i < children.length; i++) {
        	ReportData reportData = ((BugzillaReport)children[i]).getReportData();
        	if (reportData == null) {
        		return this;
        	}
        	String status = reportData.getString(ReportData.STATUS);
        	
        	if (reportData.getString(ReportData.SEVERITY).equals("critical")) {
        		criticalBugs++;
        	}
        	
        	Integer count = (Integer)bugFreqs.get(status);
        	if (count == null) {
        		bugFreqs.put(status, new Integer(1));
        	}
        	else {
        		bugFreqs.put(status, new Integer(count.intValue() + 1));
        	}
        }
        
        bold("Query from " + query.getQueryUrl().getBaseUrl()).endl();
        if (summary != null && !summary.equals("")) {
        	append("Summary:\t\t").italic(summary).endl();
        }
        if (comment != null && !comment.equals("")) {
        	append("Comment:\t\t").italic(comment).endl();
        }
        endl();
        
        append("Total Bugs:\t" + children.length).endl();
        Iterator iter = bugFreqs.keySet().iterator();
        while (iter.hasNext()) {
        	String status = (String)iter.next(); 
        	String tab = "\t";
        	int statusLength;
        	if ( (statusLength = status.length()) < 8) {
        		tab += "\t";
        		if (statusLength < 4) {
        			tab += "\t";
        		}
        	}
        	append(status + tab + bugFreqs.get(status)).endl();
        }
        endl();
        if (criticalBugs > 0) {
        	append("This query contains").bold(" "+criticalBugs).append(" critical " + ((criticalBugs > 1) ? "bugs" : "bug"));
        }
        
        return this;
    }
    
    private BugzillaModelPresenter append(BugzillaComment bugzillaComment) {
        final CommentData comment= bugzillaComment.getCommentData();
        if (comment == null)
            return this;
        bold(comment.getString(CommentData.AUTHOR)).append(" - ").append(comment.getDate(CommentData.DATE)).endl(2);

        if (comment.attachmentDesc != null && comment.attachmentDesc.getBoolean(AttachmentDescription.OBSOLETE))
            append("*** This attachment is obsolete ***").endl(2);
        append(comment.getString(CommentData.TEXT));
        return this;
    }

    private BugzillaModelPresenter append(BugzillaReport bugzillaReport) {
        
        if (!bugzillaReport.hasLocalContent())
            return this;

        final ReportData report= bugzillaReport.getReportData();
        
        bold("[").bold(report.getString(ReportData.ID)).bold("]").space().bold(report.getString(ReportData.TITLE)).endl(2);

        append("Assigned To: ").append(report.getString(ReportData.ASSIGNEDTO)).endl();
        append("Severity: ").append(report.getString(ReportData.SEVERITY)).endl();
        append("Priority: ").append(report.getString(ReportData.PRIORITY)).endl();
        append("Target Milestone: ").append(report.getString(ReportData.TARGETMILESTONE)).endl();
        endl();
        append("Operating System: ").append(report.getString(ReportData.OPERATINGSYSTEM)).endl();
        append("Platform: ").append(report.getString(ReportData.PLATFORM)).endl();
        
        endl();
        
        /* append first comment
        final Iterator iter= bugzillaReport.getComments().iterator();
        if (iter.hasNext()) {
            append((BugzillaComment)iter.next());
        }
        */
        return this;
    }

    private BugzillaModelPresenter append(String suffix) {
        fBuffer.append(suffix);
        return this;
    }
    
    private BugzillaModelPresenter bold(String suffix) {
        final int offset= fBuffer.length();
        final int length= suffix.length();
        fBuffer.append(suffix);
        fPresentation.addStyleRange(new StyleRange(offset, length, null, null, SWT.BOLD));
        return this;
    }
    
    private BugzillaModelPresenter italic(String suffix) {
        final int offset= fBuffer.length();
        final int length= suffix.length();
        fBuffer.append(suffix);
        fPresentation.addStyleRange(new StyleRange(offset, length, null, null, SWT.ITALIC));
        return this;
    }
    
    private BugzillaModelPresenter endl() {
        fBuffer.append("\n");
        return this;
    }
    
    private BugzillaModelPresenter endl(int n) {
        for (int i= 0; i < n; ++i)
            fBuffer.append("\n");
        return this;
    }
    
    private BugzillaModelPresenter space() {
        fBuffer.append(" ");
        return this;
    }
    
//    private BugzillaModelPresenter space(int n) {
//        for (int i= 0; i < n; i++)
//            fBuffer.append(" ");
//        return this;
//    }
    
    private BugzillaModelPresenter append(Date date) {
        fBuffer.append(DateFormat.getDateTimeInstance().format(date));
        return this;
    }

}
}




/*******************************************************************************
 * Copyright (c) 2000, 2004 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials 
 * are made available under the terms of the Common Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/cpl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.team.bugzilla.view;

import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.jface.viewers.IOpenListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.OpenEvent;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.SWT;
import org.eclipse.swt.browser.LocationListener;
import org.eclipse.swt.custom.SashForm;
import org.eclipse.swt.custom.StyledText;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.team.bugs.model.IGenericModel;
import org.eclipse.team.bugs.model.IProviderListener;
import org.eclipse.team.bugzilla.browser.BugzillaBrowser;
import org.eclipse.team.bugzilla.browser.IWebContentAdapter;
import org.eclipse.team.bugzilla.model.BugzillaModel;
import org.eclipse.team.bugzilla.model.BugzillaProvider;
import org.eclipse.team.bugzilla.tools.BugzillaSelection;
import org.eclipse.team.bugzilla.tools.IBugzillaSelectionListener;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.part.PageBook;

public class TextPane implements IBugzillaSelectionListener, IProviderListener, IOpenListener {
    
    private StyledText fStyledText;
    //private Control fEmptyControl;
    private PageBook fPageBook;
    private SashForm sashForm = null;
    private int[] userWeights = {2, 1};
    
    private BugzillaSelection fSelection;
    
    private final DelayedRefreshPresenter fDelayedRefresh;
    private BugzillaViewExtension fExtension;
    
    public TextPane(BugzillaViewExtension extension, Composite parent) {
        fExtension= extension;
        fDelayedRefresh= new DelayedRefreshPresenter();
        
        fPageBook= new PageBook(parent, SWT.NONE);
        //fEmptyControl= new Composite(fPageBook, SWT.NONE);
        fStyledText= new StyledText(fPageBook, SWT.H_SCROLL | SWT.V_SCROLL | SWT.READ_ONLY);
        fSelection= new BugzillaSelection(StructuredSelection.EMPTY);
        
        final ActionManager manager= fExtension.getActionManager();
        manager.createTextContextMenu(fStyledText);
        
        if (parent.getParent() instanceof SashForm) {
        	sashForm = (SashForm)parent.getParent();
        	hideView();
        }
    }

    public void selectionChanged(BugzillaSelection selection) {
        fSelection= selection;

        final BugzillaModel element= fSelection.getOnlyElement();
        fDelayedRefresh.refresh(element);
        
        if (element != null) {
            present(element);
        }
        else {
        	hideView();
        }
    }


    public void elementsAdded(IGenericModel parent, IGenericModel[] children) {
    }

    public void elementsChanged(IGenericModel[] elements) {
        /**
         * We only update the styled text if the model has just refreshed
         * and is currently selected.
         */
        final BugzillaModel selected= fSelection.getOnlyElement();
        if (selected == null)
            return;
        
        for (int i = 0; i < elements.length; i++) {
            if (selected == elements[i] && !selected.isRefreshing()) {
                present(selected);
            }
        }
    }

    public void elementsRemoved(IGenericModel parent, IGenericModel[] children) {
    }
    
    private void present(BugzillaModel element) {
    	
    	final IPresentableAdapter adapter= getPresentableAdapter(element);
        if (adapter == null) {
        	hideView();
        	return;
        }
                
        adapter.present(element, fStyledText);
        //final boolean hasText= fStyledText.getText().trim().length() != 0;
        fPageBook.showPage(fStyledText);
        
        if (sashForm.getWeights()[1] == 0) {
        	showView();
        }
    }
    
    private void showView() {
    	if (sashForm == null) {
    		return;
    	}
    	sashForm.setWeights(userWeights);
    }
    
    private void hideView() {
    	if (sashForm == null) {
    		return;
    	}
    	if  ((sashForm.getWeights())[1] != 0) {
    		userWeights = sashForm.getWeights();
    	}
    	sashForm.setWeights(new int[] {1, 0});
    }
    
    private IPresentableAdapter getPresentableAdapter(Object o) {
        if (o instanceof IAdaptable) {
            return (IPresentableAdapter)((IAdaptable)o).getAdapter(IPresentableAdapter.class);
        }
        return null;
    }

    public void open(OpenEvent event) {
        if (!(event.getSelection() instanceof IStructuredSelection))
            return;
        
        final IStructuredSelection selection= (IStructuredSelection)event.getSelection();
        
        if (!(selection.getFirstElement() instanceof BugzillaModel))
            return;
        
        final BugzillaModel model= (BugzillaModel)selection.getFirstElement();
        
        final IWebContentAdapter adapter= (IWebContentAdapter)model.getAdapter(IWebContentAdapter.class);
        if (adapter == null)
            return;
        
        final LocationListener listener= (BugzillaProvider)model.getProvider();
        
        final String url= adapter.getURL(model);
        if (url != null) {
            final IWorkbenchPart part= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
            BugzillaBrowser.open(part, listener, url.replaceAll("format=rdf", ""));
        }
        
    }

//    public String getSelection() {
//        return fStyledText.getSelectionText();
//    }
//
//    public boolean hasFocus() {
//        return fStyledText.isFocusControl();
//    }
    
    public StyledText getStyledText() {
        return fStyledText;
    }
    
    public Control getControl() {
        return fPageBook;
    }
    }
}

Return to bug 81795

Lines 801-808 Link Here

(-)src/org/eclipse/team/bugzilla/dialogs/AddQueryDialog.java (-4 / +1 lines)
801	}	801	}
802		802
803	/**	803	/**
804	* @param searchGroup	804	* @param group
805	* @return
806	*/	805	*/
807	private Combo createSearchTypeCombo(Composite group) {	806	private Combo createSearchTypeCombo(Composite group) {
808	Combo combo = new Combo(group, SWT.READ_ONLY);	807	Combo combo = new Combo(group, SWT.READ_ONLY);
Lines 839-847 Link Here
839	}	838	}
840		839
841	/**	840	/**
842	*
843	* @param group	841	* @param group
844	* @return
845	*/	842	*/
846	private List createList(Composite group) {	843	private List createList(Composite group) {
847	GridData smallVertData = new GridData(SWT.FILL, SWT.FILL, true, true);	844	GridData smallVertData = new GridData(SWT.FILL, SWT.FILL, true, true);

Lines 1-187 Link Here

(-)src/org/eclipse/team/bugzilla/view/TextPane.java (-186 / +185 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.view;	12	package org.eclipse.team.bugzilla.view;
13		13
14	import org.eclipse.core.runtime.IAdaptable;	14	import org.eclipse.core.runtime.IAdaptable;
15	import org.eclipse.jface.viewers.IOpenListener;	15	import org.eclipse.jface.viewers.IOpenListener;
16	import org.eclipse.jface.viewers.IStructuredSelection;	16	import org.eclipse.jface.viewers.IStructuredSelection;
17	import org.eclipse.jface.viewers.OpenEvent;	17	import org.eclipse.jface.viewers.OpenEvent;
18	import org.eclipse.jface.viewers.StructuredSelection;	18	import org.eclipse.jface.viewers.StructuredSelection;
19	import org.eclipse.swt.SWT;	19	import org.eclipse.swt.SWT;
20	import org.eclipse.swt.browser.LocationListener;	20	import org.eclipse.swt.browser.LocationListener;
21	import org.eclipse.swt.custom.SashForm;	21	import org.eclipse.swt.custom.SashForm;
22	import org.eclipse.swt.custom.StyledText;	22	import org.eclipse.swt.custom.StyledText;
23	import org.eclipse.swt.widgets.Composite;	23	import org.eclipse.swt.widgets.Composite;
24	import org.eclipse.swt.widgets.Control;	24	import org.eclipse.swt.widgets.Control;
25	import org.eclipse.team.bugs.model.IGenericModel;	25	import org.eclipse.team.bugs.model.IGenericModel;
26	import org.eclipse.team.bugs.model.IProviderListener;	26	import org.eclipse.team.bugs.model.IProviderListener;
27	import org.eclipse.team.bugzilla.browser.BugzillaBrowser;	27	import org.eclipse.team.bugzilla.browser.BugzillaBrowser;
28	import org.eclipse.team.bugzilla.browser.IWebContentAdapter;	28	import org.eclipse.team.bugzilla.browser.IWebContentAdapter;
29	import org.eclipse.team.bugzilla.model.BugzillaModel;	29	import org.eclipse.team.bugzilla.model.BugzillaModel;
30	import org.eclipse.team.bugzilla.model.BugzillaProvider;	30	import org.eclipse.team.bugzilla.model.BugzillaProvider;
31	import org.eclipse.team.bugzilla.tools.BugzillaSelection;	31	import org.eclipse.team.bugzilla.tools.BugzillaSelection;
32	import org.eclipse.team.bugzilla.tools.IBugzillaSelectionListener;	32	import org.eclipse.team.bugzilla.tools.IBugzillaSelectionListener;
33	import org.eclipse.ui.IWorkbenchPart;	33	import org.eclipse.ui.IWorkbenchPart;
34	import org.eclipse.ui.PlatformUI;	34	import org.eclipse.ui.PlatformUI;
35	import org.eclipse.ui.part.PageBook;	35	import org.eclipse.ui.part.PageBook;
36		36
37	public class TextPane implements IBugzillaSelectionListener, IProviderListener, IOpenListener {	37	public class TextPane implements IBugzillaSelectionListener, IProviderListener, IOpenListener {
38		38
39	private StyledText fStyledText;	39	private StyledText fStyledText;
40	//private Control fEmptyControl;	40	//private Control fEmptyControl;
41	private PageBook fPageBook;	41	private PageBook fPageBook;
42	private SashForm sashForm = null;	42	private SashForm sashForm = null;
43	private int[] userWeights = {2, 1};	43	private int[] userWeights = {2, 1};
44		44
45	private BugzillaSelection fSelection;	45	private BugzillaSelection fSelection;
46		46
47	private final DelayedRefreshPresenter fDelayedRefresh;	47	private final DelayedRefreshPresenter fDelayedRefresh;
48	private BugzillaViewExtension fExtension;	48	private BugzillaViewExtension fExtension;
49		49
50	public TextPane(BugzillaViewExtension extension, Composite parent) {	50	public TextPane(BugzillaViewExtension extension, Composite parent) {
51	fExtension= extension;	51	fExtension= extension;
52	fDelayedRefresh= new DelayedRefreshPresenter();	52	fDelayedRefresh= new DelayedRefreshPresenter();
53		53
54	fPageBook= new PageBook(parent, SWT.NONE);	54	fPageBook= new PageBook(parent, SWT.NONE);
55	//fEmptyControl= new Composite(fPageBook, SWT.NONE);	55	//fEmptyControl= new Composite(fPageBook, SWT.NONE);
56	fStyledText= new StyledText(fPageBook, SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.READ_ONLY);	56	fStyledText= new StyledText(fPageBook, SWT.H_SCROLL \| SWT.V_SCROLL \| SWT.READ_ONLY);
57	fSelection= new BugzillaSelection(StructuredSelection.EMPTY);	57	fSelection= new BugzillaSelection(StructuredSelection.EMPTY);
58		58
59	final ActionManager manager= fExtension.getActionManager();	59	final ActionManager manager= fExtension.getActionManager();
60	manager.createTextContextMenu(fStyledText);	60	manager.createTextContextMenu(fStyledText);
61		61
62	if (parent.getParent() instanceof SashForm) {	62	if (parent.getParent() instanceof SashForm) {
63	sashForm = (SashForm)parent.getParent();	63	sashForm = (SashForm)parent.getParent();
64	hideView();	64	hideView();
65	}	65	}
66	}	66	}
67		67
68	public void selectionChanged(BugzillaSelection selection) {	68	public void selectionChanged(BugzillaSelection selection) {
69	fSelection= selection;	69	fSelection= selection;
70		70
71	final BugzillaModel element= fSelection.getOnlyElement();	71	final BugzillaModel element= fSelection.getOnlyElement();
72	fDelayedRefresh.refresh(element);	72	fDelayedRefresh.refresh(element);
73		73
74	if (element != null) {	74	if (element != null) {
75	present(element);	75	present(element);
76	}	76	}
77	else {	77	else {
78	hideView();	78	hideView();
79	}	79	}
80	}	80	}
81		81
82		82
83	public void elementsAdded(IGenericModel parent, IGenericModel[] children) {	83	public void elementsAdded(IGenericModel parent, IGenericModel[] children) {
84	}	84	}
85		85
86	public void elementsChanged(IGenericModel[] elements) {	86	public void elementsChanged(IGenericModel[] elements) {
87	/**	87	/**
88	* We only update the styled text if the model has just refreshed	88	* We only update the styled text if the model has just refreshed
89	* and is currently selected.	89	* and is currently selected.
90	*/	90	*/
91	final BugzillaModel selected= fSelection.getOnlyElement();	91	final BugzillaModel selected= fSelection.getOnlyElement();
92	if (selected == null)	92	if (selected == null)
93	return;	93	return;
94		94
95	for (int i = 0; i < elements.length; i++) {	95	for (int i = 0; i < elements.length; i++) {
96	if (selected == elements[i] && !selected.isRefreshing()) {	96	if (selected == elements[i] && !selected.isRefreshing()) {
97	present(selected);	97	present(selected);
98	}	98	}
99	}	99	}
100	}	100	}
101		101
102	public void elementsRemoved(IGenericModel parent, IGenericModel[] children) {	102	public void elementsRemoved(IGenericModel parent, IGenericModel[] children) {
103	}	103	}
104		104
105	private void present(BugzillaModel element) {	105	private void present(BugzillaModel element) {
106		106
107	final IPresentableAdapter adapter= getPresentableAdapter(element);	107	final IPresentableAdapter adapter= getPresentableAdapter(element);
108	if (adapter == null) {	108	if (adapter == null) {
109	hideView();	109	hideView();
110	return;	110	return;
111	}	111	}
112		112
113	adapter.present(element, fStyledText);	113	adapter.present(element, fStyledText);
114	//final boolean hasText= fStyledText.getText().trim().length() != 0;	114	//final boolean hasText= fStyledText.getText().trim().length() != 0;
115	fPageBook.showPage(fStyledText);	115	fPageBook.showPage(fStyledText);
116		116
117	if (sashForm.getWeights()[1] == 0) {	117	if (sashForm.getWeights()[1] == 0) {
118	showView();	118	showView();
119	}	119	}
120	}	120	}
121		121
122	private void showView() {	122	private void showView() {
123	if (sashForm == null) {	123	if (sashForm == null) {
124	return;	124	return;
125	}	125	}
126	sashForm.setWeights(userWeights);	126	sashForm.setWeights(userWeights);
127	}	127	}
128		128
129	private void hideView() {	129	private void hideView() {
130	if (sashForm == null) {	130	if (sashForm == null) {
131	return;	131	return;
132	}	132	}
133	int current[];	133	if ((sashForm.getWeights())[1] != 0) {
134	if ((current = sashForm.getWeights())[1] != 0) {	134	userWeights = sashForm.getWeights();
135	userWeights = sashForm.getWeights();	135	}
136	}	136	sashForm.setWeights(new int[] {1, 0});
137	sashForm.setWeights(new int[] {1, 0});	137	}
138	}	138
139		139	private IPresentableAdapter getPresentableAdapter(Object o) {
140	private IPresentableAdapter getPresentableAdapter(Object o) {	140	if (o instanceof IAdaptable) {
141	if (o instanceof IAdaptable) {	141	return (IPresentableAdapter)((IAdaptable)o).getAdapter(IPresentableAdapter.class);
142	return (IPresentableAdapter)((IAdaptable)o).getAdapter(IPresentableAdapter.class);	142	}
143	}	143	return null;
144	return null;	144	}
145	}	145
146		146	public void open(OpenEvent event) {
147	public void open(OpenEvent event) {	147	if (!(event.getSelection() instanceof IStructuredSelection))
148	if (!(event.getSelection() instanceof IStructuredSelection))	148	return;
149	return;	149
150		150	final IStructuredSelection selection= (IStructuredSelection)event.getSelection();
151	final IStructuredSelection selection= (IStructuredSelection)event.getSelection();	151
152		152	if (!(selection.getFirstElement() instanceof BugzillaModel))
153	if (!(selection.getFirstElement() instanceof BugzillaModel))	153	return;
154	return;	154
155		155	final BugzillaModel model= (BugzillaModel)selection.getFirstElement();
156	final BugzillaModel model= (BugzillaModel)selection.getFirstElement();	156
157		157	final IWebContentAdapter adapter= (IWebContentAdapter)model.getAdapter(IWebContentAdapter.class);
158	final IWebContentAdapter adapter= (IWebContentAdapter)model.getAdapter(IWebContentAdapter.class);	158	if (adapter == null)
159	if (adapter == null)	159	return;
160	return;	160
161		161	final LocationListener listener= (BugzillaProvider)model.getProvider();
162	final LocationListener listener= (BugzillaProvider)model.getProvider();	162
163		163	final String url= adapter.getURL(model);
164	final String url= adapter.getURL(model);	164	if (url != null) {
165	if (url != null) {	165	final IWorkbenchPart part= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();
166	final IWorkbenchPart part= PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActivePart();	166	BugzillaBrowser.open(part, listener, url.replaceAll("format=rdf", ""));
167	BugzillaBrowser.open(part, listener, url.replaceAll("format=rdf", ""));	167	}
168	}	168
169		169	}
170	}	170
171		171	// public String getSelection() {
172	// public String getSelection() {	172	// return fStyledText.getSelectionText();
173	// return fStyledText.getSelectionText();	173	// }
174	// }	174	//
175	//	175	// public boolean hasFocus() {
176	// public boolean hasFocus() {	176	// return fStyledText.isFocusControl();
177	// return fStyledText.isFocusControl();	177	// }
178	// }	178
179		179	public StyledText getStyledText() {
180	public StyledText getStyledText() {	180	return fStyledText;
181	return fStyledText;	181	}
182	}	182
183		183	public Control getControl() {
184	public Control getControl() {	184	return fPageBook;
185	return fPageBook;	185	}
186	}
187	}	186	}

Lines 1-82 Link Here

(-)src/org/eclipse/team/bugzilla/adapters/BugzillaAttachmentAdapter.java (-82 / +82 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.adapters;	12	package org.eclipse.team.bugzilla.adapters;
13		13
14	import org.eclipse.jface.resource.ImageDescriptor;	14	import org.eclipse.jface.resource.ImageDescriptor;
15	import org.eclipse.swt.custom.StyledText;	15	import org.eclipse.swt.custom.StyledText;
16	import org.eclipse.swt.graphics.FontData;	16	import org.eclipse.swt.graphics.FontData;
17	import org.eclipse.team.bugzilla.BugzillaImages;	17	import org.eclipse.team.bugzilla.BugzillaImages;
18	import org.eclipse.team.bugzilla.browser.IWebContentAdapter;	18	import org.eclipse.team.bugzilla.browser.IWebContentAdapter;
19	import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;	19	import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
20	import org.eclipse.team.bugzilla.model.BugzillaAttachment;	20	import org.eclipse.team.bugzilla.model.BugzillaAttachment;
21	import org.eclipse.team.bugzilla.view.BugzillaModelPresenter;	21	import org.eclipse.team.bugzilla.view.BugzillaModelPresenter;
22	import org.eclipse.team.bugzilla.view.IPresentableAdapter;	22	import org.eclipse.team.bugzilla.view.IPresentableAdapter;
23		23
24	/**	24	/**
25	*	25	*
26	*/	26	*/
27	public class BugzillaAttachmentAdapter extends ModelElementAdapter implements IPresentableAdapter, IWebContentAdapter {	27	public class BugzillaAttachmentAdapter extends ModelElementAdapter implements IPresentableAdapter, IWebContentAdapter {
28		28
29	public BugzillaAttachmentAdapter() {	29	public BugzillaAttachmentAdapter() {
30	super();	30	super();
31	}	31	}
32		32
33	public void present(Object presentable, StyledText styledText) {	33	public void present(Object presentable, StyledText styledText) {
34		34
35	if (!(presentable instanceof BugzillaAttachment))	35	if (!(presentable instanceof BugzillaAttachment))
36	return;	36	return;
37		37
38	new BugzillaModelPresenter().present((BugzillaAttachment)presentable, styledText);	38	new BugzillaModelPresenter().present((BugzillaAttachment)presentable, styledText);
39	}	39	}
40		40
41	protected ImageDescriptor doGetImageDescriptor(Object object) {	41	protected ImageDescriptor doGetImageDescriptor(Object object) {
42	final BugzillaAttachment attachment= (BugzillaAttachment)object;	42	final BugzillaAttachment attachment= (BugzillaAttachment)object;
43	return attachment.getData() != null ? BugzillaImages.ATTACHMENT: BugzillaImages.INCOMPLETE_ATTACHMENT;	43	return attachment.getData() != null ? BugzillaImages.ATTACHMENT: BugzillaImages.INCOMPLETE_ATTACHMENT;
44	}	44	}
45		45
46	public String getLabel(Object o) {	46	public String getLabel(Object o) {
47	final BugzillaAttachment attachment= (BugzillaAttachment)o;	47	final BugzillaAttachment attachment= (BugzillaAttachment)o;
48	return attachment.isRefreshing() ? getRefreshingLabel("attachment " + attachment.getID()) : getStandardLabel(attachment);	48	return attachment.isRefreshing() ? getRefreshingLabel("attachment " + attachment.getID()) : getStandardLabel(attachment);
49	}	49	}
50		50
51	/**	51	/**
52	* @param attachment	52	* @param attachment
53	* @return	53	* @return String
54	*/	54	*/
55	private String getStandardLabel(final BugzillaAttachment attachment) {	55	private String getStandardLabel(final BugzillaAttachment attachment) {
56	final StringBuffer label= new StringBuffer();	56	final StringBuffer label= new StringBuffer();
57		57
58	if (attachment.getDescription().getBoolean(AttachmentDescription.OBSOLETE))	58	if (attachment.getDescription().getBoolean(AttachmentDescription.OBSOLETE))
59	label.append("[OBSOLETE] ");	59	label.append("[OBSOLETE] ");
60		60
61	label.append("[").append(attachment.getDescription().getString(AttachmentDescription.ID)).append("] ");	61	label.append("[").append(attachment.getDescription().getString(AttachmentDescription.ID)).append("] ");
62		62
63	if (attachment.hasLocalContent())	63	if (attachment.hasLocalContent())
64	label.append(attachment.getDescription().getString(AttachmentDescription.DESCRIPTION));	64	label.append(attachment.getDescription().getString(AttachmentDescription.DESCRIPTION));
65		65
66	return label.toString();	66	return label.toString();
67	}	67	}
68		68
69	public String getURL(Object o) {	69	public String getURL(Object o) {
70	return null;	70	return null;
71	}	71	}
72		72
73	/* (non-Javadoc)	73	/* (non-Javadoc)
74	* @see org.eclipse.team.bugzilla.adapters.ModelElementAdapter#getFont(java.lang.Object)	74	* @see org.eclipse.team.bugzilla.adapters.ModelElementAdapter#getFont(java.lang.Object)
75	*/	75	*/
76	public FontData getFont(Object element) {	76	public FontData getFont(Object element) {
77	final BugzillaAttachment attachment= (BugzillaAttachment)element;	77	final BugzillaAttachment attachment= (BugzillaAttachment)element;
78	if (attachment.isRefreshing())	78	if (attachment.isRefreshing())
79	return getRefreshingFont();	79	return getRefreshingFont();
80	return super.getFont(element);	80	return super.getFont(element);
81	}	81	}
82	}	82	}

Lines 1-68 Link Here

(-)src/org/eclipse/team/bugzilla/datatypes/BugzillaConfiguration.java (-68 / +62 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.team.bugzilla.datatypes;	11	package org.eclipse.team.bugzilla.datatypes;
12		12
13	import org.eclipse.team.bugzilla.BugzillaFactory;	13	import org.eclipse.team.bugzilla.BugzillaFactory;
14		14
15		15
16		16
17	public class BugzillaConfiguration {	17	public class BugzillaConfiguration {
18		18
19	private String fName;	19	private String fName;
20	private String fBaseURL;	20	private String fBaseURL;
21	private String fCookie;	21	private String fCookie;
22	private int version;	22	private int version;
23		23
24	public BugzillaConfiguration(String name, String baseURL) {	24	public BugzillaConfiguration(String name, String baseURL) {
25	fName= name;	25	fName= name;
26	fBaseURL= baseURL;	26	fBaseURL= baseURL;
27	version = BugzillaFactory.VERSION_UNKNOWN;	27	version = BugzillaFactory.VERSION_UNKNOWN;
28	}	28	}
29		29
30	public void setBaseURL(String baseURL) {	30	public void setBaseURL(String baseURL) {
31	fBaseURL = baseURL;	31	fBaseURL = baseURL;
32	}	32	}
33		33
34	public String getBaseURL() {	34	public String getBaseURL() {
35	return fBaseURL;	35	return fBaseURL;
36	}	36	}
37		37
38	public String getName() {	38	public String getName() {
39	return fName;	39	return fName;
40	}	40	}
41		41
42	public void setName(String name) {	42	public void setName(String name) {
43	fName = name;	43	fName = name;
44	}	44	}
45		45
46	/**	46	public void setLoginCookie(String cookie) {
47	* @param cookie	47	this.fCookie = cookie;
48	*/	48	}
49	public void setLoginCookie(String cookie) {	49
50	this.fCookie = cookie;	50	public String getLoginCookie() {
51	}	51	return fCookie;
52		52	}
53	/**	53
54	* @return	54
55	*/	55	public int getVersion() {
56	public String getLoginCookie() {	56	return version;
57	return fCookie;	57	}
58	}	58
59		59	public void setVersion(int version) {
60		60	this.version = version;
61	public int getVersion() {	61	}
62	return version;	62	}
63	}
64
65	public void setVersion(int version) {
66	this.version = version;
67	}
68	}

Lines 1-40 Link Here

(-)src/org/eclipse/team/bugzilla/model/IRemoteModel.java (-40 / +39 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.model;	12	package org.eclipse.team.bugzilla.model;
13		13
14	import org.eclipse.core.runtime.IProgressMonitor;	14	import org.eclipse.core.runtime.IProgressMonitor;
15	import org.eclipse.team.bugs.model.IGenericModel;	15	import org.eclipse.team.bugs.model.IGenericModel;
16	import org.eclipse.team.bugzilla.BugzillaException;	16	import org.eclipse.team.bugzilla.BugzillaException;
17		17
18		18
19	/**	19	/**
20	* An interface for elements which have remote content.	20	* An interface for elements which have remote content.
21	*/	21	*/
22	public interface IRemoteModel extends IGenericModel {	22	public interface IRemoteModel extends IGenericModel {
23		23
24	/**	24	/**
25	* Re-fetch data from the BTS.	25	* Re-fetch data from the BTS.
26	*	26	*
27	* @param monitor a progress monitor	27	* @param monitor a progress monitor
28	*/	28	*/
29	public void refresh(IProgressMonitor monitor) throws BugzillaException;	29	public void refresh(IProgressMonitor monitor) throws BugzillaException;
30		30
31	/**	31	/**
32	* Update this element with the new data.	32	* Update this element with the new data.
33	* @param state the new data	33	*/
34	*/	34	public void update();
35	public void update();	35
36		36
37		37	public boolean needsRefresh();
38	public boolean needsRefresh();	38
39		39	}
40	}

Lines 1-162 Link Here

(-)src/org/eclipse/team/bugzilla/operations/BugzillaOperations.java (-161 / +160 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2003 IBM Corporation and others.	2	* Copyright (c) 2000, 2003 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.team.bugzilla.operations;	11	package org.eclipse.team.bugzilla.operations;
12		12
13	import java.io.BufferedReader;	13	import java.io.BufferedReader;
14	import java.io.IOException;	14	import java.io.IOException;
15	import java.io.InputStream;	15	import java.io.InputStreamReader;
16	import java.io.InputStreamReader;	16	import java.net.MalformedURLException;
17	import java.net.MalformedURLException;	17	import java.net.URL;
18	import java.net.URL;	18	import java.net.URLConnection;
19	import java.net.URLConnection;	19	import java.util.regex.Matcher;
20	import java.util.regex.Matcher;	20	import java.util.regex.Pattern;
21	import java.util.regex.Pattern;	21
22		22	import org.eclipse.core.runtime.IProgressMonitor;
23	import org.eclipse.core.runtime.IProgressMonitor;	23	import org.eclipse.jface.resource.ImageDescriptor;
24	import org.eclipse.jface.resource.ImageDescriptor;	24	import org.eclipse.team.bugzilla.BugzillaException;
25	import org.eclipse.team.bugzilla.BugzillaException;	25	import org.eclipse.team.bugzilla.BugzillaFactory;
26	import org.eclipse.team.bugzilla.BugzillaFactory;	26	import org.eclipse.team.bugzilla.datatypes.AttachmentData;
27	import org.eclipse.team.bugzilla.datatypes.AttachmentData;	27	import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
28	import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;	28	import org.eclipse.team.bugzilla.datatypes.BugzillaConfiguration;
29	import org.eclipse.team.bugzilla.datatypes.BugzillaConfiguration;	29	import org.eclipse.team.bugzilla.datatypes.QueryData;
30	import org.eclipse.team.bugzilla.datatypes.QueryData;	30	import org.eclipse.team.bugzilla.datatypes.QueryURL;
31	import org.eclipse.team.bugzilla.datatypes.QueryURL;	31	import org.eclipse.team.bugzilla.datatypes.ReportData;
32	import org.eclipse.team.bugzilla.datatypes.ReportData;	32	import org.eclipse.team.bugzilla.xml.Parser;
33	import org.eclipse.team.bugzilla.xml.Parser;	33	import org.eclipse.team.bugzilla.xml.VersionHandler;
34	import org.eclipse.team.bugzilla.xml.VersionHandler;	34
35		35
36		36	public abstract class BugzillaOperations {
37	public abstract class BugzillaOperations {	37
38		38	protected static String bugScript; /* TODO: jpound - part of redirect workaround for gcj */
39	protected static String bugScript; /* TODO: jpound - part of redirect workaround for gcj */	39	//TODO:private static final String BAD_XML_HEADER = "<?xml version=\"1.0\" ?>";
40	//TODO:private static final String BAD_XML_HEADER = "<?xml version=\"1.0\" ?>";	40	public static BugzillaOperations getOperations(IProgressMonitor monitor, BugzillaConfiguration configuration) throws BugzillaException {
41	public static BugzillaOperations getOperations(IProgressMonitor monitor, BugzillaConfiguration configuration) throws BugzillaException {	41	int version = configuration.getVersion();
42	int version = configuration.getVersion();	42	if (version < 0) {
43	if (version < 0) {	43	version = getVersion(monitor, configuration);
44	version = getVersion(monitor, configuration);	44	configuration.setVersion(version);
45	configuration.setVersion(version);	45	}
46	}	46	return create(version);
47	return create(version);	47	}
48	}	48
49		49	public static BugzillaOperations create(int version) {
50	public static BugzillaOperations create(int version) {	50	switch (version) {
51	switch (version) {	51	case BugzillaFactory.VERSION_2_16:
52	case BugzillaFactory.VERSION_2_16:	52	return new BugzillaOperations_2_16();
53	return new BugzillaOperations_2_16();	53	case BugzillaFactory.VERSION_2_18:
54	case BugzillaFactory.VERSION_2_18:	54	return new BugzillaOperations_2_18();
55	return new BugzillaOperations_2_18();	55
56		56	}
57	}	57	return null;
58	return null;	58	}
59	}	59
60		60	public static int getVersion(IProgressMonitor monitor, BugzillaConfiguration configuration) throws BugzillaException {
61	public static int getVersion(IProgressMonitor monitor, BugzillaConfiguration configuration) throws BugzillaException {	61	// find the version by requesting an invalid bug.
62	// find the version by requesting an invalid bug.	62	String url = configuration.getBaseURL();
63	String url = configuration.getBaseURL();	63	if (!url.endsWith("/")) {
64	if (!url.endsWith("/")) {	64	url += "/";
65	url += "/";	65	}
66	}	66	try {
67	try {	67	final HTTPConnection connection= new HTTPConnection(url + "xml.cgi?id=1");
68	final HTTPConnection connection= new HTTPConnection(url + "xml.cgi?id=1");	68	final String xml= connection.getString(monitor);
69	final String xml= connection.getString(monitor);	69	final Parser parser= new Parser(false, false);
70	final Parser parser= new Parser(false, false);	70	final VersionHandler handler= new VersionHandler();
71	final VersionHandler handler= new VersionHandler();	71	parser.parse(xml, handler);
72	parser.parse(xml, handler);	72	bugScript = "xml.cgi?id=";
73	bugScript = "xml.cgi?id=";	73	return handler.getVersion();
74	return handler.getVersion();	74	} catch (Exception e) {
75	} catch (Exception e) {	75	/* FIXME: jpound - work around for gcj not handling the xml.cgi redirect in bugilla 2.18 */
76	/* FIXME: jpound - work around for gcj not handling the xml.cgi redirect in bugilla 2.18 */	76	bugScript = "show_bug.cgi?ctype=xml&id=";
77	bugScript = "show_bug.cgi?ctype=xml&id=";	77	final HTTPConnection connection= new HTTPConnection(url + bugScript + "1");
78	final HTTPConnection connection= new HTTPConnection(url + bugScript + "1");	78	final String xml= connection.getString(monitor);
79	final String xml= connection.getString(monitor);	79	final Parser parser= new Parser(false, false);
80	final Parser parser= new Parser(false, false);	80	final VersionHandler handler= new VersionHandler();
81	final VersionHandler handler= new VersionHandler();	81	parser.parse(xml, handler);
82	parser.parse(xml, handler);	82	return handler.getVersion();
83	return handler.getVersion();	83	}
84	}	84	}
85	}	85
86		86	public static ImageDescriptor getBugzillaIcon(String url) {
87	public static ImageDescriptor getBugzillaIcon(String url) {	87	try {
88	try {	88	BufferedReader read = new BufferedReader(new InputStreamReader(new URL(url).openStream()));
89	BufferedReader read = new BufferedReader(new InputStreamReader(new URL(url).openStream()));	89	String line;
90	String line;	90	String image;
91	String image;	91	url = url.endsWith("/") ? url : url + "/";
92	url = url.endsWith("/") ? url : url + "/";	92	Pattern iconFlag = Pattern.compile(".rel=\".icon\".*");
93	Pattern iconFlag = Pattern.compile(".rel=\".icon\".*");	93
94		94	while ((line = read.readLine()) != null) {
95	while ((line = read.readLine()) != null) {	95
96		96	Matcher m = iconFlag.matcher(line);
97	Matcher m = iconFlag.matcher(line);	97	if (m.matches()) {
98	if (m.matches()) {	98	image = parseUrl(read, line, url);
99	image = parseUrl(read, line, url);	99	read.close();
100	read.close();	100	return (image == null) ? null : ImageDescriptor.createFromURL(new URL(image));
101	return (image == null) ? null : ImageDescriptor.createFromURL(new URL(image));	101	}
102	}	102	}
103	}	103	read.close();
104	read.close();	104	/* Attempt to find the default icon */
105	/* Attempt to find the default icon */	105	URL base = new URL(url);
106	URL base = new URL(url);	106	URL iconUrl = new URL(base.getProtocol() + "://" + base.getHost() + "/" + "favicon.ico");
107	URL iconUrl = new URL(base.getProtocol() + "://" + base.getHost() + "/" + "favicon.ico");	107
108		108	URLConnection con = iconUrl.openConnection();
109	URLConnection con = iconUrl.openConnection();	109	int len = con.getContentLength();
110	int len = con.getContentLength();	110
111		111	if (len <= 0) {
112	if (len <= 0) {	112	return null;
113	return null;	113	}
114	}	114
115		115
116		116	ImageDescriptor defaultIcon = ImageDescriptor.createFromURL(new URL(iconUrl.toString()));
117	ImageDescriptor defaultIcon = ImageDescriptor.createFromURL(new URL(iconUrl.toString()));	117
118		118	if (defaultIcon.getImageData() != null) {
119	if (defaultIcon.getImageData() != null) {	119	return defaultIcon;
120	return defaultIcon;	120	}
121	}	121
122		122	} catch (MalformedURLException e) {
123	} catch (MalformedURLException e) {	123	System.err.println("BugzillaOperations: Malformed URL when fetching icon");
124	System.err.println("BugzillaOperations: Malformed URL when fetching icon");	124	} catch (IOException e) {
125	} catch (IOException e) {	125	System.err.println("BugzillaOperations: IOException exception when fetching icon");
126	System.err.println("BugzillaOperations: IOException exception when fetching icon");	126	}
127	}	127	return null;
128	return null;	128	}
129	}	129
130		130	private static String parseUrl(BufferedReader read, String line, String url) throws IOException {
131	private static String parseUrl(BufferedReader read, String line, String url) throws IOException {	131	String hrefFlag = "href=\"";
132	String hrefFlag = "href=\"";	132	int index;
133	int index;	133	do {
134	do {	134	if ((index = line.indexOf(hrefFlag)) >= 0) {
135	if ((index = line.indexOf(hrefFlag)) >= 0) {	135	/* keep breaking off begining part of string to get icon url */
136	/* keep breaking off begining part of string to get icon url */	136	line = line.substring(index + hrefFlag.length());
137	line = line.substring(index + hrefFlag.length());	137	url += line.substring(0, line.indexOf("\""));
138	url += line.substring(0, line.indexOf("\""));	138
139		139	return url;
140	return url;	140	}
141	}	141	} while ((line = read.readLine()) != null);
142	} while ((line = read.readLine()) != null);	142
143		143	return null;
144	return null;	144	}
145	}	145
146		146	public abstract ReportData getReportData(IProgressMonitor monitor, BugzillaConfiguration configuration, String id) throws BugzillaException;
147	public abstract ReportData getReportData(IProgressMonitor monitor, BugzillaConfiguration configuration, String id) throws BugzillaException;	147
148		148	public abstract QueryData getQueryData(IProgressMonitor monitor, BugzillaConfiguration configuration, QueryURL queryURL) throws BugzillaException;
149	public abstract QueryData getQueryData(IProgressMonitor monitor, BugzillaConfiguration configuration, QueryURL queryURL) throws BugzillaException;	149
150		150	public abstract AttachmentData getAttachment(IProgressMonitor monitor, BugzillaConfiguration configuration, AttachmentDescription desc) throws BugzillaException;
151	public abstract AttachmentData getAttachment(IProgressMonitor monitor, BugzillaConfiguration configuration, AttachmentDescription desc) throws BugzillaException;	151
152		152	public abstract String getReportURL(BugzillaConfiguration configuration, String reportID);
153	public abstract String getReportURL(BugzillaConfiguration configuration, String reportID);	153
154		154	public abstract String getCommentURL(BugzillaConfiguration configuration, String reportID, int commentNbr);
155	public abstract String getCommentURL(BugzillaConfiguration configuration, String reportID, int commentNbr);	155
156		156	public abstract String getAttachmentURL(BugzillaConfiguration configuration, String attachmentID);
157	public abstract String getAttachmentURL(BugzillaConfiguration configuration, String attachmentID);	157
158		158	public abstract String getReportIDFromURL(BugzillaConfiguration configuration, String url);
159	public abstract String getReportIDFromURL(BugzillaConfiguration configuration, String url);	159
160		160	public abstract String getQueryURL(BugzillaConfiguration configuration, String url);
161	public abstract String getQueryURL(BugzillaConfiguration configuration, String url);
162	}	161	}

Lines 1-252 Link Here

(-)src/org/eclipse/team/bugzilla/persistence/PersistenceManager.java (-252 / +251 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.persistence;	12	package org.eclipse.team.bugzilla.persistence;
13		13
14	import java.util.ArrayList;	14	import java.util.ArrayList;
15	import java.util.HashMap;	15	import java.util.HashMap;
16	import java.util.Map;	16	import java.util.Map;
17		17
18	import org.eclipse.core.runtime.IAdaptable;	18	import org.eclipse.core.runtime.IAdaptable;
19	import org.eclipse.core.runtime.preferences.InstanceScope;	19	import org.eclipse.core.runtime.preferences.InstanceScope;
20	import org.eclipse.team.bugs.extension.BugsException;	20	import org.eclipse.team.bugs.extension.BugsException;
21	import org.eclipse.team.bugs.model.IBugProvider;	21	import org.eclipse.team.bugs.model.IBugProvider;
22	import org.eclipse.team.bugs.model.IGenericModel;	22	import org.eclipse.team.bugs.model.IGenericModel;
23	import org.eclipse.team.bugs.model.IProviderListener;	23	import org.eclipse.team.bugs.model.IProviderListener;
24	import org.eclipse.team.bugzilla.BugzillaException;	24	import org.eclipse.team.bugzilla.BugzillaException;
25	import org.eclipse.team.bugzilla.BugzillaPlugin;	25	import org.eclipse.team.bugzilla.BugzillaPlugin;
26	import org.eclipse.team.bugzilla.adapters.BugzillaAdapterFactory;	26	import org.eclipse.team.bugzilla.adapters.BugzillaAdapterFactory;
27	import org.eclipse.team.bugzilla.model.BugzillaContainer;	27	import org.eclipse.team.bugzilla.model.BugzillaContainer;
28	import org.eclipse.team.bugzilla.model.BugzillaFolder;	28	import org.eclipse.team.bugzilla.model.BugzillaFolder;
29	import org.eclipse.team.bugzilla.model.BugzillaHistoryFolder;	29	import org.eclipse.team.bugzilla.model.BugzillaHistoryFolder;
30	import org.eclipse.team.bugzilla.model.BugzillaModel;	30	import org.eclipse.team.bugzilla.model.BugzillaModel;
31	import org.eclipse.team.bugzilla.model.BugzillaProvider;	31	import org.eclipse.team.bugzilla.model.BugzillaProvider;
32	import org.eclipse.team.bugzilla.model.BugzillaQuery;	32	import org.eclipse.team.bugzilla.model.BugzillaQuery;
33	import org.eclipse.team.bugzilla.model.BugzillaReport;	33	import org.eclipse.team.bugzilla.model.BugzillaReport;
34	import org.osgi.service.prefs.BackingStoreException;	34	import org.osgi.service.prefs.BackingStoreException;
35	import org.osgi.service.prefs.Preferences;	35	import org.osgi.service.prefs.Preferences;
36		36
37	/**	37	/**
38	*	38	*
39	*/	39	*/
40	public class PersistenceManager {	40	public class PersistenceManager {
41		41
42	/*	42	/*
43	* The preference node in the instance scope where the providers are persisted	43	* The preference node in the instance scope where the providers are persisted
44	*/	44	*/
45	private static final String PROVIDER_STORE_ID = "providers"; //$NON-NLS-1$	45	private static final String PROVIDER_STORE_ID = "providers"; //$NON-NLS-1$
46		46
47	protected static final BugzillaModel [] EMPTY_ARRAY= new BugzillaModel[0];	47	protected static final BugzillaModel [] EMPTY_ARRAY= new BugzillaModel[0];
48		48
49	/**	49	/**
50	* The key for the model type preference.	50	* The key for the model type preference.
51	*/	51	*/
52	public final static String MODEL_TYPE= "org.eclipse.team.bugzilla.modelType"; //$NON-NLS-1$	52	public final static String MODEL_TYPE= "org.eclipse.team.bugzilla.modelType"; //$NON-NLS-1$
53		53
54	public final static String ELEMENT_ID = "org.eclipse.team.bugzilla.elementId"; //$NON-NLS-1$	54	public final static String ELEMENT_ID = "org.eclipse.team.bugzilla.elementId"; //$NON-NLS-1$
55		55
56	/**	56	/**
57	* IDs for the different persistent model types.	57	* IDs for the different persistent model types.
58	*/	58	*/
59	public final static String PROVIDER= "provider"; //$NON-NLS-1$	59	public final static String PROVIDER= "provider"; //$NON-NLS-1$
60	public final static String FOLDER= "folder"; //$NON-NLS-1$	60	public final static String FOLDER= "folder"; //$NON-NLS-1$
61	public final static String HISTORY= "history"; //$NON-NLS-1$	61	public final static String HISTORY= "history"; //$NON-NLS-1$
62	public final static String REPORT= "report"; //$NON-NLS-1$	62	public final static String REPORT= "report"; //$NON-NLS-1$
63	public final static String QUERY= "query"; //$NON-NLS-1$	63	public final static String QUERY= "query"; //$NON-NLS-1$
64		64
65	private final static Map type2classMap;	65	private final static Map type2classMap;
66		66
67	/*	67	/*
68	* Listener that is registered with each provider to update	68	* Listener that is registered with each provider to update
69	* the store when the model changes	69	* the store when the model changes
70	*/	70	*/
71	private static IProviderListener listener = new IProviderListener() {	71	private static IProviderListener listener = new IProviderListener() {
72	/* (non-Javadoc)	72	/* (non-Javadoc)
73	* @see org.eclipse.team.bugs.model.IProviderListener#modelAdded(org.eclipse.team.bugs.model.IGenericModel, org.eclipse.team.bugs.model.IGenericModel)	73	* @see org.eclipse.team.bugs.model.IProviderListener#modelAdded(org.eclipse.team.bugs.model.IGenericModel, org.eclipse.team.bugs.model.IGenericModel)
74	*/	74	*/
75	public void elementsAdded(IGenericModel parent, IGenericModel[] children) {	75	public void elementsAdded(IGenericModel parent, IGenericModel[] children) {
76	elementsChanged(children);	76	elementsChanged(children);
77	}	77	}
78		78
79	/* (non-Javadoc)	79	/* (non-Javadoc)
80	* @see org.eclipse.team.bugs.model.IProviderListener#modelChanged(org.eclipse.team.bugs.model.IGenericModel)	80	* @see org.eclipse.team.bugs.model.IProviderListener#modelChanged(org.eclipse.team.bugs.model.IGenericModel)
81	*/	81	*/
82	public void elementsChanged(IGenericModel[] elements) {	82	public void elementsChanged(IGenericModel[] elements) {
83	for (int i = 0; i < elements.length; i++) {	83	for (int i = 0; i < elements.length; i++) {
84	final BugzillaModel model = (BugzillaModel)elements[i];	84	final BugzillaModel model = (BugzillaModel)elements[i];
85	final IPersistenceAdapter adapter = getPersistenceAdapter(elements[i]);	85	final IPersistenceAdapter adapter = getPersistenceAdapter(elements[i]);
86	if (adapter != null)	86	if (adapter != null)
87	adapter.storeElement(model, false);	87	adapter.storeElement(model, false);
88	}	88	}
89	final BugzillaProvider provider= ((BugzillaModel)elements[0]).getBugzillaProvider();	89	final BugzillaProvider provider= ((BugzillaModel)elements[0]).getBugzillaProvider();
90	try {	90	try {
91	AbstractPersistenceAdapter.getPreferences(provider).flush();	91	AbstractPersistenceAdapter.getPreferences(provider).flush();
92	} catch (BackingStoreException e) {	92	} catch (BackingStoreException e) {
93	BugzillaPlugin.log(BugzillaException.asBugsException(e));	93	BugzillaPlugin.log(BugzillaException.asBugsException(e));
94	}	94	}
95	}	95	}
96		96
97	/* (non-Javadoc)	97	/* (non-Javadoc)
98	* @see org.eclipse.team.bugs.model.IProviderListener#modelRemoved(org.eclipse.team.bugs.model.IGenericModel, org.eclipse.team.bugs.model.IGenericModel)	98	* @see org.eclipse.team.bugs.model.IProviderListener#modelRemoved(org.eclipse.team.bugs.model.IGenericModel, org.eclipse.team.bugs.model.IGenericModel)
99	*/	99	*/
100	public void elementsRemoved(IGenericModel parent, IGenericModel[] children) {	100	public void elementsRemoved(IGenericModel parent, IGenericModel[] children) {
101	for (int i = 0; i < children.length; i++) {	101	for (int i = 0; i < children.length; i++) {
102	final BugzillaModel model = (BugzillaModel)children[i];	102	final BugzillaModel model = (BugzillaModel)children[i];
103	final IPersistenceAdapter adapter = getPersistenceAdapter(parent);	103	final IPersistenceAdapter adapter = getPersistenceAdapter(parent);
104	if (adapter != null)	104	if (adapter != null)
105	adapter.purgeChild((BugzillaModel)parent, model, false);	105	adapter.purgeChild((BugzillaModel)parent, model, false);
106	}	106	}
107	try {	107	try {
108	AbstractPersistenceAdapter.getPreferences(parent).flush();	108	AbstractPersistenceAdapter.getPreferences(parent).flush();
109	} catch (BackingStoreException e) {	109	} catch (BackingStoreException e) {
110	BugzillaPlugin.log(BugzillaException.asBugsException(e));	110	BugzillaPlugin.log(BugzillaException.asBugsException(e));
111	}	111	}
112	}	112	}
113	};	113	};
114		114
115		115
116	static {	116	static {
117	type2classMap = new HashMap();	117	type2classMap = new HashMap();
118	type2classMap.put(PROVIDER, BugzillaProvider.class);	118	type2classMap.put(PROVIDER, BugzillaProvider.class);
119	type2classMap.put(FOLDER, BugzillaFolder.class);	119	type2classMap.put(FOLDER, BugzillaFolder.class);
120	type2classMap.put(HISTORY, BugzillaHistoryFolder.class);	120	type2classMap.put(HISTORY, BugzillaHistoryFolder.class);
121	type2classMap.put(REPORT, BugzillaReport.class);	121	type2classMap.put(REPORT, BugzillaReport.class);
122	type2classMap.put(QUERY, BugzillaQuery.class);	122	type2classMap.put(QUERY, BugzillaQuery.class);
123	}	123	}
124		124
125	/**	125	/**
126	* Return the root preferences node whose children are providers	126	* Return the root preferences node whose children are providers
127	* @return the root preferences node whose children are providers	127	* @return the root preferences node whose children are providers
128	*/	128	*/
129	/* package */ static Preferences getRootNode() {	129	/* package */ static Preferences getRootNode() {
130	return new InstanceScope().getNode(BugzillaPlugin.ID).node(PROVIDER_STORE_ID);	130	return new InstanceScope().getNode(BugzillaPlugin.ID).node(PROVIDER_STORE_ID);
131	}	131	}
132		132
133	/**	133	/**
134	* Restore the providers from the preference store and return the restored providers	134	* Restore the providers from the preference store and return the restored providers
135	* @return the restored providers	135	* @return the restored providers
136	*/	136	*/
137	public static IBugProvider[] restoreProviders() {	137	public static IBugProvider[] restoreProviders() {
138	BugzillaModel[] providers = restoreChildren(null /* no parent */, getRootNode());	138	BugzillaModel[] providers = restoreChildren(null /* no parent */, getRootNode());
139	IBugProvider[] result = new IBugProvider[providers.length];	139	IBugProvider[] result = new IBugProvider[providers.length];
140	System.arraycopy(providers, 0, result, 0, providers.length);	140	System.arraycopy(providers, 0, result, 0, providers.length);
141	return result;	141	return result;
142	}	142	}
143		143
144	/**	144	/**
145	* Return the persistence adapter for the given element	145	* Return the persistence adapter for the given element
146	* or <code>null</code> if there isn't one.	146	* or <code>null</code> if there isn't one.
147	* @param element the element	147	* @param element the element
148	* @return the persistence adapter for the given element	148	* @return the persistence adapter for the given element
149	* or <code>null</code>	149	* or <code>null</code>
150	*/	150	*/
151	public static IPersistenceAdapter getPersistenceAdapter(Object element) {	151	public static IPersistenceAdapter getPersistenceAdapter(Object element) {
152	if (element instanceof IAdaptable) {	152	if (element instanceof IAdaptable) {
153	Object adapter = ((IAdaptable)element).getAdapter(IPersistenceAdapter.class);	153	Object adapter = ((IAdaptable)element).getAdapter(IPersistenceAdapter.class);
154	if (adapter instanceof IPersistenceAdapter)	154	if (adapter instanceof IPersistenceAdapter)
155	return (IPersistenceAdapter)adapter;	155	return (IPersistenceAdapter)adapter;
156	}	156	}
157	return null;	157	return null;
158	}	158	}
159		159
160	/*	160	/*
161	* Method used by persistence adapters to restore a bugzilla model	161	* Method used by persistence adapters to restore a bugzilla model
162	*/	162	*/
163	/* package */ static BugzillaModel restoreChild(BugzillaContainer parent, Preferences node) {	163	/* package */ static BugzillaModel restoreChild(BugzillaContainer parent, Preferences node) {
164	final String type= node.get(MODEL_TYPE, ""); //$NON-NLS-1$	164	final String type= node.get(MODEL_TYPE, ""); //$NON-NLS-1$
165	final String id = node.get(ELEMENT_ID, ""); //$NON-NLS-1$	165	final String id = node.get(ELEMENT_ID, ""); //$NON-NLS-1$
166	IPersistenceAdapter adapter = getPersistenceAdapter(type);	166	IPersistenceAdapter adapter = getPersistenceAdapter(type);
167	if (adapter != null) {	167	if (adapter != null) {
168	try {	168	try {
169	BugzillaModel element = adapter.restoreElement(parent, node, id);	169	BugzillaModel element = adapter.restoreElement(parent, node, id);
170	return element;	170	return element;
171	} catch (BugzillaException e) {	171	} catch (BugzillaException e) {
172	BugzillaPlugin.log(e);	172	BugzillaPlugin.log(e);
173	}	173	}
174	}	174	}
175	return null;	175	return null;
176	}	176	}
177		177
178	/**	178	/**
179	* Restore the childen of the given element.	179	* Restore the childen of the given element.
180	* @param parent the element	180	* @param parent the element
181	* @param node the node for the element that may contain child nodes	181	* @param node the node for the element that may contain child nodes
182	* representing children of the element	182	* representing children of the element
183	* @return the restored children	183	* @return the restored children
184	*/	184	*/
185	/* package */ static final BugzillaModel[] restoreChildren(BugzillaContainer parent, Preferences node) {	185	/* package */ static final BugzillaModel[] restoreChildren(BugzillaContainer parent, Preferences node) {
186	final String [] childrenNames;	186	final String [] childrenNames;
187	try {	187	try {
188	childrenNames= node.childrenNames();	188	childrenNames= node.childrenNames();
189	} catch (BackingStoreException e) {	189	} catch (BackingStoreException e) {
190	BugzillaPlugin.log(BugsException.asBugsException(e));	190	BugzillaPlugin.log(BugsException.asBugsException(e));
191	return EMPTY_ARRAY;	191	return EMPTY_ARRAY;
192	}	192	}
193	final ArrayList children= new ArrayList();	193	final ArrayList children= new ArrayList();
194	for (int i = 0; i < childrenNames.length; i++) {	194	for (int i = 0; i < childrenNames.length; i++) {
195	final String childName= childrenNames[i];	195	final String childName= childrenNames[i];
196	final Preferences childNode= node.node(childName);	196	final Preferences childNode= node.node(childName);
197	final BugzillaModel child= restoreChild(parent, childNode);	197	final BugzillaModel child= restoreChild(parent, childNode);
198	if (child != null)	198	if (child != null)
199	children.add(child);	199	children.add(child);
200	}	200	}
201	return (BugzillaModel[]) children.toArray(new BugzillaModel[children.size()]);	201	return (BugzillaModel[]) children.toArray(new BugzillaModel[children.size()]);
202	}	202	}
203		203
204	private static IPersistenceAdapter getPersistenceAdapter(String type) {	204	private static IPersistenceAdapter getPersistenceAdapter(String type) {
205	Class typeClass = (Class)type2classMap.get(type);	205	Class typeClass = (Class)type2classMap.get(type);
206	if (typeClass != null) {	206	if (typeClass != null) {
207	Object adapter = BugzillaAdapterFactory.getPersistenceAdapter(typeClass);	207	Object adapter = BugzillaAdapterFactory.getPersistenceAdapter(typeClass);
208	if (adapter instanceof IPersistenceAdapter)	208	if (adapter instanceof IPersistenceAdapter)
209	return (IPersistenceAdapter)adapter;	209	return (IPersistenceAdapter)adapter;
210	}	210	}
211	return null;	211	return null;
212	}	212	}
213		213
214	/**	214	/**
215	* The provider has been added so persist it's state	215	* The provider has been added so persist it's state
216	* @param provider	216	* @param provider
217	*/	217	*/
218	public static void providerAdded(BugzillaProvider provider) {	218	public static void providerAdded(BugzillaProvider provider) {
219	IPersistenceAdapter adapter = getPersistenceAdapter(provider);	219	IPersistenceAdapter adapter = getPersistenceAdapter(provider);
220	if (adapter != null) {	220	if (adapter != null) {
221	adapter.storeElement(provider, true /* flush to disk */);	221	adapter.storeElement(provider, true /* flush to disk */);
222	}	222	}
223	provider.getEventHandler().addProviderListener(listener );	223	provider.getEventHandler().addProviderListener(listener );
224	}	224	}
225		225
226	/**	226	/**
227	* The provider has been removed so purge any persisted state	227	* The provider has been removed so purge any persisted state
228	* @param provider	228	* @param provider
229	*/	229	*/
230	public static void providerRemoved(BugzillaProvider provider) {	230	public static void providerRemoved(BugzillaProvider provider) {
231	IPersistenceAdapter adapter = getPersistenceAdapter(provider);	231	IPersistenceAdapter adapter = getPersistenceAdapter(provider);
232	if (adapter != null) {	232	if (adapter != null) {
233	adapter.purgeChild(null, provider, true /* flush to disk */);	233	adapter.purgeChild(null, provider, true /* flush to disk */);
234	}	234	}
235	provider.getEventHandler().removeProviderListener(listener);	235	provider.getEventHandler().removeProviderListener(listener);
236	}	236	}
237		237
238	/**	238	/**
239	* @param container	239	* @param container
240	* @return	240	*/
241	*/	241	public static Preferences getPreferenceNode(BugzillaContainer container) {
242	public static Preferences getPreferenceNode(BugzillaContainer container) {	242	return AbstractPersistenceAdapter.getPreferences(container);
243	return AbstractPersistenceAdapter.getPreferences(container);	243	}
244	}	244
245		245	/*
246	/*	246	* Do not allow instantiation
247	* Do not allow instantiation	247	*/
248	*/	248	private PersistenceManager() {
249	private PersistenceManager() {	249	}
250	}	250
251		251	}
252	}

Lines 1-28 Link Here

(-)src/org/eclipse/team/bugzilla/tools/IBugzillaSelectionProvider.java (-28 / +25 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.tools;	12	package org.eclipse.team.bugzilla.tools;
13		13
14	/**	14	/**
15	*	15	*
16	*/	16	*/
17	public interface IBugzillaSelectionProvider {	17	public interface IBugzillaSelectionProvider {
18		18
19	/**	19	BugzillaSelection getSelection();
20	* @return	20
21	*/	21	void addListener(IBugzillaSelectionListener listener);
22	BugzillaSelection getSelection();	22
23		23	void removeListener(IBugzillaSelectionListener listener);
24	void addListener(IBugzillaSelectionListener listener);	24
25		25	}
26	void removeListener(IBugzillaSelectionListener listener);
27
28	}

Lines 1-103 Link Here

(-)src/org/eclipse/team/bugzilla/view/ActionManager.java (-103 / +103 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.view;	12	package org.eclipse.team.bugzilla.view;
13		13
14	import org.eclipse.jface.action.*;	14	import org.eclipse.jface.action.*;
15	import org.eclipse.swt.custom.StyledText;	15	import org.eclipse.swt.custom.StyledText;
16	import org.eclipse.swt.events.FocusAdapter;	16	import org.eclipse.swt.events.FocusAdapter;
17	import org.eclipse.swt.events.FocusEvent;	17	import org.eclipse.swt.events.FocusEvent;
18	import org.eclipse.team.bugs.extension.IViewerProxy;	18	import org.eclipse.team.bugs.extension.IViewerProxy;
19	import org.eclipse.team.bugzilla.actions.*;	19	import org.eclipse.team.bugzilla.actions.*;
20	import org.eclipse.team.bugzilla.tools.IBugzillaSelectionProvider;	20	import org.eclipse.team.bugzilla.tools.IBugzillaSelectionProvider;
21	import org.eclipse.ui.IWorkbenchActionConstants;	21	import org.eclipse.ui.IWorkbenchActionConstants;
22	import org.eclipse.ui.actions.ActionFactory;	22	import org.eclipse.ui.actions.ActionFactory;
23		23
24	/**	24	/**
25	*	25	*
26	*/	26	*/
27	class ActionManager extends FocusAdapter {	27	class ActionManager extends FocusAdapter {
28		28
29	private final BugzillaDeleteAction fDeleteAction;	29	private final BugzillaDeleteAction fDeleteAction;
30	private final BugzillaCopyAction fCopyAction;	30	private final BugzillaCopyAction fCopyAction;
31	private final BugzillaPasteAction fPasteAction;	31	private final BugzillaPasteAction fPasteAction;
32	private final BugzillaMoveAction fMoveAction;	32	private final BugzillaMoveAction fMoveAction;
33	private final BugzillaRenameAction fRenameAction;	33	private final BugzillaRenameAction fRenameAction;
34	private final RefreshAction fRefreshAction;	34	private final RefreshAction fRefreshAction;
35		35
36	private final ShowInBrowserAction fShowInBrowserAction;	36	private final ShowInBrowserAction fShowInBrowserAction;
37	private final ClearHistoryAction fClearHistoryAction;	37	private final ClearHistoryAction fClearHistoryAction;
38		38
39	private final TextSelectAllAction fTextSelectAllAction;	39	private final TextSelectAllAction fTextSelectAllAction;
40		40
41	private final BugzillaViewExtension fExtension;	41	//private final BugzillaViewExtension fExtension;
42		42
43	public ActionManager(BugzillaViewExtension extension) {	43	public ActionManager(BugzillaViewExtension extension) {
44		44
45	fExtension= extension;	45	//fExtension= extension;
46	final IViewerProxy proxy= extension.getProxy();	46	final IViewerProxy proxy= extension.getProxy();
47	final IBugzillaSelectionProvider provider = extension.getBugzillaSelectionProvider();	47	final IBugzillaSelectionProvider provider = extension.getBugzillaSelectionProvider();
48	fDeleteAction= new BugzillaDeleteAction(proxy, provider);	48	fDeleteAction= new BugzillaDeleteAction(proxy, provider);
49	fPasteAction= new BugzillaPasteAction(proxy, provider);	49	fPasteAction= new BugzillaPasteAction(proxy, provider);
50	fCopyAction= new BugzillaCopyAction(proxy, extension, fPasteAction);	50	fCopyAction= new BugzillaCopyAction(proxy, extension, fPasteAction);
51	fMoveAction= new BugzillaMoveAction(proxy, provider);	51	fMoveAction= new BugzillaMoveAction(proxy, provider);
52	fRenameAction= new BugzillaRenameAction(proxy, provider);	52	fRenameAction= new BugzillaRenameAction(proxy, provider);
53	fClearHistoryAction= new ClearHistoryAction(proxy, provider);	53	fClearHistoryAction= new ClearHistoryAction(proxy, provider);
54	fShowInBrowserAction= new ShowInBrowserAction(proxy, provider);	54	fShowInBrowserAction= new ShowInBrowserAction(proxy, provider);
55	fRefreshAction= new RefreshAction(proxy, provider);	55	fRefreshAction= new RefreshAction(proxy, provider);
56	fTextSelectAllAction= new TextSelectAllAction(extension);	56	fTextSelectAllAction= new TextSelectAllAction(extension);
57		57
58	proxy.registerGlobalAction(ActionFactory.DELETE.getId(), fDeleteAction);	58	proxy.registerGlobalAction(ActionFactory.DELETE.getId(), fDeleteAction);
59	proxy.registerGlobalAction(ActionFactory.COPY.getId(), fCopyAction);	59	proxy.registerGlobalAction(ActionFactory.COPY.getId(), fCopyAction);
60	proxy.registerGlobalAction(ActionFactory.PASTE.getId(), fPasteAction);	60	proxy.registerGlobalAction(ActionFactory.PASTE.getId(), fPasteAction);
61	proxy.registerGlobalAction(ActionFactory.MOVE.getId(), fMoveAction);	61	proxy.registerGlobalAction(ActionFactory.MOVE.getId(), fMoveAction);
62	proxy.registerGlobalAction(ActionFactory.RENAME.getId(), fRenameAction);	62	proxy.registerGlobalAction(ActionFactory.RENAME.getId(), fRenameAction);
63	proxy.registerGlobalAction(ActionFactory.REFRESH.getId(), fRefreshAction);	63	proxy.registerGlobalAction(ActionFactory.REFRESH.getId(), fRefreshAction);
64	proxy.registerGlobalAction(ActionFactory.SELECT_ALL.getId(), fTextSelectAllAction);	64	proxy.registerGlobalAction(ActionFactory.SELECT_ALL.getId(), fTextSelectAllAction);
65	}	65	}
66		66
67	public void fillContextMenu(IMenuManager menu) {	67	public void fillContextMenu(IMenuManager menu) {
68	if (fShowInBrowserAction.isEnabled())	68	if (fShowInBrowserAction.isEnabled())
69	menu.add(fShowInBrowserAction);	69	menu.add(fShowInBrowserAction);
70	if (fClearHistoryAction.isEnabled())	70	if (fClearHistoryAction.isEnabled())
71	menu.add(fClearHistoryAction);	71	menu.add(fClearHistoryAction);
72	}	72	}
73		73
74	public void updateActionEnablements() {	74	public void updateActionEnablements() {
75	fShowInBrowserAction.setEnablement();	75	fShowInBrowserAction.setEnablement();
76	fDeleteAction.setEnablement();	76	fDeleteAction.setEnablement();
77	fCopyAction.setEnablement();	77	fCopyAction.setEnablement();
78	fPasteAction.setEnablement();	78	fPasteAction.setEnablement();
79	fMoveAction.setEnablement();	79	fMoveAction.setEnablement();
80	fRefreshAction.setEnablement();	80	fRefreshAction.setEnablement();
81	fRenameAction.setEnablement();	81	fRenameAction.setEnablement();
82	fClearHistoryAction.setEnablement();	82	fClearHistoryAction.setEnablement();
83	fTextSelectAllAction.setEnablement();	83	fTextSelectAllAction.setEnablement();
84	}	84	}
85		85
86	/* (non-Javadoc)	86	/* (non-Javadoc)
87	* @see org.eclipse.swt.events.FocusAdapter#focusGained(org.eclipse.swt.events.FocusEvent)	87	* @see org.eclipse.swt.events.FocusAdapter#focusGained(org.eclipse.swt.events.FocusEvent)
88	*/	88	*/
89	public void focusGained(FocusEvent e) {	89	public void focusGained(FocusEvent e) {
90	updateActionEnablements();	90	updateActionEnablements();
91	}	91	}
92		92
93	/**	93	/**
94	* @param styledText	94	* @param styledText
95	*/	95	*/
96	public void createTextContextMenu(StyledText styledText) {	96	public void createTextContextMenu(StyledText styledText) {
97	final MenuManager menu= new MenuManager(null);	97	final MenuManager menu= new MenuManager(null);
98	menu.add(fCopyAction);	98	menu.add(fCopyAction);
99	menu.add(fTextSelectAllAction);	99	menu.add(fTextSelectAllAction);
100	menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));	100	menu.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));
101	styledText.setMenu(menu.createContextMenu(styledText));	101	styledText.setMenu(menu.createContextMenu(styledText));
102	}	102	}
103	}	103	}

Lines 1-337 Link Here

(-)src/org/eclipse/team/bugzilla/view/BugzillaModelPresenter.java (-337 / +336 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright (c) 2000, 2004 IBM Corporation and others.	2	* Copyright (c) 2000, 2004 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials	3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Common Public License v1.0	4	* are made available under the terms of the Common Public License v1.0
5	* which accompanies this distribution, and is available at	5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/cpl-v10.html	6	* http://www.eclipse.org/legal/cpl-v10.html
7	*	7	*
8	* Contributors:	8	* Contributors:
9	* IBM Corporation - initial API and implementation	9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/	10	*******************************************************************************/
11		11
12	package org.eclipse.team.bugzilla.view;	12	package org.eclipse.team.bugzilla.view;
13		13
14	import java.io.UnsupportedEncodingException;	14	import java.io.UnsupportedEncodingException;
15	import java.net.URLDecoder;	15	import java.net.URLDecoder;
16	import java.text.DateFormat;	16	import java.text.DateFormat;
17	import java.util.Date;	17	import java.util.Date;
18	import java.util.HashMap;	18	import java.util.HashMap;
19	import java.util.Iterator;	19	import java.util.Iterator;
20		20
21	import org.eclipse.jface.text.TextPresentation;	21	import org.eclipse.jface.text.TextPresentation;
22	import org.eclipse.swt.SWT;	22	import org.eclipse.swt.SWT;
23	import org.eclipse.swt.custom.BusyIndicator;	23	import org.eclipse.swt.custom.BusyIndicator;
24	import org.eclipse.swt.custom.StyleRange;	24	import org.eclipse.swt.custom.StyleRange;
25	import org.eclipse.swt.custom.StyledText;	25	import org.eclipse.swt.custom.StyledText;
26	import org.eclipse.team.bugzilla.datatypes.AttachmentData;	26	import org.eclipse.team.bugzilla.datatypes.AttachmentData;
27	import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;	27	import org.eclipse.team.bugzilla.datatypes.AttachmentDescription;
28	import org.eclipse.team.bugzilla.datatypes.CommentData;	28	import org.eclipse.team.bugzilla.datatypes.CommentData;
29	import org.eclipse.team.bugzilla.datatypes.ReportData;	29	import org.eclipse.team.bugzilla.datatypes.ReportData;
30	import org.eclipse.team.bugzilla.model.BugzillaAttachment;	30	import org.eclipse.team.bugzilla.model.BugzillaAttachment;
31	import org.eclipse.team.bugzilla.model.BugzillaComment;	31	import org.eclipse.team.bugzilla.model.BugzillaComment;
32	import org.eclipse.team.bugzilla.model.BugzillaFolder;	32	import org.eclipse.team.bugzilla.model.BugzillaModel;
33	import org.eclipse.team.bugzilla.model.BugzillaModel;	33	import org.eclipse.team.bugzilla.model.BugzillaQuery;
34	import org.eclipse.team.bugzilla.model.BugzillaQuery;	34	import org.eclipse.team.bugzilla.model.BugzillaReport;
35	import org.eclipse.team.bugzilla.model.BugzillaReport;	35
36		36	public class BugzillaModelPresenter {
37	public class BugzillaModelPresenter {	37
38		38	protected TextPresentation fPresentation;
39	protected TextPresentation fPresentation;	39	protected StringBuffer fBuffer;
40	protected StringBuffer fBuffer;	40	protected StyledText fStyledText;
41	protected StyledText fStyledText;	41
42		42	public BugzillaModelPresenter() {
43	public BugzillaModelPresenter() {	43	fStyledText= null;
44	fStyledText= null;	44	fPresentation= null;
45	fPresentation= null;	45	fBuffer= null;
46	fBuffer= null;	46	}
47	}	47
48		48	private void begin(StyledText styledText) {
49	private void begin(StyledText styledText) {	49	fPresentation= new TextPresentation();
50	fPresentation= new TextPresentation();	50	fBuffer= new StringBuffer();
51	fBuffer= new StringBuffer();	51	fStyledText= styledText;
52	fStyledText= styledText;	52
53		53	}
54	}	54
55		55	private void end(final boolean wordWrap) {
56	private void end(final boolean wordWrap) {	56	BusyIndicator.showWhile(fStyledText.getDisplay(), new Runnable() {
57	BusyIndicator.showWhile(fStyledText.getDisplay(), new Runnable() {	57	public void run() {
58	public void run() {	58	fStyledText.setRedraw(false);
59	fStyledText.setRedraw(false);	59	fStyledText.setText("");
60	fStyledText.setText("");	60	fStyledText.setWordWrap(wordWrap);
61	fStyledText.setWordWrap(wordWrap);	61	fStyledText.setText(fBuffer.toString());
62	fStyledText.setText(fBuffer.toString());	62	TextPresentation.applyTextPresentation(fPresentation, fStyledText);
63	TextPresentation.applyTextPresentation(fPresentation, fStyledText);	63	fStyledText.setRedraw(true);
64	fStyledText.setRedraw(true);	64	}
65	}	65	});
66	});	66
67		67	fBuffer= null;
68	fBuffer= null;	68	fPresentation= null;
69	fPresentation= null;	69	fStyledText= null;
70	fStyledText= null;	70	}
71	}	71
72		72	// public void present(BugzillaProvider provider, StyledText styledText) {
73	// public void present(BugzillaProvider provider, StyledText styledText) {	73	// begin(styledText);
74	// begin(styledText);	74	// end(true);
75	// end(true);	75	// }
76	// }	76
77		77	public void present(BugzillaQuery query, StyledText styledText) {
78	public void present(BugzillaQuery query, StyledText styledText) {	78	begin(styledText);
79	begin(styledText);	79	append(query);
80	append(query);	80	end(true);
81	end(true);	81	}
82	}	82
83		83	public void present(BugzillaReport report, StyledText styledText) {
84	public void present(BugzillaReport report, StyledText styledText) {	84	begin(styledText);
85	begin(styledText);	85	append(report);
86	append(report);	86	end(true);
87	end(true);	87	}
88	}	88
89		89	public void present(BugzillaComment comment, StyledText styledText) {
90	public void present(BugzillaComment comment, StyledText styledText) {	90	begin(styledText);
91	begin(styledText);	91	append(comment);
92	append(comment);	92	end(true);
93	end(true);	93	}
94	}	94
95		95	public void present(BugzillaAttachment bugzillaAttachment, StyledText styledText) {
96	public void present(BugzillaAttachment bugzillaAttachment, StyledText styledText) {	96
97		97	final AttachmentData attachment= bugzillaAttachment.getData();
98	final AttachmentData attachment= bugzillaAttachment.getData();	98
99		99	boolean wordWrap= false;
100	boolean wordWrap= false;	100	begin(styledText);
101	begin(styledText);	101
102		102	if (attachment != null) {
103	if (attachment != null) {	103	final String data= bugzillaAttachment.getDataAsString();
104	final String data= bugzillaAttachment.getDataAsString();	104	final String mimeType= bugzillaAttachment.getData().getString(AttachmentData.MIMETYPE);
105	final String mimeType= bugzillaAttachment.getData().getString(AttachmentData.MIMETYPE);	105	if (mimeType.startsWith("text/")) {
106	if (mimeType.startsWith("text/")) {	106	append(data);
107	append(data);	107	wordWrap= false;
108	wordWrap= false;	108	} else {
109	} else {	109	append(attachment.getString(AttachmentData.FILENAME)).space().append("[").append(mimeType).append("]");
110	append(attachment.getString(AttachmentData.FILENAME)).space().append("[").append(mimeType).append("]");	110	wordWrap= true;
111	wordWrap= true;	111	}
112	}	112	}
113	}	113	end(wordWrap);
114	end(wordWrap);	114	}
115	}	115
116		116	// /**
117	/**	117	// * @param folder
118	* @param folder	118	// * @param styledText
119	* @param styledText	119	// */
120	*/	120	// public void present(BugzillaFolder folder, StyledText styledText) {
121	// public void present(BugzillaFolder folder, StyledText styledText) {	121	// begin(styledText);
122	// begin(styledText);	122	// append(folder);
123	// append(folder);	123	// end(true);
124	// end(true);	124	// }
125	// }	125
126		126	// /**
127	// /**	127	// * @param folder
128	// * @param folder	128	// */
129	// */	129	// private void append(BugzillaFolder folder) {
130	// private void append(BugzillaFolder folder) {	130	// /* TODO: jpound - implement folder presentation */
131	// /* TODO: jpound - implement folder presentation */	131	// bold(folder.getName()).endl().endl();
132	// bold(folder.getName()).endl().endl();	132	//
133	//	133	// BugzillaModel[] children = folder.getChildren();
134	// BugzillaModel[] children = folder.getChildren();	134	// int numQueries = 0;
135	// int numQueries = 0;	135	// int numBugs = 0;
136	// int numBugs = 0;	136	// if (children != null) {
137	// if (children != null) {	137	// for (int i = 0; i < children.length; i++) {
138	// for (int i = 0; i < children.length; i++) {	138	// if (children[i] instanceof BugzillaQuery) {
139	// if (children[i] instanceof BugzillaQuery) {	139	// numQueries++;
140	// numQueries++;	140	// }
141	// }	141	// else {
142	// else {	142	// numBugs++;
143	// numBugs++;	143	// }
144	// }	144	// }
145	// }	145	// }
146	// }	146	// else {
147	// else {	147	// italic("Empty Folder");
148	// italic("Empty Folder");	148	// return;
149	// return;	149	// }
150	// }	150	//
151	//	151	// if (numQueries > 0) {
152	// if (numQueries > 0) {	152	// append("Queries:\t" + numQueries).endl();
153	// append("Queries:\t" + numQueries).endl();	153	// }
154	// }	154	// if (numBugs > 0) {
155	// if (numBugs > 0) {	155	// append("Bugs:\t\t" + numBugs);
156	// append("Bugs:\t\t" + numBugs);	156	// }
157	// }	157	// }
158	// }	158
159		159	private BugzillaModelPresenter append(BugzillaQuery query) {
160	private BugzillaModelPresenter append(BugzillaQuery query) {	160
161		161	String queryUrl = query.getQueryUrl().toUrlString();
162	String queryUrl = query.getQueryUrl().toUrlString();	162	String summary = null;
163	String summary = null;	163	String comment = null;
164	String comment = null;	164
165		165	int summaryIndex = queryUrl.indexOf("short_desc=");
166	int summaryIndex = queryUrl.indexOf("short_desc=");	166	if (summaryIndex >= 0) {
167	if (summaryIndex >= 0) {	167	summary = queryUrl.substring(summaryIndex, queryUrl.length());
168	summary = queryUrl.substring(summaryIndex, queryUrl.length());	168	int ampIndex = summary.indexOf('&');
169	int ampIndex = summary.indexOf('&');	169	if (ampIndex < 0) {
170	if (ampIndex < 0) {	170	ampIndex = summary.length();
171	ampIndex = summary.length();	171	}
172	}	172	try {
173	try {	173	summary = URLDecoder.decode(summary.substring(summary.indexOf('=') + 1, ampIndex), "UTF-8");
174	summary = URLDecoder.decode(summary.substring(summary.indexOf('=') + 1, ampIndex), "UTF-8");	174	} catch (UnsupportedEncodingException e) {
175	} catch (UnsupportedEncodingException e) {	175	e.printStackTrace();
176	e.printStackTrace();	176	}
177	}	177	}
178	}	178
179		179	int commentIndex = queryUrl.indexOf("long_desc=");
180	int commentIndex = queryUrl.indexOf("long_desc=");	180	if (commentIndex >= 0) {
181	if (commentIndex >= 0) {	181	comment = queryUrl.substring(commentIndex, queryUrl.length());
182	comment = queryUrl.substring(commentIndex, queryUrl.length());	182	int ampIndex = comment.indexOf('&');
183	int ampIndex = comment.indexOf('&');	183	if (ampIndex < 0) {
184	if (ampIndex < 0) {	184	ampIndex = comment.length();
185	ampIndex = comment.length();	185	}
186	}	186	try {
187	try {	187	comment = URLDecoder.decode(comment.substring(comment.indexOf('=') + 1, ampIndex), "UTF-8");
188	comment = URLDecoder.decode(comment.substring(comment.indexOf('=') + 1, ampIndex), "UTF-8");	188	} catch (UnsupportedEncodingException e) {
189	} catch (UnsupportedEncodingException e) {	189	e.printStackTrace();
190	e.printStackTrace();	190	}
191	}	191	}
192	}	192
193		193	BugzillaModel[] children = query.getChildren();
194	BugzillaModel[] children = query.getChildren();	194	HashMap bugFreqs = new HashMap(7); // 7 bugzilla status'
195	HashMap bugFreqs = new HashMap(7); // 7 bugzilla status'	195	int criticalBugs = 0;
196	int criticalBugs = 0;	196
197		197	for (int i = 0; i < children.length; i++) {
198	for (int i = 0; i < children.length; i++) {	198	ReportData reportData = ((BugzillaReport)children[i]).getReportData();
199	ReportData reportData = ((BugzillaReport)children[i]).getReportData();	199	if (reportData == null) {
200	if (reportData == null) {	200	return this;
201	return this;	201	}
202	}	202	String status = reportData.getString(ReportData.STATUS);
203	String status = reportData.getString(ReportData.STATUS);	203
204		204	if (reportData.getString(ReportData.SEVERITY).equals("critical")) {
205	if (reportData.getString(ReportData.SEVERITY).equals("critical")) {	205	criticalBugs++;
206	criticalBugs++;	206	}
207	}	207
208		208	Integer count = (Integer)bugFreqs.get(status);
209	Integer count = (Integer)bugFreqs.get(status);	209	if (count == null) {
210	if (count == null) {	210	bugFreqs.put(status, new Integer(1));
211	bugFreqs.put(status, new Integer(1));	211	}
212	}	212	else {
213	else {	213	bugFreqs.put(status, new Integer(count.intValue() + 1));
214	bugFreqs.put(status, new Integer(count.intValue() + 1));	214	}
215	}	215	}
216	}	216
217		217	bold("Query from " + query.getQueryUrl().getBaseUrl()).endl();
218	bold("Query from " + query.getQueryUrl().getBaseUrl()).endl();	218	if (summary != null && !summary.equals("")) {
219	if (summary != null && !summary.equals("")) {	219	append("Summary:\t\t").italic(summary).endl();
220	append("Summary:\t\t").italic(summary).endl();	220	}
221	}	221	if (comment != null && !comment.equals("")) {
222	if (comment != null && !comment.equals("")) {	222	append("Comment:\t\t").italic(comment).endl();
223	append("Comment:\t\t").italic(comment).endl();	223	}
224	}	224	endl();
225	endl();	225
226		226	append("Total Bugs:\t" + children.length).endl();
227	append("Total Bugs:\t" + children.length).endl();	227	Iterator iter = bugFreqs.keySet().iterator();
228	Iterator iter = bugFreqs.keySet().iterator();	228	while (iter.hasNext()) {
229	while (iter.hasNext()) {	229	String status = (String)iter.next();
230	String status = (String)iter.next();	230	String tab = "\t";
231	String tab = "\t";	231	int statusLength;
232	int statusLength;	232	if ( (statusLength = status.length()) < 8) {
233	if ( (statusLength = status.length()) < 8) {	233	tab += "\t";
234	tab += "\t";	234	if (statusLength < 4) {
235	if (statusLength < 4) {	235	tab += "\t";
236	tab += "\t";	236	}
237	}	237	}
238	}	238	append(status + tab + bugFreqs.get(status)).endl();
239	append(status + tab + bugFreqs.get(status)).endl();	239	}
240	}	240	endl();
241	endl();	241	if (criticalBugs > 0) {
242	if (criticalBugs > 0) {	242	append("This query contains").bold(" "+criticalBugs).append(" critical " + ((criticalBugs > 1) ? "bugs" : "bug"));
243	append("This query contains").bold(" "+criticalBugs).append(" critical " + ((criticalBugs > 1) ? "bugs" : "bug"));	243	}
244	}	244
245		245	return this;
246	return this;	246	}
247	}	247
248		248	private BugzillaModelPresenter append(BugzillaComment bugzillaComment) {
249	private BugzillaModelPresenter append(BugzillaComment bugzillaComment) {	249	final CommentData comment= bugzillaComment.getCommentData();
250	final CommentData comment= bugzillaComment.getCommentData();	250	if (comment == null)
251	if (comment == null)	251	return this;
252	return this;	252	bold(comment.getString(CommentData.AUTHOR)).append(" - ").append(comment.getDate(CommentData.DATE)).endl(2);
253	bold(comment.getString(CommentData.AUTHOR)).append(" - ").append(comment.getDate(CommentData.DATE)).endl(2);	253
254		254	if (comment.attachmentDesc != null && comment.attachmentDesc.getBoolean(AttachmentDescription.OBSOLETE))
255	if (comment.attachmentDesc != null && comment.attachmentDesc.getBoolean(AttachmentDescription.OBSOLETE))	255	append("* This attachment is obsolete *").endl(2);
256	append("* This attachment is obsolete *").endl(2);	256	append(comment.getString(CommentData.TEXT));
257	append(comment.getString(CommentData.TEXT));	257	return this;
258	return this;	258	}
259	}	259
260		260	private BugzillaModelPresenter append(BugzillaReport bugzillaReport) {
261	private BugzillaModelPresenter append(BugzillaReport bugzillaReport) {	261
262		262	if (!bugzillaReport.hasLocalContent())
263	if (!bugzillaReport.hasLocalContent())	263	return this;
264	return this;	264
265		265	final ReportData report= bugzillaReport.getReportData();
266	final ReportData report= bugzillaReport.getReportData();	266
267		267	bold("[").bold(report.getString(ReportData.ID)).bold("]").space().bold(report.getString(ReportData.TITLE)).endl(2);
268	bold("[").bold(report.getString(ReportData.ID)).bold("]").space().bold(report.getString(ReportData.TITLE)).endl(2);	268
269		269	append("Assigned To: ").append(report.getString(ReportData.ASSIGNEDTO)).endl();
270	append("Assigned To: ").append(report.getString(ReportData.ASSIGNEDTO)).endl();	270	append("Severity: ").append(report.getString(ReportData.SEVERITY)).endl();
271	append("Severity: ").append(report.getString(ReportData.SEVERITY)).endl();	271	append("Priority: ").append(report.getString(ReportData.PRIORITY)).endl();
272	append("Priority: ").append(report.getString(ReportData.PRIORITY)).endl();	272	append("Target Milestone: ").append(report.getString(ReportData.TARGETMILESTONE)).endl();
273	append("Target Milestone: ").append(report.getString(ReportData.TARGETMILESTONE)).endl();	273	endl();
274	endl();	274	append("Operating System: ").append(report.getString(ReportData.OPERATINGSYSTEM)).endl();
275	append("Operating System: ").append(report.getString(ReportData.OPERATINGSYSTEM)).endl();	275	append("Platform: ").append(report.getString(ReportData.PLATFORM)).endl();
276	append("Platform: ").append(report.getString(ReportData.PLATFORM)).endl();	276
277		277	endl();
278	endl();	278
279		279	/* append first comment
280	/* append first comment	280	final Iterator iter= bugzillaReport.getComments().iterator();
281	final Iterator iter= bugzillaReport.getComments().iterator();	281	if (iter.hasNext()) {
282	if (iter.hasNext()) {	282	append((BugzillaComment)iter.next());
283	append((BugzillaComment)iter.next());	283	}
284	}	284	*/
285	*/	285	return this;
286	return this;	286	}
287	}	287
288		288	private BugzillaModelPresenter append(String suffix) {
289	private BugzillaModelPresenter append(String suffix) {	289	fBuffer.append(suffix);
290	fBuffer.append(suffix);	290	return this;
291	return this;	291	}
292	}	292
293		293	private BugzillaModelPresenter bold(String suffix) {
294	private BugzillaModelPresenter bold(String suffix) {	294	final int offset= fBuffer.length();
295	final int offset= fBuffer.length();	295	final int length= suffix.length();
296	final int length= suffix.length();	296	fBuffer.append(suffix);
297	fBuffer.append(suffix);	297	fPresentation.addStyleRange(new StyleRange(offset, length, null, null, SWT.BOLD));
298	fPresentation.addStyleRange(new StyleRange(offset, length, null, null, SWT.BOLD));	298	return this;
299	return this;	299	}
300	}	300
301		301	private BugzillaModelPresenter italic(String suffix) {
302	private BugzillaModelPresenter italic(String suffix) {	302	final int offset= fBuffer.length();
303	final int offset= fBuffer.length();	303	final int length= suffix.length();
304	final int length= suffix.length();	304	fBuffer.append(suffix);
305	fBuffer.append(suffix);	305	fPresentation.addStyleRange(new StyleRange(offset, length, null, null, SWT.ITALIC));
306	fPresentation.addStyleRange(new StyleRange(offset, length, null, null, SWT.ITALIC));	306	return this;
307	return this;	307	}
308	}	308
309		309	private BugzillaModelPresenter endl() {
310	private BugzillaModelPresenter endl() {	310	fBuffer.append("\n");
311	fBuffer.append("\n");	311	return this;
312	return this;	312	}
313	}	313
314		314	private BugzillaModelPresenter endl(int n) {
315	private BugzillaModelPresenter endl(int n) {	315	for (int i= 0; i < n; ++i)
316	for (int i= 0; i < n; ++i)	316	fBuffer.append("\n");
317	fBuffer.append("\n");	317	return this;
318	return this;	318	}
319	}	319
320		320	private BugzillaModelPresenter space() {
321	private BugzillaModelPresenter space() {	321	fBuffer.append(" ");
322	fBuffer.append(" ");	322	return this;
323	return this;	323	}
324	}	324
325		325	// private BugzillaModelPresenter space(int n) {
326	// private BugzillaModelPresenter space(int n) {	326	// for (int i= 0; i < n; i++)
327	// for (int i= 0; i < n; i++)	327	// fBuffer.append(" ");
328	// fBuffer.append(" ");	328	// return this;
329	// return this;	329	// }
330	// }	330
331		331	private BugzillaModelPresenter append(Date date) {
332	private BugzillaModelPresenter append(Date date) {	332	fBuffer.append(DateFormat.getDateTimeInstance().format(date));
333	fBuffer.append(DateFormat.getDateTimeInstance().format(date));	333	return this;
334	return this;	334	}
335	}	335
336		336	}
337	}