[Rubyeclipse-commit] org.rubypeople.rdt.ui/src/org/rubypeople/rdt/internal/ui/viewsupport DecoratingRubyLabelProvider.java,NONE,1.1 MemberFilterAction.java,NONE,1.1 AppearanceAwareLabelProvider.java,NONE,1.1 RubyUILabelProvider.java,NONE,1.1 StatusBarUpdater.java,NONE,1.1 MemberFilter.java,NONE,1.1 StorageLabelProvider.java,NONE,1.1 RubyElementImageProvider.java,NONE,1.1

[Christopher W. <caw...@us...>]

Update of /cvsroot/rubyeclipse/org.rubypeople.rdt.ui/src/org/rubypeople/rdt/internal/ui/viewsupport
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv11198/src/org/rubypeople/rdt/internal/ui/viewsupport

Added Files:
	DecoratingRubyLabelProvider.java MemberFilterAction.java 
	AppearanceAwareLabelProvider.java RubyUILabelProvider.java 
	StatusBarUpdater.java MemberFilter.java 
	StorageLabelProvider.java RubyElementImageProvider.java 
Log Message:
new UI classes for element labels and images

--- NEW FILE: StatusBarUpdater.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;


import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IResource;
import org.eclipse.jface.action.IStatusLineManager;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.ISelectionChangedListener;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.SelectionChangedEvent;
import org.rubypeople.rdt.core.IRubyElement;
import org.rubypeople.rdt.internal.corext.util.Messages;
import org.rubypeople.rdt.internal.ui.RubyUIMessages;
import org.rubypeople.rdt.ui.RubyElementLabels;


/**
 * Add the <code>StatusBarUpdater</code> to your ViewPart to have the statusbar
 * describing the selected elements.
 */
public class StatusBarUpdater implements ISelectionChangedListener {
    
    private final long LABEL_FLAGS= RubyElementLabels.DEFAULT_QUALIFIED | RubyElementLabels.ROOT_POST_QUALIFIED | RubyElementLabels.APPEND_ROOT_PATH | RubyElementLabels.M_PARAMETER_NAMES;
            
    private IStatusLineManager fStatusLineManager;
    
    public StatusBarUpdater(IStatusLineManager statusLineManager) {
        fStatusLineManager= statusLineManager;
    }
        
    /*
     * @see ISelectionChangedListener#selectionChanged
     */
    public void selectionChanged(SelectionChangedEvent event) {
        String statusBarMessage= formatMessage(event.getSelection());
        fStatusLineManager.setMessage(statusBarMessage);
    }
    
    
    protected String formatMessage(ISelection sel) {
        if (sel instanceof IStructuredSelection && !sel.isEmpty()) {
            IStructuredSelection selection= (IStructuredSelection) sel;
            
            int nElements= selection.size();
            if (nElements > 1) {
                return Messages.format(RubyUIMessages.StatusBarUpdater_num_elements_selected, String.valueOf(nElements)); 
            } else { 
                Object elem= selection.getFirstElement();
                if (elem instanceof IRubyElement) {
                    return formatRubyElementMessage((IRubyElement) elem);
                } else if (elem instanceof IResource) {
                    return formatResourceMessage((IResource) elem);
                }
            }
        }
        return "";  //$NON-NLS-1$
    }
        
    private String formatRubyElementMessage(IRubyElement element) {
        return RubyElementLabels.getElementLabel(element, LABEL_FLAGS);
    }
        
    private String formatResourceMessage(IResource element) {
        IContainer parent= element.getParent();
        if (parent != null && parent.getType() != IResource.ROOT)
            return element.getName() + RubyElementLabels.CONCAT_STRING + parent.getFullPath().makeRelative().toString();
        else
            return element.getName();
    }   

}

--- NEW FILE: MemberFilterAction.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;

import org.eclipse.jface.action.Action;

import org.eclipse.ui.PlatformUI;

import org.rubypeople.rdt.ui.actions.*;

/**
 * Action used to enable / disable method filter properties
 */
public class MemberFilterAction extends Action {

    private int fFilterProperty;
    private MemberFilterActionGroup fFilterActionGroup;
    
    public MemberFilterAction(MemberFilterActionGroup actionGroup, String title, int property, String contextHelpId, boolean initValue) {
        super(title);
        fFilterActionGroup= actionGroup;
        fFilterProperty= property;
        
        PlatformUI.getWorkbench().getHelpSystem().setHelp(this, contextHelpId);

        setChecked(initValue);
    }
    
    /**
     * Returns this action's filter property.
     */
    public int getFilterProperty() {
        return fFilterProperty;
    }
    
    /*
     * @see Action#actionPerformed
     */
    public void run() { 
        fFilterActionGroup.setMemberFilter(fFilterProperty, isChecked());
    }
        
}

--- NEW FILE: AppearanceAwareLabelProvider.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;

import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jface.util.IPropertyChangeListener;
import org.eclipse.jface.util.PropertyChangeEvent;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.rubypeople.rdt.ui.PreferenceConstants;
import org.rubypeople.rdt.ui.RubyElementLabels;

/**
 * RubyUILabelProvider that respects settings from the Appearance preference page.
 * Triggers a viewer update when a preference changes.
 */
public class AppearanceAwareLabelProvider extends RubyUILabelProvider implements IPropertyChangeListener {

    public final static long DEFAULT_TEXTFLAGS= RubyElementLabels.ROOT_VARIABLE | RubyElementLabels.REFERENCED_ROOT_POST_QUALIFIED;
    public final static int DEFAULT_IMAGEFLAGS= RubyElementImageProvider.OVERLAY_ICONS;
    
    private long fTextFlagMask;
    private int fImageFlagMask;

    /**
     * Constructor for AppearanceAwareLabelProvider.
     */
    public AppearanceAwareLabelProvider(long textFlags, int imageFlags) {
        super(textFlags, imageFlags);
        initMasks();
        PreferenceConstants.getPreferenceStore().addPropertyChangeListener(this);
    }

    /**
     * Creates a labelProvider with DEFAULT_TEXTFLAGS and DEFAULT_IMAGEFLAGS
     */ 
    public AppearanceAwareLabelProvider() {
        this(DEFAULT_TEXTFLAGS, DEFAULT_IMAGEFLAGS);
    }
    
    private void initMasks() {
        IPreferenceStore store= PreferenceConstants.getPreferenceStore();
        fTextFlagMask= -1;
        if (!store.getBoolean(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES)) {
            fTextFlagMask ^= RubyElementLabels.P_COMPRESSED;
        }
        
        fImageFlagMask= -1;
    }

    /*
     * @see IPropertyChangeListener#propertyChange(PropertyChangeEvent)
     */
    public void propertyChange(PropertyChangeEvent event) {
        String property= event.getProperty();
        if (property.equals(PreferenceConstants.APPEARANCE_PKG_NAME_PATTERN_FOR_PKG_VIEW)
                || property.equals(PreferenceConstants.APPEARANCE_COMPRESS_PACKAGE_NAMES)) {
            initMasks();
            LabelProviderChangedEvent lpEvent= new LabelProviderChangedEvent(this, null); // refresh all
            fireLabelProviderChanged(lpEvent);
        }       
    }

    /*
     * @see IBaseLabelProvider#dispose()
     */
    public void dispose() {
        PreferenceConstants.getPreferenceStore().removePropertyChangeListener(this);
        super.dispose();
    }

    /*
     * @see RubyUILabelProvider#evaluateImageFlags()
     */
    protected int evaluateImageFlags(Object element) {
        return getImageFlags() & fImageFlagMask;
    }

    /*
     * @see RubyUILabelProvider#evaluateTextFlags()
     */
    protected long evaluateTextFlags(Object element) {
        return getTextFlags() & fTextFlagMask;
    }

}

--- NEW FILE: StorageLabelProvider.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;


import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.resources.IStorage;

import org.eclipse.swt.graphics.Image;

import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.ui.IEditorRegistry;
import org.eclipse.ui.IFileEditorMapping;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.PlatformUI;

/**
 * Standard label provider for IStorage objects.
 * Use this class when you want to present IStorage objects in a viewer.
 */
public class StorageLabelProvider extends LabelProvider {

    private IEditorRegistry fEditorRegistry= null;
    private Map fJarImageMap= new HashMap(10);
    private Image fDefaultImage;

    private IEditorRegistry getEditorRegistry() {
        if (fEditorRegistry == null)
            fEditorRegistry= PlatformUI.getWorkbench().getEditorRegistry();
        return fEditorRegistry;
    }

    /* (non-Javadoc)
     * @see ILabelProvider#getImage
     */
    public Image getImage(Object element) {
        // FIXME Use this for gem files (was intended for JARs)?
        if (element instanceof IStorage) 
            return getImageForJarEntry((IStorage)element);

        return super.getImage(element);
    }

    /* (non-Javadoc)
     * @see ILabelProvider#getText
     */
    public String getText(Object element) {
        if (element instanceof IStorage)
            return ((IStorage)element).getName();

        return super.getText(element);
    }

    /* (non-Javadoc)
     * 
     * @see IBaseLabelProvider#dispose
     */
    public void dispose() {
        if (fJarImageMap != null) {
            Iterator each= fJarImageMap.values().iterator();
            while (each.hasNext()) {
                Image image= (Image)each.next();
                image.dispose();
            }
            fJarImageMap= null;
        }
        fDefaultImage= null;
    }
    
    /*
     * Gets and caches an image for a JarEntryFile.
     * The image for a JarEntryFile is retrieved from the EditorRegistry.
     */ 
    private Image getImageForJarEntry(IStorage element) {
        if (fJarImageMap == null)
            return getDefaultImage();

        if (element == null || element.getName() == null)
            return getDefaultImage();

        // Try to find icon for full name
        String name= element.getName();
        Image image= (Image)fJarImageMap.get(name);
        if (image != null) 
            return image;
        IFileEditorMapping[] mappings= getEditorRegistry().getFileEditorMappings();
        int i= 0;
        while (i < mappings.length) {
            if (mappings[i].getLabel().equals(name))
                break;
            i++;
        }
        String key= name;
        if (i == mappings.length) {
            // Try to find icon for extension
            IPath path= element.getFullPath();
            if (path == null)
                return getDefaultImage();
            key= path.getFileExtension();
            if (key == null)
                return getDefaultImage();
            image= (Image)fJarImageMap.get(key);
            if (image != null) 
                return image;
        }

        // Get the image from the editor registry   
        ImageDescriptor desc= getEditorRegistry().getImageDescriptor(name);
        image= desc.createImage();

        fJarImageMap.put(key, image);

        return image;
    }
    
    private Image getDefaultImage() {
        if (fDefaultImage == null)
            fDefaultImage= PlatformUI.getWorkbench().getSharedImages().getImage(ISharedImages.IMG_OBJ_FILE);
        return fDefaultImage;
    }
}

--- NEW FILE: DecoratingRubyLabelProvider.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;

import org.eclipse.swt.graphics.Color;

import org.eclipse.jface.viewers.DecoratingLabelProvider;
import org.eclipse.jface.viewers.IColorProvider;

import org.eclipse.ui.PlatformUI;

public class DecoratingRubyLabelProvider extends DecoratingLabelProvider implements IColorProvider {
    
    /**
     * Decorating label provider for Ruby. Combines a RubyUILabelProvider
     * with problem and override indicuator with the workbench decorator (label
     * decorator extension point).
     */
    public DecoratingRubyLabelProvider(RubyUILabelProvider labelProvider) {
        this(labelProvider, true);
    }

    /**
     * Decorating label provider for Ruby. Combines a RubyUILabelProvider
     * (if enabled with problem indicator) with the workbench
     * decorator (label decorator extension point).
     */
    public DecoratingRubyLabelProvider(RubyUILabelProvider labelProvider, boolean errorTick) {
        super(labelProvider, PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator());
        if (errorTick) {
            // TODO Uncomment when we have a ProblemsLabelDecorator
            //labelProvider.addLabelDecorator(new ProblemsLabelDecorator(null));
        }
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
     */
    public Color getForeground(Object element) {
        // label provider is a RubyUILabelProvider
        return ((IColorProvider) getLabelProvider()).getForeground(element);
    }

    /* (non-Javadoc)
     * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
     */
    public Color getBackground(Object element) {
        // label provider is a RubyUILabelProvider
        return ((IColorProvider) getLabelProvider()).getBackground(element);
    }

}

--- NEW FILE: RubyUILabelProvider.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;

import java.util.ArrayList;

import org.eclipse.core.resources.IStorage;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jface.util.ListenerList;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.IColorProvider;
import org.eclipse.jface.viewers.ILabelDecorator;
import org.eclipse.jface.viewers.ILabelProvider;
import org.eclipse.jface.viewers.ILabelProviderListener;
import org.eclipse.jface.viewers.LabelProviderChangedEvent;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Image;
import org.rubypeople.rdt.ui.RubyElementLabels;


public class RubyUILabelProvider implements ILabelProvider, IColorProvider {
    
    protected ListenerList fListeners = new ListenerList(1);
    
    protected RubyElementImageProvider fImageLabelProvider;
    protected StorageLabelProvider fStorageLabelProvider;
    
    private ArrayList fLabelDecorators;

    private int fImageFlags;
    private long fTextFlags;

    /**
     * Creates a new label provider with default flags.
     */
    public RubyUILabelProvider() {
        this(RubyElementLabels.ALL_DEFAULT, RubyElementImageProvider.OVERLAY_ICONS);
    }

    /**
     * @param textFlags Flags defined in <code>RubyElementLabels</code>.
     * @param imageFlags Flags defined in <code>RubyElementImageProvider</code>.
     */
    public RubyUILabelProvider(long textFlags, int imageFlags) {
        fImageLabelProvider= new RubyElementImageProvider();
        fLabelDecorators= null; 
        
        fStorageLabelProvider= new StorageLabelProvider();
        fImageFlags= imageFlags;
        fTextFlags= textFlags;
    }
    
    /**
     * Adds a decorator to the label provider
     */
    public void addLabelDecorator(ILabelDecorator decorator) {
        if (fLabelDecorators == null) {
            fLabelDecorators= new ArrayList(2);
        }
        fLabelDecorators.add(decorator);
    }
    
    /**
     * Sets the textFlags.
     * @param textFlags The textFlags to set
     */
    public final void setTextFlags(long textFlags) {
        fTextFlags= textFlags;
    }

    /**
     * Sets the imageFlags 
     * @param imageFlags The imageFlags to set
     */
    public final void setImageFlags(int imageFlags) {
        fImageFlags= imageFlags;
    }
    
    /**
     * Gets the image flags.
     * Can be overwriten by super classes.
     * @return Returns a int
     */
    public final int getImageFlags() {
        return fImageFlags;
    }

    /**
     * Gets the text flags.
     * @return Returns a int
     */
    public final long getTextFlags() {
        return fTextFlags;
    }
    
    /**
     * Evaluates the image flags for a element.
     * Can be overwriten by super classes.
     * @return Returns a int
     */
    protected int evaluateImageFlags(Object element) {
        return getImageFlags();
    }

    /**
     * Evaluates the text flags for a element. Can be overwriten by super classes.
     * @return Returns a int
     */
    protected long evaluateTextFlags(Object element) {
        return getTextFlags();
    }
    
    protected Image decorateImage(Image image, Object element) {
        if (fLabelDecorators != null && image != null) {
            for (int i= 0; i < fLabelDecorators.size(); i++) {
                ILabelDecorator decorator= (ILabelDecorator) fLabelDecorators.get(i);
                image= decorator.decorateImage(image, element);
            }
        }
        return image;
    }

    /* (non-Rubydoc)
     * @see ILabelProvider#getImage
     */
    public Image getImage(Object element) {
        Image result= fImageLabelProvider.getImageLabel(element, evaluateImageFlags(element));
        if (result == null && (element instanceof IStorage)) {
            result= fStorageLabelProvider.getImage(element);
        }
        
        return decorateImage(result, element);
    }

    protected String decorateText(String text, Object element) {
        if (fLabelDecorators != null && text.length() > 0) {
            for (int i= 0; i < fLabelDecorators.size(); i++) {
                ILabelDecorator decorator= (ILabelDecorator) fLabelDecorators.get(i);
                text= decorator.decorateText(text, element);
            }
        }   
        return text;
    }


    /* (non-Rubydoc)
     * @see ILabelProvider#getText
     */
    public String getText(Object element) {
        String result= RubyElementLabels.getTextLabel(element, evaluateTextFlags(element));
        if (result.length() == 0 && (element instanceof IStorage)) {
            result= fStorageLabelProvider.getText(element);
        }
        
        return decorateText(result, element);
    }

    /* (non-Rubydoc)
     * @see IBaseLabelProvider#dispose
     */
    public void dispose() {
        if (fLabelDecorators != null) {
            for (int i= 0; i < fLabelDecorators.size(); i++) {
                ILabelDecorator decorator= (ILabelDecorator) fLabelDecorators.get(i);
                decorator.dispose();
            }
            fLabelDecorators= null;
        }
        fStorageLabelProvider.dispose();
        fImageLabelProvider.dispose();
    }
    
    /* (non-Rubydoc)
     * @see IBaseLabelProvider#addListener(ILabelProviderListener)
     */
    public void addListener(ILabelProviderListener listener) {
        if (fLabelDecorators != null) {
            for (int i= 0; i < fLabelDecorators.size(); i++) {
                ILabelDecorator decorator= (ILabelDecorator) fLabelDecorators.get(i);
                decorator.addListener(listener);
            }
        }
        fListeners.add(listener);   
    }

    /* (non-Rubydoc)
     * @see IBaseLabelProvider#isLabelProperty(Object, String)
     */
    public boolean isLabelProperty(Object element, String property) {
        return true;    
    }

    /* (non-Rubydoc)
     * @see IBaseLabelProvider#removeListener(ILabelProviderListener)
     */
    public void removeListener(ILabelProviderListener listener) {
        if (fLabelDecorators != null) {
            for (int i= 0; i < fLabelDecorators.size(); i++) {
                ILabelDecorator decorator= (ILabelDecorator) fLabelDecorators.get(i);
                decorator.removeListener(listener);
            }
        }
        fListeners.remove(listener);    
    }
    
    public static ILabelDecorator[] getDecorators(boolean errortick, ILabelDecorator extra) {
        if (errortick) {
            if (extra == null) {
                return new ILabelDecorator[] {};
            } else {
                return new ILabelDecorator[] { extra };
            }
        }
        if (extra != null) {
            return new ILabelDecorator[] { extra };
        }
        return null;
    }

    /* (non-Rubydoc)
     * @see org.eclipse.jface.viewers.IColorProvider#getForeground(java.lang.Object)
     */
    public Color getForeground(Object element) {
        return null;
    }

    /* (non-Rubydoc)
     * @see org.eclipse.jface.viewers.IColorProvider#getBackground(java.lang.Object)
     */
    public Color getBackground(Object element) {
        return null;
    }
    
    /**
     * Fires a label provider changed event to all registered listeners
     * Only listeners registered at the time this method is called are notified.
     *
     * @param event a label provider changed event
     *
     * @see ILabelProviderListener#labelProviderChanged
     */
    protected void fireLabelProviderChanged(final LabelProviderChangedEvent event) {
        Object[] listeners = fListeners.getListeners();
        for (int i = 0; i < listeners.length; ++i) {
            final ILabelProviderListener l = (ILabelProviderListener) listeners[i];
            Platform.run(new SafeRunnable() {
                public void run() {
                    l.labelProviderChanged(event);
                }
            });
        }
    }

}

--- NEW FILE: MemberFilter.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;

import org.eclipse.jface.viewers.Viewer;
import org.eclipse.jface.viewers.ViewerFilter;
import org.rubypeople.rdt.core.Flags;
import org.rubypeople.rdt.core.IMember;
import org.rubypeople.rdt.core.IMethod;
import org.rubypeople.rdt.core.IRubyElement;
import org.rubypeople.rdt.core.IType;
import org.rubypeople.rdt.core.RubyModelException;

/**
 * Filter for the methods viewer. Changing a filter property does not trigger a
 * refiltering of the viewer
 */
public class MemberFilter extends ViewerFilter {

    public static final int FILTER_NONPUBLIC = 1;
    public static final int FILTER_STATIC = 2;
    public static final int FILTER_FIELDS = 4;
    public static final int FILTER_LOCALTYPES = 8;

    private int fFilterProperties;

    /**
     * Modifies filter and add a property to filter for
     */
    public final void addFilter(int filter) {
        fFilterProperties |= filter;
    }

    /**
     * Modifies filter and remove a property to filter for
     */
    public final void removeFilter(int filter) {
        fFilterProperties &= (-1 ^ filter);
    }

    /**
     * Tests if a property is filtered
     */
    public final boolean hasFilter(int filter) {
        return (fFilterProperties & filter) != 0;
    }

    /*
     * @see ViewerFilter#isFilterProperty(java.lang.Object, java.lang.String)
     */
    public boolean isFilterProperty(Object element, Object property) {
        return false;
    }

    /*
     * @see ViewerFilter#select(org.eclipse.jface.viewers.Viewer,
     *      java.lang.Object, java.lang.Object)
     */
    public boolean select(Viewer viewer, Object parentElement, Object element) {
        if (element instanceof IMember) {
            IMember member = (IMember) element;
            int memberType = member.getElementType();

            if (hasFilter(FILTER_FIELDS)) {
                if ((memberType == IRubyElement.CLASS_VAR) || (memberType == IRubyElement.CONSTANT)
                        || (memberType == IRubyElement.INSTANCE_VAR)
                        || (memberType == IRubyElement.LOCAL_VARIABLE)) { return false; }
            }

            if (member.isType(IRubyElement.METHOD)) {
                IMethod method = (IMethod) member;
                try {
                    if (hasFilter(FILTER_NONPUBLIC) && !Flags.isPublic(method.getVisibility())) { return false; }
                } catch (RubyModelException e) {
                   return true;
                }
                if (hasFilter(FILTER_STATIC) && method.isSingleton()) { return false; }
            }
            if (hasFilter(FILTER_LOCALTYPES) && memberType == IRubyElement.TYPE
                    && isLocalType((IType) member)) { return false; }

            if (member.getElementName().startsWith("<")) { // filter out
                // <clinit>
                // //$NON-NLS-1$
                return false;
            }
        }
        return true;
    }

    private boolean isLocalType(IType type) {
        IRubyElement parent = type.getParent();
        return parent instanceof IMember && !(parent instanceof IType);
    }

    private boolean isTopLevelType(IMember member) {
        IType parent = member.getDeclaringType();
        return parent == null;
    }
}

--- NEW FILE: RubyElementImageProvider.java ---
/*******************************************************************************
 * Copyright (c) 2000, 2005 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.rubypeople.rdt.internal.ui.viewsupport;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.debug.internal.ui.ImageDescriptorRegistry;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.util.Assert;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.graphics.Point;
import org.eclipse.ui.ISharedImages;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.model.IWorkbenchAdapter;
import org.rubypeople.rdt.core.Flags;
import org.rubypeople.rdt.core.IMember;
import org.rubypeople.rdt.core.IMethod;
import org.rubypeople.rdt.core.IRubyElement;
import org.rubypeople.rdt.core.IRubyProject;
import org.rubypeople.rdt.core.IType;
import org.rubypeople.rdt.core.RubyCore;
import org.rubypeople.rdt.core.RubyModelException;
import org.rubypeople.rdt.internal.ui.RubyPlugin;
import org.rubypeople.rdt.internal.ui.RubyPluginImages;
import org.rubypeople.rdt.internal.ui.RubyUIMessages;
import org.rubypeople.rdt.ui.RubyElementImageDescriptor;

/**
 * Default strategy of the Ruby plugin for the construction of Ruby element
 * icons.
 */
public class RubyElementImageProvider {

    /**
     * Flags for the RubyImageLabelProvider: Generate images with overlays.
     */
    public final static int OVERLAY_ICONS = 0x1;

    /**
     * Generate small sized images.
     */
    public final static int SMALL_ICONS = 0x2;

    /**
     * Use the 'light' style for rendering types.
     */
    public final static int LIGHT_TYPE_ICONS = 0x4;

    public static final Point SMALL_SIZE = new Point(16, 16);
    public static final Point BIG_SIZE = new Point(22, 16);

    private static ImageDescriptor DESC_OBJ_PROJECT_CLOSED;
    private static ImageDescriptor DESC_OBJ_PROJECT;
    {
        ISharedImages images = RubyPlugin.getDefault().getWorkbench().getSharedImages();
        DESC_OBJ_PROJECT_CLOSED = images
                .getImageDescriptor(IDE.SharedImages.IMG_OBJ_PROJECT_CLOSED);
        DESC_OBJ_PROJECT = images.getImageDescriptor(IDE.SharedImages.IMG_OBJ_PROJECT);
    }

    private ImageDescriptorRegistry fRegistry;

    public RubyElementImageProvider() {
        fRegistry = null; // lazy initialization
    }

    /**
     * Returns the icon for a given element. The icon depends on the element
     * type and element properties. If configured, overlay icons are constructed
     * for <code>ISourceReference</code>s.
     * 
     * @param flags
     *            Flags as defined by the RubyImageLabelProvider
     */
    public Image getImageLabel(Object element, int flags) {
        return getImageLabel(computeDescriptor(element, flags));
    }

    private Image getImageLabel(ImageDescriptor descriptor) {
        if (descriptor == null) return null;
        return getRegistry().get(descriptor);
    }

    private ImageDescriptorRegistry getRegistry() {
        if (fRegistry == null) {
            fRegistry = RubyPlugin.getImageDescriptorRegistry();
        }
        return fRegistry;
    }

    private ImageDescriptor computeDescriptor(Object element, int flags) {
        if (element instanceof IRubyElement) {
            return getRubyImageDescriptor((IRubyElement) element, flags);
        } else if (element instanceof IFile) {
            IFile file = (IFile) element;
            if (RubyCore.isRubyLikeFileName(file.getName())) { return getCUResourceImageDescriptor(
                    file, flags); // image for a CU not on the build path
            }
            return getWorkbenchImageDescriptor(file, flags);
        } else if (element instanceof IAdaptable) { return getWorkbenchImageDescriptor(
                (IAdaptable) element, flags); }
        return null;
    }

    private static boolean showOverlayIcons(int flags) {
        return (flags & OVERLAY_ICONS) != 0;
    }

    private static boolean useSmallSize(int flags) {
        return (flags & SMALL_ICONS) != 0;
    }

    private static boolean useLightIcons(int flags) {
        return (flags & LIGHT_TYPE_ICONS) != 0;
    }

    /**
     * Returns an image descriptor for a compilation unit not on the class path.
     * The descriptor includes overlays, if specified.
     */
    public ImageDescriptor getCUResourceImageDescriptor(IFile file, int flags) {
        Point size = useSmallSize(flags) ? SMALL_SIZE : BIG_SIZE;
        return new RubyElementImageDescriptor(RubyPluginImages.DESC_OBJS_RUBY_RESOURCE, 0, size);
    }

    /**
     * Returns an image descriptor for a java element. The descriptor includes
     * overlays, if specified.
     */
    public ImageDescriptor getRubyImageDescriptor(IRubyElement element, int flags) {
        int adornmentFlags = computeRubyAdornmentFlags(element, flags);
        Point size = useSmallSize(flags) ? SMALL_SIZE : BIG_SIZE;
        return new RubyElementImageDescriptor(getBaseImageDescriptor(element, flags),
                adornmentFlags, size);
    }

    /**
     * Returns an image descriptor for a IAdaptable. The descriptor includes
     * overlays, if specified (only error ticks apply). Returns
     * <code>null</code> if no image could be found.
     */
    public ImageDescriptor getWorkbenchImageDescriptor(IAdaptable adaptable, int flags) {
        IWorkbenchAdapter wbAdapter = (IWorkbenchAdapter) adaptable
                .getAdapter(IWorkbenchAdapter.class);
        if (wbAdapter == null) { return null; }
        ImageDescriptor descriptor = wbAdapter.getImageDescriptor(adaptable);
        if (descriptor == null) { return null; }

        Point size = useSmallSize(flags) ? SMALL_SIZE : BIG_SIZE;
        return new RubyElementImageDescriptor(descriptor, 0, size);
    }

    // ---- Computation of base image key
    // -------------------------------------------------

    /**
     * Returns an image descriptor for a ruby element. This is the base image,
     * no overlays.
     */
    public ImageDescriptor getBaseImageDescriptor(IRubyElement element, int renderFlags) {
        try {
            switch (element.getElementType()) {
            case IRubyElement.METHOD: {
                IMethod method = (IMethod) element;
                IType declType = method.getDeclaringType();
                int flags = method.getVisibility();
                return getMethodImageDescriptor(flags);
            }
            case IRubyElement.GLOBAL:
                return RubyPluginImages.DESC_OBJS_GLOBAL;

            case IRubyElement.CLASS_VAR:
                return RubyPluginImages.DESC_OBJS_CLASS_VAR;

            case IRubyElement.CONSTANT:
                return RubyPluginImages.DESC_OBJS_CONSTANT;

            case IRubyElement.LOCAL_VARIABLE:
                return RubyPluginImages.DESC_OBJS_LOCAL_VAR;

            case IRubyElement.INSTANCE_VAR:
                return RubyPluginImages.DESC_OBJS_INSTANCE_VAR;

            case IRubyElement.IMPORT:
                return RubyPluginImages.DESC_OBJS_IMPDECL;

            case IRubyElement.IMPORT_CONTAINER:
                return RubyPluginImages.DESC_OBJS_IMPCONT;

            case IRubyElement.TYPE: {
                IType type = (IType) element;
                
                IType declType = type.getDeclaringType();
                boolean isInner = declType != null;
                return getTypeImageDescriptor(type.isModule(), isInner, useLightIcons(renderFlags));
            }

            case IRubyElement.SCRIPT:
                return RubyPluginImages.DESC_OBJS_SCRIPT;

            case IRubyElement.PROJECT:
                IRubyProject jp = (IRubyProject) element;
                if (jp.getProject().isOpen()) {
                    IProject project = jp.getProject();
                    IWorkbenchAdapter adapter = (IWorkbenchAdapter) project
                            .getAdapter(IWorkbenchAdapter.class);
                    if (adapter != null) {
                        ImageDescriptor result = adapter.getImageDescriptor(project);
                        if (result != null) return result;
                    }
                    return DESC_OBJ_PROJECT;
                }
                return DESC_OBJ_PROJECT_CLOSED;

            case IRubyElement.RUBY_MODEL:
                return RubyPluginImages.DESC_OBJS_RUBY_MODEL;
            }

            Assert.isTrue(false, RubyUIMessages.RubyImageLabelprovider_assert_wrongImage);
            return RubyPluginImages.DESC_OBJS_GHOST;
        } catch (RubyModelException e) {
            return RubyPluginImages.DESC_OBJS_UNKNOWN;
        }
    }

    public void dispose() {
    }

    // ---- Methods to compute the adornments flags
    // ---------------------------------

    private int computeRubyAdornmentFlags(IRubyElement element, int renderFlags) {
        int flags = 0;
        if (showOverlayIcons(renderFlags) && element instanceof IMember) {
            IMember member = (IMember) element;

            if (element.getElementType() == IRubyElement.METHOD
                    && ((IMethod) element).isConstructor())
                flags |= RubyElementImageDescriptor.CONSTRUCTOR;

        }
        return flags;
    }

    public static ImageDescriptor getMethodImageDescriptor(int flags) {
        if (Flags.isPublic(flags)) return RubyPluginImages.DESC_MISC_PUBLIC;
        if (Flags.isProtected(flags)) return RubyPluginImages.DESC_MISC_PROTECTED;
        return RubyPluginImages.DESC_MISC_PRIVATE;
    }

    public static ImageDescriptor getTypeImageDescriptor(boolean isModule, boolean isInner, boolean useLightIcons) {
        if (isModule) { 
            if (useLightIcons) { return RubyPluginImages.DESC_OBJS_MODULEALT; }
            if (isInner) { return getInnerModuleImageDescriptor(); }
            return RubyPluginImages.DESC_OBJS_MODULE; }
        if (useLightIcons) { return RubyPluginImages.DESC_OBJS_CLASSALT; }
        if (isInner) { return getInnerClassImageDescriptor(); }
        return getClassImageDescriptor();
    }

    public static Image getDecoratedImage(ImageDescriptor baseImage, int adornments, Point size) {
        return RubyPlugin.getImageDescriptorRegistry().get(
                new RubyElementImageDescriptor(baseImage, adornments, size));
    }

    private static ImageDescriptor getClassImageDescriptor() {
        return RubyPluginImages.DESC_OBJS_CLASS;
    }

    private static ImageDescriptor getInnerClassImageDescriptor() {
        return RubyPluginImages.DESC_OBJS_INNER_CLASS;
    }
    
    private static ImageDescriptor getInnerModuleImageDescriptor() {
        return RubyPluginImages.DESC_OBJS_MODULE;
    }

    public static ImageDescriptor getFieldImageDescriptor() {
        // TODO What about other types of fields!
        return RubyPluginImages.DESC_OBJS_CLASS_VAR;
    }
}