Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2006, 2008 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.pde.internal.ua.ui.wizards.cheatsheet;
 
 
 import  org.eclipse.swt.SWT;
 import  org.eclipse.swt.events.ModifyEvent;
 import  org.eclipse.swt.events.ModifyListener;
 import  org.eclipse.swt.events.SelectionAdapter;
 import  org.eclipse.swt.events.SelectionEvent;
 import  org.eclipse.swt.layout.GridData;
 import  org.eclipse.swt.layout.GridLayout;
 import  org.eclipse.swt.widgets.*;
RegisterCSWizardPage
 
 public abstract class RegisterCSWizardPage extends WizardPage implements IRegisterCSData {
 
 	public final static String F_PAGE_NAME = "register-cs"//$NON-NLS-1$	
 
 	public final static String F_CS_ELEMENT_CATEGORY = "category"//$NON-NLS-1$
 
 	public final static String F_CS_ELEMENT_CHEATSHEET = "cheatsheet"//$NON-NLS-1$
 
 	public final static String F_CS_ELEMENT_DESCRIPTION = "description"//$NON-NLS-1$
 
 	private final static String F_LOCALE_VARIABLE = "$nl$/"//$NON-NLS-1$
 
 	private Combo fCategoryCombo;
 
 	private Button fCategoryButton;
 
 	private Text fDescriptionText;
 
 	protected IModel fCheatSheetModel;
 
 
 
 
 
 

Parameters:
pageName
 
 	public RegisterCSWizardPage(IModel model) {
 		super();
 
 		 = model;
 	}

 
 	private void initialize() {
 
 
 		 = null;
 		 = null;
 		 = null;
 
 
 		 = null;
 		 = null;
 
		// Get the project the cheat sheet is stored in
	}

	private void initializePluginModel() {
		IPluginModelBase base = PluginRegistry.findModel(getPluginProject());
		// should never happen
		if (base == null)
			return;
		if (base instanceof IBundlePluginModelBase)
		else
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getDataDescription()
	 */
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getDataCategoryName()
	 */
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getDataCategoryType()
	 */
	public int getDataCategoryType() {
		String categoryID = getDataCategoryID();
		if (categoryID == null) {
		}
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getDataCategoryID()
	 */
		if ( != null) {
		}
		return null;
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getDataContentFile()
	 */
		// Retrieve the project relative path to the cheat sheet
		// Prepend the locale specific variable
		return  + portablePath;
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getDataCheatSheetID()
	 */
	}
	/* (non-Javadoc)
	 * @see org.eclipse.pde.internal.ui.wizards.cheatsheet.IRegisterCSData#getPluginProject()
	 */
	}

Returns:
	public abstract String getDataCheatSheetName();

Returns:
	public abstract boolean isCompositeCheatSheet();
	/* (non-Javadoc)
	 * @see org.eclipse.jface.dialogs.IDialogPage#createControl(org.eclipse.swt.widgets.Composite)
	 */
	public void createControl(Composite parent) {
		createUI(parent);
	}

Parameters:
parent
	private void createUI(Composite parent) {
		// Create the container
		Composite container = createUIContainer(parent);
		// Create the label
		createUILabel(container);
		// Create the group
		Group group = createUIGroup(container);
		// Create the category field
		// Create the description field
		// Set the control for the reciever
		// Must be done otherwise a null assertion error is generated
		setControl(container);
		// Apply the dialog font to all controls using the default font
		Dialog.applyDialogFont(container);
		// Provide functionality for the help button
	}

Parameters:
container
	private void createUILabel(Composite container) {
		Label label = new Label(container, SWT.WRAP);
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		data.widthHint = 300;
		label.setLayoutData(data);
	}

Parameters:
container
Returns:
	private Group createUIGroup(Composite container) {
		Group group = new Group(container, SWT.NONE);
		GridLayout layout = new GridLayout(3, false);
		layout.marginWidth = 6;
		layout.marginHeight = 6;
		group.setLayout(layout);
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		data.horizontalSpan = 3;
		data.verticalIndent = 10;
		group.setLayoutData(data);
		return group;
	}

Parameters:
parent
Returns:
	private Composite createUIContainer(Composite parent) {
		Composite container = new Composite(parent, SWT.NONE);
		GridLayout layout = new GridLayout();
		layout.numColumns = 3;
		container.setLayout(layout);
		return container;
	}

Parameters:
parent
	private void createUICategoryField(Composite parent) {
		// Create the label
		// Create the combo
		// Create the button
	}

Parameters:
parent
	private void createUICategoryLabel(Composite parent) {
		Label label = new Label(parent, SWT.NONE);
	}

Parameters:
parent
	private void createUICategoryCombo(Composite parent) {
		int style = SWT.READ_ONLY | SWT.BORDER;
		 = new Combo(parentstyle);
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		.setLayoutData(data);
	}

Parameters:
parent
	private void createUICategoryButton(Composite parent) {
		 = new Button(parent, SWT.PUSH);
		GridData data = new GridData(GridData.HORIZONTAL_ALIGN_END);
		data.widthHint = 50;
		.setLayoutData(data);
	}

Parameters:
parent
	private void createUIDescriptionField(Composite parent) {
		// Create the label
		// Create the text widget
	}

Parameters:
parent
	private void createUIDescriptionLabel(Composite parent) {
		Label label = new Label(parent, SWT.NONE);
		int style = GridData.VERTICAL_ALIGN_BEGINNING | GridData.HORIZONTAL_ALIGN_END;
		GridData data = new GridData(style);
		label.setLayoutData(data);
	}

Parameters:
parent
	private void createUIDescriptionText(Composite parent) {
		int style = SWT.MULTI | SWT.WRAP | SWT.V_SCROLL | SWT.BORDER;
		 = new Text(parentstyle);
		GridData data = new GridData(GridData.FILL_HORIZONTAL);
		data.heightHint = 60;
		data.horizontalSpan = 2;
		.setLayoutData(data);
	}

	private void createUIListeners() {
		// Create listeners for the category button
		// Create listeners for the category combo box
		// Create listeners for the description text
	}

		.addSelectionListener(new SelectionAdapter() {
			public void widgetSelected(SelectionEvent e) {
			}
		});
	}

		.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
			}
		});
	}

		.addModifyListener(new ModifyListener() {
			public void modifyText(ModifyEvent e) {
			}
		});
	}

		// Create a dialog allowing the user to input the category name
		NewCategoryNameDialog dialog = new NewCategoryNameDialog(PDEUserAssistanceUIPlugin.getActiveWorkbenchShell());
		dialog.create();
		if (dialog.open() == .) {
			String newCategoryName = dialog.getNameText();
			if (PDETextHelper.isDefinedAfterTrim(newCategoryName)) {
				String trimmedText = newCategoryName.trim();
				.add(trimmedText);
				.setText(trimmedText);
				.setFocus();
				String id = generateCategoryID(trimmedText);
			}
		}
	}

	private void updateUI() {
		if ( != null) {
			// Find all cheat sheet extensions within the host plug-in
			IPluginExtension[] extensions = RegisterCSOperation.findCheatSheetExtensions();
			// Process all category elements
			// Process all cheat sheet elements
		}
	}

Parameters:
extensions
	private void processCategoryElements(IPluginExtension[] extensions) {
		// Linear search:  Process all cheat sheet extensions found
		for (int i = 0; i < extensions.lengthi++) {
			if (extensions[i].getChildCount() == 0) {
				// Extension has no children, skip to the next extension
				continue;
			}
			IPluginExtension extension = extensions[i];
			IPluginObject[] pluginObjects = extension.getChildren();
			// Process all children
			for (int j = 0; j < pluginObjects.lengthj++) {
				if (pluginObjects[jinstanceof IPluginElement) {
					IPluginElement element = (IPluginElementpluginObjects[j];
						// Category element
						// Update the category combo
					}
				}
			}
		}
	}

Parameters:
extensions
	private void processCheatSheetElements(IPluginExtension[] extensions) {
		// Query cheat sheet extensions for information required to update
		// the description text and category combo widgets
		// Linear search:  Process all cheat sheet extensions found
		for (int i = 0; i < extensions.lengthi++) {
			if (extensions[i].getChildCount() == 0) {
				// Extension has no children, skip to the next extension
				continue;
			}
			IPluginExtension extension = extensions[i];
			IPluginObject[] pluginObjects = extension.getChildren();
			// Process all children
			for (int j = 0; j < pluginObjects.lengthj++) {
				if (pluginObjects[jinstanceof IPluginElement) {
					IPluginElement element = (IPluginElementpluginObjects[j];
						// Cheat sheet element
					}
				}
			}
		}
	}

Process category elements

Parameters:
parentElement
	private void updateUICategoryComboElement(IPluginElement parentElement) {
		// Get the id attribute
		// Get the name attribute
		// Add the category to the combo box only if
		// (1) the category name is defined
		// (2) the category has not already been added to the combo box
		if ((nameAttribute != null) && PDETextHelper.isDefined(nameAttribute.getValue()) && (idAttribute != null) && PDETextHelper.isDefined(idAttribute.getValue()) && (.containsCategoryName(nameAttribute.getValue()) == false)) {
			// TODO: MP: LOW: CompCS: Reference translated value
			.add(nameAttribute.getValue());
			// Assocate the category ID with the category name
		}
	}

Process cheatsheet elements with a category attribute

Parameters:
parentElement
		// Get the category attribute
		IPluginAttribute categoryAttribute = element.getAttribute();
		// Process the category attribute
		if ((categoryAttribute != null) && PDETextHelper.isDefined(categoryAttribute.getValue())) {
			String id = categoryAttribute.getValue();
			// Check to see if the category ID has been defined
				// Update the category combo selection
				.setText(name);
else {
				// Add the category ID to the combo box (no assoicated name)
				// This can only happen if the category is defined outside of
				// the plug-in the cheat sheet is stored in
				.setText(id);
			}
		}
	}

Parameters:
extensions
	private void processCheatSheetElement(IPluginElement parentElementString generatedID) {
		// Get the id attribute
		// Check for the generated ID for this cheat sheet
		// If a cheat sheet exists with the generated ID already, read its
		// description and populate the description text accordingly		
		if ((idAttribute != null) && PDETextHelper.isDefined(idAttribute.getValue()) && generatedID.equals(idAttribute.getValue())) {
			// Matching cheat sheet extension found
			// Process children if any
			if (parentElement.getChildCount() > 0) {
				// Update the description text widget
			}
		}
	}

Parameters:
parentElement
	private void updateUIDescriptionText(IPluginElement parentElement) {
		IPluginObject pluginObject = parentElement.getChildren()[0];
		if (pluginObject instanceof IPluginElement) {
			IPluginElement element = (IPluginElementpluginObject;
			if (element.getName().equals() && PDETextHelper.isDefinedAfterTrim(element.getText())) {
				// Triggers listener to update data description on load
				.setText(element.getText().trim());
			}
		}
	}

	private void validateUI() {
	}

Parameters:
model
extensionPointID
Returns:
	public IPluginExtension[] findExtensions(ISharedExtensionsModel modelString extensionPointID) {
		IPluginExtension[] extensions = model.getExtensions().getExtensions();
		ArrayList csExtensions = new ArrayList();
		for (int i = 0; i < extensions.lengthi++) {
			String point = extensions[i].getPoint();
			if (extensionPointID.equals(point)) {
				csExtensions.add(extensions[i]);
			}
		}
		return (IPluginExtension[]) csExtensions.toArray(new IPluginExtension[csExtensions.size()]);
	}

Returns:
		// Generate the hash code using the full path
		// Qualify with the project name
		// Append the hash code to make the name unique and allow cheat sheets
		// with the same name (but different directories) be registered 
		// individually
		String result = .getName() + '.' +  + uniqueID;
		return result;
	}

Returns:
	private String generateCategoryID(String name) {
		// Generate the hash code using the category name
		long uniqueID = hash(name);
		// Qualify with the project name
		// Append the hash code to make the name unique 
		String result = .getName() + '.' +  + uniqueID;
		return result;
	}

Parameters:
string
Returns:
	private long hash(String string) {
		int b = 378551;
		int a = 63689;
		long hash = 0;
		for (int i = 0; i < string.length(); i++) {
			hash = hash * a + string.charAt(i);
			a = a * b;
		}
		return (hash & 0x7FFFFFFF);
	}
New to GrepCode? Check out our FAQ X