Example #1
0
        private List<String> getFeedbackAsList(FeedbackElem currentFeedback)
        {
            List<String> result = new List<String>();
            FeedbackMessage feedback = currentFeedback.getFeedbackMessage ();
            String guidance = feedback.getGuidance ();
            String socratic = feedback.getSocratic ();
            String didacticConceptual = feedback.getDidacticConceptual ();
            String didacticProcedural = feedback.getDidacticProcedural ();

            result.Add (socratic);
            result.Add (guidance);
            result.Add (didacticConceptual);
            result.Add (didacticProcedural);

            return result;
        }
        public FeedbackData(String taskID, StudentModel student)
        {
            Debug.Log (":::: FeedbackData taskID: "+taskID);

            int startNumerator = 0;
            int endNumerator = 0;
            int startDenominator = 0;
            int endDenominator = 0;
            int finalNumerator = 0;
            int finalDenominator = 0;
            int resultNumerator = 0;
            int resultDenominator = 0;
            String representation = "area";

            if (taskID.Equals ("task1.1setA")) {
                endDenominator = 5;
            }

            if (taskID.Equals("task2.7.setA")){
                startNumerator = 1;
                endNumerator = 3;
                startDenominator = 6;
                endDenominator = 18;
            }
            else if (taskID.Equals("task2.7.setB")){
                startNumerator = 3;
                endNumerator = 9;
                startDenominator = 4;
                endDenominator = 12;
            }
            else if (taskID.Equals("task2.7.setC")){
                startNumerator = 7;
                endNumerator = 28;
                startDenominator = 3;
                endDenominator = 12;
            }
            else if (taskID.Equals("task2.6.setA")){
                startNumerator = 3;
                startDenominator = 4;
                endNumerator = 1;
                endDenominator = 12;
            }
            else if (taskID.Equals("task2.6.setB")){
                startNumerator = 2;
                startDenominator = 5;
                endNumerator = 1;
                endDenominator = 10;
            }
            else if (taskID.Equals("task2.6.setC")){
                startNumerator = 7;
                startDenominator = 3;
                endNumerator = 1;
                endDenominator = 21;
            }
            else if (taskID.Equals("task2.4.setA.area")){
                startNumerator = 1;
                startDenominator = 2;
            }
            else if (taskID.Equals("task2.4.setB.area")){
                startNumerator = 3;
                startDenominator = 4;
            }
            else if (taskID.Equals("task2.4.setC.area")){
                startNumerator = 7;
                startDenominator = 3;
            }
            else if (taskID.Equals("task2.4.setA.numb")){
                startNumerator = 1;
                startDenominator = 2;
                representation = "number line";
            }
            else if (taskID.Equals("task2.4.setB.numb")){
                startNumerator = 3;
                startDenominator = 4;
                representation = "number line";
            }
            else if (taskID.Equals("task2.4.setC.numb")){
                startNumerator = 7;
                startDenominator = 3;
                representation = "number line";
            }
            else if (taskID.Equals("task2.4.setA.sets")){
                startNumerator = 1;
                startDenominator = 2;
                representation = "sets";
            }
            else if (taskID.Equals("task2.4.setB.sets")){
                startNumerator = 3;
                startDenominator = 4;
                representation = "sets";
            }
            else if (taskID.Equals("task2.4.setC.sets")){
                startNumerator = 7;
                startDenominator = 3;
                representation = "sets";
            }
            else if (taskID.Equals("task2.4.setA.liqu")){
                startNumerator = 1;
                startDenominator = 2;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task2.4.setB.liqu")){
                startNumerator = 3;
                startDenominator = 4;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task2.4.setC.liqu")){
                startNumerator = 7;
                startDenominator = 3;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3aPlus.1.setA.area")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "area";
            }
            else if (taskID.Equals("task3aPlus.1.setB.area")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "area";
            }
            else if (taskID.Equals("task3aPlus.1.setC.area")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setA.numb")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setB.numb")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setC.numb")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "number line";
            }
            else if (taskID.Equals("task3aPlus.1.setA.sets")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "sets";
            }
            else if (taskID.Equals("task3aPlus.1.setB.sets")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "sets";
            }
            else if (taskID.Equals("task3aPlus.1.setC.sets")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "sets";
            }
            else if (taskID.Equals("task3aPlus.1.setA.liqu")){
                startNumerator = 3;
                startDenominator = 5;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3aPlus.1.setB.liqu")){
                startNumerator = 4;
                startDenominator = 7;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3aPlus.1.setC.liqu")){
                startNumerator = 12;
                startDenominator = 9;
                representation = "liquid measures";
            }

            else if (taskID.Equals("task3bPlus.1.setA.area")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "area";
            }
            else if (taskID.Equals("task3bPlus.1.setB.area")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "area";
            }
            else if (taskID.Equals("task3bPlus.1.setC.area")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setA.numb")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setB.numb")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setC.numb")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "number line";
            }
            else if (taskID.Equals("task3bPlus.1.setA.sets")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "sets";
            }
            else if (taskID.Equals("task3bPlus.1.setB.sets")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "sets";
            }
            else if (taskID.Equals("task3bPlus.1.setC.sets")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "sets";
            }
            else if (taskID.Equals("task3bPlus.1.setA.liqu")){
                startNumerator = 1;
                startDenominator = 6;
                endNumerator = 5;
                endDenominator = 12;
                finalNumerator = 2;
                finalDenominator = 12;
                resultNumerator = 7;
                resultDenominator = 12;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3bPlus.1.setB.liqu")){
                startNumerator = 2;
                startDenominator = 3;
                endNumerator = 2;
                endDenominator = 9;
                finalNumerator = 6;
                finalDenominator = 9;
                resultNumerator = 8;
                resultDenominator = 9;
                representation = "liquid measures";
            }
            else if (taskID.Equals("task3bPlus.1.setC.liqu")){
                startNumerator = 4;
                startDenominator = 3;
                endNumerator = 3;
                endDenominator = 6;
                finalNumerator = 8;
                finalDenominator = 6;
                resultNumerator = 11;
                resultDenominator = 6;
                representation = "liquid measures";
            }

            Debug.Log (" startNumerator: "+startNumerator+" startDenominator: "+startDenominator+" endNumerator: "+endNumerator+" endDenominator:"+endDenominator);

            FeedbackMessageString feedbackMessageString = new FeedbackMessageString (student.getLanguageEnglish(), student.getLanguageGerman(), student.getLanguageSpanish());
            feedbackMessageString.setStartNumerator(startNumerator);
            feedbackMessageString.setStartDenominator(startDenominator);
            feedbackMessageString.setEndNumerator(endNumerator);
            feedbackMessageString.setEndDenominator(endDenominator);
            feedbackMessageString.setFinalNumerator(finalNumerator);
            feedbackMessageString.setFinalDenominator(finalDenominator);
            //feedbackMessageString.setRepresentation(representation);

            tooManyReps = new FeedbackElem ();
            tooManyReps.setID("TMR");
            FeedbackMessage tooManyRepsM = new FeedbackMessage ();
            tooManyRepsM.setDidacticConceptual (feedbackMessageString.allTooManyReps_guidance());
            tooManyReps.setFeedbackMessage (tooManyRepsM);
            tooManyReps.setFeedbackType (FeedbackType.nextStep);
            Fraction nextSteptooManyRepsM = new Fraction ();
            nextSteptooManyRepsM.setRepsOnScreenBelow (7);
            tooManyReps.setNextStep (nextSteptooManyRepsM);

            S1 = new FeedbackElem ();
            S1.setID("S1");
            FeedbackMessage S1M = new FeedbackMessage ();
            S1M.setSocratic (feedbackMessageString.S1M_socratic());
            S1M.setDidacticConceptual (feedbackMessageString.S1M_didacticConceptual());
            S1.setFeedbackMessage (S1M);
            S1.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepS1 = new Fraction ();
            nextStepS1.setSpeech (true);
            S1.setNextStep (nextStepS1);

            S2 = new FeedbackElem ();
            S2.setID ("S2");
            FeedbackMessage S2M = new FeedbackMessage ();
            S2M.setSocratic (feedbackMessageString.S2M_socratic());
            S2M.setGuidance (feedbackMessageString.S2M_guidance());
            S2M.setDidacticConceptual (feedbackMessageString.S2M_didacticConceptual());
            S2M.setHighlighting(Highlighting.RepresentationToolBox);
            S2.setFeedbackMessage (S2M);
            S2.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepS2 = new Fraction ();
            nextStepS2.setAnyValue (true);
            S2.setNextStep (nextStepS2);

            S3 = new FeedbackElem ();
            S3.setID ("S3");
            FeedbackMessage S3M = new FeedbackMessage ();
            S3M.setSocratic (feedbackMessageString.S3M_socratic());
            S3M.setGuidance (feedbackMessageString.S3M_guidance());
            S3M.setDidacticConceptual (feedbackMessageString.S3M_didacticConceptual());
            S3M.setDidacticProcedural (feedbackMessageString.S3M_didacticProcedural());
            S3M.setHighlighting(Highlighting.ArrowButtons);
            S3.setFeedbackMessage (S3M);
            S3.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepS3 = new Fraction ();
            nextStepS3.setAnyValue (true);
            S3.setNextStep (nextStepS3);

            M1 = new FeedbackElem ();
            M1.setID ("M1");
            FeedbackMessage M1M = new FeedbackMessage ();
            M1M.setSocratic (feedbackMessageString.M1M_socratic());
            M1M.setGuidance (feedbackMessageString.M1M_guidance());
            M1M.setDidacticConceptual (feedbackMessageString.M1M_didacticConceptual());
            M1M.setDidacticProcedural (feedbackMessageString.M1M_didacticProcedural());
            M1M.setHighlighting(Highlighting.ArrowButtons);
            M1.setFeedbackMessage (M1M);
            M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM1 = new Fraction ();
            nextStepM1.setDenominator(endDenominator);
            M1.setNextStep (nextStepM1);

            M2 = new FeedbackElem ();
            M2.setID ("M2");
            FeedbackMessage M2M = new FeedbackMessage ();
            M2M.setSocratic (feedbackMessageString.M2M_socratic());
            M2M.setGuidance (feedbackMessageString.M2M_guidance());
            M2M.setDidacticConceptual (feedbackMessageString.M2M_didacticConceptual());
            M2M.setDidacticProcedural (feedbackMessageString.M2M_didacticProcedural());
            M2.setFeedbackMessage (M2M);
            M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM2 = new Fraction ();
            nextStepM2.setDenominator(endDenominator);
            M2.setNextStep (nextStepM2);

            CM2 = new FeedbackElem ();
            CM2.setID ("CM2");
            FeedbackMessage CM2M = new FeedbackMessage ();
            CM2M.setSocratic (feedbackMessageString.CM2M_socratic());
            CM2M.setGuidance (feedbackMessageString.CM2M_guidance());
            CM2M.setDidacticConceptual (feedbackMessageString.CM2M_didacticConceptual());
            CM2M.setDidacticProcedural (feedbackMessageString.CM2M_didacticProcedural());
            CM2.setFeedbackMessage (CM2M);
            CM2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepCM2 = new Fraction ();
            nextStepCM2.setDenominator(endDenominator);
            CM2.setNextStep (nextStepCM2);

            M3 = new FeedbackElem ();
            M3.setID ("M3");
            FeedbackMessage M3M = new FeedbackMessage ();
            M3M.setSocratic (feedbackMessageString.M3M_socratic());
            M3M.setGuidance (feedbackMessageString.M3M_guidance());
            M3M.setDidacticConceptual (feedbackMessageString.M3M_didacticConceptual());
            M3.setFeedbackMessage (M3M);
            M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM3 = new Fraction ();
            int[] valuesM3num = new int[2] {startNumerator, endNumerator};
            int[] valuesM3denom = new int[2] {startDenominator, endDenominator};
            nextStepM3.setNumerators(valuesM3num);
            nextStepM3.setDenominators(valuesM3denom);
            M3.setNextStep (nextStepM2);

            M4 = new FeedbackElem ();
            M4.setID ("M4");
            FeedbackMessage M4M = new FeedbackMessage ();
            M4M.setDidacticConceptual (feedbackMessageString.M4M_didacticConceptual());
            M4.setFeedbackMessage (M4M);
            M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepM4 = new Fraction ();
            nextStepM4.setSpeech (true);
            M4.setNextStep (nextStepM2);

            M5 = new FeedbackElem ();
            M5.setID ("M5");
            FeedbackMessage M5M = new FeedbackMessage ();
            M5M.setSocratic (feedbackMessageString.M5M_socratic());
            M5M.setGuidance (feedbackMessageString.M5M_guidance());
            M5M.setDidacticConceptual (feedbackMessageString.M5M_didacticConceptual());
            M5M.setDidacticProcedural (feedbackMessageString.M5M_didacticProcedural());
            M5.setFeedbackMessage (M5M);
            M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM5 = new Fraction ();
            nextStepM5.setDenominator(endDenominator);
            M5.setNextStep (nextStepM2);

            CM5 = new FeedbackElem ();
            CM5.setID ("CM5");
            FeedbackMessage CM5M = new FeedbackMessage ();
            CM5M.setSocratic (feedbackMessageString.CM5M_socratic());
            CM5M.setGuidance (feedbackMessageString.CM5M_guidance());
            CM5M.setDidacticConceptual (feedbackMessageString.CM5M_didacticConceptual());
            CM5M.setDidacticProcedural (feedbackMessageString.CM5M_didacticProcedural());
            CM5.setFeedbackMessage (M5M);
            CM5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepCM5 = new Fraction ();
            nextStepCM5.setDenominator(endDenominator);
            CM5.setNextStep (nextStepCM2);

            M6 = new FeedbackElem ();
            M6.setID ("M6");
            FeedbackMessage M6M = new FeedbackMessage ();
            M6M.setSocratic (feedbackMessageString.M6M_socratic());
            M6M.setGuidance (feedbackMessageString.M6M_guidance());
            M6M.setDidacticConceptual (feedbackMessageString.M6M_didacticConceptual());
            M6M.setDidacticProcedural (feedbackMessageString.M6M_didacticProcedural());
            M6M.setHighlighting (Highlighting.ArrowButtons);
            M6.setFeedbackMessage (M6M);
            M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM6 = new Fraction ();
            nextStepM6.setNumerator(endNumerator);
            M6.setNextStep (nextStepM6);

            CM6 = new FeedbackElem ();
            CM6.setID ("CM6");
            FeedbackMessage CM6M = new FeedbackMessage ();
            CM6M.setSocratic (feedbackMessageString.M6M_socratic());
            CM6M.setGuidance (feedbackMessageString.M6M_guidance());
            CM6M.setDidacticConceptual (feedbackMessageString.CM6M_didacticConceptual());
            CM6M.setDidacticProcedural (feedbackMessageString.CM6M_didacticProcedural());
            CM6M.setHighlighting (Highlighting.ArrowButtons);
            CM6.setFeedbackMessage (CM6M);
            CM6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepCM6 = new Fraction ();
            nextStepCM6.setNumerator(1);
            nextStepCM6.setDenominator(3);
            nextStepCM6.sameRepresentation (true);
            CM6.setNextStep (nextStepCM6);

            CM6Second = new FeedbackElem ();
            CM6Second.setID ("CM6Second");
            FeedbackMessage CM6MSecond = new FeedbackMessage ();
            CM6MSecond.setSocratic (feedbackMessageString.CM6MSecond_socratic());
            CM6MSecond.setGuidance (feedbackMessageString.CM6MSecond_guidance());
            CM6MSecond.setDidacticConceptual (feedbackMessageString.CM6MSecond_didacticConceptual());
            CM6MSecond.setDidacticProcedural (feedbackMessageString.CM6MSecond_didacticProcedural());
            CM6MSecond.setHighlighting (Highlighting.ArrowButtons);
            CM6Second.setFeedbackMessage (CM6MSecond);
            CM6Second.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepCM6Second = new Fraction ();
            nextStepCM6Second.setNumerator(1);
            nextStepCM6Second.setDenominator(5);
            nextStepCM6Second.sameRepresentation (true);
            CM6Second.setNextStep (nextStepCM6Second);

            M7 = new FeedbackElem ();
            M7.setID ("M7");
            FeedbackMessage M7M = new FeedbackMessage ();
            M7M.setSocratic (feedbackMessageString.M7M_socratic());
            M7M.setGuidance (feedbackMessageString.M7M_guidance());
            M7M.setDidacticConceptual (feedbackMessageString.M7M_didacticConceptual());
            M7M.setDidacticProcedural (feedbackMessageString.M7M_didacticProcedural());
            M7.setFeedbackMessage (M7M);
            M7.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM7 = new Fraction ();
            nextStepM7.setDenominator(endDenominator);
            M7.setNextStep (nextStepM7);

            CM7 = new FeedbackElem ();
            CM7.setID ("CM7");
            FeedbackMessage CM7M = new FeedbackMessage ();
            CM7M.setSocratic (feedbackMessageString.CM7M_socratic());
            CM7M.setGuidance (feedbackMessageString.CM7M_guidance());
            CM7M.setDidacticProcedural (feedbackMessageString.CM7M_didacticProcedural());
            CM7.setFeedbackMessage (CM7M);
            CM7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepCM7 = new Fraction ();
            nextStepCM7.sameRepresentation (true);
            CM7.setNextStep (nextStepCM7);

            M8 = new FeedbackElem ();
            M8.setID ("M8");
            FeedbackMessage M8M = new FeedbackMessage ();
            M8M.setSocratic (feedbackMessageString.M8M_socratic());
            M8M.setGuidance (feedbackMessageString.M8M_guidance());
            M8M.setDidacticConceptual (feedbackMessageString.M8M_didacticConceptual());
            M8M.setDidacticProcedural (feedbackMessageString.M8M_didacticProcedural());
            M8.setFeedbackMessage (M8M);
            M8.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM8 = new Fraction ();
            nextStepM8.setNumerator (startNumerator);
            nextStepM8.setDenominator (startDenominator);
            M8.setNextStep (nextStepM8);

            M9 = new FeedbackElem ();
            M9.setID ("M9");
            FeedbackMessage M9M = new FeedbackMessage ();
            M9M.setSocratic (feedbackMessageString.M9M_socratic());
            M9M.setGuidance (feedbackMessageString.M9M_guidance());
            M9M.setDidacticConceptual (feedbackMessageString.M9M_didacticConceptual());
            M9M.setDidacticProcedural (feedbackMessageString.M9M_didacticProcedural());
            M9.setFeedbackMessage (M9M);
            M9.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM9 = new Fraction ();
            nextStepM9.setNumerator (endNumerator);
            nextStepM9.setDenominator (endDenominator);
            M9.setNextStep (nextStepM9);

            M10 = new FeedbackElem ();
            M10.setID ("M10");
            FeedbackMessage M10M = new FeedbackMessage ();
            M10M.setSocratic (feedbackMessageString.M10M_socratic());
            M10M.setGuidance (feedbackMessageString.M10M_guidance());
            M10M.setDidacticConceptual (feedbackMessageString.M10M_didacticConceptual());
            M10M.setHighlighting (Highlighting.ComparisonBox);
            M10.setFeedbackMessage (M10M);
            M10.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepM10 = new Fraction ();
            nextStepM10.setComparison (true);
            M10.setNextStep (nextStepM10);

            CM8 = new FeedbackElem ();
            CM8.setID ("CM8");
            FeedbackMessage CM8M = new FeedbackMessage ();
            CM8M.setSocratic (feedbackMessageString.CM8M_socratic());
            CM8M.setGuidance (feedbackMessageString.CM8M_guidance());
            CM8M.setDidacticConceptual (feedbackMessageString.CM8M_didacticConceptual());
            CM8M.setDidacticProcedural (feedbackMessageString.CM8M_didacticProcedural());
            CM8M.setHighlighting (Highlighting.ComparisonBox);
            CM8.setFeedbackMessage (CM8M);
            CM8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepCM8 = new Fraction ();
            nextStepCM8.setComparison (true);
            CM8.setNextStep (nextStepCM8);

            M11 = new FeedbackElem ();
            M11.setID ("M11");
            FeedbackMessage M11M = new FeedbackMessage ();
            M11M.setSocratic (feedbackMessageString.M11M_socratic());
            M11M.setGuidance (feedbackMessageString.M11M_guidance());
            M11M.setDidacticConceptual (feedbackMessageString.M11M_didacticConceptual());
            M11M.setHighlighting (Highlighting.RepresentationToolBox);
            M11.setFeedbackMessage (M11M);
            M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM11 = new Fraction ();
            nextStepM11.setNumerator (startNumerator);
            nextStepM11.setDenominator (startDenominator);
            nextStepM11.setComparison (true);
            M11.setNextStep (nextStepM11);

            M12 = new FeedbackElem ();
            M12.setID ("M12");
            FeedbackMessage M12M = new FeedbackMessage ();
            M12M.setDidacticConceptual (feedbackMessageString.M12M_didacticConceptual());
            M12.setFeedbackMessage (M12M);
            M12.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepM12 = new Fraction ();
            nextStepM12.setSpeech (true);
            M12.setNextStep (nextStepM12);

            M13 = new FeedbackElem ();
            M13.setID ("M13");
            FeedbackMessage M13M = new FeedbackMessage ();
            M13M.setSocratic (feedbackMessageString.M13M_socratic());
            M13M.setGuidance (feedbackMessageString.M13M_guidance());
            M13M.setDidacticConceptual (feedbackMessageString.M13M_didacticConceptual());
            M13M.setHighlighting (Highlighting.ComparisonBox);
            M13.setFeedbackMessage (M13M);
            M13.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepM13 = new Fraction ();
            nextStepM13.setComparison (true);
            M13.setNextStep (nextStepM13);

            CM11 = new FeedbackElem ();
            CM11.setID ("CM11");
            FeedbackMessage CM11M = new FeedbackMessage ();
            CM11M.setDidacticConceptual (feedbackMessageString.CM11M_didacticConceptual());
            CM11.setFeedbackMessage (CM11M);
            CM11.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepCM11 = new Fraction ();
            nextStepCM11.setSpeech (true);
            CM11.setNextStep (nextStepCM11);

            CM12 = new FeedbackElem ();
            CM12.setID ("CM12");
            FeedbackMessage CM12M = new FeedbackMessage ();
            CM12M.setSocratic (feedbackMessageString.CM12M_socratic());
            CM12.setFeedbackMessage (CM12M);
            CM12.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepCM12 = new Fraction ();
            nextStepCM12.setSpeech (true);
            CM12.setNextStep (nextStepCM12);

            E1 = new FeedbackElem ();
            E1.setID ("E1");
            FeedbackMessage E1M = new FeedbackMessage ();
            E1M.setDidacticConceptual (feedbackMessageString.E1M_didacticConceptual());
            E1.setFeedbackMessage (E1M);
            E1.setFeedbackType (FeedbackType.affirmation);

            E2 = new FeedbackElem ();
            E2.setID ("E2");
            FeedbackMessage E2M = new FeedbackMessage ();
            E2M.setDidacticConceptual (feedbackMessageString.E2M_didacticConceptual());
            E2.setFeedbackMessage (E2M);
            Fraction nextStepE2 = new Fraction ();
            nextStepE2.setSpeech (true);
            E2.setNextStep (nextStepE2);
            E2.setFeedbackType (FeedbackType.reflection);

            CE2 = new FeedbackElem ();
            CE2.setID ("CE2");
            FeedbackMessage CE2M = new FeedbackMessage ();
            CE2M.setDidacticConceptual (feedbackMessageString.CE2M_didacticConceptual());
            CE2.setFeedbackMessage (CE2M);
            Fraction nextStepCE2 = new Fraction ();
            nextStepCE2.setSpeech (true);
            CE2.setNextStep (nextStepCE2);
            CE2.setFeedbackType (FeedbackType.reflection);

            R1 = new FeedbackElem ();
            R1.setID ("R1");
            FeedbackMessage R1M = new FeedbackMessage ();
            R1M.setDidacticConceptual (feedbackMessageString.R1M_didacticConceptual());
            R1.setFeedbackMessage (R1M);
            Fraction nextStepR1 = new Fraction ();
            nextStepR1.setSpeech (true);
            R1.setNextStep (nextStepR1);
            R1.setFeedbackType (FeedbackType.reflection);

            R2 = new FeedbackElem ();
            R2.setID ("R2");
            FeedbackMessage R2M = new FeedbackMessage ();
            R2M.setDidacticConceptual (feedbackMessageString.R2M_didacticConceptual());
            R2.setFeedbackMessage (R2M);
            Fraction nextStepR2 = new Fraction ();
            nextStepR2.setSpeech (true);
            R2.setNextStep (nextStepR2);
            R2.setFeedbackType (FeedbackType.reflection);

            O1 = new FeedbackElem ();
            O1.setID ("O1");
            FeedbackMessage O1M = new FeedbackMessage ();
            O1M.setDidacticConceptual (feedbackMessageString.O1M_didacticConceptual());
            O1.setFeedbackMessage (O1M);
            Fraction nextStepO1 = new Fraction ();
            nextStepO1.setAnyValue (true);
            O1.setNextStep (nextStepO1);
            O1.setFeedbackType (FeedbackType.taskNotFinished);

            O2 = new FeedbackElem ();
            O2.setID ("O2");
            FeedbackMessage O2M = new FeedbackMessage ();
            O2M.setDidacticConceptual (feedbackMessageString.O2M_didacticConceptual());
            O2.setFeedbackMessage (O2M);
            Fraction nextStepO2 = new Fraction ();
            nextStepO2.setAnyValue (true);
            O2.setNextStep (nextStepO2);
            O2.setFeedbackType (FeedbackType.taskNotFinished);

            FM6 = new FeedbackElem ();
            FM6.setID ("FM6");
            FeedbackMessage MF6M = new FeedbackMessage ();
            MF6M.setSocratic (feedbackMessageString.MF6M_socratic());
            MF6M.setGuidance (feedbackMessageString.MF6M_guidance());
            FM6.setFeedbackMessage (MF6M);
            FM6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepFM6 = new Fraction ();
            nextStepFM6.differntRepresentation (true);
            nextStepFM6.allSameValue(true);
            FM6.setNextStep (nextStepFM6);

            FM10 = new FeedbackElem ();
            FM10.setID ("FM10");
            FeedbackMessage MF10M = new FeedbackMessage ();
            MF10M.setSocratic (feedbackMessageString.MF10M_socratic());
            FM10.setFeedbackMessage (MF10M);
            FM10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepFM10 = new Fraction ();
            nextStepFM10.setSpeech (true);
            FM10.setNextStep (nextStepFM10);

            FM11 = new FeedbackElem ();
            FM11.setID ("FM11");
            FeedbackMessage MF11M = new FeedbackMessage ();
            MF11M.setSocratic (feedbackMessageString.MF11M_socratic());
            MF11M.setGuidance (feedbackMessageString.MF11M_guidance());
            FM11.setFeedbackMessage (MF11M);
            FM11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepFM11 = new Fraction ();
            nextStepFM11.differntRepresentation (true);
            nextStepFM11.allSameValue(true);
            FM11.setNextStep (nextStepFM11);

            FM12 = new FeedbackElem ();
            FM12.setID ("FM12");
            FeedbackMessage MF12M = new FeedbackMessage ();
            MF12M.setSocratic (feedbackMessageString.MF12M_socratic());
            MF12M.setGuidance (feedbackMessageString.MF12M_guidance());
            FM12.setFeedbackMessage (MF12M);
            FM12.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepFM12 = new Fraction ();
            nextStepFM12.allSameValue(true);
            FM12.setNextStep (nextStepFM12);

            FE1 = new FeedbackElem ();
            FE1.setID("FE1");
            FeedbackMessage MFE1M = new FeedbackMessage ();
            MFE1M.setDidacticConceptual (feedbackMessageString.MFE1M_didacticConceptual());
            FE1.setFeedbackMessage (MFE1M);
            FE1.setFeedbackType (FeedbackType.affirmation);

            FE2 = new FeedbackElem ();
            FE2.setID("FE2");
            FeedbackMessage MFE2M = new FeedbackMessage ();
            MFE2M.setDidacticConceptual (feedbackMessageString.MFE2M_didacticConceptual());
            FE2.setFeedbackMessage (MFE2M);
            FE2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepFE2 = new Fraction ();
            nextStepFE2.setSpeech (true);
            FE2.setNextStep (nextStepFE2);

            F2M1 = new FeedbackElem ();
            F2M1.setID ("F2M1");
            FeedbackMessage F2M1M = new FeedbackMessage ();
            F2M1M.setSocratic (feedbackMessageString.F2M1M_socratic());
            F2M1M.setGuidance (feedbackMessageString.F2M1M_guidance());
            F2M1M.setDidacticConceptual (feedbackMessageString.F2M1M_didacticConceptual());
            F2M1M.setDidacticProcedural (feedbackMessageString.F2M1M_didacticProcedural());
            F2M1.setFeedbackMessage (F2M1M);
            F2M1.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M1 = new Fraction ();
            nextStepF2M1.setNumeratorAnyValue (true);
            F2M1.setNextStep (nextStepF2M1);

            F2M4 = new FeedbackElem ();
            F2M4.setID ("F2M4");
            FeedbackMessage F2M4M = new FeedbackMessage ();
            F2M4M.setSocratic (feedbackMessageString.F2M4M_socratic());
            F2M4.setFeedbackMessage (F2M4M);
            F2M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepF2M4 = new Fraction ();
            nextStepF2M4.setSpeech(true);
            F2M4.setNextStep (nextStepF2M4);

            F2M6 = new FeedbackElem ();
            F2M6.setID ("F2M6");
            FeedbackMessage F2M6M = new FeedbackMessage ();
            F2M6M.setSocratic (feedbackMessageString.F2M6M_socratic());
            F2M6M.setGuidance (feedbackMessageString.F2M6M_guidance());
            F2M6M.setDidacticConceptual (feedbackMessageString.F2M6M_didacticConceptual());
            F2M6M.setDidacticProcedural (feedbackMessageString.F2M6M_didacticProcedural());
            F2M6.setFeedbackMessage (F2M6M);
            F2M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M6 = new Fraction ();
            int[] partitionValuesM6 = new int[4] {2,3,4,5};
            nextStepF2M6.setPartitionValues(partitionValuesM6);
            F2M6.setNextStep (nextStepF2M6);

            F2M7 = new FeedbackElem ();
            F2M7.setID ("F2M7");
            FeedbackMessage F2M7M = new FeedbackMessage ();
            F2M7M.setSocratic (feedbackMessageString.F2M7M_socratic());
            F2M7M.setGuidance (feedbackMessageString.F2M7M_guidance());
            F2M7M.setDidacticConceptual (feedbackMessageString.F2M7M_didacticConceptual());
            F2M7M.setDidacticProcedural (feedbackMessageString.F2M7M_didacticProcedural());
            F2M7.setFeedbackMessage (F2M7M);
            F2M7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M7 = new Fraction ();
            int[] partitionValuesM7 = new int[4] {2,3,4,5};
            nextStepF2M7.setPartitionValues(partitionValuesM7);
            F2M7.setNextStep (nextStepF2M7);

            F2M7b = new FeedbackElem ();
            F2M7b.setID ("F2M7b");
            FeedbackMessage F2M7bM = new FeedbackMessage ();
            F2M7bM.setSocratic (feedbackMessageString.F2M7bM_socratic());
            F2M7bM.setGuidance (feedbackMessageString.F2M7bM_guidance());
            F2M7bM.setDidacticConceptual (feedbackMessageString.F2M7bM_didacticConceptual());
            F2M7bM.setDidacticProcedural (feedbackMessageString.F2M7bM_didacticProcedural());
            F2M7b.setFeedbackMessage (F2M7bM);
            F2M7b.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M7b = new Fraction ();
            int[] partitionValuesM7b = new int[4] {2,3,4,5};
            nextStepF2M7b.setPartitionValues(partitionValuesM7b);
            F2M7b.setNextStep (nextStepF2M7b);

            F2M7c = new FeedbackElem ();
            F2M7c.setID ("F2M7c");
            FeedbackMessage F2M7cM = new FeedbackMessage ();
            F2M7cM.setSocratic (feedbackMessageString.F2M7cM_socratic());
            F2M7cM.setGuidance (feedbackMessageString.F2M7cM_guidance());
            F2M7cM.setDidacticConceptual (feedbackMessageString.F2M7cM_didacticConceptual());
            F2M7cM.setDidacticProcedural (feedbackMessageString.F2M7cM_didacticProcedural());
            F2M7c.setFeedbackMessage (F2M7cM);
            F2M7c.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M7c = new Fraction ();
            int[] partitionValuesM7c = new int[4] {2,3,4,5};
            nextStepF2M7c.setPartitionValues(partitionValuesM7c);
            F2M7c.setNextStep (nextStepF2M7c);

            F2M10 = new FeedbackElem ();
            F2M10.setID ("F2M10");
            FeedbackMessage F2M10M = new FeedbackMessage ();
            F2M10M.setSocratic (feedbackMessageString.F2M10M_socratic());
            F2M10.setFeedbackMessage (F2M10M);
            F2M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepF2M10 = new Fraction ();
            nextStepF2M10.setSpeech(true);
            F2M10.setNextStep (nextStepF2M10);

            F2M11 = new FeedbackElem ();
            F2M11.setID ("F2M11");
            FeedbackMessage F2M11M = new FeedbackMessage ();
            F2M11M.setSocratic (feedbackMessageString.F2M11M_socratic());
            F2M11M.setGuidance (feedbackMessageString.F2M11M_guidance());
            F2M11.setFeedbackMessage (F2M11M);
            F2M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepF2M11 = new Fraction ();
            int[] partitionValuesM11 = new int[4] {2,3,4,5};
            nextStepF2M11.setPartitionValues(partitionValuesM11);
            F2M11.setNextStep (nextStepF2M11);

            F2E1 = new FeedbackElem ();
            F2E1.setID("F2E1");
            FeedbackMessage MF2E1M = new FeedbackMessage ();
            MF2E1M.setDidacticConceptual (feedbackMessageString.MF2E1M_didacticConceptual());
            F2E1.setFeedbackMessage (MF2E1M);
            F2E1.setFeedbackType (FeedbackType.affirmation);

            F2E2 = new FeedbackElem ();
            F2E2.setID("F2E2");
            FeedbackMessage MF2E2M = new FeedbackMessage ();
            MF2E2M.setDidacticConceptual (feedbackMessageString.MF2E2M_didacticConceptual());
            F2E2.setFeedbackMessage (MF2E2M);
            F2E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepF2E2 = new Fraction ();
            nextStepF2E2.setSpeech (true);
            F2E2.setNextStep (nextStepF2E2);

            T24M1 = new FeedbackElem ();
            T24M1.setID ("T24M1");
            FeedbackMessage T24M1M = new FeedbackMessage ();
            T24M1M.setSocratic (feedbackMessageString.T24M1M_socratic());
            T24M1M.setGuidance (feedbackMessageString.T24M1M_guidance());
            T24M1M.setDidacticConceptual (feedbackMessageString.T24M1M_didacticConceptual());
            T24M1M.setDidacticProcedural (feedbackMessageString.T24M1M_didacticProcedural());
            T24M1M.setHighlighting (Highlighting.ArrowButtons);
            T24M1.setFeedbackMessage (T24M1M);
            T24M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M1 = new Fraction ();
            nextStepT24M1.setDenominator(startDenominator);
            T24M1.setNextStep (nextStepT24M1);

            T24M2 = new FeedbackElem ();
            T24M2.setID ("T24M2");
            FeedbackMessage T24M2M = new FeedbackMessage ();
            T24M2M.setSocratic (feedbackMessageString.T24M2M_socratic());
            T24M2M.setGuidance (feedbackMessageString.T24M2M_guidance());
            T24M2M.setDidacticConceptual (feedbackMessageString.T24M2M_didacticConceptual());
            T24M2M.setDidacticProcedural (feedbackMessageString.T24M2M_didacticProcedural());
            T24M2.setFeedbackMessage (T24M2M);
            T24M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M2 = new Fraction ();
            nextStepT24M2.setDenominator(startDenominator);
            T24M2.setNextStep (nextStepT24M2);

            T24M3 = new FeedbackElem ();
            T24M3.setID ("T24M3");
            FeedbackMessage T24M3M = new FeedbackMessage ();
            T24M3M.setSocratic (feedbackMessageString.T24M3M_socratic());
            T24M3M.setGuidance (feedbackMessageString.T24M3M_guidance());
            T24M3M.setDidacticConceptual (feedbackMessageString.T24M3M_didacticConceptual());
            T24M3.setFeedbackMessage (T24M3M);
            T24M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M3 = new Fraction ();
            nextStepT24M3.setNumerator(startNumerator);
            nextStepT24M3.setDenominator(startDenominator);
            T24M3.setNextStep (nextStepT24M3);

            T24M4 = new FeedbackElem ();
            T24M4.setID ("T24M4");
            FeedbackMessage T24M4M = new FeedbackMessage ();
            T24M4M.setDidacticConceptual (feedbackMessageString.T24M4M_didacticConceptual());
            T24M4.setFeedbackMessage (T24M4M);
            T24M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT24M4 = new Fraction ();
            nextStepT24M4.setSpeech (true);
            T24M4.setNextStep (nextStepT24M4);

            T24M5 = new FeedbackElem ();
            T24M5.setID ("T24M5");
            FeedbackMessage T24M5M = new FeedbackMessage ();
            T24M5M.setSocratic (feedbackMessageString.T24M5M_socratic());
            T24M5M.setGuidance (feedbackMessageString.T24M5M_guidance());
            T24M5M.setDidacticConceptual (feedbackMessageString.T24M5M_didacticConceptual());
            T24M5M.setDidacticProcedural (feedbackMessageString.T24M5M_didacticProcedural());
            T24M5.setFeedbackMessage (T24M5M);
            T24M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M5 = new Fraction ();
            nextStepT24M5.setDenominator(startDenominator);
            T24M5.setNextStep (nextStepT24M5);

            T24M6 = new FeedbackElem ();
            T24M6.setID ("T24M6");
            FeedbackMessage T24M6M = new FeedbackMessage ();
            T24M6M.setSocratic (feedbackMessageString.T24M6M_socratic());
            T24M6M.setGuidance (feedbackMessageString.T24M6M_guidance());
            T24M6M.setDidacticConceptual (feedbackMessageString.T24M6M_didacticConceptual());
            T24M6M.setDidacticProcedural (feedbackMessageString.T24M6M_didacticProcedural());
            T24M6M.setHighlighting (Highlighting.ArrowButtons);
            T24M6.setFeedbackMessage (T24M6M);
            T24M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M6 = new Fraction ();
            nextStepT24M6.setNumerator(startNumerator);
            nextStepT24M6.setDenominator(startDenominator);
            nextStepT24M6.setEquivalentFraction (true);
            T24M6.setNextStep (nextStepT24M6);

            T24M7 = new FeedbackElem ();
            T24M7.setID ("T24M7");
            FeedbackMessage T24M7M = new FeedbackMessage ();
            T24M7M.setSocratic (feedbackMessageString.T24M7M_socratic());
            T24M7M.setGuidance (feedbackMessageString.T24M7M_guidance());
            T24M7M.setDidacticConceptual (feedbackMessageString.T24M7M_didacticConceptual());
            T24M7M.setDidacticProcedural (feedbackMessageString.T24M7M_didacticProcedural());
            T24M7.setFeedbackMessage (T24M7M);
            T24M7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M7 = new Fraction ();
            nextStepT24M7.setPartitionBool (true);
            T24M7.setNextStep (nextStepT24M7);

            T24M8 = new FeedbackElem ();
            T24M8.setID ("T24M8");
            FeedbackMessage T24M8M = new FeedbackMessage ();
            T24M8M.setSocratic (feedbackMessageString.T24M8M_socratic());
            T24M8M.setGuidance (feedbackMessageString.T24M8M_guidance());
            T24M8M.setDidacticConceptual (feedbackMessageString.T24M8M_didacticConceptual());
            T24M8M.setHighlighting (Highlighting.ComparisonBox);
            T24M8.setFeedbackMessage (T24M8M);
            T24M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT24M8 = new Fraction ();
            nextStepT24M8.setComparison (true);
            T24M8.setNextStep (nextStepT24M8);

            T24M9 = new FeedbackElem ();
            T24M9.setID ("T24M9");
            FeedbackMessage T24M9M = new FeedbackMessage ();
            T24M9M.setSocratic (feedbackMessageString.T24M9M_socratic());
            T24M9M.setGuidance (feedbackMessageString.T24M9M_guidance());
            T24M9M.setDidacticConceptual (feedbackMessageString.T24M9M_didacticConceptual());
            T24M9M.setHighlighting (Highlighting.RepresentationToolBox);
            T24M9.setFeedbackMessage (T24M9M);
            T24M9.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M9 = new Fraction ();
            nextStepT24M9.setComparison (true);
            T24M9.setNextStep (nextStepT24M9);

            T24M10 = new FeedbackElem ();
            T24M10.setID ("T24M10");
            FeedbackMessage T24M10M = new FeedbackMessage ();
            T24M10M.setDidacticConceptual (feedbackMessageString.T24M10M_didacticConceptual());
            T24M10.setFeedbackMessage (T24M10M);
            T24M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT24M10 = new Fraction ();
            nextStepT24M10.setSpeech (true);
            T24M10.setNextStep (nextStepT24M10);

            T24M11 = new FeedbackElem ();
            T24M11.setID ("T24M11");
            FeedbackMessage T24M11M = new FeedbackMessage ();
            T24M11M.setSocratic (feedbackMessageString.T24M11M_socratic());
            T24M11M.setGuidance (feedbackMessageString.T24M11M_guidance());
            T24M11M.setDidacticConceptual (feedbackMessageString.T24M11M_didacticConceptual());
            T24M11M.setHighlighting (Highlighting.ComparisonBox);
            T24M11.setFeedbackMessage (T24M11M);
            T24M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M11 = new Fraction ();
            nextStepT24M11.setComparison (true);
            T24M11.setNextStep (nextStepT24M11);

            T24M12 = new FeedbackElem ();
            T24M12.setID ("T24M12");
            FeedbackMessage T24M12M = new FeedbackMessage ();
            T24M12M.setSocratic (feedbackMessageString.T24M12M_socratic());
            T24M12M.setGuidance (feedbackMessageString.T24M12M_guidance());
            T24M12M.setDidacticConceptual (feedbackMessageString.T24M12M_didacticConceptual());
            T24M12M.setDidacticProcedural (feedbackMessageString.T24M12M_didacticProcedural());
            T24M12.setFeedbackMessage (T24M12M);
            T24M12.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M12 = new Fraction ();
            nextStepT24M12.setNumerator(startNumerator);
            nextStepT24M12.setDenominator(startDenominator);
            T24M12.setNextStep (nextStepT24M12);

            T24M13 = new FeedbackElem ();
            T24M13.setID ("T24M13");
            FeedbackMessage T24M13M = new FeedbackMessage ();
            T24M13M.setSocratic (feedbackMessageString.T24M13M_socratic());
            T24M13M.setGuidance (feedbackMessageString.T24M13M_guidance());
            T24M13M.setDidacticConceptual (feedbackMessageString.T24M13M_didacticConceptual());
            T24M13M.setDidacticProcedural (feedbackMessageString.T24M13M_didacticProcedural());
            T24M13.setFeedbackMessage (T24M13M);
            T24M13.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT24M13 = new Fraction ();
            nextStepT24M13.setNumerator(startNumerator);
            nextStepT24M13.setDenominator(startDenominator);
            T24M13.setNextStep (nextStepT24M13);

            T24E1 = new FeedbackElem ();
            T24E1.setID ("T24E1");
            FeedbackMessage T24E1M = new FeedbackMessage ();
            T24E1M.setDidacticConceptual (feedbackMessageString.T24E1M_didacticConceptual());
            T24E1.setFeedbackMessage (T24E1M);
            T24E1.setFeedbackType (FeedbackType.affirmation);

            T24E2 = new FeedbackElem ();
            T24E2.setID ("T24E2");
            FeedbackMessage T24E2M = new FeedbackMessage ();
            T24E2M.setDidacticConceptual (feedbackMessageString.T24E2M_didacticConceptual());
            T24E2.setFeedbackMessage (T24E2M);
            T24E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT24E2 = new Fraction ();
            nextStepT24E2.setSpeech (true);
            T24E2.setNextStep (nextStepT24E2);

            T26M1 = new FeedbackElem ();
            T26M1.setID ("T26M1");
            FeedbackMessage T26M1M = new FeedbackMessage ();
            T26M1M.setGuidance (feedbackMessageString.T26M1M_guidance());
            T26M1M.setSocratic (feedbackMessageString.T26M1M_socratic());
            T26M1M.setDidacticConceptual (feedbackMessageString.T26M1M_didacticConceptual());
            T26M1M.setDidacticProcedural (feedbackMessageString.T26M1M_didacticProcedural());
            T26M1M.setHighlighting (Highlighting.ArrowButtons);
            T26M1.setFeedbackMessage (T26M1M);
            T26M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M1 = new Fraction ();
            int[] values = new int[2] {startDenominator, endDenominator};
            nextStepT26M1.setDenominators (values);
            T26M1.setNextStep (nextStepT26M1);

            T26M2 = new FeedbackElem ();
            T26M2.setID ("T26M2");
            FeedbackMessage T26M2M = new FeedbackMessage ();
            T26M2M.setGuidance (feedbackMessageString.T26M2M_guidance());
            T26M2M.setSocratic (feedbackMessageString.T26M2M_socratic());
            T26M2M.setDidacticConceptual (feedbackMessageString.T26M2M_didacticConceptual());
            T26M2M.setDidacticProcedural (feedbackMessageString.T26M2M_didacticProcedural());
            T26M2M.setHighlighting (Highlighting.ArrowButtons);
            T26M2.setFeedbackMessage (T26M2M);
            T26M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M2 = new Fraction ();
            int[] values2 = new int[2] {startDenominator, endDenominator};
            nextStepT26M2.setDenominators (values2);
            T26M2.setNextStep (nextStepT26M2);

            T26M3 = new FeedbackElem ();
            T26M3.setID ("T26M3");
            FeedbackMessage T26M3M = new FeedbackMessage ();
            T26M3M.setGuidance (feedbackMessageString.T26M3M_guidance());
            T26M3M.setSocratic (feedbackMessageString.T26M3M_socratic());
            T26M3M.setDidacticConceptual (feedbackMessageString.T26M3M_didacticConceptual());
            T26M3.setFeedbackMessage (T26M3M);
            T26M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M3 = new Fraction ();
            int[] values3 = new int[2] {startNumerator, endNumerator};
            int[] values4 = new int[2] {startDenominator, endDenominator};
            nextStepT26M3.setNumerators (values3);
            nextStepT26M3.setDenominators (values4);
            T26M3.setNextStep (nextStepT26M3);

            T26M4 = new FeedbackElem ();
            T26M4.setID ("T26M4");
            FeedbackMessage T26M4M = new FeedbackMessage ();
            T26M4M.setDidacticConceptual (feedbackMessageString.T26M4M_didacticConceptual());
            T26M4.setFeedbackMessage (T26M4M);
            T26M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT26M4 = new Fraction ();
            nextStepT26M4.setSpeech (true);
            T26M4.setNextStep (nextStepT26M4);

            T26M5 = new FeedbackElem ();
            T26M5.setID ("T26M5");
            FeedbackMessage T26M5M = new FeedbackMessage ();
            T26M5M.setGuidance (feedbackMessageString.T26M5M_guidance());
            T26M5M.setSocratic (feedbackMessageString.T26M5M_socratic());
            T26M5M.setDidacticConceptual (feedbackMessageString.T26M5M_didacticConceptual());
            T26M5M.setDidacticProcedural (feedbackMessageString.T26M5M_didacticProcedural());
            T26M5.setFeedbackMessage (T26M5M);
            T26M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M5 = new Fraction ();
            int[] valuesM5 = new int[2] {startDenominator, endDenominator};
            nextStepT26M5.setDenominators (valuesM5);
            T26M5.setNextStep (nextStepT26M5);

            T26M6 = new FeedbackElem ();
            T26M6.setID ("T26M6");
            FeedbackMessage T26M6M = new FeedbackMessage ();
            T26M6M.setGuidance (feedbackMessageString.T26M6M_guidance());
            T26M6M.setSocratic (feedbackMessageString.T26M6M_socratic());
            T26M6M.setDidacticConceptual (feedbackMessageString.T26M6M_didacticConceptual());
            T26M6M.setDidacticProcedural (feedbackMessageString.T26M6M_didacticProcedural());
            T26M6M.setHighlighting (Highlighting.ArrowButtons);
            T26M6.setFeedbackMessage (T26M6M);
            T26M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M6 = new Fraction ();
            int[] valuesM6num = new int[2] {startNumerator, endNumerator};
            int[] valuesM6den = new int[2] {startDenominator, endDenominator};
            nextStepT26M6.setNumerators (valuesM6num);
            nextStepT26M6.setDenominators (valuesM6den);
            T26M6.setNextStep (nextStepT26M6);

            T26M7 = new FeedbackElem ();
            T26M7.setID ("T26M7");
            FeedbackMessage T26M7M = new FeedbackMessage ();
            T26M7M.setGuidance (feedbackMessageString.T26M7M_guidance());
            T26M7M.setSocratic (feedbackMessageString.T26M7M_socratic());
            T26M7M.setDidacticConceptual (feedbackMessageString.T26M7M_didacticConceptual());
            T26M7M.setDidacticProcedural (feedbackMessageString.T26M7M_didacticProcedural());
            T26M7M.setHighlighting (Highlighting.ArrowButtons);
            T26M7.setFeedbackMessage (T26M7M);
            T26M7.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M7 = new Fraction ();
            int[] valuesM7num = new int[2] {startNumerator, endNumerator};
            int[] valuesM7den = new int[2] {startDenominator, endDenominator};
            nextStepT26M7.setNumerators (valuesM6num);
            nextStepT26M7.setDenominators (valuesM6den);
            T26M7.setNextStep (nextStepT26M7);

            T26M7start = new FeedbackElem ();
            T26M7start.setID ("T26M7start");
            FeedbackMessage T26M7startM = new FeedbackMessage ();
            T26M7startM.setGuidance (feedbackMessageString.T26M7Mstart_guidance());
            T26M7startM.setSocratic (feedbackMessageString.T26M7Mstart_socratic());
            T26M7startM.setDidacticConceptual (feedbackMessageString.T26M7Mstart_didacticConceptual());
            T26M7startM.setDidacticProcedural (feedbackMessageString.T26M7Mstart_didacticProcedural());
            T26M7startM.setHighlighting (Highlighting.ArrowButtons);
            T26M7start.setFeedbackMessage (T26M7startM);
            T26M7start.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M7start = new Fraction ();
            nextStepT26M7start.setNumerator (endNumerator);
            nextStepT26M7start.setDenominator (endDenominator);
            T26M7start.setNextStep (nextStepT26M7start);

            T26M7end = new FeedbackElem ();
            T26M7end.setID ("T26M7end");
            FeedbackMessage T26M7endM = new FeedbackMessage ();
            T26M7endM.setGuidance (feedbackMessageString.T26M7Mend_guidance());
            T26M7endM.setSocratic (feedbackMessageString.T26M7Mend_socratic());
            T26M7endM.setDidacticConceptual (feedbackMessageString.T26M7Mend_didacticConceptual());
            T26M7endM.setDidacticProcedural (feedbackMessageString.T26M7Mend_didacticProcedural());
            T26M7endM.setHighlighting (Highlighting.ArrowButtons);
            T26M7end.setFeedbackMessage (T26M7endM);
            T26M7end.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M7end = new Fraction ();
            nextStepT26M7end.setNumerator (startNumerator);
            nextStepT26M7end.setDenominator (startDenominator);
            T26M7end.setNextStep (nextStepT26M7end);

            T26M8 = new FeedbackElem ();
            T26M8.setID ("T26M8");
            FeedbackMessage T26M8M = new FeedbackMessage ();
            T26M8M.setGuidance (feedbackMessageString.T26M8M_guidance());
            T26M8M.setSocratic (feedbackMessageString.T26M8M_socratic());
            T26M8M.setDidacticConceptual (feedbackMessageString.T26M8M_didacticConceptual());
            T26M8M.setHighlighting (Highlighting.ComparisonBox);
            T26M8.setFeedbackMessage (T26M8M);
            T26M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT26M8 = new Fraction ();
            nextStepT26M8.sameRepresentation (true);
            T26M8.setNextStep (nextStepT26M8);

            T26M10 = new FeedbackElem ();
            T26M10.setID ("T26M10");
            FeedbackMessage T26M10M = new FeedbackMessage ();
            T26M10M.setDidacticConceptual (feedbackMessageString.T26M10M_didacticConceptual());
            T26M10.setFeedbackMessage (T26M10M);
            T26M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT26M10 = new Fraction ();
            nextStepT26M10.setSpeech (true);
            T26M10.setNextStep (nextStepT26M10);

            T26M11 = new FeedbackElem ();
            T26M11.setID ("T26M11");
            FeedbackMessage T26M11M = new FeedbackMessage ();
            T26M11M.setGuidance (feedbackMessageString.T26M11M_guidance());
            T26M11M.setSocratic (feedbackMessageString.T26M11M_socratic());
            T26M11M.setDidacticConceptual (feedbackMessageString.T26M11M_didacticConceptual());
            T26M11M.setHighlighting (Highlighting.ComparisonBox);
            T26M11.setFeedbackMessage (T26M11M);
            T26M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT26M11 = new Fraction ();
            nextStepT26M11.setComparison (true);
            T26M11.setNextStep (nextStepT26M11);

            T26E1 = new FeedbackElem ();
            T26E1.setID ("T26E1");
            FeedbackMessage T26E1M = new FeedbackMessage ();
            T26E1M.setDidacticConceptual (feedbackMessageString.T26E1M_didacticConceptual());
            T26E1.setFeedbackMessage (T26E1M);
            T26E1.setFeedbackType (FeedbackType.affirmation);

            T26E2 = new FeedbackElem ();
            T26E2.setID ("T26E2");
            FeedbackMessage T26E2M = new FeedbackMessage ();
            T26E2M.setDidacticConceptual (feedbackMessageString.T26E2M_didacticConceptual());
            T26E2.setFeedbackMessage (T26E2M);
            T26E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT26E2 = new Fraction ();
            nextStepT26E2.setSpeech (true);
            T26E2.setNextStep (nextStepT26E2);

            T3aP1M1 = new FeedbackElem ();
            T3aP1M1.setID ("T3aP1M1");
            FeedbackMessage T3aP1M1M = new FeedbackMessage ();
            T3aP1M1M.setSocratic (feedbackMessageString.T3aP1M1M_socratic());
            T3aP1M1M.setGuidance (feedbackMessageString.T3aP1M1M_guidance());
            T3aP1M1M.setDidacticConceptual (feedbackMessageString.T3aP1M1M_didacticConceptual());
            T3aP1M1M.setDidacticProcedural (feedbackMessageString.T3aP1M1M_didacticProcedural());
            T3aP1M1M.setHighlighting (Highlighting.ArrowButtons);
            T3aP1M1.setFeedbackMessage (T3aP1M1M);
            T3aP1M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M1 = new Fraction ();
            nextStepT3aP1M1.setDenominator (startDenominator);
            T3aP1M1.setNextStep (nextStepT3aP1M1);

            T3aP1M2 = new FeedbackElem ();
            T3aP1M2.setID ("T3aP1M2");
            FeedbackMessage T3aP1M2M = new FeedbackMessage ();
            T3aP1M2M.setSocratic (feedbackMessageString.T3aP1M2M_socratic());
            T3aP1M2M.setGuidance (feedbackMessageString.T3aP1M2M_guidance());
            T3aP1M2M.setDidacticConceptual (feedbackMessageString.T3aP1M2M_didacticConceptual());
            T3aP1M2M.setDidacticProcedural (feedbackMessageString.T3aP1M2M_didacticProcedural());
            T3aP1M2.setFeedbackMessage (T3aP1M2M);
            T3aP1M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M2 = new Fraction ();
            nextStepT3aP1M2.setDenominator (startDenominator);
            T3aP1M2.setNextStep (nextStepT3aP1M2);

            T3aP1M3 = new FeedbackElem ();
            T3aP1M3.setID ("T3aP1M3");
            FeedbackMessage T3aP1M3M = new FeedbackMessage ();
            T3aP1M3M.setSocratic (feedbackMessageString.T3aP1M3M_socratic());
            T3aP1M3M.setGuidance (feedbackMessageString.T3aP1M3M_guidance());
            T3aP1M3M.setDidacticConceptual (feedbackMessageString.T3aP1M3M_didacticConceptual());
            T3aP1M3.setFeedbackMessage (T3aP1M3M);
            T3aP1M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M3 = new Fraction ();
            nextStepT3aP1M3.setFractionForAdditionTask(startDenominator, startNumerator);
            T3aP1M3.setNextStep (nextStepT3aP1M3);

            T3aP1M4 = new FeedbackElem ();
            T3aP1M4.setID ("T3aP1M4");
            FeedbackMessage T3aP1M4M = new FeedbackMessage ();
            T3aP1M4M.setDidacticConceptual (feedbackMessageString.T3aP1M4M_didacticConceptual());
            T3aP1M4.setFeedbackMessage (T3aP1M4M);
            T3aP1M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3aP1M4 = new Fraction ();
            nextStepT3aP1M4.setSpeech (true);
            T3aP1M4.setNextStep (nextStepT3aP1M4);

            T3aP1M5 = new FeedbackElem ();
            T3aP1M5.setID ("T3aP1M5");
            FeedbackMessage T3aP1M5M = new FeedbackMessage ();
            T3aP1M5M.setSocratic (feedbackMessageString.T3aP1M5M_socratic());
            T3aP1M5M.setGuidance (feedbackMessageString.T3aP1M5M_guidance());
            T3aP1M5M.setDidacticConceptual (feedbackMessageString.T3aP1M5M_didacticConceptual());
            T3aP1M5M.setDidacticProcedural (feedbackMessageString.T3aP1M5M_didacticProcedural());
            T3aP1M5.setFeedbackMessage (T3aP1M5M);
            T3aP1M5.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M5 = new Fraction ();
            nextStepT3aP1M5.setDenominator (startDenominator);
            T3aP1M5.setNextStep (nextStepT3aP1M5);

            T3aP1M6 = new FeedbackElem ();
            T3aP1M6.setID ("T3aP1M6");
            FeedbackMessage T3aP1M6M = new FeedbackMessage ();
            T3aP1M6M.setSocratic (feedbackMessageString.T3aP1M6M_socratic());
            T3aP1M6M.setGuidance (feedbackMessageString.T3aP1M6M_guidance());
            T3aP1M6M.setDidacticConceptual (feedbackMessageString.T3aP1M6M_didacticConceptual());
            T3aP1M6M.setDidacticProcedural (feedbackMessageString.T3aP1M6M_didacticProcedural());
            T3aP1M6M.setHighlighting (Highlighting.ArrowButtons);
            T3aP1M6.setFeedbackMessage (T3aP1M6M);
            T3aP1M6.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3aP1M6 = new Fraction ();
            nextStepT3aP1M6.setFractionForAdditionTask(startDenominator, startNumerator);
            T3aP1M6.setNextStep (nextStepT3aP1M6);

            T3aP1M7 = new FeedbackElem ();
            T3aP1M7.setID ("T3aP1M7");
            FeedbackMessage T3aP1M7M = new FeedbackMessage ();
            T3aP1M7M.setSocratic (feedbackMessageString.T3aP1M7M_socratic());
            T3aP1M7M.setGuidance (feedbackMessageString.T3aP1M7M_guidance());
            T3aP1M7.setFeedbackMessage (T3aP1M7M);
            T3aP1M7.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M7 = new Fraction ();
            nextStepT3aP1M7.setFractionForAdditionTaskEnd(startDenominator, startNumerator);
            T3aP1M7.setNextStep (nextStepT3aP1M7);

            T3aP1M8 = new FeedbackElem ();
            T3aP1M8.setID ("T3aP1M8");
            FeedbackMessage T3aP1M8M = new FeedbackMessage ();
            T3aP1M8M.setSocratic (feedbackMessageString.T3aP1M8M_socratic());
            T3aP1M8M.setGuidance (feedbackMessageString.T3aP1M8M_guidance());
            T3aP1M8.setFeedbackMessage (T3aP1M8M);
            T3aP1M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3aP1M8 = new Fraction ();
            nextStepT3aP1M8.setFractionForAdditionTaskEnd(startDenominator, startNumerator);
            T3aP1M8.setNextStep (nextStepT3aP1M8);

            T3aP1M10 = new FeedbackElem ();
            T3aP1M10.setID ("T3aP1M10");
            FeedbackMessage T3aP1M10M = new FeedbackMessage ();
            T3aP1M10M.setDidacticConceptual (feedbackMessageString.T3aP1M10M_didacticConceptual());
            T3aP1M10.setFeedbackMessage (T3aP1M10M);
            T3aP1M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3aP1M10 = new Fraction ();
            nextStepT3aP1M10.setSpeech(true);
            T3aP1M10.setNextStep (nextStepT3aP1M10);

            T3aP1M11 = new FeedbackElem ();
            T3aP1M11.setID ("T3aP1M11");
            FeedbackMessage T3aP1M11M = new FeedbackMessage ();
            T3aP1M11M.setSocratic (feedbackMessageString.T3aP1M11M_socratic());
            T3aP1M11M.setGuidance (feedbackMessageString.T3aP1M11M_guidance());
            T3aP1M11M.setDidacticConceptual (feedbackMessageString.T3aP1M11M_didacticConceptual());
            T3aP1M11.setFeedbackMessage (T3aP1M11M);
            T3aP1M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3aP1M11 = new Fraction ();
            nextStepT3aP1M11.setAdditionBox (true);
            T3aP1M11.setNextStep (nextStepT3aP1M11);

            T3aP1E1 = new FeedbackElem ();
            T3aP1E1.setID ("T3aP1E1");
            FeedbackMessage T3aP1E1M = new FeedbackMessage ();
            T3aP1E1M.setDidacticConceptual (feedbackMessageString.T3aP1E1M_didacticConceptual());
            T3aP1E1.setFeedbackMessage (T3aP1E1M);
            T3aP1E1.setFeedbackType (FeedbackType.affirmation);

            T3aP1E2 = new FeedbackElem ();
            T3aP1E2.setID ("T3aP1E2");
            FeedbackMessage T3aP1E2M = new FeedbackMessage ();

            T3aP1E2M.setDidacticConceptual (feedbackMessageString.T3aP1E2M_didacticConceptual());
            T3aP1E2.setFeedbackMessage (T3aP1E2M);
            T3aP1E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3aPE2 = new Fraction ();
            nextStepT3aPE2.setSpeech(true);
            T3aP1E2.setNextStep (nextStepT3aPE2);

            T3bP1S3 = new FeedbackElem ();
            T3bP1S3.setID ("T3bP1S3");
            FeedbackMessage T3bP1S3M = new FeedbackMessage ();
            T3bP1S3M.setSocratic (feedbackMessageString.T3bP1_affirmationInstruction_socratic());
            T3bP1S3M.setGuidance (feedbackMessageString.T3bP1_affirmationInstruction_guidance());
            T3bP1S3M.setDidacticConceptual (feedbackMessageString.T3bP1_affirmationInstruction_didacticConceptual());
            T3bP1S3M.setDidacticProcedural (feedbackMessageString.T3bP1_affirmationInstruction_didacticProcedural());
            T3bP1S3.setFeedbackMessage (T3bP1S3M);
            T3bP1S3.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1S3 = new Fraction ();
            nextStepT3bP1S3.setAnyValue (true);
            T3bP1S3.setNextStep (nextStepT3bP1S3);

            T3bP1M1 = new FeedbackElem ();
            T3bP1M1.setID ("T3bP1M1");
            FeedbackMessage T3bP1M1M = new FeedbackMessage ();
            T3bP1M1M.setSocratic (feedbackMessageString.T3bP1M1_socratic());
            T3bP1M1M.setGuidance (feedbackMessageString.T3bP1M1_guidance());
            T3bP1M1M.setDidacticConceptual (feedbackMessageString.T3bP1M1_didacticConceptual());
            T3bP1M1M.setDidacticProcedural (feedbackMessageString.T3bP1M1_didacticProcedural());
            T3bP1M1.setFeedbackMessage (T3bP1M1M);
            T3bP1M1.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M1 = new Fraction ();
            int[] valuesM1denom = new int[2] {startDenominator, endDenominator};
            nextStepT3bP1M1.setDenominators(valuesM1denom);
            T3bP1M1.setNextStep (nextStepT3bP1M1);

            T3bP1M2 = new FeedbackElem ();
            T3bP1M2.setID ("T3bP1M2");
            FeedbackMessage T3bP1M2M = new FeedbackMessage ();
            T3bP1M2M.setSocratic (feedbackMessageString.T3bP1M2_socratic());
            T3bP1M2M.setGuidance (feedbackMessageString.T3bP1M2_guidance());
            T3bP1M2M.setDidacticConceptual (feedbackMessageString.T3bP1M2_didacticConceptual());
            T3bP1M2M.setDidacticProcedural (feedbackMessageString.T3bP1M2_didacticProcedural());
            T3bP1M2.setFeedbackMessage (T3bP1M2M);
            T3bP1M2.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M2 = new Fraction ();
            nextStepT3bP1M2.setDenominator(startDenominator);
            T3bP1M2.setNextStep (nextStepT3bP1M2);

            T3bP1M3 = new FeedbackElem ();
            T3bP1M3.setID ("T3bP1M3");
            FeedbackMessage T3bP1M3M = new FeedbackMessage ();
            T3bP1M3M.setSocratic (feedbackMessageString.T3bP1M3_socratic());
            T3bP1M3M.setGuidance (feedbackMessageString.T3bP1M3_guidance());
            T3bP1M3M.setDidacticConceptual (feedbackMessageString.T3bP1M3_didacticConceptual());
            T3bP1M3.setFeedbackMessage (T3bP1M3M);
            T3bP1M3.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M3 = new Fraction ();
            int[] valuesT3bM3num = new int[2] {startNumerator, endNumerator};
            int[] valuesT3bM3denom = new int[2] {startDenominator, endDenominator};
            nextStepT3bP1M3.setNumerators(valuesT3bM3num);
            nextStepT3bP1M3.setDenominators(valuesT3bM3denom);
            T3bP1M3.setNextStep (nextStepT3bP1M3);

            T3bP1M4 = new FeedbackElem ();
            T3bP1M4.setID ("T3bP1M4");
            FeedbackMessage T3bP1M4M = new FeedbackMessage ();
            T3bP1M4M.setDidacticConceptual (feedbackMessageString.T3bP1M4_didacticConceptual());
            T3bP1M4.setFeedbackMessage (T3bP1M4M);
            T3bP1M4.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3bP1M4 = new Fraction ();
            nextStepT3bP1M4.setSpeech (true);
            T3bP1M4.setNextStep (nextStepT3bP1M4);

            T3bP1M5 = new FeedbackElem ();
            T3bP1M5.setID ("T3bP1M5");
            FeedbackMessage T3bP1M5M = new FeedbackMessage ();
            T3bP1M5M.setSocratic (feedbackMessageString.T3bP1M5_socratic());
            T3bP1M5M.setGuidance (feedbackMessageString.T3bP1M5_guidance());
            T3bP1M5M.setDidacticConceptual (feedbackMessageString.T3bP1M5_didacticConceptual());
            T3bP1M5M.setDidacticProcedural (feedbackMessageString.T3bP1M5_didacticProcedural());
            T3bP1M5.setFeedbackMessage (T3bP1M5M);
            T3bP1M5.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M5 = new Fraction ();
            nextStepT3bP1M5.setDenominator(startDenominator);
            T3bP1M5.setNextStep (nextStepT3bP1M5);

            T3bP1M7start = new FeedbackElem ();
            T3bP1M7start.setID ("T3bP1M7start");
            FeedbackMessage T3bP1M7Mstart = new FeedbackMessage ();
            T3bP1M7Mstart.setSocratic (feedbackMessageString.T3bP1M7_socratic());
            T3bP1M7Mstart.setGuidance (feedbackMessageString.T3bP1M7First_guidance());
            T3bP1M7start.setFeedbackMessage (T3bP1M7Mstart);
            T3bP1M7start.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M7start = new Fraction ();
            nextStepT3bP1M7start.setNumerator(startNumerator);
            nextStepT3bP1M7start.setDenominator(startDenominator);
            T3bP1M7start.setNextStep (nextStepT3bP1M7start);

            T3bP1M7end = new FeedbackElem ();
            T3bP1M7end.setID ("T3bP1M7end");
            FeedbackMessage T3bP1M7Mend = new FeedbackMessage ();
            T3bP1M7Mend.setSocratic (feedbackMessageString.T3bP1M7_socratic());
            T3bP1M7Mend.setGuidance (feedbackMessageString.T3bP1M7Second_guidance());
            T3bP1M7end.setFeedbackMessage (T3bP1M7Mend);
            T3bP1M7end.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M7end = new Fraction ();
            nextStepT3bP1M7end.setNumerator(endNumerator);
            nextStepT3bP1M7end.setDenominator(endDenominator);
            T3bP1M7end.setNextStep (nextStepT3bP1M7end);

            T3bP1M8 = new FeedbackElem ();
            T3bP1M8.setID ("T3bP1M8");
            FeedbackMessage T3bP1M8M = new FeedbackMessage ();
            T3bP1M8M.setSocratic (feedbackMessageString.T3bP1M8_socratic());
            T3bP1M8M.setGuidance (feedbackMessageString.T3bP1M8_guidance());
            T3bP1M8M.setDidacticConceptual (feedbackMessageString.T3bP1M8_didacticConceptual());
            T3bP1M8M.setDidacticProcedural (feedbackMessageString.T3bP1M8_didacticProcedural());
            T3bP1M8.setFeedbackMessage (T3bP1M8M);
            T3bP1M8.setFeedbackType (FeedbackType.problemSolving);
            Fraction nextStepT3bP1M8 = new Fraction ();
            nextStepT3bP1M8.setDenominator(endDenominator);
            T3bP1M8.setNextStep (nextStepT3bP1M8);

            T3bP1M10 = new FeedbackElem ();
            T3bP1M10.setID ("T3bP1M10");
            FeedbackMessage T3bP1M10M = new FeedbackMessage ();
            T3bP1M10M.setDidacticConceptual (feedbackMessageString.T3bP1M10_didacticConceptual());
            T3bP1M10.setFeedbackMessage (T3bP1M10M);
            T3bP1M10.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3bP1M10 = new Fraction ();
            nextStepT3bP1M10.setSpeech (true);
            T3bP1M10.setNextStep (nextStepT3bP1M10);

            T3bP1M11 = new FeedbackElem ();
            T3bP1M11.setID ("T3bP1M11");
            FeedbackMessage T3bP1M11M = new FeedbackMessage ();
            T3bP1M11M.setSocratic (feedbackMessageString.T3bP1M11_socratic());
            T3bP1M11M.setGuidance (feedbackMessageString.T3bP1M11_guidance());
            T3bP1M11M.setDidacticConceptual (feedbackMessageString.T3bP1M11_didacticConceptual());
            T3bP1M11.setFeedbackMessage (T3bP1M11M);
            T3bP1M11.setFeedbackType (FeedbackType.nextStep);
            Fraction nextStepT3bP1M11 = new Fraction ();
            nextStepT3bP1M11.setAdditionBox (true);
            T3bP1M11.setNextStep (nextStepT3bP1M11);

            T3bP1E1 = new FeedbackElem ();
            T3bP1E1.setID ("T3bP1E1");
            FeedbackMessage T3bP1E1M = new FeedbackMessage ();
            T3bP1E1M.setDidacticConceptual (feedbackMessageString.T3bP1E1_didacticConceptual());
            T3bP1E1.setFeedbackMessage (T3bP1E1M);
            T3bP1E1.setFeedbackType (FeedbackType.affirmation);

            T3bP1E2 = new FeedbackElem ();
            T3bP1E2.setID ("T3bP1E2");
            FeedbackMessage T3bP1E2M = new FeedbackMessage ();
            T3bP1E2M.setDidacticConceptual (feedbackMessageString.T3bP1E2_didacticConceptual());
            T3bP1E2.setFeedbackMessage (T3bP1E2M);
            T3bP1E2.setFeedbackType (FeedbackType.reflection);
            Fraction nextStepT3bP1E2 = new Fraction ();
            nextStepT3bP1E2.setSpeech(true);
            T3bP1E2.setNextStep (nextStepT3bP1E2);
        }
 public static void setCurrentFeedback(FeedbackElem feedback, int pointer)
 {
     currentFeedback = feedback;
     currentFeedbackPointer = pointer;
 }
        private void setNewFeedback()
        {
            String feedbackID = currentFeedback.getID();;
            if (feedbackID.Equals ("")) {
                currentFeedback = feedbackData.S2;
            }

            studentModel.setCurrentFeedback (currentFeedback);
            string currentFeedbackID = currentFeedback.getID();
            int currentCounter = 0;

            string guidance = currentFeedback.getFeedbackMessage ().getGuidance ();
            string socratic = currentFeedback.getFeedbackMessage ().getSocratic ();
            string didacticConceptual = currentFeedback.getFeedbackMessage ().getDidacticConceptual ();
            string didacticProcedural = currentFeedback.getFeedbackMessage ().getDidacticProcedural();

            FeedbackData thisFeedbackData = studentModel.getFeedbackData ();
            if (thisFeedbackData == null) {
                thisFeedbackData = feedbackData;
            }

            FeedbackElem studentFeedbackElem = thisFeedbackData.getFeedbackElem (currentFeedbackID);
            int studentCounter = studentFeedbackElem.getCounter();
            currentCounter = studentCounter;

            Debug.Log ("studentCounter: "+studentCounter);

            if (studentCounter == 0) {
                studentModel.setFeedbackCounterRule("feedbackCounter-studentCounter-0");
                if (socratic.Length>0) currentCounter = 1;
                else if (guidance.Length>0) currentCounter =2;
                else if (didacticConceptual.Length>0) currentCounter=3;
                else if (didacticProcedural.Length>0) currentCounter = 4;
            }
            else if (studentCounter == 1){
                studentModel.setFeedbackCounterRule("feedbackCounter-studentCounter-1");
                if (guidance.Length>0) currentCounter =2;
                else if (didacticConceptual.Length>0) currentCounter=3;
                else if (didacticProcedural.Length>0) currentCounter = 4;
            }
            else if (studentCounter == 2){
                studentModel.setFeedbackCounterRule("feedbackCounter-studentCounter-2");
                if (didacticConceptual.Length>0) currentCounter=3;
                else if (didacticProcedural.Length>0) currentCounter = 4;
            }
            else if (studentCounter == 3){
                studentModel.setFeedbackCounterRule("feedbackCounter-studentCounter-3");
                if (didacticProcedural.Length>0) currentCounter = 4;
            }
            else if (studentCounter ==4){
                studentModel.setFeedbackCounterRule("feedbackCounter-studentCounter-4");
                currentCounter = 1;
            }

            studentModel.setCurrentFeedbackLevel (currentCounter);
            studentFeedbackElem.setCounter (currentCounter);
            studentModel.setPreviousFeedback (currentFeedback);
            studentModel.addFeedbackProvided (currentFeedback);
            studentModel.setDisplayedMessageType (currentFeedback.getFeedbackType());
            FeedbackStrategyModel.setCurrentFeedback (currentFeedback, currentCounter);
        }
 public void processDoneEvent()
 {
     Debug.Log ("::: processDoneEvent ::: ");
     processEvent ();
     Debug.Log ("::: isTaskCompleted ::: "+studentModel.isTaskCompleted());
     if (studentModel.isTaskCompleted ()) {
         if (taskID.Equals ("task1.1setA")){
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task1.1");
             currentFeedback = feedbackData.CE2;
             setNewFeedback();
         }
         else if (taskID.Equals("task2.1")){
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task2.1");
             Debug.Log (":: task 2.1 :: feebdack FE2");
             currentFeedback = feedbackData.FE2;
             setNewFeedback();
         }
         else if (taskID.Equals ("task2.2")) {
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task2.2");
             currentFeedback = feedbackData.F2E2;
             setNewFeedback();
         }
         else if (taskID.Equals("task2.4.setA.area") || taskID.Equals("task2.4.setB.area") || taskID.Equals("task2.4.setC.area") ||
                  taskID.Equals("task2.4.setA.numb") || taskID.Equals("task2.4.setB.numb") || taskID.Equals("task2.4.setC.numb") ||
                  taskID.Equals("task2.4.setA.sets") || taskID.Equals("task2.4.setB.sets") || taskID.Equals("task2.4.setC.sets") ||
                  taskID.Equals("task2.4.setA.liqu") || taskID.Equals("task2.4.setB.liqu") || taskID.Equals("task2.4.setC.liqu")){
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task2.4");
             currentFeedback = feedbackData.T24E2;
             setNewFeedback();
         }
         else if (taskID.Equals("task2.6.setA") || taskID.Equals("task2.6.setB") || taskID.Equals("task2.6.setC")){
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task2.6");
             currentFeedback = feedbackData.T26E2;
             setNewFeedback();
         }
         else if (taskID.Equals("task2.7.setA") ||taskID.Equals("task2.7.setB") || taskID.Equals("task2.7.setC")) {
             if (studentModel.getParticitionUsed()){
                 studentModel.setMessageRule("processDoneEvent-taskCompleted-partitionUsed-task2.7");
                 Debug.Log (" currentFeedback = feedbackData.R1");
                 currentFeedback = feedbackData.R1;
             }
             else {
                 studentModel.setMessageRule("processDoneEvent-taskCompleted-partitionNotUsed-task2.7");
                 Debug.Log (" currentFeedback = feedbackData.R1");
                 currentFeedback = feedbackData.R2;
             }
             setNewFeedback();
         }
         else if (taskID.Equals("task3aPlus.1.setA.area") || taskID.Equals("task3aPlus.1.setB.area") || taskID.Equals("task3aPlus.1.setC.area") ||
                  taskID.Equals("task3aPlus.1.setA.numb") || taskID.Equals("task3aPlus.1.setB.numb") || taskID.Equals("task3aPlus.1.setC.numb") ||
                  taskID.Equals("task3aPlus.1.setA.sets") || taskID.Equals("task3aPlus.1.setB.sets") || taskID.Equals("task3aPlus.1.setC.sets") ||
                  taskID.Equals("task3aPlus.1.setA.liqu") || taskID.Equals("task3aPlus.1.setB.liqu") || taskID.Equals("task3aPlus.1.setC.liqu") ){
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task3a");
             currentFeedback = feedbackData.T3aP1E2;
             setNewFeedback();
         }
         else if (taskID.Equals("task3bPlus.1.setA.area") || taskID.Equals("task3bPlus.1.setB.area") || taskID.Equals("task3bPlus.1.setC.area") ||
                  taskID.Equals("task3bPlus.1.setA.numb") || taskID.Equals("task3bPlus.1.setB.numb") || taskID.Equals("task3bPlus.1.setC.numb") ||
                  taskID.Equals("task3bPlus.1.setA.sets") || taskID.Equals("task3bPlus.1.setB.sets") || taskID.Equals("task3bPlus.1.setC.sets") ||
                  taskID.Equals("task3bPlus.1.setA.liqu") || taskID.Equals("task3bPlus.1.setB.liqu") || taskID.Equals("task3bPlus.1.setC.liqu") ){
             studentModel.setMessageRule("processDoneEvent-taskCompleted-task3b");
             currentFeedback = feedbackData.T3bP1E2;
             setNewFeedback();
         }
         TDSWrapper.ArrowButtonEnable (true);
     }
     else {
         if (studentModel.firstDoneButtonPressed()){
             studentModel.setMessageRule("processDoneEvent-taskNotCompleted-first");
             currentFeedback = feedbackData.O1;
         }
         else {
             studentModel.setMessageRule("processDoneEvent-taskNotCompleted-second");
             currentFeedback = feedbackData.O2;
             TDSWrapper.ArrowButtonEnable (true);
         }
         studentModel.setDoneButtonPressed ();
         setNewFeedback();
     }
 }
        public void processEvent()
        {
            Debug.Log ("processEvent");
            Debug.Log ("taskID: "+taskID);
            Fraction testCurrentFraction = studentModel.getCurrentFraction ();
            Debug.Log ("testCurrentFraction: "+testCurrentFraction);

            if (taskID.Equals ("task3bPlus.1.setA.area") || taskID.Equals ("task3bPlus.1.setB.area") || taskID.Equals ("task3bPlus.1.setC.area") ||
                taskID.Equals ("task3bPlus.1.setA.numb") || taskID.Equals ("task3bPlus.1.setB.numb") || taskID.Equals ("task3bPlus.1.setC.numb") ||
                taskID.Equals ("task3bPlus.1.setA.sets") || taskID.Equals ("task3bPlus.1.setB.sets") || taskID.Equals ("task3bPlus.1.setC.sets") ||
                taskID.Equals ("task3bPlus.1.setA.liqu") || taskID.Equals ("task3bPlus.1.setB.liqu") || taskID.Equals ("task3bPlus.1.setC.liqu")) {

                checkForFeedbackFollowed ();

                int startNumerator = 0;
                int startDenominator = 0;
                int endNumerator = 0;
                int endDenominator = 0;
                int finalNumerator = 0;
                int finalDenominator = 0;
                int resultNumerator = 0;
                int resultDenominator = 0;

                string representation = "area";

                if (taskID.Equals("task3bPlus.1.setA.area")){
                    startNumerator = 1;
                    startDenominator = 6;
                    endNumerator = 5;
                    endDenominator = 12;
                    finalNumerator = 2;
                    finalDenominator = 12;
                    resultNumerator = 7;
                    resultDenominator = 12;
                    representation = "area";
                }
                else if (taskID.Equals("task3bPlus.1.setB.area")){
                    startNumerator = 2;
                    startDenominator = 3;
                    endNumerator = 2;
                    endDenominator = 9;
                    finalNumerator = 6;
                    finalDenominator = 9;
                    resultNumerator = 8;
                    resultDenominator = 9;
                    representation = "area";
                }
                else if (taskID.Equals("task3bPlus.1.setC.area")){
                    startNumerator = 4;
                    startDenominator = 3;
                    endNumerator = 3;
                    endDenominator = 6;
                    finalNumerator = 8;
                    finalDenominator = 6;
                    resultNumerator = 11;
                    resultDenominator = 6;
                    representation = "number line";
                }
                else if (taskID.Equals("task3bPlus.1.setA.numb")){
                    startNumerator = 1;
                    startDenominator = 6;
                    endNumerator = 5;
                    endDenominator = 12;
                    finalNumerator = 2;
                    finalDenominator = 12;
                    resultNumerator = 7;
                    resultDenominator = 12;
                    representation = "number line";
                }
                else if (taskID.Equals("task3bPlus.1.setB.numb")){
                    startNumerator = 2;
                    startDenominator = 3;
                    endNumerator = 2;
                    endDenominator = 9;
                    finalNumerator = 6;
                    finalDenominator = 9;
                    resultNumerator = 8;
                    resultDenominator = 9;
                    representation = "number line";
                }
                else if (taskID.Equals("task3bPlus.1.setC.numb")){
                    startNumerator = 4;
                    startDenominator = 3;
                    endNumerator = 3;
                    endDenominator = 6;
                    finalNumerator = 8;
                    finalDenominator = 6;
                    resultNumerator = 11;
                    resultDenominator = 6;
                    representation = "number line";
                }
                else if (taskID.Equals("task3bPlus.1.setA.sets")){
                    startNumerator = 1;
                    startDenominator = 6;
                    endNumerator = 5;
                    endDenominator = 12;
                    finalNumerator = 2;
                    finalDenominator = 12;
                    resultNumerator = 7;
                    resultDenominator = 12;
                    representation = "sets";
                }
                else if (taskID.Equals("task3bPlus.1.setB.sets")){
                    startNumerator = 2;
                    startDenominator = 3;
                    endNumerator = 2;
                    endDenominator = 9;
                    finalNumerator = 6;
                    finalDenominator = 9;
                    resultNumerator = 8;
                    resultDenominator = 9;
                    representation = "sets";
                }
                else if (taskID.Equals("task3bPlus.1.setC.sets")){
                    startNumerator = 4;
                    startDenominator = 3;
                    endNumerator = 3;
                    endDenominator = 6;
                    finalNumerator = 8;
                    finalDenominator = 6;
                    resultNumerator = 11;
                    resultDenominator = 6;
                    representation = "sets";
                }
                else if (taskID.Equals("task3bPlus.1.setA.liqu")){
                    startNumerator = 1;
                    startDenominator = 6;
                    endNumerator = 5;
                    endDenominator = 12;
                    finalNumerator = 2;
                    finalDenominator = 12;
                    resultNumerator = 7;
                    resultDenominator = 12;
                    representation = "liquid measures";
                }
                else if (taskID.Equals("task3bPlus.1.setB.liqu")){
                    startNumerator = 2;
                    startDenominator = 3;
                    endNumerator = 2;
                    endDenominator = 9;
                    finalNumerator = 6;
                    finalDenominator = 9;
                    resultNumerator = 8;
                    resultDenominator = 9;
                    representation = "liquid measures";
                }
                else if (taskID.Equals("task3bPlus.1.setC.liqu")){
                    startNumerator = 4;
                    startDenominator = 3;
                    endNumerator = 3;
                    endDenominator = 6;
                    finalNumerator = 8;
                    finalDenominator = 6;
                    resultNumerator = 11;
                    resultDenominator = 6;
                    representation = "liquid measures";
                }

                Fraction currentFraction = studentModel.getCurrentFraction ();

                if (currentFraction != null) {
                    int numerator = currentFraction.getNumerator ();
                    int denominator = currentFraction.getDenominator ();
                    int partition = currentFraction.getPartition ();

                    if (partition != 0) {
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    if ((numerator == 0) && (denominator == 0)) {
                        studentModel.setMessageRule("processEvent-task3b-checkFor-Num-Den-Not-0");
                        currentFeedback = feedbackData.T3bP1S3;
                    }
                    else if (includesSolution(finalNumerator, finalDenominator, endNumerator, endDenominator, resultNumerator, resultDenominator) && studentModel.getAdditionBox()){
                        studentModel.setMessageRule("processEvent-task3b-checkForAddedFraction-Num-Den-AddBox");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.T3bP1E1;
                    }
                    else if (includesSolution(finalNumerator, finalDenominator, endNumerator, endDenominator, resultNumerator, resultDenominator) && !studentModel.getAdditionBox()){
                        studentModel.setMessageRule("processEvent-task3b-checkForAddedFraction-Num-Den");
                        currentFeedback = feedbackData.T3bP1M11;
                    }

                    else if (((denominator == startDenominator) ||  (denominator == endDenominator)) &&
                             (studentModel.getPreviousFeedback().getID().Equals(feedbackData.T3bP1M1.getID ()) ||
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.T3bP1M2.getID ()))){
                        studentModel.setMessageRule("processEvent-task3b-correct-Den-PreviousFeedback-T3bP1M1-T3bP1M2");
                        currentFeedback = feedbackData.T3bP1M4;
                    }

                    else if ((denominator == finalDenominator) && (numerator == finalNumerator) && (partition != 0)){
                        studentModel.setMessageRule("processEvent-task3b-correct-finalNum-finalDen-partition");
                        currentFeedback = feedbackData.T3bP1M10;
                    }

                    else if ((denominator == finalDenominator) && (numerator == finalNumerator)){
                        studentModel.setMessageRule("processEvent-task3b-correct-finalNum-finalDen-no-partition");
                        currentFeedback = feedbackData.T3bP1M10;
                    }

                    else if ((denominator == startDenominator) && (numerator == startNumerator)){
                        studentModel.setMessageRule("processEvent-task3b-correct-startNum-startDen");
                        currentFeedback = feedbackData.T3bP1M8;
                    }

                    else if (denominator == startDenominator){
                        studentModel.setMessageRule("processEvent-task3b-correct-startDen");
                        currentFeedback = feedbackData.T3bP1M7start;
                    }

                    else if (denominator == endDenominator){
                        studentModel.setMessageRule("processEvent-task3b-correct-endDen");
                        currentFeedback = feedbackData.T3bP1M7end;
                    }

                    else if ((numerator == startDenominator) &&
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.T3bP1M1.getID ())){
                        studentModel.setMessageRule("processEvent-task3-Den-PreviousFeedback-T3bP1M1");
                        currentFeedback = feedbackData.T3bP1M5;
                    }

                    else if (numerator == startDenominator){
                        studentModel.setMessageRule("processEvent-task3b-checkFor-Numerator-asDenominator");
                        currentFeedback = feedbackData.T3bP1M2;
                    }

                    else if ((denominator != startDenominator) || (denominator != endDenominator)){
                        studentModel.setMessageRule("processEvent-task3b-checkFor-startDen-endDen");
                        currentFeedback = feedbackData.T3bP1M1;
                    }

                    else if (((numerator != startNumerator) && (denominator != startDenominator)) ||
                             ((numerator != endNumerator) && (denominator != endDenominator))){
                        studentModel.setMessageRule("processEvent-task3b-checkFor-num-Den-notFromSet");
                        currentFeedback = feedbackData.T3bP1M3;
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task3b-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();
            }

            if (taskID.Equals("task3aPlus.1.setA.area") || taskID.Equals("task3aPlus.1.setB.area") || taskID.Equals("task3aPlus.1.setC.area") ||
                taskID.Equals("task3aPlus.1.setA.numb") || taskID.Equals("task3aPlus.1.setB.numb") || taskID.Equals("task3aPlus.1.setC.numb") ||
                taskID.Equals("task3aPlus.1.setA.sets") || taskID.Equals("task3aPlus.1.setB.sets") || taskID.Equals("task3aPlus.1.setC.sets") ||
                taskID.Equals("task3aPlus.1.setA.liqu") || taskID.Equals("task3aPlus.1.setB.liqu") || taskID.Equals("task3aPlus.1.setC.liqu") ){

                checkForFeedbackFollowed ();

                int startNumerator = 0;
                int startDenominator = 0;
                string representation = "area";

                if (taskID.Equals("task3aPlus.1.setA.area")){
                    startNumerator = 3;
                    startDenominator = 5;
                    representation = "area";
                }
                else if (taskID.Equals("task3aPlus.1.setB.area")){
                    startNumerator = 4;
                    startDenominator = 7;
                    representation = "area";
                }
                else if (taskID.Equals("task3aPlus.1.setC.area")){
                    startNumerator = 12;
                    startDenominator = 9;
                    representation = "number line";
                }
                else if (taskID.Equals("task3aPlus.1.setA.numb")){
                    startNumerator = 3;
                    startDenominator = 5;
                    representation = "number line";
                }
                else if (taskID.Equals("task3aPlus.1.setB.numb")){
                    startNumerator = 4;
                    startDenominator = 7;
                    representation = "number line";
                }
                else if (taskID.Equals("task3aPlus.1.setC.numb")){
                    startNumerator = 12;
                    startDenominator = 9;
                    representation = "number line";
                }
                else if (taskID.Equals("task3aPlus.1.setA.sets")){
                    startNumerator = 3;
                    startDenominator = 5;
                    representation = "sets";
                }
                else if (taskID.Equals("task3aPlus.1.setB.sets")){
                    startNumerator = 4;
                    startDenominator = 7;
                    representation = "sets";
                }
                else if (taskID.Equals("task3aPlus.1.setC.sets")){
                    startNumerator = 12;
                    startDenominator = 9;
                    representation = "sets";
                }
                else if (taskID.Equals("task3aPlus.1.setA.liqu")){
                    startNumerator = 3;
                    startDenominator = 5;
                    representation = "liquid measures";
                }
                else if (taskID.Equals("task3aPlus.1.setB.liqu")){
                    startNumerator = 4;
                    startDenominator = 7;
                    representation = "liquid measures";
                }
                else if (taskID.Equals("task3aPlus.1.setC.liqu")){
                    startNumerator = 12;
                    startDenominator = 9;
                    representation = "liquid measures";
                }

                Fraction currentFraction = studentModel.getCurrentFraction ();

                if (currentFraction != null) {
                    int numerator = currentFraction.getNumerator ();
                    int denominator = currentFraction.getDenominator ();
                    int partition = currentFraction.getPartition ();

                    if (partition != 0) {
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    if ((numerator == 0) && (denominator == 0)) {
                        studentModel.setMessageRule("processEvent-task3-checkFor-Num-Den-Not-0");
                        currentFeedback = feedbackData.S3;
                    }

                    //needs to be removed when new rules that include a third fraction of the solution fraction has been added
                    else if (checkForAddedFraction(startNumerator, startDenominator)){
                        studentModel.setMessageRule("processEvent-task3-checkForAddedFraction-Num-Den");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.T3aP1E1;
                    }

                    else if (checkForAddedFraction(startNumerator, startDenominator) && studentModel.getAdditionBox()){
                        studentModel.setMessageRule("processEvent-task3-checkForAddedFraction-Num-Den-AddBox");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.T3aP1E1;
                    }
                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }
                    else if (checkForAddedFraction(startNumerator, startDenominator) && (!studentModel.getAdditionBox())){
                        studentModel.setMessageRule("processEvent-task3-checkForAddedFraction-Num-Den-Not-AddBox");
                        currentFeedback = feedbackData.T3aP1M11;
                    }

                    else if ((numerator == startDenominator) &&
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.T3aP1M1.getID ())){
                        studentModel.setMessageRule("processEvent-task3-Den-PreviousFeedback-T3aP1M1");
                        currentFeedback = feedbackData.T3aP1M5;
                    }

                    else if ((denominator == startDenominator) &&
                             (studentModel.getPreviousFeedback().getID().Equals(feedbackData.T3aP1M1.getID ()) ||
                     studentModel.getPreviousFeedback().getID().Equals(feedbackData.T3aP1M2.getID ()))){
                        studentModel.setMessageRule("processEvent-task3-Den-PreviousFeedback-T3aP1M1-or-T3aP1M2");
                        currentFeedback = feedbackData.T3aP1M4;
                    }

                    else if ((numerator == 0) && (denominator == startDenominator)){
                        studentModel.setMessageRule("processEvent-task3-Num-startDen");
                        currentFeedback = feedbackData.T3aP1M6;
                    }

                    else if (onlyOneFractionCreatedForAddition(startNumerator, startDenominator)){
                        studentModel.setMessageRule("processEvent-task3-onlyOneFractionCreatedForAddition");
                        currentFeedback = feedbackData.T3aP1M7;
                    }

                    //(numerator >= startNumerato) needs to get changed (>) for new rules that include a third fraction of the solution fraction
                    else if ((denominator == startDenominator) && (numerator >= startNumerator)){
                        studentModel.setMessageRule("processEvent-task3-startDen-greater-startNum");
                        currentFeedback = feedbackData.T3aP1M8;
                    }
                    //(numerator >= startNumerato) needs to get changed (>) for new rules that include a third fraction of the solution fraction
                    else if ((denominator != startDenominator) && (numerator >= startNumerator)){
                        studentModel.setMessageRule("processEvent-task3-Not-startDen-greater-startNum");
                        currentFeedback = feedbackData.T3aP1M3;
                    }

                    else if (numerator == startDenominator){
                        studentModel.setMessageRule("processEvent-task3-startDenom");
                        currentFeedback = feedbackData.T3aP1M2;
                    }

                    else if (denominator != startDenominator){
                        studentModel.setMessageRule("processEvent-task3-Not-startDenom");
                        currentFeedback = feedbackData.T3aP1M1;
                    }

                    else {
                        studentModel.setMessageRule("processEvent-task3-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task3-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();

            }

            else if (taskID.Equals("task2.6.setA") || taskID.Equals("task2.6.setB") || taskID.Equals("task2.6.setC")){

                checkForFeedbackFollowed ();

                int startNumerator = 0;
                int startDenominator = 0;
                int endNumerator = 0;
                int endDenominator = 0;

                if (taskID.Equals("task2.6.setA")){
                    startNumerator = 3;
                    startDenominator = 4;
                    endNumerator = 1;
                    endDenominator = 12;
                }
                else if (taskID.Equals("task2.6.setB")){
                    startNumerator = 2;
                    startDenominator = 5;
                    endNumerator = 1;
                    endDenominator = 10;
                }
                else if (taskID.Equals("task2.6.setC")){
                    startNumerator = 7;
                    startDenominator = 3;
                    endNumerator = 1;
                    endDenominator = 21;
                }

                Fraction currentFraction = studentModel.getCurrentFraction ();

                if (currentFraction != null) {
                    int numerator = currentFraction.getNumerator ();
                    int denominator = currentFraction.getDenominator ();
                    int partition = currentFraction.getPartition ();

                    if (partition != 0) {
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    if (currentSetIncludesFraction(startNumerator, startDenominator) &&
                        currentSetIncludesFraction(endNumerator, endDenominator) && studentModel.getComparedFractions()){
                        studentModel.setMessageRule("processEvent-task2.6-task-completed");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.T26E1;
                    }
                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }
                    else if ((numerator == 0) && (denominator == 0)) {
                        studentModel.setMessageRule("processEvent-task2.6-Num-Den-Not-0");
                        currentFeedback = feedbackData.S3;
                    }
                    else if (currentSetIncludesFraction(startNumerator, startDenominator) &&
                             currentSetIncludesFraction(endNumerator, endDenominator) && (studentModel.getComparedFractions() == false)){
                        studentModel.setMessageRule("processEvent-task2.6-correctResult-But-Not-compared");
                        currentFeedback = feedbackData.T26M11;
                    }
                    else if (currentSetIncludesFraction(startNumerator, startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.6-currentSetIncludesFraction-start-Num-Den");
                        currentFeedback = feedbackData.T26M7start;
                    }
                    else if (currentSetIncludesFraction(endNumerator, endDenominator)){
                        studentModel.setMessageRule("processEvent-task2.6-currentSetIncludesFraction-end-Num-Den");
                        currentFeedback = feedbackData.T26M7end;
                    }

                    else if (((denominator == startDenominator) || (denominator == endDenominator)) &&
                             (studentModel.getPreviousFeedback().getID().Equals(feedbackData.T26M1.getID ()) ||
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.T26M2.getID ()))){
                        studentModel.setMessageRule("processEvent-task2.6-startDen-endDen-previousFeedack-T26M1-T26M2");
                        currentFeedback = feedbackData.T26M4;
                    }
                    else if (((numerator == startDenominator) || (numerator == endDenominator)) &&
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.T26M1.getID ())){
                        studentModel.setMessageRule("processEvent-task2.6-startDen-endDen-previousFeedack-T26M1");
                        currentFeedback = feedbackData.T26M5;
                    }
                    else if ((denominator == startDenominator) || (denominator == endDenominator)){
                        studentModel.setMessageRule("processEvent-task2.6-startDen-or-endDen");
                        currentFeedback = feedbackData.T26M6;
                    }
                    else if (sameRepresentations() == false){
                        studentModel.setMessageRule("processEvent-task2.6-Not-sameRepresentations");
                        currentFeedback = feedbackData.T26M8;
                    }
                    else if ((numerator == 0) && ((denominator != startDenominator) || (denominator != endDenominator))){
                        studentModel.setMessageRule("processEvent-task2.6-Num-Not-0-Den-else");
                        currentFeedback = feedbackData.T26M1;
                    }
                    else if ((numerator == startDenominator) || (numerator == endDenominator)){
                        studentModel.setMessageRule("processEvent-task2.6-startDen-or-endDem");
                        currentFeedback = feedbackData.T26M2;
                    }
                    else if ((numerator != 0) &&
                             (((numerator!=startNumerator) && (denominator!=startDenominator)) ||
                     ((numerator!=endNumerator) && (denominator!=endDenominator)))){
                        studentModel.setMessageRule("processEvent-task2.6-Not-startNum-or-endNum-startDen-or-endDem");
                        currentFeedback = feedbackData.T26M3;
                    }

                    else {
                        studentModel.setMessageRule("processEvent-task2.6-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task2.6-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();
            }

            else if (taskID.Equals("task2.4.setA.area") || taskID.Equals("task2.4.setB.area") || taskID.Equals("task2.4.setC.area") ||
                taskID.Equals("task2.4.setA.numb") || taskID.Equals("task2.4.setB.numb") || taskID.Equals("task2.4.setC.numb") ||
                taskID.Equals("task2.4.setA.sets") || taskID.Equals("task2.4.setB.sets") || taskID.Equals("task2.4.setC.sets") ||
                taskID.Equals("task2.4.setA.liqu") || taskID.Equals("task2.4.setB.liqu") || taskID.Equals("task2.4.setC.liqu")){

                checkForFeedbackFollowed ();

                int startNumerator = 0;
                int startDenominator = 0;
                string representation = "area";

                if (taskID.Equals("task2.4.setA.area")){
                    startNumerator = 1;
                    startDenominator = 2;
                }
                else if (taskID.Equals("task2.4.setB.area")){
                    startNumerator = 3;
                    startDenominator = 4;
                }
                else if (taskID.Equals("task2.4.setC.area")){
                    startNumerator = 7;
                    startDenominator = 3;
                }
                else if (taskID.Equals("task2.4.setA.numb")){
                    startNumerator = 1;
                    startDenominator = 2;
                    representation = "number line";
                }
                else if (taskID.Equals("task2.4.setB.numb")){
                    startNumerator = 3;
                    startDenominator = 4;
                    representation = "number line";
                }
                else if (taskID.Equals("task2.4.setC.numb")){
                    startNumerator = 7;
                    startDenominator = 3;
                    representation = "number line";
                }
                else if (taskID.Equals("task2.4.setA.sets")){
                    startNumerator = 1;
                    startDenominator = 2;
                    representation = "sets";
                }
                else if (taskID.Equals("task2.4.setB.sets")){
                    startNumerator = 3;
                    startDenominator = 4;
                    representation = "sets";
                }
                else if (taskID.Equals("task2.4.setC.sets")){
                    startNumerator = 7;
                    startDenominator = 3;
                    representation = "sets";
                }
                else if (taskID.Equals("task2.4.setA.liqu")){
                    startNumerator = 1;
                    startDenominator = 2;
                    representation = "liquid measures";
                }
                else if (taskID.Equals("task2.4.setB.liqu")){
                    startNumerator = 3;
                    startDenominator = 4;
                    representation = "liquid measures";
                }
                else if (taskID.Equals("task2.4.setC.liqu")){
                    startNumerator = 7;
                    startDenominator = 3;
                    representation = "liquid measures";
                }

                Fraction currentFraction = studentModel.getCurrentFraction ();

                if (currentFraction != null) {
                    int numerator = currentFraction.getNumerator ();
                    int denominator = currentFraction.getDenominator ();
                    int partition = currentFraction.getPartition ();

                    if (partition != 0) {
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    Debug.Log (":: numerator: "+numerator);
                    Debug.Log (":: denominator: "+denominator);
                    Debug.Log (":: equivalent: "+equivalent(numerator, denominator, startNumerator, startDenominator));
                    Debug.Log (":: checkCurrentFractionsForEquivalence: "+checkCurrentFractionsForEquivalence(startNumerator, startDenominator));
                    Debug.Log (":: getComparedFractions: "+studentModel.getComparedFractions());
                    Debug.Log (":: getComparedResult: "+studentModel.getComparedResult());

                    if ((numerator == 0) && (denominator == 0)) {
                        studentModel.setMessageRule("processEvent-task2.4-Den-Num-0");
                        currentFeedback = feedbackData.S3;
                    }

                    else if (equivalent(numerator, denominator, startNumerator, startDenominator) &&
                             (studentModel.getCurrentFractions().Count == 1)){
                        studentModel.setMessageRule("processEvent-task2.4-completed-Not-compared");
                        //studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.T24M12;
                    }

                    else if (checkCurrentFractionsForEquivalence(startNumerator, startDenominator) && studentModel.getComparedResult()){
                        studentModel.setMessageRule("processEvent-task2.4-task-completed");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.T24E1;
                    }
                    else if (checkCurrentFractionsForEquivalence(startNumerator, startDenominator) && !studentModel.getComparedResult()){
                        studentModel.setMessageRule("processEvent-task2.4-checkCurrentFractionsForEquivalence-not-compared");
                        currentFeedback = feedbackData.T24M11;
                    }
                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }
                    else if (currentSetContainsEqivalentFraction(startNumerator, startDenominator) &&
                             (!currentSetContainsFraction(startNumerator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-currentSetContainsEqivalentFraction-not-currentSetContainsFraction");
                        currentFeedback = feedbackData.T24M13;
                    }
                    else if ((numerator == startNumerator) && (denominator == startDenominator)) {
                        studentModel.setMessageRule("processEvent-task2.4-startNum-endDenom");
                        currentFeedback = feedbackData.T24M7;
                    }
                    else if ((numerator == 0) && ((denominator == startDenominator) || multiple(denominator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-startDen-multiple");
                        currentFeedback = feedbackData.T24M6;
                    }

                    else if (!equivalent(numerator, denominator, startNumerator, startDenominator) &&
                             ((numerator != 0) && (!multiple(numerator, startNumerator))) &&
                             ((denominator == startDenominator) || multiple(denominator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-startDen-not-multipleNum");
                        currentFeedback = feedbackData.T24M9;
                    }
                    else if (studentModel.getPreviousFeedback().getID().Equals(feedbackData.T24M8.getID ())){
                        studentModel.setMessageRule("processEvent-task2.4-previousFeedback-T24M8");
                        currentFeedback = feedbackData.T24M5;
                    }
                    else if (!equivalent(numerator, denominator, startNumerator, startDenominator) &&
                             ((numerator != 0) && (multiple(numerator, startNumerator))) &&
                             ((denominator == startDenominator) || multiple(denominator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-not-Equivalent-01");
                        currentFeedback = feedbackData.T24M8;
                    }

                    else if (!equivalent(numerator, denominator, startNumerator, startDenominator) &&
                             (numerator == 0)  &&
                             ((denominator == startDenominator) || multiple(denominator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-not-Equivalent-02");
                        currentFeedback = feedbackData.T24M10;
                    }

                    else if (studentModel.getPreviousFeedback().getID().Equals(feedbackData.T24M1.getID ()) &&
                             (numerator == startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.4-previousFeedback-T24M1");
                        currentFeedback = feedbackData.T24M5;
                    }
                    else if (((denominator == startDenominator) || (multiple(denominator, startDenominator))) &&
                            (studentModel.getPreviousFeedback().getID().Equals(feedbackData.T24M1.getID ()) ||
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.T24M2.getID ()))){
                        studentModel.setMessageRule("processEvent-task2.4-previousFeedback-T24M1-or-T24M2");
                        currentFeedback = feedbackData.T24M4;
                    }
                    else if ((denominator != startDenominator) && (!multiple(denominator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-Not-startDen-not-multiple");
                        currentFeedback = feedbackData.T24M1;
                    }
                    else if (numerator == startDenominator){
                        studentModel.setMessageRule("processEvent-task2.4-startDenom");
                        currentFeedback = feedbackData.T24M2;
                    }
                    else if (((numerator != startNumerator) || (denominator != startDenominator)) &&
                             !equivalent(numerator, denominator, startNumerator, startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.4-not-equivalent-all");
                        currentFeedback = feedbackData.T24M3;
                    }
                    else if ((denominator == startDenominator) || (multiple(denominator, startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.4-startDen-multipleDen");
                        currentFeedback = feedbackData.T24M6;
                    }

                    else {
                        studentModel.setMessageRule("processEvent-task2.4-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task2.4-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();
            }

            if (taskID.Equals ("task2.2")) {
                checkForFeedbackFollowed ();

                Fraction currentFraction = studentModel.getCurrentFraction ();

                if (currentFraction != null) {
                    int numerator = currentFraction.getNumerator ();
                    int denominator = currentFraction.getDenominator ();
                    int partition = currentFraction.getPartition ();

                    if (partition != 0) {
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    if ((numerator == 0) && (denominator == 0)) {
                        studentModel.setMessageRule("processEvent-task2.2-Num-Dem-0");
                        currentFeedback = feedbackData.S3;
                    }
                    else if ((denominator != 0) && (numerator == 0)){
                        studentModel.setMessageRule("processEvent-task2.2-Num-Dem-not-0");
                        currentFeedback = feedbackData.F2M1;
                    }
                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }
                    else if ((partition == 0)  && (denominator != 0) && (numerator != 0) &&
                             studentModel.getPreviousFeedback().getID().Equals(feedbackData.F2M1.getID ())){
                        studentModel.setMessageRule("processEvent-task2.2-previousFeedback-F2M1");
                        currentFeedback = feedbackData.F2M4;
                    }
                    else if ((partition == 0)  && (denominator != 0) && (numerator != 0)){
                        studentModel.setMessageRule("processEvent-task2.2-partition-0");
                        currentFeedback = feedbackData.F2M6;
                    }
                    else if ((partition == 2)  && (denominator != 0) && (numerator != 0)){
                        studentModel.setMessageRule("processEvent-task2.2-partition-2");
                        currentFeedback = feedbackData.F2M7;
                    }

                    else if ((partition == 3)  && (denominator != 0) && (numerator != 0)){
                        studentModel.setMessageRule("processEvent-task2.2-partition-3");
                        currentFeedback = feedbackData.F2M7b;
                    }

                    else if ((partition == 4)  && (denominator != 0) && (numerator != 0)){
                        studentModel.setMessageRule("processEvent-task2.2-partition-4");
                        currentFeedback = feedbackData.F2M7c;
                    }

                    else if ((partition >= 5)  && (denominator != 0) && (numerator != 0)){
                        studentModel.setMessageRule("processEvent-task2.2-partition-5");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.F2E1;
                    }
                    else if ((partition != 2) && (partition != 3) && (partition != 4)
                             && (partition < 5) && (partition != 0)){
                        studentModel.setMessageRule("processEvent-task2.2-partition-wrongValue");
                        currentFeedback = feedbackData.F2M11;
                    }
                    else {
                        studentModel.setMessageRule("processEvent-task2.2-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task2.2-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();
            }

            if (taskID.Equals("task2.1")){
                checkForFeedbackFollowed();
                Debug.Log (":::: Hier in Task 2.1 ::: ");

                Fraction currentFraction =studentModel.getCurrentFraction();
                if (currentFraction != null){
                    int numerator = currentFraction.getNumerator();
                    int denominator = currentFraction.getDenominator();
                    int partition = currentFraction.getPartition();

                    if (partition != 0){
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    Debug.Log (":::: numerator: "+numerator);
                    Debug.Log (":::: denominator: "+denominator);
                    Debug.Log (":::: sameRepresentations: "+sameRepresentations());
                    Debug.Log (":::: sameValues: "+sameValues());
                    Debug.Log (":::: createdReps: "+createdReps());
                    Debug.Log (":::: fourWithDiffRepAndSameValues: "+fourWithDiffRepAndSameValues());

                    if ((numerator ==0) && (denominator ==0)){
                        studentModel.setMessageRule("processEvent-task2.1-Num-Den-0");
                        currentFeedback = feedbackData.S3;
                    }
                    //else if (!sameRepresentations() && sameValues() && (createdReps() == 2)){
                    //	currentFeedback = feedbackData.FM10;
                    //}
                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }

                    else if (!sameRepresentations() && sameValues() && (createdReps() < 4)){
                        studentModel.setMessageRule("processEvent-task2.1-not-sameRep-sameValues-reps-less-4");
                        currentFeedback = feedbackData.FM11;
                    }
                    else if (!sameRepresentations() && !sameValues() && (createdReps() > 1)){
                        studentModel.setMessageRule("processEvent-task2.1-not-sameRep-not-sameValues-reps-greater-1");
                        currentFeedback = feedbackData.FM12;
                    }
                    else if (fourWithDiffRepAndSameValues()){
                        studentModel.setMessageRule("processEvent-task2.1-fourWithDiffRepAndSameValues");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.FE1;
                    }
                    //else if (!sameRepresentations() && sameValues() && (createdReps() >= 4)){
                    //	studentModel.setTaskCompleted(true);
                    //	currentFeedback = feedbackData.FE1;
                    //}

                    else if ((numerator !=0) || (denominator !=0)) {
                        studentModel.setMessageRule("processEvent-task2.1-Num-Den-not-0");
                        currentFeedback = feedbackData.FM6;
                    }
                    else {
                        studentModel.setMessageRule("processEvent-task2.1-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task2.1-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();
            }

            if (taskID.Equals("task1.1setA")){
                checkForFeedbackFollowed();

                int firstNumerator = 1;
                int firstDenominator = 3;
                int secondNumerator = 1;
                int secondDenominator = 5;

                bool compared = false;

                Fraction currentFraction =studentModel.getCurrentFraction();

                if (currentFraction != null){
                    int numerator = currentFraction.getNumerator();
                    int denominator = currentFraction.getDenominator();
                    int partition = currentFraction.getPartition();

                    if (partition != 0){
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    if (studentModel.getComparedFractions() && currentSetIncludesFraction(firstNumerator, firstDenominator)
                             && currentSetIncludesFraction(secondNumerator, secondDenominator)){
                        studentModel.setMessageRule("processEvent-task1-task-completed");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.E1;
                    }
                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }
                    else if (!studentModel.getComparedFractions() && currentSetIncludesFraction(firstNumerator, firstDenominator)
                                && currentSetIncludesFraction(secondNumerator, secondDenominator)){
                        studentModel.setMessageRule("processEvent-task1-task-completed-not-compared");
                        //currentFeedback = feedbackData.M13;
                        currentFeedback = feedbackData.CM8;
                    }
                    else if ((numerator ==0) && (denominator ==0)){
                        studentModel.setMessageRule("processEvent-task1-Num-Den-0");
                        currentFeedback = feedbackData.S3;
                    }
                    else if ((denominator != firstDenominator) && (denominator != secondDenominator)
                             && (numerator == 0)){
                        studentModel.setMessageRule("processEvent-task1-Num-0");
                        currentFeedback = feedbackData.M1;
                    }
                    else if ((denominator != firstDenominator) && (denominator != secondDenominator)
                             && (numerator != firstNumerator) && (numerator != secondNumerator)){
                        studentModel.setMessageRule("processEvent-task1-Num-Den-wrongValues");
                        currentFeedback = feedbackData.M3;
                    }
                    else if (numerator == firstDenominator){
                        studentModel.setMessageRule("processEvent-task1-Num-firstDen");
                        currentFeedback = feedbackData.M2;
                    }
                    else if (numerator == secondDenominator){
                        studentModel.setMessageRule("processEvent-task1-Num-SecondDen");
                        currentFeedback = feedbackData.CM2;
                    }
                    else if ((denominator == firstDenominator)
                             && (studentModel.getPreviousFeedback().getID().Equals(feedbackData.M1.getID ())
                        || studentModel.getPreviousFeedback().getID().Equals(feedbackData.M2.getID ()))){
                        studentModel.setMessageRule("processEvent-task1-previousFeedback-M1-or-M2");
                        currentFeedback = feedbackData.M4;
                    }
                    else if ((denominator == secondDenominator)
                             && (studentModel.getPreviousFeedback().getID().Equals(feedbackData.M1.getID ())
                        || studentModel.getPreviousFeedback().getID().Equals(feedbackData.CM2.getID ()))){
                        studentModel.setMessageRule("processEvent-task1-previousFeedback-M1-or-CM2");
                        currentFeedback = feedbackData.M4;
                    }
                    else if ((numerator == firstDenominator) && studentModel.getPreviousFeedback().getID().Equals(feedbackData.M1.getID ())){
                        studentModel.setMessageRule("processEvent-task1-firstDen-previousFeedback-M1");
                        currentFeedback = feedbackData.M5;
                    }
                    else if ((numerator == secondDenominator) && studentModel.getPreviousFeedback().getID().Equals(feedbackData.M1.getID ())){
                        studentModel.setMessageRule("processEvent-task1-SecondDen-previousFeedback-M1");
                        currentFeedback = feedbackData.CM5;
                    }
                    else if ((numerator==firstNumerator) && (denominator == firstDenominator)
                            && !currentSetIncludesFraction(secondNumerator, secondDenominator)){
                        studentModel.setMessageRule("processEvent-task1-firstDen-Not-currentSetIncludesFraction");
                        currentFeedback = feedbackData.CM6Second;
                    }
                    else if ((numerator==secondNumerator) && (denominator == secondDenominator)
                             && !currentSetIncludesFraction(firstNumerator, firstDenominator)){
                        studentModel.setMessageRule("processEvent-task1-secondDen-Not-currentSetIncludesFraction");
                        currentFeedback = feedbackData.CM6;
                    }
                    else if (denominator==secondDenominator
                             && currentSetIncludesFraction(firstNumerator, firstDenominator)){
                        studentModel.setMessageRule("processEvent-task1-secondDen-currentSetIncludesFraction");
                        currentFeedback = feedbackData.CM12;
                    }
                    else if (denominator==firstDenominator){
                        studentModel.setMessageRule("processEvent-task1-firstDen");
                        currentFeedback = feedbackData.CM11;
                    }

                    else {
                        studentModel.setMessageRule("processEvent-task1-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task1-Default-02");
                    currentFeedback = new FeedbackElem();
                }
                setNewFeedback();
            }

            if (taskID.Equals("task2.7.setA") ||taskID.Equals("task2.7.setB") || taskID.Equals("task2.7.setC")){
                checkForFeedbackFollowed();

                Debug.Log ("task2.7.setB or EQUIValence2");
                bool correctSolution = false;
                bool correctDenominator = false;

                int startNumerator = 0;
                int endNumerator = 0;
                int startDenominator = 0;
                int endDenominator = 0;

                if (taskID.Equals("task2.7.setA")){
                    startNumerator = 1;
                    endNumerator = 3;
                    startDenominator = 6;
                    endDenominator = 18;
                }
                else if (taskID.Equals("task2.7.setB")){
                    startNumerator = 3;
                    endNumerator = 9;
                    startDenominator = 4;
                    endDenominator = 12;
                }
                else if (taskID.Equals("task2.7.setC")){
                    startNumerator = 7;
                    endNumerator = 28;
                    startDenominator = 3;
                    endDenominator = 12;
                }

                Fraction currentFraction =studentModel.getCurrentFraction();

                Debug.Log (":::: currentFraction: "+currentFraction);

                if (currentFraction != null){

                    int numerator = currentFraction.getNumerator();
                    int denominator = currentFraction.getDenominator();
                    int partition = currentFraction.getPartition();

                    if (partition != 0){
                        numerator = numerator * partition;
                        denominator = denominator * partition;
                    }

                    Debug.Log (":::: numerator: "+numerator+" denominator: "+denominator);
                    Debug.Log (":::: getComparedResult: "+studentModel.getComparedResult());
                    Debug.Log (":::: currentSetIncludesFraction END: "+currentSetIncludesFraction(endNumerator,endDenominator));
                    Debug.Log (":::: currentSetIncludesFraction START: "+currentSetIncludesFraction(startNumerator,startDenominator));

                    if (!studentModel.getComparedResult() && currentSetIncludesFraction(endNumerator,endDenominator) && currentSetIncludesFraction(startNumerator,startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.7-completed-Not-compared");
                        currentFeedback = feedbackData.M13;
                    }

                    else if (studentModel.getComparedResult() && currentSetIncludesFraction(endNumerator,endDenominator) && currentSetIncludesFraction(startNumerator,startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.7-completed");
                        studentModel.setTaskCompleted(true);
                        currentFeedback = feedbackData.E1;
                    }

                    else if (!belowAmountOfReps(7)){
                        studentModel.setMessageRule("processEvent-tooManyReps");
                        currentFeedback = feedbackData.tooManyReps;
                    }
                    //else if ((numerator == endNumerator) && (denominator == endDenominator)) {
                    //	Debug.Log ("solution found ");
                    //	studentModel.setTaskCompleted(true);
                    //	currentFeedback = feedbackData.E1;
                    //}

                    else if (currentSetIncludesFraction(endNumerator,endDenominator) &&
                             (onlyOneFraction() || (!currentSetIncludesFraction(startNumerator,startDenominator)))){
                        studentModel.setMessageRule("processEvent-task2.7-currentSetIncludesFraction-onlyOneFraction");
                        currentFeedback = feedbackData.M8;
                    }
                    else if (currentSetIncludesFraction(startNumerator,startDenominator) &&
                             ((!onlyOneFraction()) || (!currentSetIncludesFraction(endNumerator,endDenominator)))){
                        studentModel.setMessageRule("processEvent-task2.7-currentSetIncludesFraction-Not-onlyOneFraction");
                        currentFeedback = feedbackData.M9;
                    }

                    else if ((denominator == 0) && (numerator == 0)){
                        studentModel.setMessageRule("processEvent-task2.7-Num-Den-0");
                        currentFeedback = feedbackData.S3;
                    }

                    else if ((numerator != endNumerator) && (denominator == endDenominator) &&
                         (studentModel.getPreviousFeedback().getID().Equals(feedbackData.M1.getID()) ||
                         studentModel.getPreviousFeedback().getID().Equals(feedbackData.M2.getID ()))){
                        studentModel.setMessageRule("processEvent-task2.7-previousFeedback-M1-or-M2");
                        currentFeedback = feedbackData.M4;
                    }

                    else if ((numerator != endNumerator) && (numerator == endDenominator) && studentModel.getPreviousFeedback().getID().Equals(feedbackData.M1.getID())){
                        studentModel.setMessageRule("processEvent-task2.7-previousFeedback-M1");
                        currentFeedback = feedbackData.M5;
                    }

                    else if ((numerator == startNumerator) && (denominator == startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.7-startNum-startDen");
                        currentFeedback = feedbackData.M7;
                    }

                    else if ((numerator != endNumerator) && (denominator == endDenominator) &&
                         studentModel.getPreviousFeedback().getID().Equals(feedbackData.M10.getID ())){
                        studentModel.setMessageRule("processEvent-task2.7-previousFeedback-M11");
                        currentFeedback = feedbackData.M11;
                    }

                    else if ((numerator != endNumerator) && (denominator == endDenominator) &&
                         (!studentModel.getReflectionForDenominatorShown())){
                        studentModel.setMessageRule("processEvent-task2.7-not-getReflectionForDenominatorShown");
                        currentFeedback = feedbackData.M12;
                        studentModel.setReflectionForDenominatorShown(true);
                    }

                    else if ((numerator != endNumerator) && (denominator == endDenominator) && studentModel.getReflectionForDenominatorShown()){
                        studentModel.setMessageRule("processEvent-task2.7-getReflectionForDenominatorShown");
                        currentFeedback = feedbackData.M10;
                    }

                    else if ((numerator != endNumerator) &&
                            ((denominator == endDenominator) || (denominator == startDenominator))){
                        studentModel.setMessageRule("processEvent-task2.7-Num-wrongValue");
                        currentFeedback = feedbackData.M6;
                    }

                    else if ((denominator != endDenominator) && (denominator != startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.7-Den-wrongValue");
                        currentFeedback = feedbackData.M1;
                    }

                    else if ((numerator == endDenominator) || (numerator == startDenominator)){
                        studentModel.setMessageRule("processEvent-task2.7-endDen-startDen");
                        currentFeedback = feedbackData.M2;
                    }

                    else if (((numerator != startNumerator) || (denominator != startDenominator)) && ((numerator != endNumerator) || (denominator != endDenominator))){
                        studentModel.setMessageRule("processEvent-task2.7-Num-Den-wrongValues");
                        currentFeedback = feedbackData.M3;
                    }

                    else {
                        studentModel.setMessageRule("processEvent-task2.7-Default-01");
                        currentFeedback = new FeedbackElem();
                    }
                }
                else {
                    studentModel.setMessageRule("processEvent-task2.7-Default-02");
                    currentFeedback = new FeedbackElem();
                }

                setNewFeedback();

            }
        }
 public void addFeedbackProvided(FeedbackElem elem)
 {
     feedbackProvided.Add (elem);
 }
 public void setPreviousFeedback(FeedbackElem elem)
 {
     previous = elem;
 }
 public void setFeedbackElemViewed(FeedbackElem current)
 {
     viewedFeedback = current;
 }
 public void setCurrentFeedback(FeedbackElem value)
 {
     currentFeedback = value;
 }