class.ilObjGlossaryGUI.php

Go to the documentation of this file.

<?php

/* Copyright (c) 1998-2012 ILIAS open source, Extended GPL, see docs/LICENSE */

require_once("./Services/Object/classes/class.ilObjectGUI.php");
require_once("./Modules/Glossary/classes/class.ilObjGlossary.php");
require_once("./Modules/Glossary/classes/class.ilGlossaryTermGUI.php");
require_once("./Modules/Glossary/classes/class.ilGlossaryDefinition.php");
require_once("./Modules/Glossary/classes/class.ilTermDefinitionEditorGUI.php");
require_once("./Services/COPage/classes/class.ilPCParagraph.php");

class ilObjGlossaryGUI extends ilObjectGUI
{
        var $admin_tabs;
        var $mode;
        var $term;

        protected $term_id;

        protected $ctrl;

        protected $user;

        protected $toolbar;

        protected $tabs;

        protected $setting;

        protected $access;

        protected $rbacsystem;

        protected $help;

        protected $term_perm;

        protected $log;

        function __construct($a_data,$a_id = 0,$a_call_by_reference = true, $a_prepare_output = true)
        {
                global $DIC;

                $this->ctrl = $DIC->ctrl();
                $this->lng = $DIC->language();
                $this->user = $DIC->user();
                $this->toolbar = $DIC->toolbar();
                $this->tabs = $DIC->tabs();
                $this->setting = $DIC["ilSetting"];
                $this->access = $DIC->access();
                $this->rbacsystem = $DIC->rbac()->system();
                $this->help = $DIC["ilHelp"];

                $this->log = ilLoggerFactory::getLogger('glo');

                include_once("./Modules/Glossary/classes/class.ilGlossaryTermPermission.php");
                $this->term_perm = ilGlossaryTermPermission::getInstance();

                $this->ctrl->saveParameter($this, array("ref_id", "offset"));

                $this->lng->loadLanguageModule("content");
                $this->lng->loadLanguageModule("glo");
                
                $this->type = "glo";
                parent::__construct($a_data, $a_id, $a_call_by_reference, false);
                
                // determine term id and check whether it is valid (belongs to
                // current glossary)
                $this->term_id = (int) $_GET["term_id"];
                $term_glo_id = ilGlossaryTerm::_lookGlossaryID($this->term_id);
                include_once("./Modules/Glossary/classes/class.ilGlossaryTermReferences.php");
                if ($this->term_id > 0 && $term_glo_id != $this->object->getId()
                        && !ilGlossaryTermReferences::isReferenced($this->object->getId(), $this->term_id))
                {
                        $this->term_id = "";
                }

                $this->tax_id = $this->object->getTaxonomyId();
                if ($this->tax_id > 0)
                {
                        $this->ctrl->saveParameter($this, array("show_tax", "tax_node"));
                        
                        include_once("./Services/Taxonomy/classes/class.ilObjTaxonomy.php");
                        $this->tax = new ilObjTaxonomy($this->tax_id);
                }
                if ((int) $_GET["tax_node"] > 1 && $this->tax->getTree()->readRootId() != $_GET["tax_node"])
                {
                        $this->tax_node = (int) $_GET["tax_node"];
                }
        }

        function executeCommand()
        {
                $cmd = $this->ctrl->getCmd();
                $next_class = $this->ctrl->getNextClass($this);

                $this->log->debug("glossary term, next class ".$next_class.", cmd: ".$cmd);

                switch ($next_class)
                {
                        case 'ilobjectmetadatagui';
                                $this->checkPermission("write");
                                
                                $this->getTemplate();
                                $this->setTabs();
                                $this->setLocator();
                                $this->addHeaderAction();

                                $this->tabs_gui->activateTab('meta_data');
                                include_once 'Services/Object/classes/class.ilObjectMetaDataGUI.php';
                                $md_gui = new ilObjectMetaDataGUI($this->object, 'term');       
                                $this->ctrl->forwardCommand($md_gui);
                                break;
                        
                        case "ilglossarytermgui":
                                if (!$this->term_perm->checkPermission("edit_content", $this->term_id) &&
                                        !$this->term_perm->checkPermission("write", $this->term_id))
                                {
                                        include_once("./Modules/Glossary/exceptions/class.ilGlossaryException.php");
                                        throw new ilGlossaryException("No permission.");
                                }
                                $this->getTemplate();
//                              $this->quickList();
                                $this->ctrl->setReturn($this, "listTerms");
                                $term_gui = new ilGlossaryTermGUI($this->term_id);
                                $term_gui->setGlossary($this->object);
                                //$ret = $term_gui->executeCommand();
                                $ret = $this->ctrl->forwardCommand($term_gui);
                                break;
                                
                        case "ilinfoscreengui":
                                $this->addHeaderAction();
                                $this->showInfoScreen();
                                break;
                                
                        case "ilobjstylesheetgui":
                                include_once ("./Services/Style/Content/classes/class.ilObjStyleSheetGUI.php");
                                $this->ctrl->setReturn($this, "editStyleProperties");
                                $style_gui = new ilObjStyleSheetGUI("", $this->object->getStyleSheetId(), false, false);
                                $style_gui->omitLocator();
                                if ($cmd == "create" || $_GET["new_type"]=="sty")
                                {
                                        $style_gui->setCreationMode(true);
                                }

                                if ($cmd == "confirmedDelete")
                                {
                                        $this->object->setStyleSheetId(0);
                                        $this->object->update();
                                }

                                $ret = $this->ctrl->forwardCommand($style_gui);

                                if ($cmd == "save" || $cmd == "copyStyle" || $cmd == "importStyle")
                                {
                                        $style_id = $ret;
                                        $this->object->setStyleSheetId($style_id);
                                        $this->object->update();
                                        $this->ctrl->redirectByClass("ilobjstylesheetgui", "edit");
                                }
                                break;

                                
                        case 'ilpermissiongui':
                                if (strtolower($_GET["baseClass"]) == "iladministrationgui")
                                {
                                        $this->prepareOutput();
                                }
                                else
                                {
                                        $this->getTemplate();
                                        $this->setTabs();
                                        $this->setLocator();
                                        $this->addHeaderAction();
                                }
                                include_once("Services/AccessControl/classes/class.ilPermissionGUI.php");
                                $perm_gui = new ilPermissionGUI($this);
                                $ret = $this->ctrl->forwardCommand($perm_gui);
                                break;
                                
                        case "ilcommonactiondispatchergui":
                                include_once("Services/Object/classes/class.ilCommonActionDispatcherGUI.php");
                                $gui = ilCommonActionDispatcherGUI::getInstanceFromAjaxCall();
                                $this->ctrl->forwardCommand($gui);
                                break;

                        case "ilobjtaxonomygui":
                                $this->getTemplate();
                                $this->setTabs();
                                $this->setLocator();
                                $this->addHeaderAction();
                                $this->tabs->activateTab("settings");
                                $this->setSettingsSubTabs("taxonomy");

                                include_once("./Services/Taxonomy/classes/class.ilObjTaxonomyGUI.php");
                                $this->ctrl->setReturn($this, "properties");
                                $tax_gui = new ilObjTaxonomyGUI();
                                $tax_gui->setMultiple(false);
                                
                                /*include_once("./Modules/Glossary/classes/class.ilTermTaxInfo.php");
                                $term_info = new ilTermTaxInfo();*/
                                //$tax_gui->activateAssignedItemSorting($term_info, "glo", "term");
                                
                                $tax_gui->setAssignedObject($this->object->getId());
                                $ret = $this->ctrl->forwardCommand($tax_gui);
                                break;

                        case "ilexportgui":
                                $this->getTemplate();
                                $this->setTabs();
                                $this->tabs->activateTab("export");
                                $this->setLocator();
                                include_once("./Services/Export/classes/class.ilExportGUI.php");
                                $exp_gui = new ilExportGUI($this);
                                //$exp_gui->addFormat("xml", "", $this, "export");
                                $exp_gui->addFormat("xml");
                                $exp_gui->addFormat("html", "", $this, "exportHTML");
                                $exp_gui->addCustomColumn($this->lng->txt("cont_public_access"),
                                                $this, "getPublicAccessColValue");
                                $exp_gui->addCustomMultiCommand($this->lng->txt("cont_public_access"),
                                                $this, "publishExportFile");
                                $ret = $this->ctrl->forwardCommand($exp_gui);
                                break;

                        case 'ilobjectcopygui':
                                $this->prepareOutput();
                                include_once './Services/Object/classes/class.ilObjectCopyGUI.php';
                                $cp = new ilObjectCopyGUI($this);
                                $cp->setType('glo');
                                $this->ctrl->forwardCommand($cp);
                                break;

                        case "ilglossaryforeigntermcollectorgui":
                                $this->ctrl->setReturn($this, "");
                                $this->getTemplate();
                                $this->setTabs();
                                $this->setLocator();
                                $this->addHeaderAction();
                                include_once("./Modules/Glossary/classes/class.ilGlossaryForeignTermCollectorGUI.php");
                                $coll = ilGlossaryForeignTermCollectorGUI::getInstance($this);
                                $this->ctrl->forwardCommand($coll);
                                break;

                        default:                                
                                $cmd = $this->ctrl->getCmd("listTerms");

                                if (($cmd == "create") && ($_POST["new_type"] == "term"))
                                {
                                        $this->ctrl->setCmd("create");
                                        $this->ctrl->setCmdClass("ilGlossaryTermGUI");
                                        $ret = $this->executeCommand();
                                        return;
                                }
                                else
                                {
                                        if (!in_array($cmd, array("quickList")))
                                        {
                                                if (strtolower($_GET["baseClass"]) == "iladministrationgui" ||
                                                        $this->getCreationMode() == true)
                                                {
                                                        $this->prepareOutput();
                                                        $cmd.= "Object";
                                                }
                                                else
                                                {
                                                        $this->getTemplate();
                                                        $this->setTabs();
                                                        $this->setLocator();
                                                        $this->addHeaderAction();
                                                        
                                                        if($cmd == "redrawHeaderAction")
                                                        {
                                                                $cmd = "redrawHeaderActionObject";
                                                        }
                                                }
                                        }
                                        $ret = $this->$cmd();
                                }
                                break;
                }

                if (!in_array($cmd, array("quickList")))
                {
                        if (strtolower($_GET["baseClass"]) != "iladministrationgui")
                        {
                                if (!$this->getCreationMode())
                                {
                                        $this->tpl->show();
                                }
                        }
                }
                else
                {
                        $this->tpl->show(false);
                }
        }

        function assignObject()
        {
                include_once("./Modules/Glossary/classes/class.ilObjGlossary.php");

                $this->object = new ilObjGlossary($this->id, true);
        }

        /*protected function initCreationForms($a_new_type)
        {
                $forms = array(
                        self::CFORM_NEW => $this->initCreateForm($a_new_type),
                        self::CFORM_IMPORT => $this->initImportForm($a_new_type)
                        );

                return $forms;
        }*/

    function initCreateForm($a_new_type)
        {
                include_once("Services/Form/classes/class.ilPropertyFormGUI.php");
                $form = new ilPropertyFormGUI();
                $form->setTarget("_top");
                $form->setFormAction($this->ctrl->getFormAction($this));
                $form->setTitle($this->lng->txt($a_new_type."_new"));

                // title
                $ti = new ilTextInputGUI($this->lng->txt("title"), "title");
                $ti->setSize(min(40, ilObject::TITLE_LENGTH));
                $ti->setMaxLength(ilObject::TITLE_LENGTH);
                $ti->setRequired(true);
                $form->addItem($ti);

                // description
                $ta = new ilTextAreaInputGUI($this->lng->txt("description"), "desc");
                $ta->setCols(40);
                $ta->setRows(2);
                $form->addItem($ta);

                // mode
                $stati  = array(
                                                "none"=>$this->lng->txt("glo_mode_normal"),
                                                "level"=>$this->lng->txt("glo_mode_level"),
                                                "subtree"=>$this->lng->txt("glo_mode_subtree")
                                                );
                $tm = new ilSelectInputGUI($this->lng->txt("glo_mode"), "glo_mode");
                $tm->setOptions($stati);
                $tm->setInfo($this->lng->txt("glo_mode_desc"));
                $tm->setRequired(true);
                $form->addItem($tm);

                $form->addCommandButton("save", $this->lng->txt($a_new_type."_add"));
                $form->addCommandButton("cancel", $this->lng->txt("cancel"));

                return $form;
        }
        
        function importObject()
        {
                $this->createObject();
        }

        function saveObject()
        {
                $new_type = $_REQUEST["new_type"];

                // create permission is already checked in createObject. This check here is done to prevent hacking attempts
                if (!$this->checkPermissionBool("create", "", $new_type))
                {
                        $this->ilias->raiseError($this->lng->txt("no_create_permission"), $this->ilias->error_obj->MESSAGE);
                }

                $this->lng->loadLanguageModule($new_type);
                $this->ctrl->setParameter($this, "new_type", $new_type);

                $form = $this->initCreateForm($new_type);
                if ($form->checkInput())
                {
                        $this->ctrl->setParameter($this, "new_type", "");

                        include_once("./Modules/Glossary/classes/class.ilObjGlossary.php");
                        $newObj = new ilObjGlossary();
                        $newObj->setType($new_type);
                        $newObj->setTitle($form->getInput("title"));
                        $newObj->setDescription($form->getInput("desc"));
                        $newObj->setVirtualMode($form->getInput("glo_mode"));
                        $newObj->create();
                        
                        $this->putObjectInTree($newObj);

                        // always send a message
                        ilUtil::sendSuccess($this->lng->txt("glo_added"),true);
                        ilUtil::redirect("ilias.php?baseClass=ilGlossaryEditorGUI&ref_id=".$newObj->getRefId());
                }

                // display only this form to correct input
                $form->setValuesByPost();
                $this->tpl->setContent($form->getHtml());
        }

        function showInfoScreen()
        {
                $this->getTemplate();
                $this->setTabs();
                $this->setLocator();
                $this->lng->loadLanguageModule("meta");
                include_once("./Services/InfoScreen/classes/class.ilInfoScreenGUI.php");

                $info = new ilInfoScreenGUI($this);
                $info->enablePrivateNotes();
                $info->enableNews();
                if ($this->access->checkAccess("write", "", $_GET["ref_id"]))
                {
                        $info->enableNewsEditing();
                        $news_set = new ilSetting("news");
                        $enable_internal_rss = $news_set->get("enable_rss_for_internal");
                        if ($enable_internal_rss)
                        {
                                $info->setBlockProperty("news", "settings", true);
                        }
                }
                $info->addMetaDataSections($this->object->getId(),0, $this->object->getType());
                
                ilObjGlossaryGUI::addUsagesToInfo($info, $this->object->getId());
                
                $this->ctrl->forwardCommand($info);
        }
        
        static function addUsagesToInfo($info, $glo_id)
        {
                global $lng, $ilAccess;

                $info->addSection($lng->txt("glo_usages"));
                include_once("./Modules/ScormAicc/classes/class.ilObjSAHSLearningModule.php");
                $sms = ilObjSAHSLearningModule::getScormModulesForGlossary($glo_id);
                foreach ($sms as $sm)
                {
                        $link = false;
                        $refs = ilObject::_getAllReferences($sm);
                        foreach ($refs as $ref)
                        {
                                if ($link === false)
                                {
                                        if ($ilAccess->checkAccess("write", "", $ref))
                                        {
                                                include_once("./Services/Link/classes/class.ilLink.php");
                                                $link = ilLink::_getLink($ref,'sahs');
                                        }
                                }
                        }
                        
                        $entry = ilObject::_lookupTitle($sm);
                        if ($link !== false)
                        {
                                $entry = "<a href='".$link."' target='_top'>".$entry."</a>";
                        }
                        
                        $info->addProperty($lng->txt("obj_sahs"), $entry);
                }
        }
        
        
        function viewObject()
        {
                if (strtolower($_GET["baseClass"]) == "iladministrationgui")
                {
                        parent::viewObject();
                        return;
                }

                if (!$this->rbacsystem->checkAccess("visible,read",$this->object->getRefId()))
                {
                        $this->ilias->raiseError($this->lng->txt("permission_denied"),$this->ilias->error_obj->MESSAGE);
                }

        }

        function properties()
        {
                $this->checkPermission("write");

                $this->setSettingsSubTabs("general_settings");
                
                $this->initSettingsForm();
                
                // Edit ecs export settings
                include_once 'Modules/Glossary/classes/class.ilECSGlossarySettings.php';
                $ecs = new ilECSGlossarySettings($this->object);                
                $ecs->addSettingsToForm($this->form, 'glo');

                $this->tpl->setContent($this->form->getHTML());
        }

        public function initSettingsForm($a_mode = "edit")
        {
                include_once("Services/Form/classes/class.ilPropertyFormGUI.php");
                $this->form = new ilPropertyFormGUI();

                // title
                $title = new ilTextInputGUI($this->lng->txt("title"), "title");
                $title->setRequired(true);
                $this->form->addItem($title);

                // description
                $desc = new ilTextAreaInputGUI($this->lng->txt("desc"), "description");
                $this->form->addItem($desc);

                $this->lng->loadLanguageModule("rep");
                $section = new ilFormSectionHeaderGUI();
                $section->setTitle($this->lng->txt('rep_activation_availability'));
                $this->form->addItem($section);

                // online
                $online = new ilCheckboxInputGUI($this->lng->txt("cont_online"), "cobj_online");
                $online->setValue("y");
                $online->setInfo($this->lng->txt("glo_online_info"));
                $this->form->addItem($online);

                $section = new ilFormSectionHeaderGUI();
                $section->setTitle($this->lng->txt('glo_content_settings'));
                $this->form->addItem($section);

                // glossary mode
                $glo_mode = new ilRadioGroupInputGUI($this->lng->txt("glo_mode"), "glo_mode");
                //$glo_mode->setInfo($this->lng->txt("glo_mode_desc"));
                        $op1 = new ilRadioOption($this->lng->txt("glo_mode_normal"), "none",$this->lng->txt("glo_mode_normal_info"));
                        $glo_mode->addOption($op1);
                        $op2 = new ilRadioOption($this->lng->txt("glo_mode_level"), "level",$this->lng->txt("glo_mode_level_info"));
                        $glo_mode->addOption($op2);
                        $op3 = new ilRadioOption($this->lng->txt("glo_mode_subtree"), "subtree",$this->lng->txt("glo_mode_subtree_info"));
                        $glo_mode->addOption($op3);
                $this->form->addItem($glo_mode);

                // glossary mode
                /*$options = array(
                        "none"=>$this->lng->txt("glo_mode_normal"),
                        "level"=>$this->lng->txt("glo_mode_level"),
                        "subtree"=>$this->lng->txt("glo_mode_subtree")
                        );
                $glo_mode = new ilSelectInputGUI($this->lng->txt("glo_mode"), "glo_mode");
                $glo_mode->setOptions($options);
                $glo_mode->setInfo($this->lng->txt("glo_mode_desc"));
                $this->form->addItem($glo_mode);*/


                $section = new ilFormSectionHeaderGUI();
                $section->setTitle($this->lng->txt('cont_presentation'));
                $this->form->addItem($section);

                // presentation mode
                $pres_mode = new ilRadioGroupInputGUI($this->lng->txt("glo_presentation_mode"), "pres_mode");
                $pres_mode->setValue("table");
                $op1 = new ilRadioOption($this->lng->txt("glo_table_form"), "table", $this->lng->txt("glo_table_form_info"));

                        // short text length
                        $snl = new ilNumberInputGUI($this->lng->txt("glo_text_snippet_length"), "snippet_length");
                        $snl->setMaxValue(3000);
                        $snl->setMinValue(100);
                        $snl->setMaxLength(4);
                        $snl->setSize(4);
                        $snl->setInfo($this->lng->txt("glo_text_snippet_length_info"));
                        $snl->setValue(200);
                        $op1->addSubItem($snl);

                $pres_mode->addOption($op1);
                $op2 = new ilRadioOption($this->lng->txt("glo_full_definitions"), "full_def", $this->lng->txt("glo_full_definitions_info"));
                $pres_mode->addOption($op2);
                $this->form->addItem($pres_mode);

                // show taxonomy
                include_once("./Services/Taxonomy/classes/class.ilObjTaxonomy.php");
                $tax_ids = ilObjTaxonomy::getUsageOfObject($this->object->getId());
                if (count($tax_ids) > 0)
                { 
                        $show_tax = new ilCheckboxInputGUI($this->lng->txt("glo_show_taxonomy"), "show_tax");
                        $show_tax->setInfo($this->lng->txt("glo_show_taxonomy_info"));
                        $this->form->addItem($show_tax);
                }
                
                // downloads
                $down = new ilCheckboxInputGUI($this->lng->txt("cont_downloads"), "glo_act_downloads");
                $down->setValue("y");
                $down->setInfo($this->lng->txt("cont_downloads_desc"));
                $this->form->addItem($down);
                
                if ($a_mode == "edit")
                {
                        $title->setValue($this->object->getTitle());
                        $desc->setValue($this->object->getDescription());
                        $online->setChecked($this->object->getOnline());
                        $glo_mode->setValue($this->object->getVirtualMode());
                        $pres_mode->setValue($this->object->getPresentationMode());
                        $snl->setValue($this->object->getSnippetLength());
                        if (count($tax_ids) > 0)
                        {
                                $show_tax->setChecked($this->object->getShowTaxonomy());
                        }
                        
                        $down->setChecked($this->object->isActiveDownloads());
                        
                        // additional features
                        $feat = new ilFormSectionHeaderGUI();
                        $feat->setTitle($this->lng->txt('obj_features'));
                        $this->form->addItem($feat);

                        include_once './Services/Container/classes/class.ilContainer.php';
                        include_once './Services/Object/classes/class.ilObjectServiceSettingsGUI.php';
                        ilObjectServiceSettingsGUI::initServiceSettingsForm(
                                        $this->object->getId(),
                                        $this->form,
                                        array(                                          
                                                ilObjectServiceSettingsGUI::CUSTOM_METADATA
                                        )
                                );              
                }               
                
                // sort columns, if adv fields are given
                include_once("./Modules/Glossary/classes/class.ilGlossaryAdvMetaDataAdapter.php");
                $adv_ap = new ilGlossaryAdvMetaDataAdapter($this->object->getId());
                $cols = $adv_ap->getColumnOrder();
                if (count($cols) > 1)
                {
                        include_once './Modules/Glossary/classes/class.ilGloAdvColSortInputGUI.php';
                        $ti = new ilGloAdvColSortInputGUI($this->lng->txt("cont_col_ordering"), "field_order");
                        $this->form->addItem($ti);
                        $ti->setValue($cols);
                }
        
                // save and cancel commands
                $this->form->addCommandButton("saveProperties", $this->lng->txt("save"));
                                        
                $this->form->setTitle($this->lng->txt("cont_glo_properties"));
                $this->form->setFormAction($this->ctrl->getFormAction($this));
        }       


        function saveProperties()
        {
                $this->initSettingsForm();
                if ($this->form->checkInput())
                {
                        $this->object->setTitle($_POST['title']);
                        $this->object->setDescription($_POST['description']);
                        $this->object->setOnline(ilUtil::yn2tf($_POST["cobj_online"]));
                        $this->object->setVirtualMode($_POST["glo_mode"]);
//                      $this->object->setActiveGlossaryMenu(ilUtil::yn2tf($_POST["glo_act_menu"]));
                        $this->object->setActiveDownloads(ilUtil::yn2tf($_POST["glo_act_downloads"]));
                        $this->object->setPresentationMode($_POST["pres_mode"]);
                        $this->object->setSnippetLength($_POST["snippet_length"]);
                        $this->object->setShowTaxonomy($_POST["show_tax"]);
                        $this->object->update();

                        // field order of advanced metadata
                        include_once("./Modules/Glossary/classes/class.ilGlossaryAdvMetaDataAdapter.php");
                        $adv_ap = new ilGlossaryAdvMetaDataAdapter($this->object->getId());
                        $cols = $adv_ap->getColumnOrder();
                        if (count($cols) > 1)
                        {
                                $adv_ap->saveColumnOrder($_POST["field_order"]);
                        }
                        
                        // set definition short texts dirty
                        include_once("./Modules/Glossary/classes/class.ilGlossaryDefinition.php");
                        ilGlossaryDefinition::setShortTextsDirty($this->object->getId());

                        include_once './Services/Object/classes/class.ilObjectServiceSettingsGUI.php';
                        ilObjectServiceSettingsGUI::updateServiceSettingsForm(
                                $this->object->getId(),
                                $this->form,
                                array(
                                        ilObjectServiceSettingsGUI::CUSTOM_METADATA
                                )
                        );
                        
                        // Update ecs export settings
                        include_once 'Modules/Glossary/classes/class.ilECSGlossarySettings.php';        
                        $ecs = new ilECSGlossarySettings($this->object);                        
                        if($ecs->handleSettingsUpdate())
                        {
                                ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"), true);
                                $this->ctrl->redirect($this, "properties");
                        }
                        
                }
                $this->form->setValuesByPost();
                $this->tpl->setContent($this->form->getHTML());
        }


        function listTerms()
        {
                if ($_GET["show_tax"])
                {
                        $this->showTaxonomy();
                }
                
                // term
                include_once("./Services/Form/classes/class.ilTextInputGUI.php");
                $ti = new ilTextInputGUI($this->lng->txt("cont_new_term"), "new_term");
                $ti->setMaxLength(80);
                $ti->setSize(20);
                $this->toolbar->addInputItem($ti, true);
                
                // language
                $this->lng->loadLanguageModule("meta");
                $lang = ilMDLanguageItem::_getLanguages();
                if ($_SESSION["il_text_lang_".$_GET["ref_id"]] != "")
                {
                        $s_lang = $_SESSION["il_text_lang_".$_GET["ref_id"]];
                }
                else
                {
                        $s_lang = $this->user->getLanguage();
                }
                include_once("./Services/Form/classes/class.ilSelectInputGUI.php");
                $si = new ilSelectInputGUI($this->lng->txt("language"), "term_language");
                $si->setOptions($lang);
                $si->setValue($s_lang);
                $this->toolbar->addInputItem($si, true);

                $this->toolbar->setFormAction($this->ctrl->getFormAction($this));
                $this->toolbar->addFormButton($this->lng->txt("glo_add_new_term"), "addTerm");

                $this->toolbar->addSeparator();

                //ilEditClipboard::getAction() == "copy"
                include_once("./Modules/LearningModule/classes/class.ilEditClipboard.php");
                if ($this->user->clipboardHasObjectsOfType("term"))
                {
                        $this->toolbar->addButton($this->lng->txt("paste"),
                                $this->ctrl->getLinkTarget($this, "pasteTerms"));
                        $this->toolbar->addButton($this->lng->txt("clear_clipboard"),
                                $this->ctrl->getLinkTarget($this, "clearClipboard"));
                }
                else
                {
                        $this->toolbar->addButton($this->lng->txt("glo_add_from_other"),
                                $this->ctrl->getLinkTargetByClass("ilglossaryforeigntermcollectorgui", ""));
                }

                if (is_object($this->tax))
                {
                        $this->toolbar->addSeparator();
                        if ($_GET["show_tax"])
                        {
                                $this->toolbar->addButton($this->lng->txt("glo_hide_taxonomy"),
                                        $this->ctrl->getLinkTarget($this, "deactTaxonomy"));
                        }
                        else
                        {
                                $this->toolbar->addButton($this->lng->txt("glo_show_taxonomy"),
                                        $this->ctrl->getLinkTarget($this, "actTaxonomy"));
                        }
                }

                include_once("./Modules/Glossary/classes/class.ilTermListTableGUI.php");
                $tab = new ilTermListTableGUI($this, "listTerms", $this->tax_node);
                $this->tpl->setContent($tab->getHTML());
        }

        function actTaxonomy()
        {
                $this->ctrl->setParameter($this, "show_tax", 1);
                $this->ctrl->redirect($this, "listTerms");
        }

        function deactTaxonomy()
        {
                $this->ctrl->setParameter($this, "show_tax", "");
                $this->ctrl->redirect($this, "listTerms");
        }

        
        function showActions($a_actions)
        {
                foreach ($a_actions as $name => $lng)
                {
                        $d[$name] = array("name" => $name, "lng" => $lng);
                }

                $notoperations = array();
                $operations = array();

                $operations = $d;

                if (count($operations) > 0)
                {
                        foreach ($operations as $val)
                        {
                                $this->tpl->setCurrentBlock("tbl_action_btn");
                                $this->tpl->setVariable("BTN_NAME", $val["name"]);
                                $this->tpl->setVariable("BTN_VALUE", $this->lng->txt($val["lng"]));
                                $this->tpl->parseCurrentBlock();
                        }

                        $this->tpl->setCurrentBlock("tbl_action_row");
                        $this->tpl->setVariable("IMG_ARROW",ilUtil::getImagePath("arrow_downright.svg"));
                        $this->tpl->parseCurrentBlock();
                }
        }

        function addTerm()
        {
                if (trim($_POST["new_term"]) == "")
                {
                        ilUtil::sendFailure($this->lng->txt("cont_please_enter_a_term"), true);
                        $this->ctrl->redirect($this, "listTerms");
                }
                
                // add term
                include_once ("./Modules/Glossary/classes/class.ilGlossaryTerm.php");
                $term = new ilGlossaryTerm();
                $term->setGlossary($this->object);
                $term->setTerm(ilUtil::stripSlashes($_POST["new_term"]));
                $term->setLanguage($_POST["term_language"]);
                $_SESSION["il_text_lang_".$_GET["ref_id"]] = $_POST["term_language"];
                $term->create();

                // add first definition
                $def = new ilGlossaryDefinition();
                $def->setTermId($term->getId());
                $def->setTitle(ilUtil::stripSlashes($_POST["new_term"]));
                $def->create();

                $this->ctrl->setParameterByClass("ilglossarydefpagegui", "term_id", $term->getId());
                $this->ctrl->setParameterByClass("ilglossarydefpagegui", "def", $def->getId());
                $this->ctrl->redirectByClass(array("ilglossarytermgui",
                        "iltermdefinitioneditorgui", "ilglossarydefpagegui"), "edit");
        }

        function moveDefinitionUp()
        {
                include_once("./Modules/Glossary/classes/class.ilGlossaryDefinition.php");

                $definition = new ilGlossaryDefinition($_GET["def"]);
                $definition->moveUp();

                $this->ctrl->redirect($this, "listTerms");
        }

        function moveDefinitionDown()
        {
                include_once("./Modules/Glossary/classes/class.ilGlossaryDefinition.php");

                $definition = new ilGlossaryDefinition($_GET["def"]);
                $definition->moveDown();

                $this->ctrl->redirect($this, "listTerms");
        }

        function confirmDefinitionDeletion()
        {
                //$this->getTemplate();
                //$this->displayLocator();
                //$this->setTabs();

                $term = new ilGlossaryTerm($this->term_id);
                
                $add = "";
                $nr = ilGlossaryTerm::getNumberOfUsages($this->term_id);
                if ($nr > 0)
                {
                        $this->ctrl->setParameterByClass("ilglossarytermgui",
                                "term_id", $this->term_id);
                        $link = "[<a href='".
                                $this->ctrl->getLinkTargetByClass("ilglossarytermgui", "listUsages").
                                "'>".$this->lng->txt("glo_list_usages")."</a>]";
                        $add = "<br/>".sprintf($this->lng->txt("glo_term_is_used_n_times"), $nr)." ".$link;
                }
                
                include_once("./Services/Utilities/classes/class.ilConfirmationGUI.php");
                $cgui = new ilConfirmationGUI();
                $cgui->setHeaderText($this->lng->txt("info_delete_sure").$add);

                $cgui->setFormAction($this->ctrl->getFormAction($this));
                $cgui->setCancel($this->lng->txt("cancel"), "cancelDefinitionDeletion");
                $cgui->setConfirm($this->lng->txt("confirm"), "deleteDefinition");
                
                // content style
                $this->setContentStyleSheet($this->tpl);

                // syntax style
                $this->tpl->setCurrentBlock("SyntaxStyle");
                $this->tpl->setVariable("LOCATION_SYNTAX_STYLESHEET",
                        ilObjStyleSheet::getSyntaxStylePath());
                $this->tpl->parseCurrentBlock();

                $definition = new ilGlossaryDefinition($_GET["def"]);
                $page_gui = new ilGlossaryDefPageGUI($definition->getId());
                $page_gui->setTemplateOutput(false);
                $page_gui->setStyleId($this->object->getStyleSheetId());
                $page_gui->setSourcecodeDownloadScript("ilias.php?baseClass=ilGlossaryPresentationGUI&amp;ref_id=".$_GET["ref_id"]);
                $page_gui->setFileDownloadLink("ilias.php?baseClass=ilGlossaryPresentationGUI&amp;ref_id=".$_GET["ref_id"]);
                $page_gui->setFullscreenLink("ilias.php?baseClass=ilGlossaryPresentationGUI&amp;ref_id=".$_GET["ref_id"]);
                $output = $page_gui->preview();
                
                $cgui->addItem("def", $_GET["def"], $term->getTerm().$output);
                
                $this->tpl->setContent($cgui->getHTML());
        }
        
        function cancelDefinitionDeletion()
        {
                $this->ctrl->redirect($this, "listTerms");
        }


        function deleteDefinition()
        {
                $definition = new ilGlossaryDefinition($_REQUEST["def"]);
                $definition->delete();
                $this->ctrl->redirect($this, "listTerms");
        }

        function editTerm()
        {
                // deprecated
        }


        function updateTerm()
        {
                $term = new ilGlossaryTerm($this->term_id);

                $term->setTerm(ilUtil::stripSlashes($_POST["term"]));
                $term->setLanguage($_POST["term_language"]);
                $term->update();
                ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"),true);
                $this->ctrl->redirect($this, "listTerms");
        }



        function export()
        {
                $this->checkPermission("write");
                
                require_once("./Modules/Glossary/classes/class.ilGlossaryExport.php");
                $glo_exp = new ilGlossaryExport($this->object);
                $glo_exp->buildExportFile();
                $this->ctrl->redirectByClass("ilexportgui", "");
        }
        
        function exportHTML()
        {
                require_once("./Modules/Glossary/classes/class.ilGlossaryExport.php");
                $glo_exp = new ilGlossaryExport($this->object, "html");
                $glo_exp->buildExportFile();
//echo $this->tpl->get();
                $this->ctrl->redirectByClass("ilexportgui", "");
        }

        function publishExportFile()
        {
                if(!isset($_POST["file"]))
                {
                        $this->ilias->raiseError($this->lng->txt("no_checkbox"),$this->ilias->error_obj->MESSAGE);
                }
                if (count($_POST["file"]) > 1)
                {
                        $this->ilias->raiseError($this->lng->txt("cont_select_max_one_item"),$this->ilias->error_obj->MESSAGE);
                }
                
                $file = explode(":", $_POST["file"][0]);
                $export_dir = $this->object->getExportDirectory($file[0]);
                
                if ($this->object->getPublicExportFile($file[0]) ==
                        $file[1])
                {
                        $this->object->setPublicExportFile($file[0], "");
                }
                else
                {
                        $this->object->setPublicExportFile($file[0], $file[1]);
                }
                $this->object->update();
                $this->ctrl->redirectByClass("ilexportgui", "");
        }

        /*
        * list all export files
        */
        function viewExportLog()
        {
        }

        function confirmTermDeletion()
        {
                //$this->prepareOutput();
                if (!isset($_POST["id"]))
                {
                        ilUtil::sendFailure($this->lng->txt("no_checkbox"), true);
                        $this->ctrl->redirect($this, "listTerms");
                }
                
                // check ids
                include_once("./Modules/Glossary/classes/class.ilGlossaryTerm.php");
                include_once("./Modules/Glossary/classes/class.ilGlossaryTermReferences.php");
                foreach ($_POST["id"] as $term_id)
                {
                        $term_glo_id = ilGlossaryTerm::_lookGlossaryID((int) $term_id);
                        if ($term_glo_id != $this->object->getId() && !ilGlossaryTermReferences::isReferenced($this->object->getId(), $term_id))
                        {
                                ilUtil::sendFailure($this->lng->txt("glo_term_must_belong_to_glo"), true);
                                $this->ctrl->redirect($this, "listTerms");
                        }
                }
                
                // display confirmation message
                include_once("./Services/Utilities/classes/class.ilConfirmationGUI.php");
                $cgui = new ilConfirmationGUI();
                $cgui->setFormAction($this->ctrl->getFormAction($this));
                $cgui->setHeaderText($this->lng->txt("info_delete_sure"));
                $cgui->setCancel($this->lng->txt("cancel"), "cancelTermDeletion");
                $cgui->setConfirm($this->lng->txt("confirm"), "deleteTerms");

                include_once("./Modules/Glossary/classes/class.ilGlossaryTermReferences.php");

                foreach($_POST["id"] as $id)
                {
                        $term = new ilGlossaryTerm($id);

                        $add = "";
                        $nr = ilGlossaryTerm::getNumberOfUsages($id);
                        if ($nr > 0)
                        {
                                $this->ctrl->setParameterByClass("ilglossarytermgui",
                                        "term_id", $id);

                                if (ilGlossaryTermReferences::isReferenced($this->object->getId(), $id))
                                {
                                        $add = " (".$this->lng->txt("glo_term_reference").")";
                                }
                                else
                                {
                                        $link = "[<a href='".
                                                $this->ctrl->getLinkTargetByClass("ilglossarytermgui", "listUsages").
                                                "'>".$this->lng->txt("glo_list_usages")."</a>]";
                                        $add = "<div class='small'>".
                                                sprintf($this->lng->txt("glo_term_is_used_n_times"), $nr)." ".$link."</div>";

                                }
                        }
                        
                        $cgui->addItem("id[]", $id, $term->getTerm().$add);
                }

                $this->tpl->setContent($cgui->getHTML());
        }

        function cancelTermDeletion()
        {
                $this->ctrl->redirect($this, "listTerms");
        }

        function deleteTerms()
        {
                include_once("./Modules/Glossary/classes/class.ilGlossaryTermReferences.php");
                foreach($_POST["id"] as $id)
                {
                        if (ilGlossaryTermReferences::isReferenced($this->object->getId(), $id))
                        {
                                $refs = new ilGlossaryTermReferences($this->object->getId());
                                $refs->deleteTerm($id);
                                $refs->update();
                        }
                        else
                        {
                                $term = new ilGlossaryTerm($id);
                                $term->delete();
                        }
                }
                $this->ctrl->redirect($this, "listTerms");
        }

        function setLocator($a_tree = "", $a_id = "")
        {               
                if(strtolower($_GET["baseClass"]) != "ilglossaryeditorgui")
                {
                        parent::setLocator($a_tree, $a_id);
                }
                else
                {
                        if(is_object($this->object))
                        {
                                require_once("./Modules/Glossary/classes/class.ilGlossaryLocatorGUI.php");
                                $gloss_loc = new ilGlossaryLocatorGUI();
                                if (is_object($this->term))
                                {
                                        $gloss_loc->setTerm($this->term);
                                }
                                $gloss_loc->setGlossary($this->object);
                                //$gloss_loc->setDefinition($this->definition);
                                $gloss_loc->display();
                        }
                }

        }

        function view()
        {
                //$this->prepareOutput();
                $this->viewObject();
        }

        function create()
        {
                switch($_POST["new_type"])
                {
                        case "term":
                                $term_gui = new ilGlossaryTermGUI();
                                $term_gui->create();
                                break;
                }
        }

        function saveTerm()
        {
                $term_gui = new ilGlossaryTermGUI();
                $term_gui->setGlossary($this->object);
                $term_gui->save();

                ilUtil::sendSuccess($this->lng->txt("cont_added_term"),true);

                //ilUtil::redirect("glossary_edit.php?ref_id=".$_GET["ref_id"]."&cmd=listTerms");
                $this->ctrl->redirect($this, "listTerms");
        }


        function addDefinition()
        {
                $term_id = (int) $_GET["term_id"];

                include_once("./Modules/Glossary/classes/class.ilGlossaryTerm.php");
                $term_glo_id = ilGlossaryTerm::_lookGlossaryID((int) $term_id);
                if ($term_glo_id != $this->object->getId())
                {
                        ilUtil::sendFailure($this->lng->txt("glo_term_must_belong_to_glo"), true);
                        $this->ctrl->redirect($this, "listTerms");
                }

                // add term
                include_once ("./Modules/Glossary/classes/class.ilGlossaryTerm.php");
                $term = new ilGlossaryTerm($term_id);

                // add first definition
                $def = new ilGlossaryDefinition();
                $def->setTermId($term->getId());
                $def->setTitle(ilUtil::stripSlashes($term->getTerm()));
                $def->create();

                $this->ctrl->setParameterByClass("ilglossarydefpagegui", "term_id", $term->getId());
                $this->ctrl->setParameterByClass("ilglossarydefpagegui", "def", $def->getId());
                $this->ctrl->redirectByClass(array("ilglossarytermgui",
                        "iltermdefinitioneditorgui", "ilglossarydefpagegui"), "edit");
                
        }

        function getTemplate()
        {
                $this->tpl->getStandardTemplate();

                $title = $this->object->getTitle();


                if ($this->term_id > 0)
                {
                        $this->tpl->setTitle($this->lng->txt("term").": ".
                                ilGlossaryTerm::_lookGlossaryTerm($this->term_id));
                }
                else
                {
                        parent::setTitleAndDescription();
                        $this->tpl->setTitleIcon(ilUtil::getImagePath("icon_glo.svg"));
                        $this->tpl->setTitle($this->lng->txt("glo").": ".$title);
                }
        }

        function setTabs()
        {
                $this->getTabs();
        }

        function getTabs()
        {
                $this->help->setScreenIdComponent("glo");

                // list terms
                $force_active = ($_GET["cmd"] == "" || $_GET["cmd"] == "listTerms")
                                ? true
                                : false;
                $this->tabs_gui->addTarget("cont_terms",
                        $this->ctrl->getLinkTarget($this, "listTerms"), array("listTerms", ""),
                        get_class($this), "", $force_active);
                        
                $force_active = false;
                if ($this->ctrl->getCmd() == "showSummary" ||
                        strtolower($this->ctrl->getNextClass()) == "ilinfoscreengui")
                {
                        $force_active = true;
                }
                $this->tabs_gui->addTarget("info_short",
                        $this->ctrl->getLinkTargetByClass("ilinfoscreengui", "showSummary"), "",
                        "ilInfoScreenGUI", "", $force_active);

                // properties
                if ($this->rbacsystem->checkAccess('write',$this->object->getRefId()))
                {
                        $this->tabs_gui->addTarget("settings",
                                $this->ctrl->getLinkTarget($this, "properties"), "properties",
                                get_class($this));
                        
                        // meta data
                        include_once "Services/Object/classes/class.ilObjectMetaDataGUI.php";
                        $mdgui = new ilObjectMetaDataGUI($this->object, "term");                                        
                        $mdtab = $mdgui->getTab();
                        if($mdtab)
                        {
                                $this->tabs_gui->addTarget("meta_data", $mdtab,
                                        "", "ilobjectmetadatagui");
                        }
                        
                        // export
                        /*$tabs_gui->addTarget("export",
                                 $this->ctrl->getLinkTarget($this, "exportList"),
                                 array("exportList", "viewExportLog"), get_class($this));*/

                        // export
                        $this->tabs_gui->addTarget("export",
                                 $this->ctrl->getLinkTargetByClass("ilexportgui", ""),
                                 "", "ilexportgui");
                }

                // permissions
                if ($this->rbacsystem->checkAccess('edit_permission',$this->object->getRefId()))
                {
                        /*$tabs_gui->addTarget("permission_settings",
                                $this->ctrl->getLinkTarget($this, "perm"),
                                array("perm", "info"),
                                get_class($this));
                                */
                        $this->tabs_gui->addTarget("perm_settings",
                                $this->ctrl->getLinkTargetByClass(array(get_class($this),'ilpermissiongui'), "perm"), array("perm","info","owner"), 'ilpermissiongui');

                }
                
                $this->tabs_gui->addNonTabbedLink("presentation_view",
                        $this->lng->txt("glo_presentation_view"),
                        "ilias.php?baseClass=ilGlossaryPresentationGUI&amp;ref_id=".$this->object->getRefID(),
                        "_top"
                );
                
        }
        
        function setSettingsSubTabs($a_active)
        {
                if (in_array($a_active,
                        array("general_settings", "style", "taxonomy", "glossaries")))
                {
                        // general properties
                        $this->tabs->addSubTab("general_settings",
                                $this->lng->txt("settings"),
                                $this->ctrl->getLinkTarget($this, 'properties'));
                                
                        // style properties
                        $this->tabs->addSubTab("style",
                                $this->lng->txt("obj_sty"),
                                $this->ctrl->getLinkTarget($this, 'editStyleProperties'));

                        // taxonomy
                        include_once("./Services/Taxonomy/classes/class.ilObjTaxonomy.php");
                        ilObjTaxonomy::loadLanguageModule();
                        $this->tabs->addSubTab("taxonomy",
                                $this->lng->txt("tax_taxonomy"),
                                $this->ctrl->getLinkTargetByClass("ilobjtaxonomygui", ''));

                        // style properties
                        $this->tabs->addSubTab("glossaries",
                                $this->lng->txt("cont_auto_glossaries"),
                                $this->ctrl->getLinkTarget($this, 'editGlossaries'));

                        $this->tabs->activateSubTab($a_active);
                }
        }

        
        public static function _goto($a_target)
        {
                global $DIC;

                $lng = $DIC->language();
                $ilAccess = $DIC->access();
                $ilErr = $DIC["ilErr"];

                if ($ilAccess->checkAccess("read", "", $a_target))
                {
                        $_GET["ref_id"] = $a_target;
                        $_GET["baseClass"] = "ilGlossaryPresentationGUI";
                        include("ilias.php");
                        exit;
                }
                else if ($ilAccess->checkAccess("visible", "", $a_target))
                {
                        $_GET["ref_id"] = $a_target;
                        $_GET["cmd"] = "infoScreen";
                        $_GET["baseClass"] = "ilGlossaryPresentationGUI";
                        include("ilias.php");
                        exit;
                }
                else if ($ilAccess->checkAccess("read", "", ROOT_FOLDER_ID))
                {
                        ilUtil::sendFailure(sprintf($lng->txt("msg_no_perm_read_item"),
                                ilObject::_lookupTitle(ilObject::_lookupObjId($a_target))), true);
                        ilObjectGUI::_gotoRepositoryRoot();
                }

                $ilErr->raiseError($lng->txt("msg_no_perm_read_lm"), $ilErr->FATAL);
        }

        function applyFilter()
        {               
                include_once("./Modules/Glossary/classes/class.ilTermListTableGUI.php");
                $prtab = new ilTermListTableGUI($this, "listTerms", $this->tax_node);
                $prtab->resetOffset();
                $prtab->writeFilterToSession();
                $this->listTerms();             
        }
        
        function resetFilter()
        {
                include_once("./Modules/Glossary/classes/class.ilTermListTableGUI.php");
                $prtab = new ilTermListTableGUI($this, "listTerms", $this->tax_node);
                $prtab->resetOffset();
                $prtab->resetFilter();
                $this->listTerms();
        }


        
        function setContentStyleSheet($a_tpl = null)
        {
                if ($a_tpl != null)
                {
                        $ctpl = $a_tpl;
                }
                else
                {
                        $ctpl = $this->tpl;
                }

                $ctpl->setCurrentBlock("ContentStyle");
                $ctpl->setVariable("LOCATION_CONTENT_STYLESHEET",
                        ilObjStyleSheet::getContentStylePath($this->object->getStyleSheetId()));
                $ctpl->parseCurrentBlock();
        }
        
        
        function editStyleProperties()
        {
                $this->checkPermission("write");
                
                $this->initStylePropertiesForm();
                $this->tpl->setContent($this->form->getHTML());

                $this->tabs->activateTab("settings");
                $this->setSettingsSubTabs("style");
        }
        
        function initStylePropertiesForm()
        {
                include_once("./Services/Style/Content/classes/class.ilObjStyleSheet.php");
                $this->lng->loadLanguageModule("style");

                include_once("./Services/Form/classes/class.ilPropertyFormGUI.php");
                $this->form = new ilPropertyFormGUI();
                
                $fixed_style = $this->setting->get("fixed_content_style_id");
                $style_id = $this->object->getStyleSheetId();

                if ($fixed_style > 0)
                {
                        $st = new ilNonEditableValueGUI($this->lng->txt("style_current_style"));
                        $st->setValue(ilObject::_lookupTitle($fixed_style)." (".
                                $this->lng->txt("global_fixed").")");
                        $this->form->addItem($st);
                }
                else
                {
                        $st_styles = ilObjStyleSheet::_getStandardStyles(true, false,
                                $_GET["ref_id"]);

                        $st_styles[0] = $this->lng->txt("default");
                        ksort($st_styles);

                        if ($style_id > 0)
                        {
                                // individual style
                                if (!ilObjStyleSheet::_lookupStandard($style_id))
                                {
                                        $st = new ilNonEditableValueGUI($this->lng->txt("style_current_style"));
                                        $st->setValue(ilObject::_lookupTitle($style_id));
                                        $this->form->addItem($st);

//$this->ctrl->getLinkTargetByClass("ilObjStyleSheetGUI", "edit"));

                                        // delete command
                                        $this->form->addCommandButton("editStyle",
                                                $this->lng->txt("style_edit_style"));
                                        $this->form->addCommandButton("deleteStyle",
                                                $this->lng->txt("style_delete_style"));
//$this->ctrl->getLinkTargetByClass("ilObjStyleSheetGUI", "delete"));
                                }
                        }

                        if ($style_id <= 0 || ilObjStyleSheet::_lookupStandard($style_id))
                        {
                                $style_sel = ilUtil::formSelect ($style_id, "style_id",
                                        $st_styles, false, true);
                                $style_sel = new ilSelectInputGUI($this->lng->txt("style_current_style"), "style_id");
                                $style_sel->setOptions($st_styles);
                                $style_sel->setValue($style_id);
                                $this->form->addItem($style_sel);
//$this->ctrl->getLinkTargetByClass("ilObjStyleSheetGUI", "create"));
                                $this->form->addCommandButton("saveStyleSettings",
                                        $this->lng->txt("save"));
                                $this->form->addCommandButton("createStyle",
                                        $this->lng->txt("sty_create_ind_style"));
                        }
                }
                $this->form->setTitle($this->lng->txt("glo_style"));
                $this->form->setFormAction($this->ctrl->getFormAction($this));
        }

        function createStyle()
        {
                $this->ctrl->redirectByClass("ilobjstylesheetgui", "create");
        }
        
        function editStyle()
        {
                $this->ctrl->redirectByClass("ilobjstylesheetgui", "edit");
        }

        function deleteStyle()
        {
                $this->ctrl->redirectByClass("ilobjstylesheetgui", "delete");
        }

        function saveStyleSettings()
        {
                include_once("./Services/Style/Content/classes/class.ilObjStyleSheet.php");
                if ($this->setting->get("fixed_content_style_id") <= 0 &&
                        (ilObjStyleSheet::_lookupStandard($this->object->getStyleSheetId())
                        || $this->object->getStyleSheetId() == 0))
                {
                        $this->object->setStyleSheetId(ilUtil::stripSlashes($_POST["style_id"]));
                        $this->object->update();
                        ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"), true);
                }
                $this->ctrl->redirect($this, "editStyleProperties");
        }
        
        function getPublicAccessColValue($a_type, $a_file)
        {
                if ($this->object->getPublicExportFile($a_type) == $a_file)
                {
                        return $this->lng->txt("yes");
                }
        
                return " ";             
        }

        function showTaxonomy()
        {
                include_once("./Services/Taxonomy/classes/class.ilObjTaxonomy.php");
                $tax_ids = ilObjTaxonomy::getUsageOfObject($this->object->getId());
                if (count($tax_ids) > 0)
                {
                        include_once("./Services/Taxonomy/classes/class.ilTaxonomyExplorerGUI.php");
                        $tax_exp = new ilTaxonomyExplorerGUI($this, "showTaxonomy", $tax_ids[0],
                                "ilobjglossarygui", "listTerms");
                        if (!$tax_exp->handleCommand())
                        {
                                //$this->tpl->setLeftNavContent($tax_exp->getHTML());
                                $this->tpl->setLeftNavContent($tax_exp->getHTML()."&nbsp;");
                        }
                }

        }

        //
        // Auto glossaries
        //

        function editGlossaries()
        {
                $this->tabs->setTabActive("settings");
                $this->setSettingsSubTabs("glossaries");

                $this->toolbar->addButton($this->lng->txt("add"),
                        $this->ctrl->getLinkTarget($this, "showGlossarySelector"));

                include_once("./Modules/Glossary/classes/class.ilGlossaryAutoLinkTableGUI.php");
                $tab = new ilGlossaryAutoLinkTableGUI($this->object, $this, "editGlossaries");

                $this->tpl->setContent($tab->getHTML());
        }

        function showGlossarySelector()
        {
                $this->tabs->setTabActive("settings");
                $this->setSettingsSubTabs("glossaries");

                include_once 'Services/Search/classes/class.ilSearchRootSelector.php';

                $exp = new ilSearchRootSelector($this->ctrl->getLinkTarget($this,'showGlossarySelector'));
                $exp->setExpand($_GET["search_root_expand"] ? $_GET["search_root_expand"] : $this->tree->readRootId());
                $exp->setExpandTarget($this->ctrl->getLinkTarget($this,'showGlossarySelector'));
                $exp->setTargetClass(get_class($this));
                $exp->setCmd('confirmGlossarySelection');
                $exp->setClickableTypes(array("glo"));
                $exp->addFilter("glo");

                // build html-output
                $exp->setOutput(0);
                $this->tpl->setContent($exp->getOutput());

        }

        function confirmGlossarySelection()
        {
                include_once("./Services/Utilities/classes/class.ilConfirmationGUI.php");
                $cgui = new ilConfirmationGUI();
                $this->ctrl->setParameter($this, "glo_ref_id", $_GET["root_id"]);
                $cgui->setFormAction($this->ctrl->getFormAction($this));
                $cgui->setHeaderText($this->lng->txt("glo_link_glo_in_glo"));
                $cgui->setCancel($this->lng->txt("no"), "selectGlossary");
                $cgui->setConfirm($this->lng->txt("yes"), "selectGlossaryLink");
                $this->tpl->setContent($cgui->getHTML());
        }

        function selectGlossaryLink()
        {
                $glo_ref_id = (int) $_GET["glo_ref_id"];
                $glo_id = ilObject::_lookupObjId($glo_ref_id);
                $this->object->autoLinkGlossaryTerms($glo_id);
                $this->selectGlossary();
        }


        function selectGlossary()
        {
                $glos = $this->object->getAutoGlossaries();
                $glo_ref_id = (int) $_GET["glo_ref_id"];
                $glo_id = ilObject::_lookupObjId($glo_ref_id);
                if (!in_array($glo_id, $glos))
                {
                        $glos[] = $glo_id;
                }
                $this->object->setAutoGlossaries($glos);
                $this->object->update();

                ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"), true);
                $this->ctrl->redirect($this, "editGlossaries");
        }

        function removeGlossary()
        {
                $this->object->removeAutoGlossary((int) $_GET["glo_id"]);
                $this->object->update();

                ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"), true);
                $this->ctrl->redirect($this, "editGlossaries");
        }
        
        function copyTerms()
        {
                $items = ilUtil::stripSlashesArray($_POST["id"]);
                if (!is_array($items))
                {
                        ilUtil::sendFailure($this->lng->txt("no_checkbox"), true);
                        $this->ctrl->redirect($this, "listTerms");
                }

                include_once("./Modules/LearningModule/classes/class.ilEditClipboard.php");
                $this->user->clipboardDeleteObjectsOfType("term");

                // put them into the clipboard
                $time = date("Y-m-d H:i:s", time());
                $order = 0;
                foreach ($items as $id)
                {
                        $this->user->addObjectToClipboard($id,
                                "term", ilGlossaryTerm::_lookGlossaryTerm($id), 0, $time, $order);
                }

                ilEditClipboard::setAction("copy");
                ilUtil::sendInfo($this->lng->txt("glo_selected_terms_have_been_copied"), true);
                $this->ctrl->redirect($this, "listTerms");
        }
        
        function referenceTerms()
        {
                $items = ilUtil::stripSlashesArray($_POST["id"]);
                if (!is_array($items))
                {
                        ilUtil::sendFailure($this->lng->txt("no_checkbox"), true);
                        $this->ctrl->redirect($this, "listTerms");
                }

                include_once("./Modules/LearningModule/classes/class.ilEditClipboard.php");
                $this->user->clipboardDeleteObjectsOfType("term");

                // put them into the clipboard
                $time = date("Y-m-d H:i:s", time());
                $order = 0;
                foreach ($items as $id)
                {
                        $this->user->addObjectToClipboard($id,
                                "term", ilGlossaryTerm::_lookGlossaryTerm($id), 0, $time, $order);
                }

                ilEditClipboard::setAction("link");
                ilUtil::sendInfo($this->lng->txt("glo_selected_terms_have_been_copied"), true);
                $this->ctrl->redirect($this, "listTerms");
        }


        function clearClipboard()
        {
                $this->user->clipboardDeleteObjectsOfType("term");
                $this->ctrl->redirect($this, "listTerms");
        }

        function pasteTerms()
        {
                include_once("./Modules/LearningModule/classes/class.ilEditClipboard.php");
                if (ilEditClipboard::getAction() == "copy")
                {
                        foreach ($this->user->getClipboardObjects("term") as $item)
                        {
                                ilGlossaryTerm::_copyTerm($item["id"], $this->object->getId());
                        }
                }
                if (ilEditClipboard::getAction() == "link")
                {
                        include_once("./Modules/Glossary/classes/class.ilGlossaryTermReferences.php");
                        $refs = new ilGlossaryTermReferences($this->object->getId());
                        foreach ($this->user->getClipboardObjects("term") as $item)
                        {
                                $refs->addTerm($item["id"]);
                        }
                        $refs->update();
                }
                ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"), true);
                $this->ctrl->redirect($this, "listTerms");
        }
        
        
}

?>