/** @param name */
 public ReturnVariablesPropertyPanel(String name, IDesignElement element) {
   super(name, element);
   info = (ReturnInformationProvider) ((PrimitiveElement) element).getInformationProvider();
   exportedVars = new ArrayList<String>(info.getExports());
   List<Variable> vars = element.getDesign().getVariablesFor(element);
   outer:
   for (Variable v : vars) {
     for (int i = 0; i < variables.size(); i++) {
       if (variables.get(i).getName().compareToIgnoreCase(v.getName()) > 0) {
         variables.add(i, v);
         continue outer;
       }
     }
     variables.add(v);
   }
 }
    public String getColumnText(Object element, int columnIndex) {
      Variable vd = (Variable) element;

      if (columnIndex == 0) {
        return vd.getName();
      } else if (columnIndex == 1) {
        StringBuffer buf = new StringBuffer();
        buf.append(vd.getType().getName());
        if (vd.getType().hasBaseType()) // is array or map
        {
          buf.append(" of ");
          buf.append(vd.getType().getBaseTypeName());
        }
        return buf.toString();
      }

      return "N/A";
    }
  public void createControls(Composite parent) {
    parent.setLayout(new GridLayout(2, false));

    Table variableTable =
        new Table(parent, SWT.SINGLE | SWT.FULL_SELECTION | SWT.BORDER | SWT.CHECK);
    variableTable.setHeaderVisible(true);

    TableColumn nameColumn = new TableColumn(variableTable, SWT.NONE);
    nameColumn.setText("Variable Name");
    nameColumn.setWidth(150);

    TableColumn typeColumn = new TableColumn(variableTable, SWT.NONE);
    typeColumn.setText("Type");
    typeColumn.setWidth(150);

    GridData gd = new GridData(GridData.FILL_VERTICAL);
    gd.verticalSpan = 2;
    gd.widthHint = 505;
    gd.heightHint = 200;
    variableTable.setLayoutData(gd);
    variableViewer = new CheckboxTableViewer(variableTable);
    variableViewer.addCheckStateListener(
        new ICheckStateListener() {

          public void checkStateChanged(CheckStateChangedEvent event) {
            exportedVars.remove(((Variable) event.getElement()).getName());
            if (event.getChecked()) exportedVars.add(((Variable) event.getElement()).getName());
          }
        });
    variableViewer.setColumnProperties(new String[] {"Name", "Type", "Value"});
    variableViewer.setContentProvider(new VariableContentProvider());
    variableViewer.setLabelProvider(new VariableLabelProvider());
    variableViewer.setInput(this);
    for (Variable vd : variables) {
      variableViewer.setChecked(vd, exportedVars.contains(vd.getName()));
    }
  }
  /* (non-Javadoc)
   * @see org.eclipse.vtp.desktop.ui.app.editor.model.DatabaseQuerySettingsListener#targetVariableChanged()
   */
  public void targetVariableChanged() {
    if ((settings.targetVariableName == null)
        || (settings.targetVariableType == null)
        || settings.targetVariableName.equals("")) {
      currentObject = null;
      mappingTableViewer.refresh();

      return;
    }

    if ((currentObject == null)
        || (!settings.targetVariableName.equals(currentObject.getPath())
            || !settings.targetVariableType.equals(currentObject.getType()))) {
      if (settings.targetVariableExists) {
        for (int i = 0; i < incomingVariables.size(); i++) {
          Variable v = incomingVariables.get(i);

          if (v.getName().equals(settings.targetVariableName)) {
            currentObject = v;
          } else if ((settings.targetVariableName != null)
              && settings.targetVariableName.startsWith(v.getName())) {
            List<ObjectField> objectFields = v.getFields();

            for (int f = 0; f < objectFields.size(); f++) {
              ObjectField of = objectFields.get(f);

              if (of.getPath().equals(settings.targetVariableName)) {
                currentObject = of;
              }
            }
          }
        }
      } else {
        currentObject =
            VariableHelper.constructVariable(
                settings.targetVariableName,
                getElement().getDesign().getDocument().getProject().getBusinessObjectSet(),
                settings.targetVariableType);
      }

      settings.dataMapping.clear();

      if (currentObject.getType().hasBaseType()) {
        if (!currentObject.getType().isObject()) {
          settings.dataMapping.add(settings.new DataMapping("Value", -1, null));
        } else {
          List<IBusinessObject> businessObjects =
              getElement()
                  .getDesign()
                  .getDocument()
                  .getProject()
                  .getBusinessObjectSet()
                  .getBusinessObjects();

          for (int i = 0; i < businessObjects.size(); i++) {
            IBusinessObject ibo = businessObjects.get(i);

            if (ibo.getName().equals(settings.targetVariableType)) {
              List<IBusinessObjectField> fields = ibo.getFields();

              for (int f = 0; f < fields.size(); f++) {
                IBusinessObjectField ibof = fields.get(f);
                settings.dataMapping.add(settings.new DataMapping(ibof.getName(), -1, null));
              }
            }
          }
        }
      } else {
        if (currentObject.getType().isObject()) {
          List<ObjectField> fields = currentObject.getFields();

          for (int i = 0; i < fields.size(); i++) {
            ObjectField of = fields.get(i);
            settings.dataMapping.add(settings.new DataMapping(of.getName(), -1, null));
          }
        } else {
          settings.dataMapping.add(settings.new DataMapping(currentObject.getPath(), -1, null));
        }
      }

      mappingTableViewer.refresh();
    }
  }