public List <string> getSecondStringList(int selectedFirstObjectIndex)
        {
            this.secondObjects             = new List <SecondObject>();
            this.selectedFirstObjectIndex  = selectedFirstObjectIndex;
            this.selectedSecondObjectIndex = -1;

            List <String> sourceStringList = new List <string>();

            Object              targetElement    = this.firstObjects[selectedFirstObjectIndex].EaObject;
            EditorExpression    editorExpression = EditorExpression.createEditorExpression(selectedExpressionString);
            List <SecondObject> sourceList       = editorExpression.getSecondObjects(targetElement, repository);

            foreach (SecondObject actSecondObject in sourceList)
            {
                String name         = actSecondObject.Name;
                int    classifierId = actSecondObject.ClassifierId;

                if (actSecondObject.EaObject is SQLMethod)
                {
                    SQLMethod method = actSecondObject.EaObject as SQLMethod;
                    if (methodParameterClassifierIdFilter != 0)
                    {
                        if (classifierId != 0)
                        {
                            SQLElement methodReturnTypeClass     = repository.GetElementByID(classifierId);
                            SQLElement wantedParameterTypeClasss = repository.GetElementByID(methodParameterClassifierIdFilter);

                            foreach (SQLElement baseClass in EAUtil.getBaseClasses(methodReturnTypeClass))
                            {
                                if (baseClass.ElementID == methodParameterClassifierIdFilter)
                                {
                                    name = EAUtil.getMethodSignature(method);
                                    break;
                                }
                            }
                        }
                    }
                    else
                    {
                        name = EAUtil.getMethodSignature(method);
                    }
                }

                if (name != "" && !sourceStringList.Contains(name))
                {
                    sourceStringList.Add(name);
                    this.secondObjects.Add(actSecondObject);
                }
            }

            this.expression = computeExpression();

            //sourceStringList.Sort();
            sourceStringList = sourceStringList.Distinct().ToList();

            return(sourceStringList);
        }
        public List <string> getFirstStringList(String selectedExpressionString)
        {
            this.selectedExpressionString = selectedExpressionString;
            this.expression = null;

            EditorExpression editorExpression = EditorExpression.createEditorExpression(selectedExpressionString);

            this.firstObjects.Clear();
            this.secondObjects.Clear();

            List <String>      objectStringList = new List <string>();
            List <FirstObject> objectListTemp   = new List <FirstObject>();

            //if == null than Void has been selected from the dropdown menu
            if (editorExpression != null)
            {
                objectListTemp = editorExpression.getFirstObjects(getContainerElement(), repository);

                foreach (FirstObject actTarget in objectListTemp)
                {
                    String name         = actTarget.Name;
                    int    classifierId = actTarget.ClassifierId;

                    bool valid = false;
                    valid = validateFirstObject(selectedExpressionString, classifierId);
                    if (valid)
                    {
                        objectStringList.Add(name);
                        firstObjects.Add(actTarget);
                    }
                }
            }
            this.expression = computeExpression();

            //objectStringList.Sort();
            objectStringList = objectStringList.Distinct().ToList();

            return(objectStringList);
        }