class.assClozeGap.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2013 ILIAS open source, Extended GPL, see docs/LICENSE */
 
include_once "./Modules/Test/classes/inc.AssessmentConstants.php";
 
class assClozeGap 
{
 
        var $type;
 
        var $items;
 
        var $shuffle;
        
        private $gap_size = 0;
 
        public function __construct($a_type)
        {
                $this->type = $a_type;
                $this->items = array();
                $this->shuffle = true;
        }
 
        public function getType()
        {
                return $this->type;
        }
 
        public function setType($a_type = 0)
        {
                $this->type = $a_type;
        }
 
        public function getItems(ilArrayElementShuffler $shuffler)
        {
                if ($this->getShuffle())
                {
                        return $shuffler->shuffle($this->items);
                }
                
                return $this->items;
        }
 
        function getItemsRaw()
        {
                return $this->items;
        }
  
        function getItemCount() 
        {
                return count($this->items);
        }
 
        function addItem($a_item) 
        {
                $order = $a_item->getOrder();
                if (array_key_exists($order, $this->items))
                {
                        $newitems = array();
                        for ($i = 0; $i < $order; $i++)
                        {
                                array_push($newitems, $this->items[$i]);
                        }
                        array_push($newitems, $a_item);
                        for ($i = $order; $i < count($this->items); $i++)
                        {
                                array_push($newitems, $this->items[$i]);
                        }
                        $i = 0;
                        foreach ($newitems as $idx => $item)
                        {
                                $newitems[$idx]->setOrder($i);
                                $i++;
                        }
                        $this->items = $newitems;
                }
                else
                {
                        array_push($this->items, $a_item);
                }
        }
 
        function setItemPoints($order, $points) 
        {
                foreach ($this->items as $key => $item)
                {
                        if ($item->getOrder() == $order)
                        {
                                $item->setPoints($points);
                        }
                }
        }
 
        function deleteItem($order) 
        {
                if (array_key_exists($order, $this->items))
                {
                        unset($this->items[$order]);
                        $order = 0;
                        foreach ($this->items as $key => $item)
                        {
                                $this->items[$key]->setOrder($order);
                                $order++;
                        }
                }
        }
 
        function setItemLowerBound($order, $bound) 
        {
                foreach ($this->items as $key => $item)
                {
                        if ($item->getOrder() == $order)
                        {
                                $item->setLowerBound($bound);
                        }
                }
        }
 
        function setItemUpperBound($order, $bound) 
        {
                foreach ($this->items as $key => $item)
                {
                        if ($item->getOrder() == $order)
                        {
                                $item->setUpperBound($bound);
                        }
                }
        }
 
        function getItem($a_index) 
        {
                if (array_key_exists($a_index, $this->items))
                {
                        return $this->items[$a_index];
                }
                else
                {
                        return NULL;
                }
        }
 
        function clearItems() 
        {
                $this->items = array();
        }
 
        public function setShuffle($a_shuffle = true)
        {
                $this->shuffle = (bool) $a_shuffle;
        }
 
        public function getShuffle()
        {
                return $this->shuffle;
        }
 
        function getMaxWidth()
        {
                $maxwidth = 0;
                foreach ($this->items as $item)
                {
                        if (strlen($item->getAnswertext()) > $maxwidth)
                        {
                                $maxwidth = strlen($item->getAnswertext());
                        }
                }
                return $maxwidth;
        }
        
        function getBestSolutionIndexes()
        {
                $maxpoints = 0;
                foreach ($this->items as $key => $item)
                {
                        if ($item->getPoints() > $maxpoints)
                        {
                                $maxpoints = $item->getPoints();
                        }
                }
                $keys = array();
                foreach ($this->items as $key => $item)
                {
                        if ($item->getPoints() == $maxpoints)
                        {
                                array_push($keys, $key);
                        }
                }
                return $keys;
        }
 
        function getBestSolutionOutput(ilArrayElementShuffler $shuffler, $combinations = null)
        {
                global $lng;
                switch ($this->getType())
                {
                        case CLOZE_TEXT:
                        case CLOZE_SELECT:
                                $best_solutions = array();
                                if($combinations !== null && $combinations['best_solution'] == 1)
                                {
                                        $best_solutions[$combinations['points']] = array();
                                        array_push($best_solutions[$combinations['points']], $combinations['answer']);
                                }
                                else
                                {
                                        foreach ($this->getItems($shuffler) as $answer)
                                        {
                                                if (isset($best_solutions[$answer->getPoints()]) && is_array($best_solutions[$answer->getPoints()]))
                                                {
                                                        array_push($best_solutions[$answer->getPoints()], $answer->getAnswertext());
                                                }
                                                else
                                                {
                                                        $best_solutions[$answer->getPoints()] = array();
                                                        array_push($best_solutions[$answer->getPoints()], $answer->getAnswertext());
                                                }
                                        }
                                }
                                
                                krsort($best_solutions, SORT_NUMERIC);
                                reset($best_solutions);
                                $found = current($best_solutions);
                                return join(" " . $lng->txt("or") . " ", $found);
                                break;
                        case CLOZE_NUMERIC:
                                $maxpoints = 0;
                                $foundvalue = "";
                                foreach ($this->getItems($shuffler) as $answer)
                                {
                                        if ($answer->getPoints() >= $maxpoints)
                                        {
                                                $maxpoints = $answer->getPoints();
                                                $foundvalue = $answer->getAnswertext();
                                        }
                                }
                                return $foundvalue;
                                break;
                        default:
                                return "";
                }
        }
 
        public function setGapSize( $gap_size)
        {
                $this->gap_size = $gap_size;
        }
 
        public function getGapSize()
        {
                return $this->gap_size;
        }
}