--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/creatorextension/com.nokia.s60tools.creator/src/com/nokia/s60tools/creator/dialogs/AbstractDialog.java Tue Jan 12 13:17:53 2010 -0600
@@ -0,0 +1,3015 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+package com.nokia.s60tools.creator.dialogs;
+
+import java.util.Iterator;
+import java.util.Set;
+import java.util.Vector;
+
+import org.eclipse.jface.dialogs.Dialog;
+import org.eclipse.jface.dialogs.IDialogConstants;
+import org.eclipse.jface.dialogs.MessageDialog;
+import org.eclipse.jface.window.IShellProvider;
+import org.eclipse.swt.SWT;
+import org.eclipse.swt.SWTException;
+import org.eclipse.swt.custom.CCombo;
+import org.eclipse.swt.custom.TableEditor;
+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.events.SelectionListener;
+import org.eclipse.swt.events.VerifyEvent;
+import org.eclipse.swt.events.VerifyListener;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Font;
+import org.eclipse.swt.graphics.FontData;
+import org.eclipse.swt.graphics.RGB;
+import org.eclipse.swt.layout.GridData;
+import org.eclipse.swt.layout.GridLayout;
+import org.eclipse.swt.layout.RowLayout;
+import org.eclipse.swt.widgets.Button;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Control;
+import org.eclipse.swt.widgets.Display;
+import org.eclipse.swt.widgets.Event;
+import org.eclipse.swt.widgets.Label;
+import org.eclipse.swt.widgets.Listener;
+import org.eclipse.swt.widgets.Shell;
+import org.eclipse.swt.widgets.Table;
+import org.eclipse.swt.widgets.TableColumn;
+import org.eclipse.swt.widgets.TableItem;
+import org.eclipse.swt.widgets.Text;
+import org.eclipse.swt.widgets.Widget;
+import org.eclipse.ui.PlatformUI;
+
+import com.nokia.s60tools.creator.CreatorActivator;
+import com.nokia.s60tools.creator.CreatorHelpContextIDs;
+import com.nokia.s60tools.creator.components.AbstractComponent;
+import com.nokia.s60tools.creator.components.AbstractValue;
+import com.nokia.s60tools.creator.components.AbstractVariables;
+import com.nokia.s60tools.creator.components.AbstractValue.ModeTypes;
+import com.nokia.s60tools.creator.components.calendar.Calendar;
+import com.nokia.s60tools.creator.components.contact.Contact;
+import com.nokia.s60tools.creator.components.contact.ContactGroup;
+import com.nokia.s60tools.creator.components.contact.ContactSet;
+import com.nokia.s60tools.creator.components.contact.ContactSetVariables;
+import com.nokia.s60tools.creator.components.messaging.MailBox;
+import com.nokia.s60tools.creator.components.messaging.MailBoxVariables;
+import com.nokia.s60tools.creator.components.messaging.Message;
+import com.nokia.s60tools.creator.core.CreatorEditorSettings;
+import com.nokia.s60tools.creator.editors.CreatorScriptEditor;
+import com.nokia.s60tools.creator.editors.IAddComponentListener;
+import com.nokia.s60tools.creator.editors.IComponentProvider;
+import com.nokia.s60tools.creator.util.CreatorEditorConsole;
+
+/**
+ *
+ */
+public abstract class AbstractDialog extends Dialog {
+
+
+ //
+ // Variables for UI texts (column topics)
+ //
+ protected static final String AMOUNT_TXT = "Amount";
+ protected static final String MODE_TXT = "Mode";
+ protected static final String ITEM_VALUE_TXT = "Item value";
+ protected static final String ITEM_TYPE_TXT = "Item type";
+ protected static final String CLEAR_TXT = "Clear";
+
+ //
+ // Variables for UI component lengths
+ //
+ protected static final int TEXT_FIELD_LENGTH = 200;
+ protected static final int AMOUNT_FIELD_LENGTH = 50;
+ private static final int COLUMN_WIDTH_FOR_ONE_CHAR = 10;
+
+ //
+ // Help texts for UI
+ //
+ public static final String POSSIBLE_VALUES_FOR_TXT_PART_1 = "Possible values for '";
+ public static final String POSSIBLE_VALUES_FOR_TXT_PART_2 = "' are: ";
+ public static final String POSSIBLE_VALUES_FOR_TXT_PART_3 = ".";
+
+
+ public static final String MAX_AMOUNT_TEXT = "Max amount";
+ public static final String AMOUNT_FIELD_INFO_TEXT = "If amount field is empty, amount 1 is used.";
+
+
+ //
+ // UI texts
+ //
+ private static final String RANDOM_LEN_MAX = "Max";
+ private static final String RANDOM_LEN_DEFAULT = "Default";
+ private static final String SET_RANDOM_TXT = "Set random";
+ private static final String ADD_ROW_TXT = "Add row";
+
+
+ /**
+ * Unexpected error message
+ */
+ private static final String UNEXPECTED_ERROR_WHEN_CREATING_TABLE_AREA_ERROR_WAS =
+ "Unexpected error when creating table area, error was: ";
+
+
+ /**
+ * How many lines is shown in dialog by default
+ */
+ private static final int INITIAL_ITEMS_NUMBER_IN_TABLE = 20;
+ /**
+ * How many items can be in combo (max)
+ */
+ private static final int MAX_ITEMS_IN_COMBO = 30;
+
+
+ /**
+ * UI help text for refering to connection method
+ */
+ public static final String CONNECTION_METHOD_NAME_HELP_TEXT = POSSIBLE_VALUES_FOR_TXT_PART_1
+ +MailBoxVariables.CONNECTION_METHOD_NAME
+ +POSSIBLE_VALUES_FOR_TXT_PART_2
+ +"'Default' or any existing " +MailBoxVariables.CONNECTION_METHOD_NAME
+ +POSSIBLE_VALUES_FOR_TXT_PART_3;
+
+ /**
+ * UI help text for refering to incoming and outgoing connection method
+ */
+ public static final String CONNECTION_METHOD_NAME_IN_AND_OUT_HELP_TEXT = POSSIBLE_VALUES_FOR_TXT_PART_1
+ +MailBoxVariables.INCOMING_CONNECTIONMETHOD_NAME
+ + " and "
+ +MailBoxVariables.OUTGOING_CONNECTIONMETHOD_NAME
+ +POSSIBLE_VALUES_FOR_TXT_PART_2
+ +"'Default' or any existing " +MailBoxVariables.CONNECTION_METHOD_NAME
+ +POSSIBLE_VALUES_FOR_TXT_PART_3;
+
+
+ //
+ // private fields
+ //
+
+ private AbstractComponent component = null;
+ private boolean isInEditMode;
+ private Color white;
+ private Color grey;
+ protected Table itemsTable;
+ protected Text amoutTxtToComponent;
+
+ private boolean isAmountFieldsEnabled = true;
+ private boolean isRandomFieldsEnabled = true;
+ private IComponentProvider provider = null;
+ private CCombo linkToOtherComponentCombo = null;
+ private boolean isTableEnabled = true;
+ private String tableColumnHeaderAmount;
+ private Text extraNbrToComponent = null;
+ private Text extraTxtToComponent = null;
+ private String labelForExtraNumberField;
+ private String labelForExtraTextField;
+ private boolean wasErrorsWithDatas = false;
+ private Button addContactSetButton = null;
+ private Button addRowButton;
+
+
+ /**
+ * errors
+ */
+ private Vector<String> errors = null;
+
+ /**
+ * @param parentShell
+ */
+ private AbstractDialog(IShellProvider parentShell) {
+ super(parentShell);
+ throw new RuntimeException("Not accepted");
+ }
+
+ /**
+ * @param parentShell
+ */
+ private AbstractDialog(Shell parentShell) {
+ super (parentShell);
+ throw new RuntimeException("Not accepted");
+ }
+
+
+ /**
+ * @param parentShell
+ * @param component
+ */
+ public AbstractDialog(Shell parentShell, IComponentProvider provider){
+ super(parentShell);
+ this.provider = provider;
+ init();
+ }
+
+ /**
+ * @param parentShell
+ * @param component
+ */
+ public AbstractDialog(IShellProvider parentShell, IComponentProvider provider){
+ super(parentShell);
+ this.provider = provider;
+ init();
+ }
+
+
+ /**
+ * Init
+ */
+ private void init(){
+ RGB rgbWhite = new RGB(255, 255, 255);
+ white = new Color(null, rgbWhite);
+
+ //Get grey color from parent
+ grey = super.getParentShell().getBackground();
+
+ setInEditMode(provider.isInEditMode());
+ if(isInEditMode){
+ this.component = provider.getEditable();
+ }
+
+ tableColumnHeaderAmount = AMOUNT_TXT;
+ }
+
+ /**
+ * Set context sensitive help id
+ * @param control
+ * @param id
+ */
+ protected void setContextSensitiveHelpID(Control control, String id){
+
+ PlatformUI.getWorkbench().getHelpSystem().setHelp(control,id);
+
+ }
+ /**
+ * Set context sensitive help id to item by component type
+ * @param control
+ */
+ protected void setContextSensitiveHelpIDByComponentType(Control control){
+
+ if(getComponent() instanceof ContactSet){
+ PlatformUI.getWorkbench().getHelpSystem().setHelp(control,CreatorHelpContextIDs.CREATOR_HELP_CONTACT_SET);
+ }else if(getComponent() instanceof Contact || getComponent() instanceof ContactGroup){
+ PlatformUI.getWorkbench().getHelpSystem().setHelp(control,CreatorHelpContextIDs.CREATOR_HELP_CONTACTS);
+ }else if(getComponent() instanceof Message){
+ PlatformUI.getWorkbench().getHelpSystem().setHelp(control,CreatorHelpContextIDs.CREATOR_HELP_MESSAGES);
+ }else if(getComponent() instanceof Calendar){
+ PlatformUI.getWorkbench().getHelpSystem().setHelp(control,CreatorHelpContextIDs.CREATOR_HELP_CALENDAR);
+ }else{
+ PlatformUI.getWorkbench().getHelpSystem().setHelp(control,CreatorHelpContextIDs.CREATOR_HELP_GENERIC_COMPONENT);
+ }
+
+ }
+
+ /**
+ * SuperClass for all Dialogs holds instance to component created or edited.
+ * Implementing classes will know what type of {@link AbstractComponent} needs to be handle.
+ * @return component
+ */
+ public AbstractComponent getComponent() {
+ return component;
+ }
+
+
+
+ /**
+ * Set component
+ * @param component
+ */
+ protected void setComponent(AbstractComponent component) {
+ this.component = component;
+ }
+
+ /**
+ * Every dialog must be able to create a new Component by it's own type.
+ * @return AbstractComponent
+ */
+ protected abstract AbstractComponent createNewComponent();
+
+ /**
+ * Every dialog must be able to create a new Value by it's own type.
+ * @return AbstractValue
+ */
+ protected abstract AbstractValue createNewValue(String type, String value, String random, String amount);
+
+ /**
+ * Is Dialog in Edit mode (or add new mode)
+ * @return true if dialog is in edit mode, false otherwise
+ */
+ protected boolean isInEditMode() {
+ return isInEditMode;
+ }
+
+
+ /**
+ * Set Dialog to edit mode
+ * @param isInEditMode true if Dialog is in edit mode
+ */
+ protected void setInEditMode(boolean isInEditMode) {
+ this.isInEditMode = isInEditMode;
+ }
+
+
+ /**
+ * Selects given value as default to Combo
+ * @param values
+ * @param combo
+ * @param value
+ */
+ protected void setComboSelection(String[] values, CCombo combo, String value) {
+ if (values!= null && combo != null && value != null && !value.equals(AbstractValue.EMPTY_STRING)) {
+ for (int i = 0; i < values.length; i++) {
+ if (value.equalsIgnoreCase(values[i])) {
+ combo.select(i);
+ break;
+ }
+ }
+ }
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jface.window.Window#open()
+ */
+ public int open(){
+ return super.open();
+ }
+
+ /**
+ * @return Listener for making sure that text field contains only numbers
+ * Also back space and delete buttons is allowed
+ */
+ protected VerifyListener getNumberVerifyListener() {
+ return new VerifyListener() {
+ public void verifyText(VerifyEvent e) {
+ char c = e.character;
+ int i = c; // 0=48, 9=57, del = 127, backspace = 8
+ //If event is "" it's a clear command and must be accepted, otherwise only numbers, del and backspace is accepted commands
+ if ((e.text != null && e.text.equals(AbstractValue.EMPTY_STRING) )|| (i >= 48 && i <= 57) || i == 8 || i == 127) {
+ e.doit = true;// If text is not number, don't do it (set
+ // text just typed)
+ } else {
+ e.doit = false;
+ }
+ }
+ };
+ }
+
+ /**
+ * Check if valueText should be enabled or not and setting text to it
+ *
+ * @param valueTxt
+ * @param randomTxt
+ */
+ protected void setValueTextAndEnabling(final Text valueTxt,
+ String txtToValue, String randomTxt) {
+
+ //just in case taking of valueText size limit, if there was user defined on, other text will be also limited
+ valueTxt.setTextLimit(Text.LIMIT);
+
+ // If random is selected, text field is disabled and showing that random
+ // mode is on
+ if (randomTxt.equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH)
+ || randomTxt
+ .equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG))
+ {
+ removeNumberVerifyListener(valueTxt);//If there is number verify listener, that must be removed
+ valueTxt.setText(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG);
+ valueTxt.setEnabled(false);
+ }
+ else if (randomTxt.equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH)
+ || randomTxt.equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG))
+ {
+ removeNumberVerifyListener(valueTxt);//If there is number verify listener, that must be removed
+ valueTxt.setText(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG);
+ valueTxt.setEnabled(false);
+ }
+ else if (randomTxt.equals(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH)
+ || randomTxt.equals(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH_LONG))
+ {
+ valueTxt.setEnabled(true);
+ try {
+ Integer.parseInt(txtToValue);
+ valueTxt.setText(txtToValue);
+ } catch (NumberFormatException e) {
+ // When there was a text, an error will occur, skipping that one
+ valueTxt.setText("" +AbstractValue.USER_DEFINED_DEFAULT_LENGTH);
+ valueTxt.setFocus();
+ valueTxt.selectAll();
+ }
+ //even if given data was valid or not, we add verify listener
+ finally{
+ //We need number verify listener when user defined len is selected
+ valueTxt.addVerifyListener(getNumberVerifyListener());
+ //When field is for custom random length field, text limit will be 9
+ valueTxt.setTextLimit(9);
+ }
+ }
+
+ // If just started edit mode, must put initial value to txt field
+ else if (txtToValue != null && txtToValue.trim().length() > 0) {
+ removeNumberVerifyListener(valueTxt);//If there is number verify listener, that must be removed
+ valueTxt.setEnabled(true);
+ valueTxt.setText(CreatorEditorSettings.getInstance()
+ .replaceEntitiesWithChars(txtToValue));
+ }
+ // else value must be enabled, and if there was a random mode txt,
+ // cleaning in
+ else {
+ removeNumberVerifyListener(valueTxt);//If there is number verify listener, that must be removed
+ valueTxt.setEnabled(true);
+ if (valueTxt.getText() != null
+ && (valueTxt.getText().equals(
+ AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH)
+ || valueTxt.getText().equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG)
+ || valueTxt.getText().equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH))
+ || valueTxt.getText().equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG)
+ )
+ {
+ valueTxt.setText(AbstractValue.EMPTY_STRING);
+ }
+ }
+
+
+ }
+
+ /**
+ * Check if valueText should be enabled or not and setting text to it
+ *
+ * @param valueCombo
+ * @param randomTxt
+ */
+ protected void setValueTextAndEnabling(final CCombo valueCombo,
+ String txtToValue, String randomTxt, String typeComboSelection) {
+
+
+ // If random is selected, text field is disabled and showing that random
+ // mode is on. With fixed values, random lenght cannot be definede, so it allways is
+ //random with default lenght
+ boolean isRandomValue = CreatorEditorSettings.isRandomText(randomTxt);
+
+ if (isRandomValue )
+ {
+ valueCombo.setText(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG);
+ valueCombo.setEnabled(false);
+ }
+
+
+ // If just started edit mode, must put initial value to txt field
+ else if (txtToValue != null && txtToValue.trim().length() > 0) {
+
+ //When type is contact set reference, selection must be done with contactsetref as String, not by its value, which is just its id, e.g. "1"
+ boolean isContactSetReference = CreatorEditorSettings.isContactSetReference(typeComboSelection);
+ String selection;
+ if(isContactSetReference){
+ selection = getContactSetStringById(txtToValue);
+ }else{
+ selection = txtToValue;
+ }
+ valueCombo.setEnabled(true);
+ valueCombo.setText(AbstractValue.EMPTY_STRING);
+ String items[] = valueCombo.getItems();
+ if(isContactSetReference && selection == null){
+ valueCombo.setText(AbstractValue.EMPTY_STRING);
+ String errMsg = typeComboSelection
+ +" can not be set, because contact-set: '" +txtToValue +"' was not found.";
+ CreatorEditorConsole.getInstance().println(errMsg , CreatorEditorConsole.MSG_ERROR);
+ addError(errMsg);
+
+ }else{
+ for (int i = 0; i < items.length; i++) {
+ if(selection.equalsIgnoreCase(items[i])){
+ valueCombo.setText(selection);
+ break;
+ }
+ }
+ }
+
+ }
+ // else value must be enabled, and if there was a random mode txt,
+ // cleaning in
+ else {
+ valueCombo.setEnabled(true);
+ if (valueCombo.getText() != null
+ && (valueCombo.getText().equals(
+ AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH)
+ || valueCombo.getText().equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG)
+ || valueCombo.getText().equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH))
+ || valueCombo.getText().equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG)
+ || valueCombo.getText().equals(AbstractValue.RANDOM_TEXT)
+ )
+ {
+ valueCombo.setText(AbstractValue.EMPTY_STRING);
+ }
+ }
+
+
+ }
+
+ /**
+ * Remove verify listener(s) from widget
+ * @param widget
+ */
+ private void removeNumberVerifyListener(final Widget widget) {
+ if( widget.isListening(SWT.Verify)){
+ Listener [] listeners = widget.getListeners(SWT.Verify);
+ for (int i = 0; i < listeners.length; i++) {
+ widget.removeListener(SWT.Verify, listeners[i]);
+ }
+ }
+ }
+
+
+ /**
+ * @return white color
+ */
+ protected Color getWhite() {
+ return white;
+ }
+
+ /**
+ * @return grey color
+ */
+ protected Color getGrey() {
+ return grey;
+ }
+
+ /**
+ * Create table columns with header names:
+ * Item Type, Item Value, Random, Amount
+ */
+ protected void createTableColums() {
+ //
+ //Create columns, set column widths
+ //
+ TableColumn columnType = new TableColumn(itemsTable, SWT.NONE);
+ columnType.setWidth (200);
+ columnType.setText(ITEM_TYPE_TXT);
+ TableColumn columnValue = new TableColumn(itemsTable, SWT.NONE);
+ columnValue.setWidth (300);
+ columnValue.setText(ITEM_VALUE_TXT);
+ TableColumn columnMode = new TableColumn(itemsTable, SWT.CENTER);
+ columnMode.setWidth (180);
+ columnMode.setText(MODE_TXT);
+ TableColumn columnAmount = new TableColumn(itemsTable, SWT.NONE);
+ columnAmount.setWidth (tableColumnHeaderAmount.length() * COLUMN_WIDTH_FOR_ONE_CHAR);
+ columnAmount.setText(tableColumnHeaderAmount);
+
+ //REMOVE btn
+ TableColumn columnRemove = new TableColumn(itemsTable, SWT.NONE);
+ columnRemove.setWidth (40);
+ }
+
+ /**
+ * Create a empty row to table
+ */
+ protected void addRow(boolean openItemType, boolean setFocusToRow) throws Exception{
+ addRow(AbstractValue.EMPTY_STRING, AbstractValue.EMPTY_STRING,
+ AbstractValue.EMPTY_STRING, AbstractValue.EMPTY_STRING, openItemType, setFocusToRow);
+ }
+
+ /**
+ * Create a row to table, and setting values to rows (if needed)
+ * @param key
+ * @param value
+ */
+ protected void addRow(String key, AbstractValue value, boolean setFocusToRow) throws Exception{
+
+ String valueStr = value.getValue();
+
+ if(value.getModeType() == ModeTypes.RandomTypeUserDefinedLength){
+ valueStr = "" +value.getRandomValueLenght();
+ }
+ addRow(key, valueStr, value.getModeValueText(), ""+ value.getAmount(), true, setFocusToRow );
+ }
+
+ /**
+ * Get item types allready existing in dialog
+ * @return
+ */
+ private String [] getAddedItems(){
+
+
+ Vector<String> addedItems = new Vector<String>();
+ if(itemsTable != null){
+
+ TableItem [] items = itemsTable.getItems();
+
+ for (int i = 0; i < items.length; i++) {
+
+ TableItem item = items[i];
+
+ if(item != null){
+
+ String key = item.getText(0);
+ addedItems.add(key);
+
+ }
+ }
+ }
+ return (String[])addedItems.toArray(new String[0]);
+ }
+
+ /**
+ * Get Item types (showable names) as String.
+ * @return item names
+ * @param addedItems items allready added to Script
+ */
+ private String [] getItemTypesAsString(String [] addedItems){
+
+ String[] itemsString = getItemTypesAsString();
+
+ if(addedItems == null || addedItems.length == 0){
+ return itemsString;
+ }
+
+ Vector<String> items = new Vector<String>(itemsString.length);
+ for (int i = 0; i < itemsString.length; i++) {
+ items.add(itemsString[i]);
+ }
+
+ //Checking what items are currently added and what is supporting only one item in one script
+
+ for (int i = 0; i < addedItems.length; i++) {
+ int itemMaxOccur = getComponent().itemMaxOccur(addedItems[i]);
+
+ if(itemMaxOccur == 1){
+ items.remove(addedItems[i]);
+ }
+ }
+
+ return (String[]) items.toArray(new String[0]);
+ }
+
+
+ /**
+ * Check item amount enablation by item name
+ * @param itemName
+ * @param amout Text
+ * @return <code>true</code> if enabled, <code>false</code> otherwise.
+ */
+ private void setAmountTextEnabletion(String itemName, Text amountText){
+
+ int itemMaxOccur = getComponent().itemMaxOccur(itemName);
+ boolean enable = (itemMaxOccur == 1) ? false : true;
+ amountText.setEnabled(enable);
+
+ if(!enable){
+ amountText.setBackground(getGrey());
+ }else{
+ amountText.setBackground(getWhite());
+ }
+
+ }
+
+ /**
+ * Get Item types (showable names) as String.
+ * @return item names
+ */
+ protected abstract String [] getItemTypesAsString();
+
+ /**
+ * Get Item values (showable names)
+ * @param itemType - one of types given by {@link #getItemTypesAsString()}
+ * @return item names if itemType has fixed values or contac-set references
+ * or <code>null</code> if itemType has no fixed values.
+ */
+ private String [] getItemValueAsString(String itemType){
+
+ String[] valuesForItemType;
+
+ //If item is contact set reference, returning
+ if(CreatorEditorSettings.isContactSetReference(itemType)){
+ valuesForItemType = getContactSetsAsString();
+ if(valuesForItemType == null){
+ valuesForItemType=new String[]{AbstractValue.EMPTY_STRING};
+ }
+ }
+ else{
+ valuesForItemType = getComponent().getValuesForItemType(itemType);
+ }
+ return valuesForItemType;
+ }
+
+
+
+ /**
+ * Create a row to table, and setting values to rows (if needed)
+ * @param key
+ * @param value
+ * @param randomValueText
+ * @param amount
+ */
+ private void addRow(String key, String value, String randomValueText,
+ String amount, boolean openItemType, boolean setFocusToRow) throws Exception{
+
+ String[] allreadyAddedItems = getAddedItems();
+ String[] itemTypesAsString = getItemTypesAsString(allreadyAddedItems);
+
+ //If there is allready all items supported added to table, adding row wont affect (Might occurr when "Add Row" is pushed
+ if(itemTypesAsString == null || itemTypesAsString.length < 1
+ && key.equals(AbstractValue.EMPTY_STRING) && value.equals(AbstractValue.EMPTY_STRING)){
+ return;
+ }
+
+ final TableItem item = new TableItem (itemsTable, SWT.NONE);
+ final int itemIndex = itemsTable.indexOf(item);
+
+
+ //
+ //CCombo for selecting item type
+ //
+
+ TableEditor typeComboEditor = new TableEditor(itemsTable);
+ // Item names
+ final CCombo typeCombo = new CCombo(itemsTable, SWT.READ_ONLY);
+ //Allready added items will be update after all lines are added.
+ typeCombo.setItems(itemTypesAsString);
+ int visibleItemsCount = itemTypesAsString.length;
+ if(visibleItemsCount > 30){
+ visibleItemsCount=30;
+ }
+ typeCombo.setVisibleItemCount(visibleItemsCount);
+ final String typeComboSelection = getTypeComboSelection(key, itemIndex, openItemType);
+ typeCombo.setText(typeComboSelection);//// Select the previously selected item from the cell: combo.select(combo.indexOf(item.getText(column)));
+ typeCombo.setBackground(getWhite());
+ item.setText(0, typeCombo.getText());
+
+ typeComboEditor.grabHorizontal = true;
+ typeComboEditor.setEditor(typeCombo, item, 0);
+
+
+ //
+ //Text for typing item value
+ //
+ TableEditor valueEditor = new TableEditor(itemsTable);
+
+ //checking if text or combo is needed
+ String [] fixedValuesForType = getItemValueAsString(typeComboSelection);
+ boolean isValuesInCombo = fixedValuesForType != null && fixedValuesForType.length > 0;
+ Text valueTxt = null;
+ CCombo valueCombo = null;
+
+ if(isValuesInCombo){
+ // Adding action to clear Button
+ valueCombo = addValueComboToTable(fixedValuesForType, value,
+ item, randomValueText, typeComboSelection);
+ valueEditor.grabHorizontal = true;
+ valueEditor.setEditor(valueCombo, item, 1);
+
+
+ }else{
+ valueTxt = createValueText(value, randomValueText,
+ setFocusToRow, item, typeComboSelection);
+ valueEditor.grabHorizontal = true;
+ valueEditor.setEditor(valueTxt, item, 1);
+
+ }
+
+
+ //
+ // CCombo for Random value selection.
+ //
+ // selecting random, max len, normal len, or no selection.
+ // If random is selected, disabling item value combo
+ //
+
+ TableEditor modeEditor = new TableEditor(itemsTable);
+ final CCombo modeCombo = new CCombo(itemsTable, SWT.READ_ONLY );
+ String[] modeValues = getModeValues(isValuesInCombo, typeComboSelection);
+ modeCombo.setItems(modeValues);
+
+ modeCombo.setText(getModeComboSelection(randomValueText, modeValues));
+
+ item.setText(2, modeCombo.getText());
+ modeCombo.setBackground(getWhite());
+
+ modeEditor.grabHorizontal = true;
+ modeEditor.setEditor(modeCombo, item, 2);
+
+ modeCombo.setEnabled(isRandomFieldsEnabled);
+ if(!isRandomFieldsEnabled){
+ modeCombo.setBackground(getGrey());
+ }else{
+ modeCombo.setBackground(getWhite());
+ }
+
+ //
+ //Text field for Amount text
+ //
+
+ TableEditor amountEditor = new TableEditor(itemsTable);
+ final Text amountTxt = new Text(itemsTable, SWT.NONE);
+ amountTxt.setTextLimit(5);
+ //don't show if amount is not set (is 0)
+ if(!amount.equals("0")){
+ amountTxt.setText(amount);
+ }
+ item.setText(3, amountTxt.getText());
+
+ // Verify that amount is typed with numbers
+ amountTxt.addVerifyListener(getNumberVerifyListener());
+
+ //Update item when modify
+ amountTxt.addModifyListener(new ModifyListener() {
+ public void modifyText(ModifyEvent e) {
+ item.setText(3, amountTxt.getText());
+ }
+ });
+
+ //In some cases amount fields is not enabled.
+ //Future improvement idea, possibility to enable/disable amountTxt by selected type.
+ if(CreatorEditorSettings.isContactSetReference(key) || CreatorEditorSettings.isContactSetReference(typeComboSelection)){
+ amountTxt.setEnabled(true);//always enabled with contact set reference
+ modeCombo.setEnabled(false);
+ modeCombo.setBackground(getGrey());
+ }
+ else if(!isAmountFieldsEnabled){
+ setModeComboEnablation(typeComboSelection, modeCombo);
+ amountTxt.setEnabled(isAmountFieldsEnabled);
+ }
+ else{
+ setModeComboEnablation(typeComboSelection, modeCombo);
+ setAmountTextEnabletion(typeComboSelection, amountTxt);
+ }
+
+
+ amountEditor.grabHorizontal = true;
+ amountEditor.setEditor(amountTxt, item, 3);
+
+ //
+ // Remove btn
+ //
+ TableEditor clrBtnEditor = new TableEditor(itemsTable);
+ final Button clearBtn = new Button(itemsTable, SWT.PUSH);
+ clearBtn.setLayoutData(new GridData( GridData.FILL_HORIZONTAL | GridData.FILL_VERTICAL));
+ clearBtn.setFont(getButtonFont());
+ clearBtn.setText(CLEAR_TXT);
+ clearBtn.pack ();//This must be called, otherwise button is not visible
+ clrBtnEditor.minimumWidth = clearBtn.getSize ().x + 5;//Using +5 to fit button precisely to column
+ clrBtnEditor.horizontalAlignment = SWT.CENTER;
+
+
+ //Setting all listeners to item value, depending on item type, listeners will be for
+ //Text or CCombo type of value.
+ setItemValueListeners(item, clrBtnEditor, valueEditor, typeCombo, fixedValuesForType,
+ isValuesInCombo, valueTxt, valueCombo, modeCombo, amountTxt,
+ clearBtn);
+
+ clrBtnEditor.setEditor(clearBtn, item, 4);
+
+ // Update item when modify
+ typeCombo.addSelectionListener(new TypeComboSelectionListener(item,
+ clrBtnEditor, valueEditor, typeCombo, valueTxt, valueCombo,
+ modeCombo, amountTxt, clearBtn));
+
+ itemsTable.addListener(SWT.SetData, new TypeComboItemsSetterListener(typeCombo));
+
+ setContextSensitiveHelpIDByComponentType(typeCombo);
+ setContextSensitiveHelpID(modeCombo, CreatorHelpContextIDs.CREATOR_HELP_RANDOM_VALUES);
+ setContextSensitiveHelpIDByComponentType(amountTxt);
+ setContextSensitiveHelpIDByComponentType(clearBtn);
+ }
+
+ private void setModeComboEnablation(final String typeComboSelection,
+ final CCombo modeCombo) {
+ boolean isModeEnabled = getComponent().getVariables().isModeEnabledForKey(typeComboSelection);
+ modeCombo.setEnabled(isModeEnabled);
+ if(!isModeEnabled){
+ modeCombo.setBackground(getGrey());
+ }else{
+ modeCombo.setBackground(getWhite());
+ }
+ }
+
+ /**
+ * Get selection for mode combo
+ * @param modeText
+ * @param modeValues
+ * @return
+ */
+ private String getModeComboSelection(String modeText, String [] modeValues) {
+
+ if(modeText != null && !modeText.equals(AbstractValue.EMPTY_STRING)){
+ for (int i = 0; i < modeValues.length; i++) {
+ if(modeText.equalsIgnoreCase(modeValues[i])){
+ return modeText;
+ }
+ }
+ }
+
+ return modeValues[0];
+ }
+
+ /**
+ * Get values for mode combo
+ * @param isValuesInCombo
+ * @param typeComboSelection
+ * @return values for mode combo
+ */
+ private String[] getModeValues(boolean isValuesInCombo, String typeComboSelection) {
+
+ boolean incValueSupported = isTypeSupportingIncValueForeEachCopy(typeComboSelection);
+
+ String[] modeValues;
+
+ if(!incValueSupported && isValuesInCombo){
+ modeValues = AbstractValue.getModeValuesForFixedValues();
+ }
+ else if(!incValueSupported){
+ modeValues = AbstractValue.getModeValues();
+ }
+ //else incValueSupported == true
+ else{
+ modeValues = AbstractValue.getModeValuesForSupportingIncValueForeEachCopy();
+ }
+
+ return modeValues;
+ }
+
+ /**
+ * Check if component is supporting <code>incvalueforeachcopy</code> parameter.
+ * @param type
+ * @return <code>true</code> if supporting.
+ */
+ private boolean isTypeSupportingIncValueForeEachCopy (String type){
+
+ return getComponent().isTypeSupportingIncValueForEachCopy(type);
+
+ }
+
+ /**
+ * Set listeners related to value item (Text or CCombo)
+ * @param item
+ * @param clrButtonEditor
+ * @param valueEditor
+ * @param typeCombo
+ * @param fixedValuesForType
+ * @param isValuesInCombo
+ * @param valueTxt
+ * @param valueCombo
+ * @param modeCombo
+ * @param amountTxt
+ * @param clearBtn
+ */
+ private void setItemValueListeners(final TableItem item,
+ TableEditor clrButtonEditor, TableEditor valueEditor, final CCombo typeCombo,
+ String[] fixedValuesForType, boolean isValuesInCombo,
+ Text valueTxt, CCombo valueCombo, final CCombo modeCombo,
+ final Text amountTxt, final Button clearBtn) {
+
+ //
+ //First remove existing listeners, so there will be no extra listeners with non existing objects
+ //
+
+ Listener[] listeners = modeCombo.getListeners(SWT.Selection);
+ for (int i = 0; i < listeners.length; i++) {
+ modeCombo.removeListener(SWT.Selection, listeners[i]);
+ }
+ listeners = clearBtn.getListeners(SWT.Selection);
+ for (int i = 0; i < listeners.length; i++) {
+ clearBtn.removeListener(SWT.Selection, listeners[i]);
+ }
+ listeners = item.getListeners(SWT.Modify);
+ for (int i = 0; i < listeners.length; i++) {
+ item.removeListener(SWT.Modify, listeners[i]);
+ }
+ if(valueCombo != null){
+ listeners = valueCombo.getListeners(SWT.SetData);
+ for (int i = 0; i < listeners.length; i++) {
+ valueCombo.removeListener(SWT.SetData, listeners[i]);
+ }
+ }
+
+
+ if(isValuesInCombo){
+
+ valueCombo.setVisibleItemCount(fixedValuesForType.length);
+
+ //Update item text when text is modified (and random Combo when value text is modified by fulfill random button)
+ valueCombo.addModifyListener( new ValueModifyListener(item, valueCombo, typeCombo));
+ //Add listener to check this value enablation by selection of another value
+ item.addListener(SWT.Modify, new CheckItemValueEnablationsListener(typeCombo, valueCombo, modeCombo, amountTxt));
+
+
+ //Update value text item text when combo selection is changed
+ modeCombo.addSelectionListener(new ModeComboSelectionListener(modeCombo, valueCombo, item));
+ item.addListener(SWT.Modify, new SetAsRandomValueItemListener(item, valueCombo, modeCombo));
+
+ // Adding action to clear Button
+ clearBtn.addSelectionListener(getClearButtonSelectionListener(item, typeCombo, valueCombo, modeCombo,
+ amountTxt));
+
+ //Adding listener to update items when new contact set is created, if there is contactSet creation button, and
+ //if we have contact set reference as type.
+ if(addContactSetButton != null && CreatorEditorSettings.isContactSetReference(typeCombo.getText())){
+ addContactSetButton.addListener(SWT.SetData, new AddNewContactSetButtonListener(valueCombo));
+ }
+
+
+ }else{
+ //Update item text when text is modified (and random Combo when value text is modified by fulfill random button)
+ valueTxt.addModifyListener( new ValueModifyListener(item, valueTxt, typeCombo));
+ //Add listener to check this value enablation by selection of another value
+ item.addListener(SWT.Modify, new CheckItemValueEnablationsListener(typeCombo, valueTxt, modeCombo, amountTxt));
+
+ //Update value text item text when combo selection is changed
+ modeCombo.addSelectionListener(new ModeComboSelectionListener(modeCombo, valueTxt, item));
+ //When fulfill all values with random -button modifies values, setting also combo and text field values
+ item.addListener(SWT.Modify, new SetAsRandomValueItemListener(item, valueTxt, modeCombo));
+
+ // Adding action to clear Button
+ clearBtn.addSelectionListener(getClearButtonSelectionListener(item, typeCombo, valueTxt, modeCombo,
+ amountTxt));
+
+ }
+
+ }
+
+
+
+ /**
+ * Creates a value text
+ * @param value
+ * @param randomValueText
+ * @param setFocusToRow
+ * @param item
+ * @param typeComboSelection
+ * @return
+ */
+ private Text createValueText(String value, String randomValueText,
+ boolean setFocusToRow, final TableItem item, String typeComboSelection) {
+ final Text valueTxt = new Text(itemsTable, SWT.NONE);
+ valueTxt.setFont(getUnicodeFont());
+ setValueTextAndEnabling(valueTxt, value, randomValueText);
+ if(setFocusToRow){
+ valueTxt.setFocus();
+ }
+ item.setText(1, valueTxt.getText());
+ if(CreatorEditorSettings.isContactSetReference(valueTxt.getText())){
+ setContextSensitiveHelpID(valueTxt, CreatorHelpContextIDs.CREATOR_HELP_CONTACT_SET);
+ }else{
+ setContextSensitiveHelpIDByComponentType(valueTxt);
+ }
+
+ setTipTextToValue(valueTxt, typeComboSelection);
+
+ return valueTxt;
+ }
+
+ /**
+ * Sets tip text to value if needed
+ * @param valueTxt
+ * @param typeComboSelection
+ */
+ private void setTipTextToValue(Text valueTxt, String typeComboSelection) {
+ AbstractVariables var = getComponent().getVariables();
+ String tipText = var.getTipText(typeComboSelection);
+ if(tipText != null){
+ valueTxt.setToolTipText(tipText);
+ }
+ }
+
+ /**
+ * Listener for mode selection combo
+ */
+ private class ModeComboSelectionListener implements SelectionListener{
+
+ private CCombo modeCombo = null;
+ private Text text = null;
+ private TableItem item = null;
+ private CCombo combo = null;
+
+ public ModeComboSelectionListener(final CCombo modeCombo, final Text text, final TableItem item){
+ this.modeCombo = modeCombo;
+ this.text = text;
+ this.item = item;
+
+ }
+ public ModeComboSelectionListener(final CCombo modeCombo, final CCombo combo, final TableItem item){
+ this.modeCombo = modeCombo;
+ this.combo = combo;
+ this.item = item;
+
+ }
+
+ public void widgetSelected(SelectionEvent event) {
+
+ String rndTxt = modeCombo.getText();
+
+ if(text!=null){
+ if(CreatorEditorSettings.isContactSetReference(rndTxt)){
+ setContextSensitiveHelpID(text, CreatorHelpContextIDs.CREATOR_HELP_CONTACT_SET);
+ }else{
+ setContextSensitiveHelpIDByComponentType(text);
+ }
+ item.setText(2, rndTxt);
+ setValueTextAndEnabling(text, null, rndTxt);
+ }
+ else{
+ if(CreatorEditorSettings.isContactSetReference(rndTxt)){
+ setContextSensitiveHelpID(combo, CreatorHelpContextIDs.CREATOR_HELP_CONTACT_SET);
+ }else{
+ setContextSensitiveHelpIDByComponentType(combo);
+ }
+ combo.setEnabled(false);
+ item.setText(2, rndTxt);
+ setValueTextAndEnabling(combo, null, rndTxt, null);
+ }
+ }
+
+ public void widgetDefaultSelected(SelectionEvent e) {
+ //Not needed
+ }
+ }
+
+
+ /**
+ * Class for listening value text changes
+ */
+ private class ValueModifyListener implements ModifyListener
+
+ {
+ private TableItem item = null;
+ private Text valueText = null;
+ private CCombo valueCombo = null;
+ private final CCombo typeCombo;
+
+ public ValueModifyListener(TableItem item , Text valueText, final CCombo typeCombo){
+ this.item = item;
+ this.valueText = valueText;
+ this.typeCombo = typeCombo;
+ }
+ public ValueModifyListener(TableItem item , CCombo valueCombo, final CCombo typeCombo){
+ this.item = item;
+ this.valueCombo = valueCombo;
+ this.typeCombo = typeCombo;
+ }
+ public void modifyText(ModifyEvent e) {
+
+ if(valueText != null){
+ item.setText(1, valueText.getText());
+ }
+ else{
+ item.setText(1, valueCombo.getText());
+ //Check that if something must do to some values by the selection
+ checkIfNeedToCallCheckItemValueEnablationListenersAndCallIfNeeded(
+ valueCombo, valueText, typeCombo);
+
+
+ }
+ }
+
+ }
+
+ /**
+ * Just for enabling to cast Events when using set as random functionality
+ */
+ private class SetRandomEvent extends Event{
+
+ }
+
+ /**
+ * Just for enabling to cast Event when checking
+ * if we should disable/enable some valus by some selection made
+ */
+ private class CheckItemValueEnablationsEvent extends Event{
+
+ private String type;
+ private String value;
+
+
+ /**
+ * @return the type
+ */
+ public String getType() {
+ return type;
+ }
+
+ /**
+ * @return the value
+ */
+ public String getValue() {
+ return value;
+ }
+
+ public void setType(String type) {
+ this.type = type;
+ }
+
+ public void setValue(String value) {
+ this.value = value;
+ }
+
+ }
+
+
+ /**
+ * Listener class for setting values as random, used by button.
+ */
+ private class SetAsRandomValueItemListener implements Listener{
+
+ TableItem item = null;
+ Text valueTxt = null;
+ CCombo randomCombo = null;
+ private CCombo valueCombo = null;
+
+ public SetAsRandomValueItemListener(TableItem item, Text valueTxt, CCombo randomCombo){
+ this.item = item;
+ this.valueTxt = valueTxt;
+ this.randomCombo = randomCombo;
+
+ }
+ public SetAsRandomValueItemListener(TableItem item,CCombo valueCombo, CCombo randomCombo){
+ this.item = item;
+ this.valueCombo = valueCombo;
+ this.randomCombo = randomCombo;
+
+ }
+
+ public void handleEvent(Event e) {
+
+ //Checking that if we have wanted event
+ if(!(e instanceof SetRandomEvent)){
+ return;
+ }
+
+ String txt = item.getText(1);
+
+ //If value is in text, but not in combo
+ if (valueTxt!=null) {
+
+ if (e.doit) {
+ removeNumberVerifyListener(valueTxt);
+ }
+ if (txt != null) {
+ setValueTextAndEnablingAndRandomComboSelection(txt,
+ valueTxt, randomCombo);
+ }
+ }
+ //else value is in combo
+ else{
+ setValueTextAndEnablingAndRandomComboSelection(txt, valueCombo, randomCombo);
+ }
+ }
+ }
+
+ /**
+ * Listener class for enabling/disabling items by some other value set in dialog.
+ * E.g. With File, crypted with CRM-FL, then all CRM-CD parameters will be disabled.
+ */
+ private class CheckItemValueEnablationsListener implements Listener{
+
+ CCombo typeCombo;
+ Text valueTxt = null;
+ Text amountTxt = null;
+ CCombo modeCombo = null;
+ private CCombo valueCombo = null;
+
+ public CheckItemValueEnablationsListener(CCombo typeCombo, Text valueTxt, CCombo modeCombo, Text amountTxt){
+ this.typeCombo = typeCombo;
+ this.valueTxt = valueTxt;
+ this.modeCombo = modeCombo;
+ this.amountTxt = amountTxt;
+
+ }
+ public CheckItemValueEnablationsListener(CCombo typeCombo,CCombo valueCombo, CCombo modeCombo, Text amountTxt){
+ this.typeCombo = typeCombo;
+ this.valueCombo = valueCombo;
+ this.modeCombo = modeCombo;
+ this.amountTxt = amountTxt;
+ }
+
+ public void handleEvent(Event e) {
+
+ if(! ( e instanceof CheckItemValueEnablationsEvent )){
+ return;
+ }
+
+ CheckItemValueEnablationsEvent event = (CheckItemValueEnablationsEvent)e;
+ String type = event.getType();
+ String value = event.getValue();
+ String typeToBeDisabled = typeCombo.getText();
+
+ enableOrDisableRowItems(type, value, typeToBeDisabled, valueTxt, valueCombo, modeCombo, amountTxt);
+
+ }
+
+
+ }
+
+ /**
+ * Enables or disable items of row
+ * @param type
+ * @param value
+ * @param typeToBeDisabled
+ * @param valueTxt
+ * @param valueCombo
+ * @param modeCombo
+ */
+ private void enableOrDisableRowItems(String type, String value,
+ String typeToBeDisabled,
+ Text valueTxt,
+ CCombo valueCombo,
+ CCombo modeCombo, Text amountTxt) {
+
+ boolean enableAllValues = !getComponent().isTypeDisabledByTypeAndValue(type, value, typeToBeDisabled);
+ boolean enableValue = enableAllValues;
+
+ String currentValueTxt;
+ if (valueTxt!=null) {
+ currentValueTxt = valueTxt.getText();
+ }else{
+ currentValueTxt = valueCombo.getText();
+ }
+
+ //Check if current value is random value now
+ boolean isRandomValue = CreatorEditorSettings.isRandomText(currentValueTxt);
+ //If value is random, and we try to enable values, dont do that
+ if (isRandomValue && enableAllValues)
+ {
+ enableValue = false;
+ }
+
+ //If value is in text, but not in combo
+ if (valueTxt!=null) {
+ valueTxt.setEnabled(enableValue);
+ }
+ //else value is in combo
+ else{
+ valueCombo.setEditable(enableValue);
+ }
+
+ //dont enable mode combo if its not enabled to this type
+ boolean isModeEnabled = getComponent().getVariables().isModeEnabledForKey(typeToBeDisabled);
+ if(isModeEnabled){
+ modeCombo.setEnabled(enableAllValues);
+ }
+
+ //amount field can be enabled or disabled if its in use
+ if(isAmountFieldsEnabled()){
+ amountTxt.setEnabled(enableAllValues);
+ }
+ }
+
+ /**
+ * Listener to set items to Type Combo when selection is made
+ */
+ private class TypeComboItemsSetterListener implements Listener{
+
+ private final CCombo typeCombo;
+
+ public TypeComboItemsSetterListener(CCombo typeCombo){
+ this.typeCombo = typeCombo;
+
+ }
+
+ public void handleEvent(Event event) {
+
+ if(event.doit && event.data != null && event.data instanceof String[]){
+ String [] items = (String[]) event.data;
+ String selectionText = typeCombo.getText();
+ typeCombo.setItems(items);
+ int count = items.length;
+ if(count > MAX_ITEMS_IN_COMBO){
+ count = MAX_ITEMS_IN_COMBO;
+ }
+ typeCombo.setVisibleItemCount(count);
+ typeCombo.setText(selectionText);
+ }
+ }
+
+ }
+
+ /**
+ * Get listener for type combo.
+ * There is logic for changing value field from text to combo and vice versa.
+ * @param item
+ * @param typeCombo
+ * @param valueTxt
+ * @param randomCombo
+ * @param amountTxt
+ * @return
+ */
+ private class TypeComboSelectionListener implements SelectionListener{
+
+ private TableItem item;
+ private CCombo typeCombo;
+ private Text valueTxt;
+ private Text amountTxt;
+ private CCombo valueCombo;
+ private CCombo modeCombo;
+ private TableEditor valueEditor;
+ private TableEditor clrBtnEditor;
+ private final Button clearBtn;
+
+ public TypeComboSelectionListener ( TableItem item,
+ TableEditor clrButtonEditor, TableEditor valueEditor, CCombo typeCombo,
+ Text valueTxt, CCombo valueCombo, CCombo modeCombo,
+ Text amountTxt, Button clearBtn){
+ this.clrBtnEditor = clrButtonEditor;
+ this.valueEditor = valueEditor;
+ this.item = item;
+ this.typeCombo = typeCombo;
+ this.valueTxt = valueTxt;
+ this.valueCombo = valueCombo;
+ this.amountTxt = amountTxt;
+ this.modeCombo = modeCombo;
+ this.clearBtn = clearBtn;
+
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
+ */
+ public void widgetSelected(SelectionEvent event) {
+
+ String typeComboSelection = typeCombo.getText();
+ item.setText(0, typeComboSelection);
+
+ String [] fixedValuesForType = getItemValueAsString(typeComboSelection);
+ //Will values be in combo afterwards
+ boolean isValuesInCombo = fixedValuesForType != null && fixedValuesForType.length > 0;
+ //Was value field type changed by user selection? Will be true if before value was text, and now it will be combo and so on...
+ boolean isValueFieldTypeChanged =
+ isValuesInCombo && valueCombo == null || !isValuesInCombo && valueTxt == null
+ ? true : false;
+
+
+ if(CreatorEditorSettings.isContactSetReference(typeComboSelection))
+ {
+ amountTxt.setEnabled(true);//always enabled with contact set reference
+ modeCombo.setEnabled(false);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_NOT_RANDOM);//Setting to edit mode when contact-set is selected
+ modeCombo.setBackground(getGrey());
+
+ }else if(!isAmountFieldsEnabled){
+ amountTxt.setText(AbstractValue.EMPTY_STRING);
+ amountTxt.setEnabled(isAmountFieldsEnabled);
+ setModeComboEnablation(typeComboSelection, modeCombo);
+ }else{
+ amountTxt.setText(AbstractValue.EMPTY_STRING);
+ setAmountTextEnabletion(typeComboSelection, amountTxt);
+ setModeComboEnablation(typeComboSelection, modeCombo);
+ }
+
+
+ // Just changing contents when value remains in combo
+ if (isValuesInCombo && !isValueFieldTypeChanged) {
+ valueCombo.setItems(fixedValuesForType);
+ valueCombo.setVisibleItemCount(fixedValuesForType.length);
+
+ //When values was in combo and type was changed to contact set, we must set listeners again to listen contact-set changes.
+ setItemValueListeners(item, clrBtnEditor, valueEditor, typeCombo, fixedValuesForType,
+ isValuesInCombo, null, valueCombo, modeCombo, amountTxt,
+ clearBtn);
+ }
+ //value remains in text
+ else if (!isValuesInCombo && !isValueFieldTypeChanged) {
+ valueTxt.setText(AbstractValue.EMPTY_STRING);
+ valueTxt.setEnabled(true);
+ }
+ //else isValueFieldTypeChanged == true
+ else{
+ //Removing old control when new will be created
+ Control editable = valueEditor.getEditor();
+ editable.dispose();
+
+ //value changed from text to combo
+ if (isValuesInCombo ) {
+ valueCombo = addValueComboToTable(fixedValuesForType, AbstractValue.EMPTY_STRING,
+ item, AbstractValue.EMPTY_STRING, typeComboSelection);
+ valueEditor.setEditor(valueCombo, item, 1);
+
+ setItemValueListeners(item, clrBtnEditor, valueEditor, typeCombo, fixedValuesForType,
+ isValuesInCombo, null, valueCombo, modeCombo, amountTxt,
+ clearBtn);
+ valueTxt = null;
+
+
+ } else// if (!isValuesInCombo && isValueFieldTypeChanged)
+ {
+ valueTxt = createValueText(AbstractValue.EMPTY_STRING, AbstractValue.EMPTY_STRING, true, item, typeComboSelection);
+ valueTxt.setEnabled(true);
+ valueEditor.setEditor(valueTxt, item, 1);
+
+ setItemValueListeners(item, clrBtnEditor, valueEditor, typeCombo, null,
+ isValuesInCombo, valueTxt, null, modeCombo, amountTxt,
+ clearBtn);
+ valueCombo = null;//For removing listners
+
+ }
+ }
+
+ //setting modeCombo values after all other changes are made
+ String modeComboValues [] = getModeValues(isValuesInCombo, typeComboSelection);
+ modeCombo.setItems(modeComboValues);
+ modeCombo.setText(getModeComboSelection(AbstractValue.EMPTY_STRING, modeComboValues));
+ item.setText(2, modeCombo.getText());
+
+ //Notify table listeners to update item combos
+ notifyTypeComboDataListeners();
+
+ }
+
+
+ //Not needed.
+ public void widgetDefaultSelected(SelectionEvent e) {
+ }
+ }
+
+ /**
+ * Notify table listeners to update type combo data
+ */
+ private void notifyTypeComboDataListeners() {
+
+ String addedItems[] = getAddedItems();//get items added allready to dialog
+ String toBeSetItems[] = getItemTypesAsString(addedItems);//get items to be set to all item types
+
+ Event itemsComboUpdateEvent = new Event();
+ itemsComboUpdateEvent.doit = true;
+ itemsComboUpdateEvent.data = toBeSetItems;
+
+ //Enabling / disabling add row button if there is no rows able to add
+ if(toBeSetItems.length == 0 && addRowButton != null){
+ addRowButton.setEnabled(false);
+ }else if(addRowButton != null){
+ addRowButton.setEnabled(true);
+ }//else no action
+
+ //Notify all type-combos that new data must be set to combos
+ itemsTable.notifyListeners(SWT.SetData, itemsComboUpdateEvent);
+ }
+
+ /**
+ * Get listener for Clear button
+ * @param item
+ * @param typeCombo
+ * @param valueTxt
+ * @param randomCombo
+ * @param amountTxt
+ * @return
+ */
+ private SelectionAdapter getClearButtonSelectionListener(
+ final TableItem item, final CCombo typeCombo, final Text valueTxt,
+ final CCombo randomCombo, final Text amountTxt) {
+ return new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent event) {
+
+
+ // Clearing data, also item texts must be cleared
+ typeCombo.setText(AbstractValue.EMPTY_STRING);
+ item.setText(0, AbstractValue.EMPTY_STRING);
+ valueTxt.setText(AbstractValue.EMPTY_STRING);
+ item.setText(1, AbstractValue.EMPTY_STRING);
+ randomCombo.setText(AbstractValue.EMPTY_STRING);
+ item.setText(2, AbstractValue.EMPTY_STRING);
+ amountTxt.setText(AbstractValue.EMPTY_STRING);
+ item.setText(3, AbstractValue.EMPTY_STRING);
+
+ typeCombo.setEnabled(true);
+ valueTxt.setEnabled(true);
+ randomCombo.setEnabled(true);
+ amountTxt.setEnabled(true);
+
+ randomCombo.setBackground(getWhite());
+
+ //Notify table listeners to update item combos
+ notifyTypeComboDataListeners();
+ }
+ };
+ }
+
+ /**
+ * Get listener for Clear button
+ * @param item
+ * @param typeCombo
+ * @param valueCombo
+ * @param randomCombo
+ * @param amountTxt
+ * @return
+ */
+ private SelectionAdapter getClearButtonSelectionListener(
+ final TableItem item, final CCombo typeCombo, final CCombo valueCombo,
+ final CCombo randomCombo, final Text amountTxt) {
+ return new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent event) {
+
+ // Clearing data, also item texts must be cleared
+ typeCombo.setText(AbstractValue.EMPTY_STRING);
+ item.setText(0, AbstractValue.EMPTY_STRING);
+ valueCombo.setText(AbstractValue.EMPTY_STRING);
+ item.setText(1, AbstractValue.EMPTY_STRING);
+ randomCombo.setText(AbstractValue.EMPTY_STRING);
+ item.setText(2, AbstractValue.EMPTY_STRING);
+ amountTxt.setText(AbstractValue.EMPTY_STRING);
+ item.setText(3, AbstractValue.EMPTY_STRING);
+
+ typeCombo.setEnabled(true);
+ valueCombo.setEnabled(true);
+ randomCombo.setEnabled(true);
+ amountTxt.setEnabled(true);
+
+ randomCombo.setBackground(getWhite());
+
+ //Notify table listeners to update item combos
+ notifyTypeComboDataListeners();
+ }
+ };
+ }
+
+
+ /**
+ * When "Set Random" button is pushed, and user wants to set all values as random
+ * editing value field and random combo selection
+ * @param txt
+ * @param valueTxt
+ * @param modeCombo
+ */
+ private void setValueTextAndEnablingAndRandomComboSelection(String txt,
+ Text valueTxt, CCombo modeCombo) {
+
+ valueTxt.setTextLimit(Text.LIMIT);
+
+ if(txt == null){
+ valueTxt.setEnabled(true);
+ valueTxt.setText(AbstractValue.EMPTY_STRING);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_NOT_RANDOM);
+ }
+ // If random is selected, text field is disabled and showing that random
+ // mode is on
+
+ //random mode with default len
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH)
+ || txt.equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG)) {
+
+ valueTxt.setEnabled(false);
+ valueTxt.setText(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH);
+ }
+ //Random mode with max len
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH)
+ || txt.equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG)) {
+ valueTxt.setEnabled(false);
+ valueTxt.setText(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_MAX_LENGTH);
+ }
+ //random mode with user defined len
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH)
+ || txt.equals(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH_LONG)) {
+ valueTxt.setEnabled(true);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH);
+ }
+ //mode is RANDOM_TEXT_INC_FOR_EACH_COPY This should not be able to occur, because RANDOM_TEXT_INC_FOR_EACH_COPY
+ //value are always phone numbers and will be on text field, just in case implemented.
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_INC_FOR_EACH_COPY)) {
+ valueTxt.setEnabled(true);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_INC_FOR_EACH_COPY);
+ }
+
+ //default, not random
+ else{
+ valueTxt.setEnabled(true);
+ valueTxt.setText(txt);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_NOT_RANDOM);
+ }
+ }
+
+ /**
+ * Checks values from type and value (from valueTxt if not null or from valuecombo if txt was null)
+ * and then checks if other items must check they enablations,
+ * and enables/disables if required
+ *
+ * @param txt
+ * @param valueCombo
+ * @param typeCombo
+ */
+ private void checkIfNeedToCallCheckItemValueEnablationListenersAndCallIfNeeded(
+ CCombo valueCombo, Text valueText, CCombo typeCombo) {
+
+ String value;
+ if(valueCombo != null){
+ value = valueCombo.getText();
+ }else{
+ value = valueText.getText();
+ }
+ String type = typeCombo.getText();
+
+ callCheckItemValueEnablationListeners(type, value);
+ }
+
+ /**
+ * Check all items from itemsTable, and enables/disables those if required by some else values
+ */
+ private void checkIfNeedToCallItemValueEnablationListners(){
+ TableItem[] items = itemsTable.getItems();
+ //Looping through all items in table
+ for (int i = 0; i < items.length; i++) {
+
+ TableItem item = items[i];
+ if (item != null) {
+ String type = item.getText(0);
+ String value = item.getText(1);
+
+ callCheckItemValueEnablationListeners(type, value);
+ }
+ }
+ }
+
+ /**
+ * Calls listeners to check they values if required by given type and value.
+ *
+ * @see AbstractComponent#hasTypeLimitationsForOtherValues(String, String)
+ *
+ * @param value
+ * @param type
+ */
+ private void callCheckItemValueEnablationListeners(String type, String value) {
+
+ //check from component, if that type and value combination needs to call listeners
+ boolean wakeUpListners = getComponent().hasTypeLimitationsForOtherValues(type, value);
+
+ //If we need to wake up listners, doing so
+ if(wakeUpListners){
+
+ TableItem[] items = itemsTable.getItems();
+ //Looping through all items in table
+ for (int i = 0; i < items.length; i++) {
+
+ TableItem item = items[i];
+ if (item != null) {
+ //Creating special event, so other listeners can check that if they are not intressed of this event
+ CheckItemValueEnablationsEvent e = new CheckItemValueEnablationsEvent();
+ e.setType(type);
+ e.setValue(value);
+ e.doit = true;
+ item.notifyListeners(SWT.Modify, e);
+ }
+ }
+ }
+ }
+
+ /**
+ * When "Set Random" button is pushed, and user wants to set all values as random
+ * editing value field and random combo selection
+ * @param txt
+ * @param valueCombo
+ * @param modeCombo
+ */
+ private void setValueTextAndEnablingAndRandomComboSelection(String txt,
+ CCombo valueCombo, CCombo modeCombo) {
+
+ valueCombo.setTextLimit(Text.LIMIT);
+
+ if(txt == null){
+ valueCombo.setEnabled(true);
+ valueCombo.setText(AbstractValue.EMPTY_STRING);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_NOT_RANDOM);
+ }
+ // If random is selected, text field is disabled and showing that random
+ // mode is on
+
+ //random mode with default len
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH)
+ || txt.equals(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG)) {
+
+ valueCombo.setEnabled(false);
+ valueCombo.setText(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH);
+ }
+ //Random mode with max len
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH)
+ || txt.equals(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG)) {
+ valueCombo.setEnabled(false);
+ valueCombo.setText(AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_MAX_LENGTH);
+ }
+ //random mode with user defined len
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH)
+ || txt.equals(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH_LONG)) {
+ valueCombo.setEnabled(true);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH);
+ }
+ //mode is RANDOM_TEXT_INC_FOR_EACH_COPY This should not be able to occur, because RANDOM_TEXT_INC_FOR_EACH_COPY
+ //value are always phone numbers and will be on text field, just in case implemented.
+ else if (txt.equals(AbstractValue.RANDOM_TEXT_INC_FOR_EACH_COPY)) {
+ valueCombo.setEnabled(true);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_INC_FOR_EACH_COPY);
+ }
+ //default, not random
+ else{
+ valueCombo.setEnabled(true);
+ valueCombo.setText(txt);
+ modeCombo.setText(AbstractValue.RANDOM_TEXT_NOT_RANDOM);
+ }
+ }
+
+
+ /**
+ * Adds one value combo to table
+ * @param values
+ * @param selectedValue
+ * @param item
+ * @param randomValueText
+ * @param typeComboSelection
+ * @return
+ */
+ private CCombo addValueComboToTable(String[] values, String selectedValue,
+ final TableItem item, String randomValueText, String typeComboSelection) {
+ TableEditor editor;
+ //
+ //value combo
+ //
+ boolean isContactSetReference = CreatorEditorSettings.isContactSetReference(typeComboSelection);
+
+ editor = new TableEditor(itemsTable);
+ final CCombo valueCombo = new CCombo(itemsTable, SWT.NONE);
+ valueCombo.setItems(values);
+ valueCombo.setEditable(false);
+ valueCombo.setBackground(getWhite());
+ if(selectedValue != null){
+ setValueTextAndEnabling(valueCombo, selectedValue, randomValueText, typeComboSelection);
+ }
+
+ item.setText(1, valueCombo.getText());
+
+ valueCombo.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent event) {
+ item.setText(1, valueCombo.getText());
+ }
+ });
+
+ editor.grabHorizontal = true;
+ editor.setEditor(valueCombo, item, 1);
+
+ if(isContactSetReference){
+ setContextSensitiveHelpID(valueCombo, CreatorHelpContextIDs.CREATOR_HELP_CONTACT_SET);
+ }else{
+ setContextSensitiveHelpIDByComponentType(valueCombo);
+ }
+
+ return valueCombo;
+ }
+
+ /**
+ * Get selection value for type Combo by item content (key) and itemIndex
+ * @param key for returning back if it was not empty
+ * @param itemIndex a row index just adding
+ * @param openItemType
+ * @return a showable Item name or empty string, key if it was not empty or next value for items,
+ * or empty string if index was over last item index
+ */
+ private String getTypeComboSelection(String key, int itemIndex, boolean openItemType) {
+ if(key == null ){
+ return AbstractValue.EMPTY_STRING;
+ }
+ else if(key.equals(AbstractValue.EMPTY_STRING)
+ && getItemTypesAsString().length > itemIndex)
+ {
+ String setThisItemAsDefaultSelection = "";
+ if(openItemType){
+ setThisItemAsDefaultSelection = getItemTypesAsString()[itemIndex];
+ }
+ return setThisItemAsDefaultSelection;
+ }else{
+ return key;
+ }
+ }
+
+ /**
+ * @return unicode Font
+ */
+ protected Font getUnicodeFont() {
+ Font defaultFont = itemsTable.getFont();
+ FontData defaulFD [] = defaultFont.getFontData();
+ FontData fd = new FontData("Arial Unicode MS", defaulFD[0].getHeight(), defaulFD[0].getStyle());
+ return new Font(Display.getCurrent(), fd);
+ }
+
+ /**
+ * Gets 1 size smaller font for the button
+ * @return same Font with smaller size
+ */
+ protected Font getButtonFont() {
+ Font defaultFont = itemsTable.getFont();
+ FontData defaulFD [] = defaultFont.getFontData();
+ FontData fd = new FontData(defaulFD[0].getName(), defaulFD[0].getHeight()-1, defaulFD[0].getStyle());
+ Font font = new Font(Display.getCurrent(), fd);
+ return font;
+ }
+
+ /* (non-Javadoc)
+ * @see org.eclipse.jface.dialogs.Dialog#createButtonsForButtonBar(org.eclipse.swt.widgets.Composite)
+ */
+ protected void createButtonsForButtonBar(Composite parent) {
+ // Creating just OK button
+ createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL,
+ true);
+ createButton(parent, IDialogConstants.CANCEL_ID, IDialogConstants.CANCEL_LABEL,
+ true);
+
+ }
+
+
+ /*
+ * Collecting Component data from table fields
+ * (non-Javadoc)
+ * @see org.eclipse.jface.dialogs.Dialog#okPressed()
+ */
+ protected void okPressed() {
+
+ //When in edit mode, just removing all attributes and replace them with current editor values
+ if(isInEditMode()){
+ getComponent().removeAllAttributes();
+ }else{
+ //otherwise creating new component
+ setComponent(createNewComponent());
+ }
+
+ if(itemsTable != null){
+
+ TableItem [] items = itemsTable.getItems();
+
+ for (int i = 0; i < items.length; i++) {
+
+ TableItem item = items[i];
+
+ if(item != null){
+
+ String type = item.getText(0);
+ String value = item.getText(1);
+
+ if(type != null && type.trim().length()>0
+ && value != null && value.trim().length()>0){
+ value = value.trim();//Editor will produce script with no extra spaces.
+
+ AbstractValue aValue = createNewValue(type, value, item.getText(2), item.getText(3));
+
+ //If field is Contact set reference
+ if(CreatorEditorSettings.isContactSetReference(type)){
+
+ AbstractComponent compToReference = getProvider().getComponents()
+ .getComponentByComponentString( value );
+
+ aValue.setContactSetReference(true);
+ aValue.setRandom(false);//contact set reference cannot be random
+ int id = 0;
+ try {
+ id=compToReference.getId();
+ } catch (Exception e) {
+ id = 0;
+ showWarningDialog("Contact Set not exist", "Contact Set with id: '" +value +"' doesn't exist, please use existing Contact Set IDs.");
+ }
+ aValue.setId(id);
+
+ int maxamount = 0;
+ try {
+ maxamount=Integer.parseInt(item.getText(3));
+ } catch (Exception e) {
+ maxamount = 0;
+ }
+ aValue.setMaxAmount(maxamount);
+ }
+
+ //Setting random type as user defined and set length by user definition
+ else if(aValue.getModeValueText().equalsIgnoreCase(AbstractValue.RANDOM_TEXT_USER_DEFINED_LENGTH)){
+ aValue.setModeType(ModeTypes.RandomTypeUserDefinedLength);
+ int randomLen;
+ try {
+ randomLen = Integer.parseInt(value);
+ } catch (NumberFormatException e) {
+ e.printStackTrace();
+ randomLen = AbstractValue.USER_DEFINED_DEFAULT_LENGTH;
+ showWarningDialog("Invalid random value", "Invalid user defined random lenght value: '"
+ +value +"'. Value was set to: '" +AbstractValue.USER_DEFINED_DEFAULT_LENGTH +"'.");
+
+ }
+ aValue.setRandomValueLenght(randomLen);
+ }
+
+ Vector<AbstractValue> v = getComponent().getAttribute(type);
+ if(v == null){
+ v = new Vector<AbstractValue>();
+ }
+ v.add(aValue);
+
+ getComponent().setAttribute(type, v);
+ }
+ }
+ }
+
+ }
+ //Amount txt for component level
+ if(amoutTxtToComponent != null){
+ String amount = amoutTxtToComponent.getText();
+ if(amount != null && amount.trim().length() > 0){
+ try {
+ int am = Integer.parseInt(amount);
+ getComponent().setAmount(am);
+ } catch (Exception e) {
+ //just in case take Exception for parseInt, should not be occur, because of text field data validation
+ e.printStackTrace();
+ getComponent().setAmount(0);
+ }
+ }
+ }
+
+
+ //If extra field number is used
+ if(extraNbrToComponent != null){
+ getComponent().addAdditionalParameter(getComponent().getIdByValue(labelForExtraNumberField), extraNbrToComponent.getText());
+ }
+ //If extra field txt is used
+ if(extraTxtToComponent != null){
+ getComponent().addAdditionalParameter(getComponent().getIdByValue(labelForExtraTextField), extraTxtToComponent.getText());
+ }
+
+ //Set link to another component if any
+ setLinkToOtherComponentByComboSelection();
+
+ super.okPressed();
+
+ }
+
+ /**
+ * Show an confirmation dialog
+ * @param title
+ * @param message
+ * @return true if OK pressed, false otherwise
+ */
+ protected boolean showConfirmationDialog(String title, String message) {
+ Shell sh;
+ if (getShell() != null) {
+ try {
+ sh = getShell();
+ } catch (SWTException e) {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ } else {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ return MessageDialog.openConfirm(sh, title, message);
+ }
+
+
+ /**
+ * Show an information dialog
+ * @param title
+ * @param message
+ */
+ protected void showInformationDialog(String title, String message) {
+ Shell sh;
+ if (getShell() != null) {
+ try {
+ sh = getShell();
+ } catch (SWTException e) {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ } else {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ MessageDialog.openInformation(sh, title, message);
+ }
+ /**
+ * Show an warning dialog
+ * @param title
+ * @param message
+ */
+ protected void showWarningDialog(String title, String message) {
+ Shell sh;
+ if (getShell() != null) {
+ try {
+ sh = getShell();
+ } catch (SWTException e) {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ } else {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ MessageDialog.openWarning(sh, title, message);
+ }
+ /**
+ * Show an error dialog
+ * @param title
+ * @param message
+ */
+ protected void showErrorDialog(String title, String message) {
+ Shell sh;
+ if (getShell() != null) {
+ try {
+ sh = getShell();
+ } catch (SWTException e) {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ } else {
+ sh = CreatorActivator.getCurrentlyActiveWbWindowShell();
+ }
+
+ MessageDialog.openError(sh, title, message);
+ }
+
+ /*
+ * (non-Javadoc)
+ * @see org.eclipse.jface.dialogs.Dialog#createDialogArea(org.eclipse.swt.widgets.Composite)
+ */
+ protected Control createDialogArea(Composite parent) {
+
+ try{
+ Composite composite = createDialogAreaComposite(parent);
+ GridLayout gridLayout = new GridLayout();
+ composite.setLayout(gridLayout);
+
+ //Create Amount area
+ createAmountArea(composite);
+
+ //Create table area
+ createTableArea(composite);
+
+ if(/*showAmountInfoText &&*/ isAmountFieldsEnabled){
+ addInformation(composite, AMOUNT_FIELD_INFO_TEXT);
+ }
+
+ if(wasErrors()){
+ showErrorDialog("Errors occured when dialog opened", getErrors());
+ }
+
+ return composite;
+ }catch(Exception e){
+ e.printStackTrace();
+ showUnableToOpenDialogErrorMsg(e);
+ }
+ return null;
+ }
+
+ /**
+ * Creates a composite for dialog area
+ * @param parent
+ * @return a Composite
+ */
+ protected Composite createDialogAreaComposite(Composite parent) {
+ Composite composite = (Composite) super.createDialogArea(parent);
+ return composite;
+ }
+
+ /**
+ * Creating all items to dialog area, a real implementation for createDialogArea(Composite parent)
+ */
+ protected void createTableArea(Composite composite) {
+ final int cols = 1;
+ GridLayout gdl = new GridLayout(cols, false);
+ GridData gd = new GridData(GridData.FILL_BOTH);
+
+
+ Composite tableComposite = new Composite(composite, SWT.SIMPLE);
+ tableComposite.setLayout(gdl);
+ tableComposite.setLayoutData(gd);
+
+ itemsTable = new Table (tableComposite, SWT.BORDER | SWT.MULTI);
+ GridData tableGd = new GridData(GridData.FILL_BOTH);
+ tableGd.heightHint = 300;
+ itemsTable.setLayoutData(tableGd);
+ itemsTable.setLinesVisible (true);
+ itemsTable.setHeaderVisible(true);
+ itemsTable.setEnabled(isTableEnabled);
+
+ //Create columns to table
+ createTableColums();
+
+ AbstractComponent component = (AbstractComponent) getComponent();
+ Set<String> keys = component.getKeys();
+ Vector<String> keysV = new Vector<String>(keys);
+
+
+ //Create rows to table +2 is for new items
+ int actualComponentItemCount = component.getAttributeCount();// +2;
+ int allCompoenentItemCount = getItemTypesAsString().length;
+ //Always create at least 12 rows
+ if(!isInEditMode() && actualComponentItemCount < INITIAL_ITEMS_NUMBER_IN_TABLE ){
+ if(allCompoenentItemCount > INITIAL_ITEMS_NUMBER_IN_TABLE){
+ actualComponentItemCount = INITIAL_ITEMS_NUMBER_IN_TABLE;
+ }
+ else{
+ actualComponentItemCount = allCompoenentItemCount;
+ }
+ }
+
+
+ //Looping through table and add existing data or empty rows
+ for (int i=0; i<actualComponentItemCount; i++) {
+ //TableEditor editor = new TableEditor (itemsTable);
+
+ //Creating empty rows if there is no data allready added at least 12 rows
+ if (i >= component.getAttributeCount()){
+ try {
+ addRow(!isInEditMode(), false);
+ } catch (Exception e) {
+ handleTableRowCreationError(e);
+ }
+ }
+ //rows of the table where is data added
+ else{
+ String key = (String) keysV.get(i);
+ Vector<AbstractValue> values = component.getAttribute(key);
+ for (Iterator<AbstractValue> iterator = values.iterator(); iterator.hasNext();) {
+ AbstractValue value = (AbstractValue) iterator
+ .next();
+ try {
+ addRow(key, value, false);
+ } catch (Exception e) {
+ handleTableRowCreationError(e);
+ }
+
+ }
+ //Adding one row to Table
+
+ }//else
+ }
+
+ //Notify listeners to update values when all rows are set
+ checkIfNeedToCallItemValueEnablationListners();
+
+ //Notify table listeners to update item combos
+ notifyTypeComboDataListeners();
+
+ //Create add row button
+ createAddRowButton(tableComposite);
+
+ if(wasErrorsWithDatas){
+ showErrorDialog("Errors on script", "There was some errors when opening component, see Console for details.");
+ }
+ }
+
+ /**
+ * Set wasErrorsWithDatas as true and prints console error message
+ * @param e
+ */
+ private void handleTableRowCreationError(Exception e) {
+ wasErrorsWithDatas = true;
+ e.printStackTrace();
+ CreatorEditorConsole.getInstance().println(UNEXPECTED_ERROR_WHEN_CREATING_TABLE_AREA_ERROR_WAS +e, CreatorEditorConsole.MSG_ERROR);
+ }
+
+ /**
+ * Creates an Add row button to selected composite
+ * @param parent
+ */
+ private void createAddRowButton(Composite parent) {
+ addRowButton = new Button(parent, SWT.PUSH);
+ addRowButton.setText(ADD_ROW_TXT);
+ //Add add row functionality
+ addRowButton.addSelectionListener(new SelectionAdapter(){
+
+ public void widgetSelected(SelectionEvent event) {
+ try {
+ addRow(true, true);
+ //Notify table listeners to update item combos
+ notifyTypeComboDataListeners();
+
+ //notify also listners if needed
+ checkIfNeedToCallItemValueEnablationListners();
+ } catch (Exception e) {
+ handleTableRowCreationError(e);
+ }
+ }
+
+ });
+ setContextSensitiveHelpID(addRowButton, CreatorHelpContextIDs.CREATOR_HELP_MODIFY_COMPONENT);
+ }
+
+ /**
+ * Creates a button to launch "Create new Contact-set" -dialog.
+ * @param composite
+ * @param addIndent - If add some empty space before creating button |" " <BUTTON>|
+ */
+ protected void createAddNewContactSetButton(Composite composite, boolean addIndent){
+
+
+ if(addIndent){
+ //Adding empty labe for decoration purposes
+ Label emptyText = new Label(composite, SWT.SIMPLE);
+ emptyText.setBackground(getGrey());
+ emptyText.setText(" ");
+ }
+
+ addContactSetButton = new Button(composite, SWT.PUSH);
+ addContactSetButton.setText(ContactSetVariables.ADD_CONTACT_SET_TXT);
+
+ //add button listener
+ addContactSetButton.addSelectionListener(provider.getAddNewContactSetComponentListener(getShell(), provider));
+ addContactSetButton.setData(linkToOtherComponentCombo);
+
+ //When a new component was added, must update data in list, doing it through listener,
+ //which is provided to dialog through event.widget.data
+ addContactSetButton.setData(new AddNewContactSetButtonListener (null));
+
+ }
+
+ /**
+ * Update link list when new component was added
+ */
+ private class AddNewContactSetButtonListener implements IAddComponentListener{
+
+ private CCombo combo = null;
+
+
+ AddNewContactSetButtonListener(CCombo combo){
+ this.combo = combo;
+
+ }
+
+
+ /* (non-Javadoc)
+ * @see com.nokia.s60tools.creator.editors.IAddComponentListener#componentAdded(com.nokia.s60tools.creator.components.AbstractComponent)
+ */
+ public void componentAdded(AbstractComponent comp) {
+
+ if(comp != null && comp.isValid() && linkToOtherComponentCombo != null){
+ String[] contactSetsAsString = getContactSetsAsString();
+ //If list is empty, cant just add one just created, so setting all values
+ String selection = linkToOtherComponentCombo.getText();
+ linkToOtherComponentCombo.setItems(contactSetsAsString);
+ if(selection != null){
+ linkToOtherComponentCombo.setText(selection);
+ }
+ linkToOtherComponentCombo.setEnabled(true);
+
+ }
+
+
+ //Woke upp also other listeners who's intressed of this event! (those who has combo!=null)
+ Event event = new Event();
+ event.doit = true;
+ addContactSetButton.notifyListeners(SWT.SetData, event);
+
+ }
+
+
+ /* (non-Javadoc)
+ * @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event)
+ */
+ public void handleEvent(Event event) {
+ if(combo != null && event.doit){
+ String text = combo.getText();
+ String[] contactSetsAsString = getContactSetsAsString();
+ combo.setItems(contactSetsAsString);
+ int length = contactSetsAsString.length;
+ if(length > MAX_ITEMS_IN_COMBO){
+ length = MAX_ITEMS_IN_COMBO;
+ }
+ combo.setVisibleItemCount(length);
+ combo.setText(text);
+ }
+ }
+ }
+
+ /**
+ * Create Amount area with label and text field to add label
+ * @param parent
+ */
+ protected void createAmountArea(Composite parent) {
+ Composite amountComp = new Composite(parent,SWT.SIMPLE);
+ amountComp.setLayout(new GridLayout(5, false));
+ GridData gridData = new GridData(GridData.FILL_BOTH);
+ gridData.heightHint = 45;
+ amountComp.setLayoutData(gridData);
+
+ createAmountAreaImpl(amountComp);
+ createFulFillWithRandomDatas(amountComp);
+ }
+
+ /**
+ * Create Amount area with label and text field to add label
+ * @param parent
+ * @param addCreateNewContactSetButton <code>true</code> if Botton for creating contact-set(s)
+ * will be created, <code>false</code> otherwise.
+ */
+ protected void createAmountArea(Composite parent, boolean addCreateNewContactSetButton) {
+
+ if(!addCreateNewContactSetButton){
+ createAmountArea(parent);
+ }
+ else{
+ Composite amountComp = new Composite(parent,SWT.SIMPLE);
+ amountComp.setLayout(new GridLayout(7, false));
+ GridData gridData = new GridData(GridData.FILL_BOTH);
+ gridData.heightHint = 45;
+ amountComp.setLayoutData(gridData);
+
+ createAmountAreaImpl(amountComp);
+ //Create button to create new contact sets
+ createAddNewContactSetButton(amountComp, true);
+
+ createFulFillWithRandomDatas(amountComp);
+ }
+ }
+
+ /**
+ * Create Amount area with label and text field to add label.
+ * Takes real composite as parameter, not parent
+ * @param composite
+ */
+ private void createAmountAreaImpl(Composite amountComp) {
+ Label amoutLb = new Label(amountComp,SWT.NONE);
+ amoutLb.setText(AMOUNT_TXT);
+
+ amoutTxtToComponent = new Text(amountComp, SWT.LEFT | SWT.BORDER);
+ amoutTxtToComponent.setLayoutData(new GridData(AMOUNT_FIELD_LENGTH,
+ SWT.DEFAULT));
+ amoutTxtToComponent.setTextLimit(10);
+ if(getComponent().getAmount() > 0){
+ amoutTxtToComponent.setText( "" +getComponent().getAmount());
+ }
+ //Verify listener must be set after setting text
+ amoutTxtToComponent.addVerifyListener(getNumberVerifyListener());
+
+ setContextSensitiveHelpID(amoutTxtToComponent, CreatorHelpContextIDs.CREATOR_HELP_GENERIC_COMPONENT);
+
+ }
+
+ /**
+ * Creates
+ * @param amountComp
+ */
+ private void createFulFillWithRandomDatas(Composite amountComp) {
+ //
+ //Fulfill items with random -functionality buttons
+ //
+
+ Label fulFillLb1 = new Label(amountComp,SWT.NONE);
+ fulFillLb1.setText(" Set all values as random with length:");
+
+ Composite radioComp = new Composite(amountComp, SWT.SIMPLE);
+ RowLayout rowLayout = new RowLayout();
+ rowLayout.type = SWT.VERTICAL;
+ radioComp.setLayout(rowLayout);
+ final Button selectLenDefaultBtn = new Button(radioComp, SWT.RADIO);
+ selectLenDefaultBtn.setText(RANDOM_LEN_DEFAULT);
+ selectLenDefaultBtn.setSelection(true);
+ final Button selectLenMaxBtn = new Button(radioComp, SWT.RADIO);
+ selectLenMaxBtn.setText(RANDOM_LEN_MAX);
+ Button setAsRandom = new Button(amountComp, SWT.PUSH);
+ setAsRandom.setText(SET_RANDOM_TXT);
+ setAsRandom.addSelectionListener(new SelectionAdapter() {
+ public void widgetSelected(SelectionEvent event) {
+ String len = AbstractVariables.RANDOM_LEN_DEFAULT_XML_VALUE;
+ boolean selection = selectLenMaxBtn.getSelection();
+ if(selection){
+ len = AbstractVariables.RANDOM_LEN_MAX_XML_VALUE;
+ }
+ boolean setAllValuesAsRandom = showConfirmationDialog("Set all Values as random", "Are you sure that you want to set all values as random? All existing values will be replaced by random value with " +len +" length.");
+ if(setAllValuesAsRandom){
+ setAllItemsAsRandom(selection);
+ }
+ }
+ });
+
+ setContextSensitiveHelpID(selectLenDefaultBtn, CreatorHelpContextIDs.CREATOR_HELP_GENERIC_COMPONENT);
+ setContextSensitiveHelpID(selectLenMaxBtn, CreatorHelpContextIDs.CREATOR_HELP_GENERIC_COMPONENT);
+ setContextSensitiveHelpID(setAsRandom, CreatorHelpContextIDs.CREATOR_HELP_GENERIC_COMPONENT);
+
+ }
+
+ /**
+ * Creates a composite and creates extra numberfield and extra text field to it
+ * @param parent
+ * @param labelForNumberField
+ * @param numberFieldValue
+ * @param labelForTextField
+ * @param textFieldValue
+ */
+ protected void createNumberAndTextFields(Composite parent, String labelForNumberField,
+ int numberFieldValue, String labelForTextField, String textFieldValue){
+
+ Composite comp = new Composite(parent,SWT.SIMPLE);
+ comp.setLayout(new GridLayout(4, false));
+ comp.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+ createExtraNumberField(labelForNumberField, numberFieldValue, comp);
+
+ createExtraTextField(labelForTextField, textFieldValue, comp);
+
+ }
+
+ /**
+ * Creates an extra text field and label to composite
+ * @param labelForTextField
+ * @param textFieldValue text value for field, or <code>null</code> if don't want any
+ * @param comp
+ */
+ protected void createExtraTextField(String labelForTextField,
+ String textFieldValue, Composite comp) {
+ this.labelForExtraTextField = labelForTextField;
+ Label txtLb = new Label(comp,SWT.NONE);
+ txtLb.setText(labelForTextField);
+
+ extraTxtToComponent = new Text(comp, SWT.LEFT | SWT.BORDER);
+ extraTxtToComponent.setLayoutData(new GridData(TEXT_FIELD_LENGTH,
+ SWT.DEFAULT ) );
+ if(textFieldValue != null){
+ extraTxtToComponent.setText(textFieldValue.trim());
+ }
+
+ setContextSensitiveHelpIDByComponentType(extraTxtToComponent);
+ }
+
+ /**
+ * Creates an extra number field and label to composite
+ * @param labelForNumberField
+ * @param numberFieldValue number value to field, give 0 if don't want any
+ * @param comp
+ */
+ protected void createExtraNumberField(String labelForNumberField,
+ int numberFieldValue, Composite comp) {
+ this.labelForExtraNumberField = labelForNumberField;
+ Label nbrLb = new Label(comp,SWT.NONE);
+ nbrLb.setText(labelForExtraNumberField);
+
+ extraNbrToComponent = new Text(comp, SWT.LEFT | SWT.BORDER);
+ extraNbrToComponent.setLayoutData(new GridData(AMOUNT_FIELD_LENGTH,
+ SWT.DEFAULT));
+ extraNbrToComponent.setTextLimit(10);
+ if(numberFieldValue > 0){
+ extraNbrToComponent.setText( "" +numberFieldValue);
+ }
+ //Verify listener must be set after setting text
+ extraNbrToComponent.addVerifyListener(getNumberVerifyListener());
+ setContextSensitiveHelpIDByComponentType(extraNbrToComponent);
+ }
+
+ /**
+ * Create Amount area with label and text field to add label
+ * @param parent
+ */
+ protected void createAmountAreaAndLinkToOtherComponentCombo(Composite parent, String comboLabel,
+ String[] contentToComponentLinkCombo, String contactSetSelection,
+ boolean addCreateNewContactSetButton, boolean createFullFillWithRandom) {
+ if(addCreateNewContactSetButton){
+ createAmountAreaAndLinkToOtherComponentComboWithCreateButton(
+ parent, comboLabel, contentToComponentLinkCombo, contactSetSelection,
+ createFullFillWithRandom);
+ }else{
+ createAmountAreaAndLinkToOtherComponentCombo(
+ parent, comboLabel, contentToComponentLinkCombo, contactSetSelection,
+ createFullFillWithRandom);
+ }
+ if(getComponent() instanceof Contact) {
+ setContextSensitiveHelpID(linkToOtherComponentCombo, CreatorHelpContextIDs.CREATOR_HELP_CONTACT_SET );
+ }else{
+ setContextSensitiveHelpIDByComponentType(linkToOtherComponentCombo);
+ }
+ }
+ /**
+ * Create Amount area with label and text field to add label
+ * @param parent
+ */
+ private void createAmountAreaAndLinkToOtherComponentCombo(Composite parent, String comboLabel,
+ String[] contentToComponentLinkCombo, String contactSetSelection,
+ boolean createFullFillWithRandom) {
+ Composite amountComp = new Composite(parent,SWT.SIMPLE);
+ int numColumns = 7;
+
+ amountComp.setLayout(new GridLayout(numColumns, false));
+ amountComp.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+ createAmountAreaImpl(amountComp);
+
+ createLinkToOtherComponentPart(amountComp, comboLabel, contentToComponentLinkCombo,
+ contactSetSelection, false);
+
+ if(createFullFillWithRandom){
+ createFulFillWithRandomDatas(amountComp);
+ }
+
+
+ }
+ /**
+ * Create Amount area with label and text field to add label
+ * @param parent
+ */
+ private void createAmountAreaAndLinkToOtherComponentComboWithCreateButton(Composite parent, String comboLabel,
+ String[] contentToComponentLinkCombo, String contactSetSelection,
+ boolean createFullFillWithRandom) {
+ Composite amountComp = new Composite(parent,SWT.SIMPLE);
+ int numColumns = 5;
+ amountComp.setLayout(new GridLayout(numColumns, false));
+ amountComp.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+ createAmountAreaImpl(amountComp);
+ if(createFullFillWithRandom){
+ createFulFillWithRandomDatas(amountComp);
+ }
+
+ createLinkToOtherComponentPart(parent, comboLabel, contentToComponentLinkCombo,
+ contactSetSelection, true);
+
+ }
+
+ protected void createLinkToOtherComponentPart(Composite parent, String comboLabel,
+ String[] contentToComponentLinkCombo, String contactSetSelection,
+ boolean addCreateNewContactSetButton) {
+
+ Composite linkComp = new Composite(parent,SWT.SIMPLE);
+ int numColumns = 2;
+ if(addCreateNewContactSetButton){
+ numColumns ++;
+ }
+
+
+ linkComp.setLayout(new GridLayout(numColumns, false));
+ linkComp.setLayoutData(new GridData(GridData.FILL_BOTH));
+ //
+ // Create link to other component
+ //
+
+ Label setLb = new Label(linkComp,SWT.NONE);
+ setLb.setText(comboLabel);
+
+ linkToOtherComponentCombo = new CCombo(linkComp, SWT.READ_ONLY | SWT.BORDER );
+ linkToOtherComponentCombo .setBackground(getWhite());
+
+ //If there is some values, setting them to combo
+ if(contentToComponentLinkCombo != null && contentToComponentLinkCombo.length > 0){
+ setComponentsToOtherComponentLinkCombo(contentToComponentLinkCombo);
+ }//Otherwise combo will be disabled
+ else{
+ linkToOtherComponentCombo .setEnabled(false);
+ }
+
+
+ //If we want to create button for add new contact-set
+ if(addCreateNewContactSetButton){
+ //Create button for creating new contact-sets
+ createAddNewContactSetButton(linkComp, false);
+ }
+
+
+ if(contactSetSelection != null){
+ setComboSelection(contentToComponentLinkCombo, linkToOtherComponentCombo, contactSetSelection);
+ }
+ }
+
+
+ /**
+ * Update items to other component link -Combo
+ * @param contentToComponentLinkCombo
+ */
+ protected void setComponentsToOtherComponentLinkCombo(
+ String[] contentToComponentLinkCombo) {
+ if(linkToOtherComponentCombo != null){
+ linkToOtherComponentCombo.setItems(contentToComponentLinkCombo);
+ }
+ }
+
+ /**
+ * Set all items in table as random.
+ * @param setAsMaxLength
+ */
+ private void setAllItemsAsRandom(boolean setAsMaxLength) {
+
+ TableItem[] items = itemsTable.getItems();
+
+ //Looping through all items in table
+ for (int i = 0; i < items.length; i++) {
+
+ TableItem item = items[i];
+
+ if (item != null) {
+ Event e = new SetRandomEvent();
+ e.doit = true;
+ item.notifyListeners(SWT.Modify, e);
+
+ String key = item.getText(0);
+
+ //When item is contact set reference, it cannot be random, or if random fields is disabled, they cannot be set as random.
+ if(isRandomFieldsEnabled() && !CreatorEditorSettings.isContactSetReference(key) && getComponent().getVariables().isModeEnabledForKey(key)){
+ //When there is a key, setting value as random
+ if (key != null && key.trim().length() > 0) {
+ //setting value as max or default
+ if(setAsMaxLength){
+ item.setText(1, AbstractValue.RANDOM_TEXT_MAX_LENGTH_LONG);
+ item.setText(2, AbstractValue.RANDOM_TEXT_MAX_LENGTH);
+
+ }
+ else{
+ item.setText(1, AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH_LONG);
+ item.setText(2, AbstractValue.RANDOM_TEXT_DEFAULT_LENGTH);
+ }
+ //Notify listeners by self
+ item.notifyListeners(SWT.Modify, e);
+
+ }
+ }
+ }
+ }
+ }
+
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.eclipse.jface.window.Window#configureShell(org.eclipse.swt.widgets.Shell)
+ */
+ protected void configureShell(Shell shell) {
+ super.configureShell(shell);
+ if(isInEditMode()){
+ shell.setText("Edit " +getComponent().getType() +"(s)");
+ }else{
+ shell.setText("Add " +getComponent().getType() +"(s)");
+ }
+ }
+
+ /**
+ * Adds an information label to view
+ * @param txt
+ */
+ protected void addInformation(Composite composite, String txt){
+ Composite infoComp = new Composite(composite,SWT.SIMPLE);
+ infoComp.setLayout(new GridLayout(1, false));
+ infoComp.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+ GridData gd = new GridData(CreatorScriptEditor.EDITOR_DEFAULT_WIDTH, SWT.DEFAULT);
+ Label info = new Label(infoComp,SWT.WRAP );
+ info.setLayoutData(gd);
+ info.setText(txt);
+ }
+
+ /**
+ * Get is amount fields enabled or not
+ * @return true if is enabled
+ */
+ protected boolean isAmountFieldsEnabled() {
+ return isAmountFieldsEnabled;
+ }
+
+ /**
+ * Set amount fields enable or disable in table
+ * @param isAmountFieldsEnabled
+ */
+ protected void setAmountFieldsEnabled(boolean isAmountFieldsEnabled) {
+ this.isAmountFieldsEnabled = isAmountFieldsEnabled;
+ }
+
+ /**
+ * Sets table enabled or disabled, default is enabled
+ * @param b
+ */
+ protected void setTableEnabled(boolean isTableEnabled) {
+ this.isTableEnabled = isTableEnabled;
+ }
+
+
+
+ /**
+ * Get {@link IComponentProvider} interface
+ * @return interface to provide component services
+ */
+ protected IComponentProvider getProvider() {
+ return provider;
+ }
+
+ /**
+ * Get selection text from other component selection Combo
+ * @return selection text, or null if not created
+ */
+ private String getLinkToOtherComponentComboSelection() {
+
+ String txt = null;
+ if(linkToOtherComponentCombo != null){
+ txt = linkToOtherComponentCombo.getText();
+ }
+ return txt;
+ }
+
+ /**
+ * Sets link to another component
+ */
+ private void setLinkToOtherComponentByComboSelection() {
+
+ //text from combo
+ String contactSetLinkText = getLinkToOtherComponentComboSelection();
+ if(contactSetLinkText != null && contactSetLinkText.trim().length() >0){
+
+ //future improvement idea, "linkToOtherComponentCombo" is not the best name for additional component level data combo
+ //also better way to handle data from that is to let real Dialog implementation to handle it.
+
+ //If component is mailbox, linktoanother component is actually type
+ if(getComponent() instanceof MailBox){
+ MailBox box = (MailBox) getComponent();
+ box.setMailBoxType(contactSetLinkText.trim());
+ }
+ else{
+ //get a component which the reference points
+ AbstractComponent compToReference = getProvider().getComponents()
+ .getComponentByComponentString( contactSetLinkText);
+ //set reference to this component
+ getComponent().setReferenceToAnotherComponent(compToReference);
+
+
+ }
+ }
+ //There is possibility that contact set reference is removed, and thats why must remove existing reference
+ else{
+ getComponent().setReferenceToAnotherComponent(null);
+ }
+
+ }
+
+ /**
+ * Get Contact Sets as String
+ * @return contact sets
+ */
+ protected String[] getContactSetsAsString() {
+
+ Vector<AbstractComponent> contSets = getProvider().getComponents().getComponents(CreatorEditorSettings.TYPE_CONTACT_SET);
+
+ String[] arr = null;
+ if(contSets != null && contSets.size() > 0){
+ arr = new String[contSets.size()+1];
+ int i = 1;
+ arr[0] = AbstractValue.EMPTY_STRING;//To be able to reset selection
+ for (Iterator<AbstractComponent> iterator = contSets.iterator(); iterator.hasNext();) {
+ AbstractComponent comp = (AbstractComponent) iterator
+ .next();
+ arr[i] = comp.toString();
+ i++;
+ }
+ }
+ return arr;
+ }
+
+ /**
+ * Get Contact Set as String or <code>null</code> if not found
+ * @param contact set id
+ * @return Get Contact Set as String or <code>null</code> if not found
+ */
+ protected String getContactSetStringById(String id) {
+ try {
+ int idInt = Integer.parseInt(id);
+ return getContactSetStringById(idInt);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ /**
+ * Get Contact Set as String or <code>null</code> if not found
+ * @param contact set id
+ * @return Get Contact Set as String or <code>null</code> if not found
+ */
+ protected String getContactSetStringById(int id) {
+
+ Vector<AbstractComponent> contSets = getProvider().getComponents().getComponents(CreatorEditorSettings.TYPE_CONTACT_SET);
+
+ for (Iterator<AbstractComponent> iterator = contSets.iterator(); iterator.hasNext();) {
+ AbstractComponent comp = (AbstractComponent) iterator
+ .next();
+ if(comp.getId() == id){
+ return comp.toString();
+ }
+ }
+ return null;
+ }
+
+ /**
+ * Set amount of table column headers if not default value
+ * @param tableColumnHeaderAmount
+ */
+ protected void setTableColumnHeaderAmount(String tableColumnHeaderAmount) {
+ this.tableColumnHeaderAmount = tableColumnHeaderAmount;
+ }
+
+ /**
+ * Greate link to another component combo
+ * @param parent
+ * @param contentToComponentLinkCombo
+ * @param contactSetSelection
+ */
+ protected void createLinkToOtherComponentCombo(Composite parent, String[] contentToComponentLinkCombo,
+ String comboLabel,
+ String contactSetSelection) {
+
+ Composite comp = new Composite(parent,SWT.SIMPLE);
+ comp.setLayout(new GridLayout(2, false));
+ comp.setLayoutData(new GridData(GridData.FILL_BOTH));
+
+ Label setLb = new Label(comp,SWT.NONE);
+ setLb.setText(comboLabel);
+
+ linkToOtherComponentCombo = new CCombo(comp, SWT.READ_ONLY | SWT.BORDER );
+ linkToOtherComponentCombo .setBackground(getWhite());
+
+ //If there is some values, setting them to combo
+ if(contentToComponentLinkCombo != null && contentToComponentLinkCombo.length > 0){
+ setComponentsToOtherComponentLinkCombo(contentToComponentLinkCombo);
+ }//Otherwise combo will be disabled
+ else{
+ linkToOtherComponentCombo .setEnabled(false);
+ }
+
+ if(contactSetSelection != null){
+ setComboSelection(contentToComponentLinkCombo, linkToOtherComponentCombo, contactSetSelection);
+ }
+
+ }
+
+ /**
+ * Check if random fields are enabled for this dialog
+ * @return <code>true</code> if random fields are enabled <code>false</code> othrewise.
+ */
+ protected boolean isRandomFieldsEnabled() {
+ return isRandomFieldsEnabled;
+ }
+
+ /**
+ * Set if random fields are enabled for this dialog
+ * @param isRandomFieldsEnabled <code>true</code> if random fields are enabled <code>false</code> othrewise.
+ */
+ protected void setRandomFieldsEnabled(boolean isRandomFieldsEnabled) {
+ this.isRandomFieldsEnabled = isRandomFieldsEnabled;
+ }
+
+
+ /***
+ * Get Text for contact-set reference check box
+ * @return UI text for associate this component to contact-set
+ */
+ protected String getContactSetRefernceText(){
+ return "Associate this " +getComponent().getType() +" to Contact-set: ";
+
+ }
+
+ /**
+ * Show error message dialog when dialog was not able to open
+ * @param e {@link Exception} which was thrown
+ */
+ protected void showUnableToOpenDialogErrorMsg(Exception e) {
+ showErrorDialog("Error", "Errors occurded when editor dialog was opened, see console for details.");
+ CreatorEditorConsole.getInstance().println("Errors occurded when try to open editor dialog for compoent:'"
+ +getComponent().getType() + "', reason: " +e, CreatorEditorConsole.MSG_ERROR);
+
+ }
+
+ /**
+ * Add an error
+ * @param errorMsg
+ */
+ protected void addError(String errorMsg){
+ if(errors == null){
+ errors = new Vector<String>();
+ }
+ errors.add(errorMsg);
+
+ }
+
+ /**
+ * Get all errors, one error will be its own line separeted with "\n"
+ * @return errors occurred when dialog was opened
+ */
+ protected String getErrors(){
+ if(errors == null){
+ return "";
+ }else{
+ StringBuffer b = new StringBuffer();
+ String newLine = "\n";
+ for (Iterator<String> iterator = errors.iterator(); iterator.hasNext();) {
+ String err= (String) iterator.next();
+ b.append(err);
+ b.append(newLine);
+ }
+ //remove last new line
+ b.delete(b.length()-newLine.length(), b.length());
+ return b.toString();
+ }
+ }
+
+ /**
+ * Was there any errors when creating dialog
+ * @return <code>true</code> if there was some errors, e.g. unable to set value to combo
+ */
+ protected boolean wasErrors(){
+ return errors != null;
+ }
+
+}