content: /*******************************************************************************
   * Copyright (c) 2000, 2009 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.eclipse.wst.jsdt.internal.ui.compare;
  
  import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.io.UnsupportedEncodingException;
  import java.util.ArrayList;
  import java.util.List;
  import java.util.MissingResourceException;
  import java.util.ResourceBundle;
  
  import org.eclipse.compare.CompareConfiguration;
  import org.eclipse.compare.IEncodedStreamContentAccessor;
  import org.eclipse.compare.IStreamContentAccessor;
  import org.eclipse.core.resources.ResourcesPlugin;
  import org.eclipse.core.runtime.Assert;
  import org.eclipse.core.runtime.CoreException;
  import org.eclipse.core.runtime.IPath;
  import org.eclipse.jface.action.IAction;
  import org.eclipse.jface.resource.ImageDescriptor;
  import org.eclipse.jface.text.IDocument;
  import org.eclipse.jface.text.IDocumentPartitioner;
  import org.eclipse.swt.graphics.Image;
  import org.eclipse.wst.jsdt.core.IJavaScriptElement;
  import org.eclipse.wst.jsdt.core.IMember;
  import org.eclipse.wst.jsdt.core.IType;
  import org.eclipse.wst.jsdt.internal.ui.JavaPluginImages;
  import org.eclipse.wst.jsdt.internal.ui.JavaScriptPlugin;
  import org.eclipse.wst.jsdt.ui.JavaScriptElementLabels;
  import org.eclipse.wst.jsdt.ui.text.IJavaScriptPartitions;
  import org.eclipse.wst.jsdt.ui.text.JavaScriptTextTools;
  
  
  class JavaCompareUtilities {
  	
  	private static final char PACKAGEDECLARATION= '%';
  	private static final char IMPORTDECLARATION= '#';
  	private static final char IMPORT_CONTAINER= '<';
  	private static final char FIELD= '^';
  	private static final char METHOD= '~';
  	private static final char INITIALIZER= '|';
  	private static final char COMPILATIONUNIT= '{';
  	private static final char TYPE= '[';
  			
  	static String getString(ResourceBundle bundle, String key, String dfltValue) {
  		
  		if (bundle != null) {
  			try {
  				return bundle.getString(key);
  			} catch (MissingResourceException x) {
  				// NeedWork
  			}
  		}
  		return dfltValue;
  	}
  	
  	static String getString(ResourceBundle bundle, String key) {
  		return getString(bundle, key, key);
  	}
  	
  	static int getInteger(ResourceBundle bundle, String key, int dfltValue) {
  		
  		if (bundle != null) {
  			try {
  				String s= bundle.getString(key);
  				if (s != null)
  					return Integer.parseInt(s);
  			} catch (NumberFormatException x) {
  				// NeedWork
  			} catch (MissingResourceException x) {
  				// NeedWork
  			}
  		}
  		return dfltValue;
  	}
  
  	static ImageDescriptor getImageDescriptor(int type) {
  		switch (type) {			
  		case IJavaScriptElement.INITIALIZER:
  		case IJavaScriptElement.METHOD:
  			return getImageDescriptor("obj16/compare_method.gif"); //$NON-NLS-1$			
  		case IJavaScriptElement.FIELD:
  			return getImageDescriptor("obj16/compare_field.gif"); //$NON-NLS-1$
  		case IJavaScriptElement.IMPORT_DECLARATION:
  			return JavaPluginImages.DESC_OBJS_IMPDECL;
  		case IJavaScriptElement.IMPORT_CONTAINER:
  			return JavaPluginImages.DESC_OBJS_IMPCONT;
  		case IJavaScriptElement.JAVASCRIPT_UNIT:
  			return JavaPluginImages.DESC_OBJS_CUNIT;
  		}
  		return ImageDescriptor.getMissingImageDescriptor();
  	}
  	
  	static ImageDescriptor getTypeImageDescriptor(boolean isClass) {
  		if (isClass)
  			return JavaPluginImages.DESC_OBJS_CLASS;
  		return JavaPluginImages.DESC_OBJS_INTERFACE;
  	}
  
  	static ImageDescriptor getEnumImageDescriptor() {
  		return JavaPluginImages.DESC_OBJS_ENUM;
  	}
  
  	static ImageDescriptor getAnnotationImageDescriptor() {
  		return JavaPluginImages.DESC_OBJS_ANNOTATION;
  	}
  
  	static ImageDescriptor getImageDescriptor(IMember element) {
  		int t= element.getElementType();
  		if (t == IJavaScriptElement.TYPE) {
  			IType type= (IType) element;
  			try {
  				return getTypeImageDescriptor(type.isClass());
  			} catch (CoreException e) {
  				JavaScriptPlugin.log(e);
  				return JavaPluginImages.DESC_OBJS_GHOST;
  			}
  		}
  		return getImageDescriptor(t);
  	}
  	
  	/**
  	 * Returns a name for the given Java element that uses the same conventions
  	 * as the JavaNode name of a corresponding element.
  	 */
  	static String getJavaElementID(IJavaScriptElement je) {
  		
  		if (je instanceof IMember && ((IMember)je).isBinary())
  			return null;
  			
  		StringBuffer sb= new StringBuffer();
  		
  		switch (je.getElementType()) {
  		case IJavaScriptElement.JAVASCRIPT_UNIT:
  			sb.append(COMPILATIONUNIT);
  			break;
  		case IJavaScriptElement.TYPE:
  			sb.append(TYPE);
  			sb.append(je.getElementName());
  			break;
  		case IJavaScriptElement.FIELD:
  			sb.append(FIELD);
  			sb.append(je.getElementName());
  			break;
  		case IJavaScriptElement.METHOD:
  			sb.append(METHOD);
  			sb.append(JavaScriptElementLabels.getElementLabel(je, JavaScriptElementLabels.M_PARAMETER_TYPES));
  			break;
  		case IJavaScriptElement.INITIALIZER:
  			String id= je.getHandleIdentifier();
  			int pos= id.lastIndexOf(INITIALIZER);
  			if (pos >= 0)
  				sb.append(id.substring(pos));
  			break;
  		case IJavaScriptElement.IMPORT_CONTAINER:
  			sb.append(IMPORT_CONTAINER);
  			break;
  		case IJavaScriptElement.IMPORT_DECLARATION:
  			sb.append(IMPORTDECLARATION);
  			sb.append(je.getElementName());			
  			break;
  		default:
  			return null;
  		}
  		return sb.toString();
  	}
  	
  	/**
  	 * Returns a name which identifies the given typed name.
  	 * The type is encoded as a single character at the beginning of the string.
  	 */
  	static String buildID(int type, String name) {
  		StringBuffer sb= new StringBuffer();
  		switch (type) {
  		case JavaNode.CU:
  			sb.append(COMPILATIONUNIT);
  			break;
  		case JavaNode.CLASS:
  		case JavaNode.INTERFACE:
  		case JavaNode.ENUM:
  		case JavaNode.ANNOTATION:
  			sb.append(TYPE);
  			sb.append(name);
  			break;
  		case JavaNode.FIELD:
  			sb.append(FIELD);
  			sb.append(name);
  			break;
  		case JavaNode.CONSTRUCTOR:
  		case JavaNode.METHOD:
  			sb.append(METHOD);
  			sb.append(name);
  			break;
  		case JavaNode.INIT:
  			sb.append(INITIALIZER);
  			sb.append(name);
  			break;
  		case JavaNode.PACKAGE:
  			sb.append(PACKAGEDECLARATION);
  			break;
  		case JavaNode.IMPORT:
  			sb.append(IMPORTDECLARATION);
  			sb.append(name);
  			break;
  		case JavaNode.IMPORT_CONTAINER:
  			sb.append(IMPORT_CONTAINER);
  			break;
  		default:
  			Assert.isTrue(false);
  			break;
  		}
  		return sb.toString();
  	}
  
  	static ImageDescriptor getImageDescriptor(String relativePath) {
  		IPath path= JavaPluginImages.ICONS_PATH.append(relativePath);
  		return JavaPluginImages.createImageDescriptor(JavaScriptPlugin.getDefault().getBundle(), path, true);
  	}
  	
  	static boolean getBoolean(CompareConfiguration cc, String key, boolean dflt) {
  		if (cc != null) {
  			Object value= cc.getProperty(key);
  			if (value instanceof Boolean)
  				return ((Boolean) value).booleanValue();
  		}
  		return dflt;
  	}
  
  	static Image getImage(IMember member) {
  		ImageDescriptor id= getImageDescriptor(member);
  		return id.createImage();
  	}
  
  	static JavaScriptTextTools getJavaTextTools() {
  		JavaScriptPlugin plugin= JavaScriptPlugin.getDefault();
  		if (plugin != null)
  			return plugin.getJavaTextTools();
  		return null;
  	}
  	
  	static IDocumentPartitioner createJavaPartitioner() {
  		JavaScriptTextTools tools= getJavaTextTools();
  		if (tools != null)
  			return tools.createDocumentPartitioner();
  		return null;
  	}
  	
  	static void setupDocument(IDocument document) {
  		JavaScriptTextTools tools= getJavaTextTools();
  		if (tools != null)
  			tools.setupJavaDocumentPartitioner(document, IJavaScriptPartitions.JAVA_PARTITIONING);
  	}
  //	
  //	static void setupPropertiesFileDocument(IDocument document) {
  //		PropertiesFileDocumentSetupParticipant.setupDocument(document);
  //	}
  	
  	/**
  	 * Reads the contents of the given input stream into a string.
  	 * The function assumes that the input stream uses the platform's default encoding
  	 * (<code>ResourcesPlugin.getEncoding()</code>).
  	 * Returns null if an error occurred.
  	 */
  	private static String readString(InputStream is, String encoding) {
  		if (is == null)
  			return null;
  		BufferedReader reader= null;
  		try {
  			StringBuffer buffer= new StringBuffer();
  			char[] part= new char[2048];
  			int read= 0;
  			reader= new BufferedReader(new InputStreamReader(is, encoding));
  
  			while ((read= reader.read(part)) != -1)
  				buffer.append(part, 0, read);
  			
  			return buffer.toString();
  			
  		} catch (IOException ex) {
  			// NeedWork
  		} finally {
  			if (reader != null) {
  				try {
  					reader.close();
  				} catch (IOException ex) {
  					// silently ignored
  				}
  			}
  		}
  		return null;
  	}
  	
  	public static String readString(IStreamContentAccessor sa) throws CoreException {
  		InputStream is= sa.getContents();
  		if (is != null) {
  			String encoding= null;
  			if (sa instanceof IEncodedStreamContentAccessor) {
  				try {
  					encoding= ((IEncodedStreamContentAccessor) sa).getCharset();
  				} catch (Exception e) {
  				}
  			}
  			if (encoding == null)
  				encoding= ResourcesPlugin.getEncoding();
  			return readString(is, encoding);
  		}
  		return null;
  	}
  
  	/**
  	 * Returns the contents of the given string as an array of bytes 
  	 * in the platform's default encoding.
  	 */
  	static byte[] getBytes(String s, String encoding) {
  		try {
  			return s.getBytes(encoding);
  		} catch (UnsupportedEncodingException e) {
  			return s.getBytes();
  		}
  	}
  	
  	/**
  	 * Breaks the contents of the given input stream into an array of strings.
  	 * The function assumes that the input stream uses the platform's default encoding
  	 * (<code>ResourcesPlugin.getEncoding()</code>).
  	 * Returns null if an error occurred.
  	 */
  	static String[] readLines(InputStream is2, String encoding) {
  		
  		BufferedReader reader= null;
  		try {
  			reader= new BufferedReader(new InputStreamReader(is2, encoding));
  			StringBuffer sb= new StringBuffer();
  			List list= new ArrayList();
  			while (true) {
  				int c= reader.read();
  				if (c == -1)
  					break;
  				sb.append((char)c);
  				if (c == '\r') {	// single CR or a CR followed by LF
  					c= reader.read();
  					if (c == -1)
  						break;
  					sb.append((char)c);
  					if (c == '\n') {
  						list.add(sb.toString());
  						sb= new StringBuffer();
  					}
  				} else if (c == '\n') {	// a single LF
  					list.add(sb.toString());
  					sb= new StringBuffer();
  				}
  			}
  			if (sb.length() > 0)
  				list.add(sb.toString());
  			return (String[]) list.toArray(new String[list.size()]);
  
  		} catch (IOException ex) {
  			return null;
  
  		} finally {
  			if (reader != null) {
  				try {
  					reader.close();
  				} catch (IOException ex) {
  					// silently ignored
  				}
  			}
  		}
  	}
  	
  	/*
  	 * Initialize the given Action from a ResourceBundle.
  	 */
  	static void initAction(IAction a, ResourceBundle bundle, String prefix) {
  		
  		String labelKey= "label"; //$NON-NLS-1$
  		String tooltipKey= "tooltip"; //$NON-NLS-1$
  		String imageKey= "image"; //$NON-NLS-1$
  		String descriptionKey= "description"; //$NON-NLS-1$
  		
  		if (prefix != null && prefix.length() > 0) {
  			labelKey= prefix + labelKey;
  			tooltipKey= prefix + tooltipKey;
  			imageKey= prefix + imageKey;
  			descriptionKey= prefix + descriptionKey;
  		}
  		
  		a.setText(getString(bundle, labelKey, labelKey));
  		a.setToolTipText(getString(bundle, tooltipKey, null));
  		a.setDescription(getString(bundle, descriptionKey, null));
  		
  		String relPath= getString(bundle, imageKey, null);
  		if (relPath != null && relPath.trim().length() > 0) {
  			
  			String dPath;
  			String ePath;
  			
  			if (relPath.indexOf("/") >= 0) { //$NON-NLS-1$
  				String path= relPath.substring(1);
  				dPath= 'd' + path;
  				ePath= 'e' + path;
  			} else {
  				dPath= "dlcl16/" + relPath; //$NON-NLS-1$
  				ePath= "elcl16/" + relPath; //$NON-NLS-1$
  			}
  			
  			ImageDescriptor id= JavaCompareUtilities.getImageDescriptor(dPath);	// we set the disabled image first (see PR 1GDDE87)
  			if (id != null)
  				a.setDisabledImageDescriptor(id);
  			id= JavaCompareUtilities.getImageDescriptor(ePath);
  			if (id != null) {
  				a.setImageDescriptor(id);
  				a.setHoverImageDescriptor(id);
  			}
  		}
  	}
  	
  	static void initToggleAction(IAction a, ResourceBundle bundle, String prefix, boolean checked) {
  
  		String tooltip= null;
  		if (checked)
  			tooltip= getString(bundle, prefix + "tooltip.checked", null);	//$NON-NLS-1$
  		else
  			tooltip= getString(bundle, prefix + "tooltip.unchecked", null);	//$NON-NLS-1$
  		if (tooltip == null)
  			tooltip= getString(bundle, prefix + "tooltip", null);	//$NON-NLS-1$
  		
  		if (tooltip != null)
  			a.setToolTipText(tooltip);
  			
  		String description= null;
  		if (checked)
  			description= getString(bundle, prefix + "description.checked", null);	//$NON-NLS-1$
  		else
  			description= getString(bundle, prefix + "description.unchecked", null);	//$NON-NLS-1$
  		if (description == null)
  			description= getString(bundle, prefix + "description", null);	//$NON-NLS-1$
  		
  		if (description != null)
  			a.setDescription(description);
  	}
  }
  