class.ilObjectGUI.php

Go to the documentation of this file.

<?php
/* Copyright (c) 1998-2009 ILIAS open source, Extended GPL, see docs/LICENSE */
 
 
class ilObjectGUI
{
        const COPY_WIZARD_NEEDS_PAGE = 1;
        
        
        
        var $ilias;
 
        var $objDefinition;
 
        var $tpl;
 
        var $tree;
 
        var $lng;
 
        var $data;
 
        var $object;
        var $ref_id;
        var $obj_id;
        var $maxcount;                  // contains number of child objects
        var $formaction;                // special formation (array "cmd" => "formaction")
        var $return_location;   // special return location (array "cmd" => "location")
        var $target_frame;      // special target frame (array "cmd" => "location")
        protected $tmp_import_dir;      // directory used during import
 
        var $tab_target_script;
        var $actions;
        var $sub_objects;
        var $omit_locator = false;
 
        protected $tabs_gui = null;
        
        protected $ctrl;
 
        const CFORM_NEW = 1;
        const CFORM_IMPORT = 2;
        const CFORM_CLONE = 3;
 
        function __construct($a_data, $a_id = 0, $a_call_by_reference = true, $a_prepare_output = true)
        {
                global $ilias, $objDefinition, $tpl, $tree, $ilCtrl, $ilErr, $lng, $ilTabs;
 
                $this->tabs_gui = $ilTabs;
 
                if (!isset($ilErr))
                {
                        $ilErr = new ilErrorHandling();
                        $ilErr->setErrorHandling(PEAR_ERROR_CALLBACK,array($ilErr,'errorHandler'));
                }
                else
                {
                        $this->ilErr = $ilErr;
                }
 
                $this->ilias = $ilias;
                $this->objDefinition = $objDefinition;
                $this->tpl = $tpl;
                $this->html = "";
                $this->ctrl = $ilCtrl;
 
                $params = array("ref_id");
 
                if (!$a_call_by_reference)
                {
                        $params = array("ref_id","obj_id");
                }
 
                $this->ctrl->saveParameter($this, $params);
 
                $this->lng = $lng;
                $this->tree = $tree;
                $this->formaction = array();
                $this->return_location = array();
                $this->target_frame = array();
                $this->actions = "";
                $this->sub_objects = "";
 
                $this->data = $a_data;
                $this->id = $a_id;
                $this->call_by_reference = $a_call_by_reference;
                $this->prepare_output = $a_prepare_output;
                $this->creation_mode = false;
 
                $this->ref_id = ($this->call_by_reference) ? $this->id : $_GET["ref_id"];
                $this->obj_id = ($this->call_by_reference) ? $_GET["obj_id"] : $this->id;
 
                if ($this->id != 0)
                {
                        $this->link_params = "ref_id=".$this->ref_id;
                }
 
                // get the object
                $this->assignObject();
                
                // set context
                if (is_object($this->object))
                {
                        if ($this->call_by_reference && $this->ref_id == $_GET["ref_id"])
                        {
                                $this->ctrl->setContext($this->object->getId(), 
                                        $this->object->getType());
                        }
                }
 
                // use global $lng instead, when creating new objects object is not available
                //$this->lng =& $this->object->lng;
 
                //prepare output
                if ($a_prepare_output)
                {
                        $this->prepareOutput();
                }
        }
        
        
        function executeCommand()
        {
                $next_class = $this->ctrl->getNextClass($this);
                $cmd = $this->ctrl->getCmd();
 
                switch($next_class)
                {
                        default:
                                $this->prepareOutput();
                                if(!$cmd)
                                {
                                        $cmd = "view";
                                }
                                $cmd .= "Object";
                                $this->$cmd();
                                        
                                break;
                }
 
                return true;
        }
 
 
        public function withReferences()
        {
                return $this->call_by_reference;
        }
        
        public function setCreationMode($a_mode = true)
        {
                $this->creation_mode = $a_mode;
        }
        
        public function getCreationMode()
        {
                return $this->creation_mode;
        }
 
        protected function assignObject()
        {
                // TODO: it seems that we always have to pass only the ref_id
//echo "<br>ilObjectGUIassign:".get_class($this).":".$this->id.":<br>";
                if ($this->id != 0)
                {
                        if ($this->call_by_reference)
                        {
                                $this->object = ilObjectFactory::getInstanceByRefId($this->id);
                        }
                        else
                        {
                                $this->object = ilObjectFactory::getInstanceByObjId($this->id);
                        }
                }
        }
 
        public function prepareOutput($a_show_subobjects = true)
        {
                global $ilLocator, $tpl, $ilUser;
 
                $this->tpl->getStandardTemplate();
                // administration prepare output
                if (strtolower($_GET["baseClass"]) == "iladministrationgui")
                {
                        $this->addAdminLocatorItems();
                        $tpl->setLocator();
 
//                      ilUtil::sendInfo();
                        ilUtil::infoPanel();
 
                        $this->setTitleAndDescription();
 
                        if ($this->getCreationMode() != true)
                        {
                                $this->setAdminTabs();
                        }
                        
                        return false;
                }
                // set locator
                $this->setLocator();
                // catch feedback message
//              ilUtil::sendInfo();
                ilUtil::infoPanel();
 
                // in creation mode (parent) object and gui object
                // do not fit
                if ($this->getCreationMode() == true)
                {
                        // repository vs. workspace
                        if($this->call_by_reference)
                        {
                                // get gui class of parent and call their title and description method
                                $obj_type = ilObject::_lookupType($_GET["ref_id"],true);
                                $class_name = $this->objDefinition->getClassName($obj_type);
                                $class = strtolower("ilObj".$class_name."GUI");
                                $class_path = $this->ctrl->lookupClassPath($class);
                                include_once($class_path);
                                $class_name = $this->ctrl->getClassForClasspath($class_path);
//echo "<br>instantiating parent for title and description";
                                $this->parent_gui_obj = new $class_name("", $_GET["ref_id"], true, false);
                                // the next line prevents the header action menu being shown
                                $this->parent_gui_obj->setCreationMode(true);
                                $this->parent_gui_obj->setTitleAndDescription();
                        }
                }
                else
                {
                        // set title and description and title icon
                        $this->setTitleAndDescription();
        
                        // set tabs
                        $this->setTabs();
 
                        // BEGIN WebDAV: Display Mount Webfolder icon.
                        if ($ilUser->getId() != ANONYMOUS_USER_ID)
                        {
                                require_once ('Services/WebDAV/classes/class.ilDAVActivationChecker.php');
                                if (ilDAVActivationChecker::_isActive())
                                {                       
                                        $this->showMountWebfolderIcon();
                                }
                        }
                        // END WebDAV: Display Mount Webfolder icon.
                        
                        // fileupload support
                        require_once './Services/FileUpload/classes/class.ilFileUploadUtil.php';
                        if (ilFileUploadUtil::isUploadAllowed($this->ref_id, $this->object->getType()))
                        {
                                $this->enableDragDropFileUpload();              
                        }
                }
                
                return true;
        }
        
        protected function setTitleAndDescription()
        {
                if (!is_object($this->object))
                {
                        if ((int) $_REQUEST["crtptrefid"] > 0)
                        {
                                $cr_obj_id = ilObject::_lookupObjId((int) $_REQUEST["crtcb"]);
                                $this->tpl->setTitle(ilObject::_lookupTitle($cr_obj_id));
                                $this->tpl->setTitleIcon(ilObject::_getIcon($cr_obj_id));
                        }
                        return;
                }
                $this->tpl->setTitle($this->object->getPresentationTitle());
                $this->tpl->setDescription($this->object->getLongDescription());
                        
                if (strtolower($_GET["baseClass"]) == "iladministrationgui")
                {
                        // alt text would be same as heading -> empty alt text
                        $this->tpl->setTitleIcon(ilObject::_getIcon("", "big", $this->object->getType()));
                }
                else
                {
                        $this->tpl->setTitleIcon(ilObject::_getIcon("", "big", $this->object->getType()),
                                $this->lng->txt("obj_" . $this->object->getType()));
                }
 
                include_once './Services/Object/classes/class.ilObjectListGUIFactory.php';
                $lgui = ilObjectListGUIFactory::_getListGUIByType($this->object->getType());
                $lgui->initItem($this->object->getRefId(), $this->object->getId());
                $this->tpl->setAlertProperties($lgui->getAlertProperties());            
        }
        
        protected function initHeaderAction($a_sub_type = null, $a_sub_id = null)
        {
                global $ilAccess; 
                
                if(!$this->creation_mode && $this->object)
                {
                        include_once "Services/Object/classes/class.ilCommonActionDispatcherGUI.php";
                        $dispatcher = new ilCommonActionDispatcherGUI(ilCommonActionDispatcherGUI::TYPE_REPOSITORY, 
                                $ilAccess, $this->object->getType(), $this->ref_id, $this->object->getId());
                        
                        $dispatcher->setSubObject($a_sub_type, $a_sub_id);
                        
                        include_once "Services/Object/classes/class.ilObjectListGUI.php";
                                ilObjectListGUI::prepareJSLinks($this->ctrl->getLinkTarget($this, "redrawHeaderAction", "", true), 
                                $this->ctrl->getLinkTargetByClass(array("ilcommonactiondispatchergui", "ilnotegui"), "", "", true, false), 
                                $this->ctrl->getLinkTargetByClass(array("ilcommonactiondispatchergui", "iltagginggui"), "", "", true, false));
                        
                        $lg = $dispatcher->initHeaderAction();                  
                        
                        if (is_object($lg))
                        {                               
                                // to enable add to desktop / remove from desktop
                                if($this instanceof ilDesktopItemHandling)
                                {
                                        $lg->setContainerObject($this);
                                }                       
                                
                                // enable multi download
                                $lg->enableMultiDownload(true);
                                
                                // comments settings are always on (for the repository)
                                // should only be shown if active or permission to toggle
                                include_once "Services/Notes/classes/class.ilNote.php";
                                if($ilAccess->checkAccess("write", "", $this->ref_id) ||
                                        $ilAccess->checkAccess("edit_permissions", "", $this->ref_id) ||
                                        ilNote::commentsActivated($this->object->getId(), 0, $this->object->getType()))
                                {
                                        $lg->enableComments(true);
                                }
                                
                                $lg->enableNotes(true);
                                $lg->enableTags(true);
                        }
                        
                        return $lg;
                }
        }
        
        protected function insertHeaderAction($a_list_gui)
        {
                if(is_object($a_list_gui))
                {
                        $this->tpl->setHeaderActionMenu($a_list_gui->getHeaderAction());
                }
        }
        
        protected function addHeaderAction()
        {       
                $this->insertHeaderAction($this->initHeaderAction());
        }
 
        protected function redrawHeaderActionObject()
        {
                global $tpl;
                
                $lg = $this->initHeaderAction();
                echo $lg->getHeaderAction();            
                
                // we need to add onload code manually (rating, comments, etc.)
                echo $tpl->getOnLoadCodeForAsynch();            
                
                exit;
        }
        
        // BEGIN WebDAV: Show Mount Webfolder Icon.
        protected function showMountWebfolderIcon()
        {
                global $tree, $tpl, $objDefinition;
 
                if ($this->object->getRefId() == "")
                {
                        return;
                }
 
                $tpl->setMountWebfolderIcon($this->object->getRefId());
        }
        // END WebDAV: Show Mount Webfolder Icon.
 
 
        protected function setTabs()
        {
                $this->getTabs();
        }
 
        protected final function setAdminTabs()
        {
                $this->getAdminTabs();
        }
 
        function getAdminTabs()
        {
                global $tree;
 
/*              if ($_GET["admin_mode"] == "repository")
                {
                        $this->ctrl->setParameterByClass("iladministrationgui", "admin_mode", "settings");
                        $this->tabs_gui->setBackTarget($this->lng->txt("administration"),
                                $this->ctrl->getLinkTargetByClass("iladministrationgui", "frameset"),
                                ilFrameTargetInfo::_getFrame("MainContent"));
                        $this->ctrl->setParameterByClass("iladministrationgui", "admin_mode", "repository");
                }*/
                
                if ($this->checkPermissionBool("visible,read"))
                {
                        $this->tabs_gui->addTarget("view",
                                $this->ctrl->getLinkTarget($this, "view"), array("", "view"), get_class($this));
 
                }
                
                if ($this->checkPermissionBool("edit_permission"))
                {
                        $this->tabs_gui->addTarget("perm_settings",
                                $this->ctrl->getLinkTargetByClass(array(get_class($this),'ilpermissiongui'), "perm"), "", "ilpermissiongui");
                }
                        
                if ($tree->getSavedNodeData($this->object->getRefId()))
                {
                        $this->tabs_gui->addTarget("trash",
                                $this->ctrl->getLinkTarget($this, "trash"), "trash", get_class($this));
                }
        }
 
 
        function getHTML()
        {
                return $this->html;
        }
 
 
        final private function setActions($a_actions = "")
        {
                if (is_array($a_actions))
                {
                        foreach ($a_actions as $name => $lng)
                        {
                                $this->actions[$name] = array("name" => $name, "lng" => $lng);
                        }
                }
                else
                {
                        $this->actions = "";
                }
        }
 
        final private function setSubObjects($a_sub_objects = "")
        {
                if (is_array($a_sub_objects))
                {
                        foreach ($a_sub_objects as $name => $options)
                        {
                                $this->sub_objects[$name] = array("name" => $name, "max" => $options["max"]);
                        }
                }
                else
                {
                        $this->sub_objects = "";
                }
        }
 
        protected function setLocator()
        {
                global $ilLocator, $tpl;
                
                if ($this->omit_locator)
                {
                        return;
                }
 
                // repository vs. workspace
                if($this->call_by_reference)
                {
                        // todo: admin workaround
                        // in the future, objectgui classes should not be called in
                        // admin section anymore (rbac/trash handling in own classes)
                        $ref_id = ($_GET["ref_id"] != "")
                                ? $_GET["ref_id"]
                                : $this->object->getRefId();
                        $ilLocator->addRepositoryItems($ref_id);
                }
                
                if(!$this->creation_mode)
                {
                        $this->addLocatorItems();
                }
                
                // not so nice workaround: todo: handle $ilLocator as tabs in ilTemplate
                if ($_GET["admin_mode"] == "" &&
                        strtolower($this->ctrl->getCmdClass()) == "ilobjrolegui")
                {
                        $this->ctrl->setParameterByClass("ilobjrolegui",
                                "rolf_ref_id", $_GET["rolf_ref_id"]);
                        $this->ctrl->setParameterByClass("ilobjrolegui",
                                "obj_id", $_GET["obj_id"]);
                        $ilLocator->addItem($this->lng->txt("role"),
                                $this->ctrl->getLinkTargetByClass(array("ilpermissiongui",
                                        "ilobjrolegui"), "perm"));
                }
 
                $tpl->setLocator();
        }
        
        protected function addLocatorItems()
        {
        }
        
        protected function omitLocator($a_omit = true)
        {
                $this->omit_locator = $a_omit;
        }
 
        protected function addAdminLocatorItems($a_do_not_add_object = false)
        {
                global $ilLocator;
                
                if ($_GET["admin_mode"] == "settings")  // system settings
                {               
                        $this->ctrl->setParameterByClass("ilobjsystemfoldergui",
                                "ref_id", SYSTEM_FOLDER_ID);
                        $ilLocator->addItem($this->lng->txt("administration"),
                                $this->ctrl->getLinkTargetByClass(array("iladministrationgui", "ilobjsystemfoldergui"), "")
                                );
                        if ($this->object && ($this->object->getRefId() != SYSTEM_FOLDER_ID && !$a_do_not_add_object))
                        {
                                $ilLocator->addItem($this->object->getTitle(),
                                        $this->ctrl->getLinkTarget($this, "view"));
                        }
                }
                else                                                    // repository administration
                {
                        $this->ctrl->setParameterByClass("iladministrationgui",
                                "ref_id", "");
                        $this->ctrl->setParameterByClass("iladministrationgui",
                                "admin_mode", "settings");
                        //$ilLocator->addItem($this->lng->txt("administration"),
                        //      $this->ctrl->getLinkTargetByClass("iladministrationgui", "frameset"),
                        //      ilFrameTargetInfo::_getFrame("MainContent"));
                        $this->ctrl->clearParametersByClass("iladministrationgui");
                        $ilLocator->addAdministrationItems();
                }
 
        }
 
        public function confirmedDeleteObject()
        {
                global $ilSetting, $lng;
                
                if(isset($_POST["mref_id"]))
                {
                        $_SESSION["saved_post"] = array_unique(array_merge($_SESSION["saved_post"], $_POST["mref_id"]));
                }
                
                include_once("./Services/Repository/classes/class.ilRepUtilGUI.php");
                $ru = new ilRepUtilGUI($this);
                $ru->deleteObjects($_GET["ref_id"], ilSession::get("saved_post"));
                ilSession::clear("saved_post");
                $this->ctrl->returnToParent($this);
        }
 
        public function cancelDeleteObject()
        {
                ilSession::clear("saved_post");
                $this->ctrl->returnToParent($this);
        }
 
 
        public function cancelObject()
        {
                ilSession::clear("saved_post");
                $this->ctrl->returnToParent($this);
        }
 
        public function createObject()
        {
                global $tpl, $ilErr;
 
                $new_type = $_REQUEST["new_type"];
 
                
                // add new object to custom parent container
                $this->ctrl->saveParameter($this, "crtptrefid");
                // use forced callback after object creation
                $this->ctrl->saveParameter($this, "crtcb");
                
                if (!$this->checkPermissionBool("create", "", $new_type))
                {
                        $ilErr->raiseError($this->lng->txt("permission_denied"),$ilErr->MESSAGE);
                }
                else
                {
                        $this->lng->loadLanguageModule($new_type);
                        $this->ctrl->setParameter($this, "new_type", $new_type);
                        
                        $forms = $this->initCreationForms($new_type);
                        
                        // copy form validation error: do not show other creation forms
                        if($_GET["cpfl"] && isset($forms[self::CFORM_CLONE]))
                        {
                                $forms = array(self::CFORM_CLONE => $forms[self::CFORM_CLONE]);
                        }
                        $tpl->setContent($this->getCreationFormsHTML($forms));
                }
        }
 
        protected function initCreationForms($a_new_type)
        {
                $forms = array(
                        self::CFORM_NEW => $this->initCreateForm($a_new_type),
                        self::CFORM_IMPORT => $this->initImportForm($a_new_type),
                        self::CFORM_CLONE => $this->fillCloneTemplate(null, $a_new_type)
                        );
                
                return $forms;
        }
 
        final protected function getCreationFormsHTML(array $a_forms)
        {
                global $tpl;
                
                // #13168- sanity check
                foreach($a_forms as $id => $form)
                {
                        if(!$form instanceof ilPropertyFormGUI)
                        {
                                unset($a_forms[$id]);
                        }
                }
                
                // no accordion if there is just one form
                if(sizeof($a_forms) == 1)
                {
                        $form_type = key($a_forms);
                        $a_forms = array_shift($a_forms);
 
                        // see bug #0016217
                        if(method_exists($this, "getCreationFormTitle"))
                        {
                                $form_title = $this->getCreationFormTitle($form_type);
                                if ($form_title != "")
                                {
                                        $a_forms->setTitle($form_title);
                                }
                        }
                        return $a_forms->getHTML();
                }
                else
                {
                        include_once("./Services/Accordion/classes/class.ilAccordionGUI.php");
 
                        $acc = new ilAccordionGUI();
                        $acc->setBehaviour(ilAccordionGUI::FIRST_OPEN);
                        $cnt = 1;
                        foreach ($a_forms as $form_type => $cf)
                        {                               
                                $htpl = new ilTemplate("tpl.creation_acc_head.html", true, true, "Services/Object");
 
                                // using custom form titles (used for repository plugins)
                                $form_title = "";
                                if(method_exists($this, "getCreationFormTitle"))
                                {
                                        $form_title = $this->getCreationFormTitle($form_type);
                                }
                                if(!$form_title)
                                {
                                        $form_title = $cf->getTitle();
                                }
 
                                // move title from form to accordion
                                $htpl->setVariable("TITLE", $this->lng->txt("option")." ".$cnt.": ".
                                        $form_title);
                                $cf->setTitle(null);
                                $cf->setTitleIcon(null);
                                $cf->setTableWidth("100%");
 
                                $acc->addItem($htpl->get(), $cf->getHTML());
 
                                $cnt++;                         
                        }
 
                        return "<div class='ilCreationFormSection'>".$acc->getHTML()."</div>";
                }
        }
 
        protected 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, "save"));
                $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);
 
                $form = $this->initDidacticTemplate($form);
 
                $form->addCommandButton("save", $this->lng->txt($a_new_type."_add"));
                $form->addCommandButton("cancel", $this->lng->txt("cancel"));
 
                return $form;
        }
 
        protected function initDidacticTemplate(ilPropertyFormGUI $form)
        {
                global $lng;
                
                $lng->loadLanguageModule('didactic');
                $existing_exclusive = false;
                $options = array();
                $options['dtpl_0'] = array($this->lng->txt('didactic_default_type'),
                        sprintf(
                                $this->lng->txt('didactic_default_type_info'),
                                $this->lng->txt('objs_'.$this->type)
                        ));
                
                include_once './Services/DidacticTemplate/classes/class.ilDidacticTemplateSettings.php';
                $templates = ilDidacticTemplateSettings::getInstanceByObjectType($this->type)->getTemplates();
                if($templates)
                {
                        foreach($templates as $template)
                        {
                                if($template->isEffective($_GET["ref_id"]))
                                {
                                        $options["dtpl_".$template->getId()] = array(
                                                $template->getPresentationTitle(),
                                                $template->getPresentationDescription()
                                        );
 
                                        if($template->isExclusive())
                                        {
                                                $existing_exclusive = true;
                                        }
                                }
 
                        }
                }
                
                $this->addDidacticTemplateOptions($options);
 
                if(sizeof($options) > 1)
                {
                        $type = new ilRadioGroupInputGUI(
                                $this->lng->txt('type'),
                                'didactic_type'
                        );
                        // workaround for containers in edit mode
                        if(!$this->getCreationMode())
                        {
                                include_once './Services/DidacticTemplate/classes/class.ilDidacticTemplateObjSettings.php';
                                $value = 'dtpl_'.ilDidacticTemplateObjSettings::lookupTemplateId($this->object->getRefId());
 
                                $type->setValue($value);
 
                                if(!in_array($value, array_keys($options)) || ($existing_exclusive && $value == "dtpl_0"))
                                {
                                        //add or rename actual value to not avaiable
                                        $options[$value] = array($this->lng->txt('not_available'));
                                }
                        }
                        else
                        {
                                if($existing_exclusive)
                                {
                                        //if an exclusive template exists use the second template as default value
                                        $keys = array_keys($options);
                                        $type->setValue($keys[1]);
                                }
                                else
                                {
                                        $type->setValue('dtpl_0');
                                }
 
                        }
                        $form->addItem($type);          
 
                        foreach($options as $id => $data)
                        {
                                $option = new ilRadioOption($data[0], $id, $data[1]);
 
                                if($existing_exclusive && $id == "dtpl_0" && $this->getCreationMode())
                                {
                                        //set default disabled if an exclusive template exists but just in creation screen
                                        $option->setDisabled(true);
                                }
 
                                $type->addOption($option);
                        }
                }
                                                        
                return $form;
        }
        
        protected function addDidacticTemplateOptions(array &$a_options)
        {
                
        }
 
        public function cancelCreation()
        {
                global $ilCtrl;
                
                $ilCtrl->redirectByClass("ilrepositorygui", "frameset");
        }
 
        public function saveObject()
        {
                global $objDefinition, $tpl;
 
                $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", "");
 
                        // create instance
                        $class_name = "ilObj".$objDefinition->getClassName($new_type);
                        $location = $objDefinition->getLocation($new_type);
                        include_once($location."/class.".$class_name.".php");
                        $newObj = new $class_name();
                        $newObj->setType($new_type);
                        $newObj->setTitle($form->getInput("title"));
                        $newObj->setDescription($form->getInput("desc"));
                        $newObj->create();
                        
                        $this->putObjectInTree($newObj);
 
                        // apply didactic template?
                        $dtpl = $this->getDidacticTemplateVar("dtpl");
                        if($dtpl)
                        {
                                $newObj->applyDidacticTemplate($dtpl);
                        }
                        
                        // auto rating
                        $this->handleAutoRating($newObj);
                        
                        // additional paramters are added to afterSave()
                        $args = func_get_args();
                        if($args)
                        {
                                $this->afterSave($newObj, $args);
                        }
                        else
                        {
                                $this->afterSave($newObj);
                        }
                        return;
                }
 
                // display only this form to correct input
                $form->setValuesByPost();
                $tpl->setContent($form->getHtml());
        }
        
        protected function getDidacticTemplateVar($a_type)
        {
                $tpl = $_POST["didactic_type"];
                if($tpl && substr($tpl, 0, strlen($a_type)+1) == $a_type."_")
                {
                        return (int)substr($tpl, strlen($a_type)+1);
                }
                return 0;
        }
 
        protected function putObjectInTree(ilObject $a_obj, $a_parent_node_id = null)
        {
                global $rbacreview, $ilUser, $objDefinition;
 
                if(!$a_parent_node_id)
                {
                        $a_parent_node_id = $_GET["ref_id"];
                }
                
                // add new object to custom parent container
                if((int)$_REQUEST["crtptrefid"])
                {
                        $a_parent_node_id = (int)$_REQUEST["crtptrefid"];
                }
 
                $a_obj->createReference();
                $a_obj->putInTree($a_parent_node_id);
                $a_obj->setPermissions($a_parent_node_id);
 
                $this->obj_id = $a_obj->getId();
                $this->ref_id = $a_obj->getRefId();
 
                // BEGIN ChangeEvent: Record save object.
                require_once('Services/Tracking/classes/class.ilChangeEvent.php');
                ilChangeEvent::_recordWriteEvent($this->obj_id, $ilUser->getId(), 'create');
                // END ChangeEvent: Record save object.
 
                // rbac log
                include_once "Services/AccessControl/classes/class.ilRbacLog.php";
                $rbac_log_roles = $rbacreview->getParentRoleIds($this->ref_id, false);
                $rbac_log = ilRbacLog::gatherFaPa($this->ref_id, array_keys($rbac_log_roles), true);
                ilRbacLog::add(ilRbacLog::CREATE_OBJECT, $this->ref_id, $rbac_log);
                
                // use forced callback after object creation
                if($_REQUEST["crtcb"])
                {
                        $callback_type = ilObject::_lookupType((int)$_REQUEST["crtcb"], true);
                        $class_name = "ilObj".$objDefinition->getClassName($callback_type)."GUI";
                        $location = $objDefinition->getLocation($callback_type);
                        include_once($location."/class.".$class_name.".php");
                        if (in_array(strtolower($class_name), array("ilobjitemgroupgui")))
                        {
                                $callback_obj = new $class_name((int)$_REQUEST["crtcb"]);
                        }
                        else
                        {
                                // #10368
                                $callback_obj = new $class_name(null, (int)$_REQUEST["crtcb"], true, false);
                        }
                        $callback_obj->afterSaveCallback($a_obj);
                }
        }
 
        protected function afterSave(ilObject $a_new_object)
        {
                ilUtil::sendSuccess($this->lng->txt("object_added"), true);
                $this->ctrl->returnToParent($this);
        }
 
        public function editObject()
        {
                global $tpl, $ilTabs;
 
                if (!$this->checkPermissionBool("write"))
                {
                        $this->ilias->raiseError($this->lng->txt("msg_no_perm_write"),$this->ilias->error_obj->MESSAGE);
                }
 
                $ilTabs->activateTab("settings");
 
                $form = $this->initEditForm();
                $values = $this->getEditFormValues();
                if($values)
                {
                        $form->setValuesByArray($values);
                }
                
                $this->addExternalEditFormCustom($form);
                
                $tpl->setContent($form->getHTML());
        }
 
        public function addExternalEditFormCustom(ilPropertyFormGUI $a_form)
        {
                // has to be done AFTER setValuesByArray() ...
        }
        
        protected function initEditForm()
        {
                global $lng, $ilCtrl;
 
                $lng->loadLanguageModule($this->object->getType());
 
                include_once("Services/Form/classes/class.ilPropertyFormGUI.php");
                $form = new ilPropertyFormGUI();
                $form->setFormAction($this->ctrl->getFormAction($this, "update"));
                $form->setTitle($this->lng->txt($this->object->getType()."_edit"));
 
                // 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);
 
                $this->initEditCustomForm($form);
 
                $form->addCommandButton("update", $this->lng->txt("save"));
                //$this->form->addCommandButton("cancelUpdate", $lng->txt("cancel"));
 
                return $form;
        }
 
        protected function initEditCustomForm(ilPropertyFormGUI $a_form)
        {
                
        }
 
        protected function getEditFormValues()
        {
                $values["title"] = $this->object->getTitle();
                $values["desc"] = $this->object->getLongDescription();
                $this->getEditFormCustomValues($values);
                return $values;
        }
 
        protected function getEditFormCustomValues(array &$a_values)
        {
 
        }
 
        public function updateObject()
        {
                global $ilTabs, $tpl;
                
                if (!$this->checkPermissionBool("write"))
                {
                        $this->ilias->raiseError($this->lng->txt("permission_denied"),$this->ilias->error_obj->MESSAGE);
                }
 
                $form = $this->initEditForm();
                if($form->checkInput() && 
                        $this->validateCustom($form))
                {
                        $this->object->setTitle($form->getInput("title"));
                        $this->object->setDescription($form->getInput("desc"));
                        $this->updateCustom($form);
                        $this->object->update();
                        
                        $this->afterUpdate();
                        return;
                }
 
                // display form again to correct errors
                $ilTabs->activateTab("settings");
                $form->setValuesByPost();
                $tpl->setContent($form->getHtml());
        }
        
        protected function validateCustom(ilPropertyFormGUI $a_form)
        {
                return true;
        }
 
        protected function updateCustom(ilPropertyFormGUI $a_form)
        {
 
        }
 
        protected function afterUpdate()
        {
                ilUtil::sendSuccess($this->lng->txt("msg_obj_modified"),true);
                $this->ctrl->redirect($this, "edit");
        }
 
        protected function initImportForm($a_new_type)
        {
                include_once("Services/Form/classes/class.ilPropertyFormGUI.php");
                $form = new ilPropertyFormGUI();
                $form->setTarget("_top");
                $form->setFormAction($this->ctrl->getFormAction($this, "importFile"));
                $form->setTitle($this->lng->txt($a_new_type."_import"));
 
                include_once("./Services/Form/classes/class.ilFileInputGUI.php");
                $fi = new ilFileInputGUI($this->lng->txt("import_file"), "importfile");
                $fi->setSuffixes(array("zip"));
                $fi->setRequired(true);
                $form->addItem($fi);
 
                $form->addCommandButton("importFile", $this->lng->txt("import"));
                $form->addCommandButton("cancel", $this->lng->txt("cancel"));
        
                return $form;
        }
 
        protected function importFileObject($parent_id = null, $a_catch_errors = true)
        {
                global $objDefinition, $tpl, $ilErr;
 
                if(!$parent_id)
                {
                        $parent_id = $_GET["ref_id"];
                }
                $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))
                {
                        $ilErr->raiseError($this->lng->txt("no_create_permission"));
                }
 
                $this->lng->loadLanguageModule($new_type);
                $this->ctrl->setParameter($this, "new_type", $new_type);
                
                $form = $this->initImportForm($new_type);
                if ($form->checkInput())
                {
                        // :todo: make some check on manifest file
 
                        if($objDefinition->isContainer($new_type))
                        {
                                include_once './Services/Export/classes/class.ilImportContainer.php';
                                $imp = new ilImportContainer((int)$parent_id);
                        }
                        else
                        {
                                include_once("./Services/Export/classes/class.ilImport.php");
                                $imp = new ilImport((int)$parent_id);
                        }
 
                        try
                        {
                                $new_id = $imp->importObject(null, $_FILES["importfile"]["tmp_name"],
                                        $_FILES["importfile"]["name"], $new_type);
                        }
                        catch (ilException $e)
                        {
                                $this->tmp_import_dir = $imp->getTemporaryImportDir();
                                if (!$a_catch_errors)
                                {
                                        throw $e;
                                }
                                // display message and form again
                                ilUtil::sendFailure($this->lng->txt("obj_import_file_error")." <br />".$e->getMessage());
                                $form->setValuesByPost();
                                $tpl->setContent($form->getHtml());
                                return;
                        }
 
                        if ($new_id > 0)
                        {
                                $this->ctrl->setParameter($this, "new_type", "");
 
                                $newObj = ilObjectFactory::getInstanceByObjId($new_id);
 
                                // put new object id into tree - already done in import for containers
                                if(!$objDefinition->isContainer($new_type))
                                {
                                        $this->putObjectInTree($newObj);
                                }
                                
                                $this->afterImport($newObj);
                        }
                        // import failed
                        else 
                        {
                                if($objDefinition->isContainer($new_type))
                                {
                                        ilUtil::sendFailure($this->lng->txt("container_import_zip_file_invalid"));
                                }
                                else
                                {
                                        // not enough information here...
                                        return;
                                }
                        }
                }
 
                // display form to correct errors
                $form->setValuesByPost();
                $tpl->setContent($form->getHtml());
        }
 
        protected function afterImport(ilObject $a_new_object)
        {
                ilUtil::sendSuccess($this->lng->txt("object_added"), true);
                $this->ctrl->returnToParent($this);
        }
 
        public function getFormAction($a_cmd, $a_formaction = "")
        {
                if ($this->formaction[$a_cmd] != "")
                {
                        return $this->formaction[$a_cmd];
                }
                else
                {
                        return $a_formaction;
                }
        }
 
        protected function setFormAction($a_cmd, $a_formaction)
        {
                $this->formaction[$a_cmd] = $a_formaction;
        }
 
        protected function getReturnLocation($a_cmd, $a_location ="")
        {
                if ($this->return_location[$a_cmd] != "")
                {
                        return $this->return_location[$a_cmd];
                }
                else
                {
                        return $a_location;
                }
        }
 
        protected function setReturnLocation($a_cmd, $a_location)
        {
//echo "-".$a_cmd."-".$a_location."-";
                $this->return_location[$a_cmd] = $a_location;
        }
 
        protected function getTargetFrame($a_cmd, $a_target_frame = "")
        {
                if ($this->target_frame[$a_cmd] != "")
                {
                        return $this->target_frame[$a_cmd];
                }
                elseif (!empty($a_target_frame))
                {
                        return "target=\"".$a_target_frame."\"";
                }
                else
                {
                        return;
                }
        }
 
        protected function setTargetFrame($a_cmd, $a_target_frame)
        {
                $this->target_frame[$a_cmd] = "target=\"".$a_target_frame."\"";
        }
 
        // BEGIN Security: Hide objects which aren't accessible by the user.
        public function isVisible($a_ref_id,$a_type)
        {
                global $ilBench;
                
                $ilBench->start("Explorer", "setOutput_isVisible");
                $visible = $this->checkPermissionBool("visible,read", "", "", $a_ref_id);
                
                if ($visible && $a_type == 'crs') {
                        global $tree;
                        if($crs_id = $tree->checkForParentType($a_ref_id,'crs'))
                        {
                                if(!$this->checkPermissionBool("write", "", "", $crs_id))
                                {
                                        // Show only activated courses
                                        $tmp_obj =& ilObjectFactory::getInstanceByRefId($crs_id,false);
        
                                        if(!$tmp_obj->isActivated())
                                        {
                                                unset($tmp_obj);
                                                $visible = false;
                                        }
                                }
                        }
                }
                
                $ilBench->stop("Explorer", "setOutput_isVisible");
 
                return $visible;
        }
        // END Security: Hide objects which aren't accessible by the user.
 
        public function viewObject()
        {
                global$tpl;
 
                if (!$this->checkPermissionBool("visible,read"))
                {
                        $this->ilias->raiseError($this->lng->txt("permission_denied"),$this->ilias->error_obj->MESSAGE);
                }
                
                // BEGIN ChangeEvent: record read event.
                require_once('Services/Tracking/classes/class.ilChangeEvent.php');
                global $ilUser;
                ilChangeEvent::_recordReadEvent(
                        $this->object->getType(),
                        $this->object->getRefId(),
                        $this->object->getId(), $ilUser->getId());              
                // END ChangeEvent: record read event.
 
                include_once("./Services/Repository/classes/class.ilAdminSubItemsTableGUI.php");
                if (!$this->call_by_reference)
                {
                        $this->ctrl->setParameter($this, "obj_id", $this->obj_id); 
                }
                $itab = new ilAdminSubItemsTableGUI($this, "view", $_GET["ref_id"]);
                
                $tpl->setContent($itab->getHTML());
        }
 
        public function deleteObject($a_error = false)
        {
                global $ilCtrl;
                
                if ($_GET["item_ref_id"] != "")
                {
                        $_POST["id"] = array($_GET["item_ref_id"]);
                }
                
                if(is_array($_POST["id"]))
                {
                        foreach($_POST["id"] as $idx => $id)
                        {
                                $_POST["id"][$idx] = (int)$id;
                        }
                }
 
                // SAVE POST VALUES (get rid of this
                ilSession::set("saved_post", $_POST["id"]);
 
                include_once("./Services/Repository/classes/class.ilRepUtilGUI.php");
                $ru = new ilRepUtilGUI($this);
                if (!$ru->showDeleteConfirmation($_POST["id"], $a_error))
                {
                        $ilCtrl->returnToParent($this);
                }
        }
 
        protected function showPossibleSubObjects()
        {
                if ($this->sub_objects == "")
                {
                        $d = $this->objDefinition->getCreatableSubObjects($this->object->getType(), ilObjectDefinition::MODE_REPOSITORY, $this->ref_id);
                }
                else
                {
                        $d = $this->sub_objects;
                }
 
                $import = false;
 
                if (count($d) > 0)
                {
                        foreach ($d as $row)
                        {
                            $count = 0;
 
                                if ($row["max"] > 0)
                                {
                                        //how many elements are present?
                                        for ($i=0; $i<count($this->data["ctrl"]); $i++)
                                        {
                                                if ($this->data["ctrl"][$i]["type"] == $row["name"])
                                                {
                                                    $count++;
                                                }
                                        }
                                }
 
                                if ($row["max"] == "" || $count < $row["max"])
                                {
                                        $subobj[] = $row["name"];
                                }
                        }
                }
 
                if (is_array($subobj))
                {
 
                        //build form
                        $opts = ilUtil::formSelect(12,"new_type",$subobj);
                        $this->tpl->setCurrentBlock("add_object");
                        $this->tpl->setVariable("SELECT_OBJTYPE", $opts);
                        $this->tpl->setVariable("BTN_NAME", "create");
                        $this->tpl->setVariable("TXT_ADD", $this->lng->txt("add"));
                        $this->tpl->parseCurrentBlock();
                }
        }
 
        final protected function getTemplateFile($a_cmd,$a_type = "")
        {
                mk(); die("ilObjectGUI::getTemplateFile() is deprecated.");
        }
 
        protected function getTabs()
        {
                // please define your tabs here
 
        }
 
        // PROTECTED
        protected function __showButton($a_cmd,$a_text,$a_target = '')
        {
                global $ilToolbar;
                
                $ilToolbar->addButton($a_text, $this->ctrl->getLinkTarget($this, $a_cmd), $a_target);
        }
 
        protected function hitsperpageObject()
        {
        ilSession::set("tbl_limit", $_POST["hitsperpage"]);
        $_GET["limit"] = $_POST["hitsperpage"];
        }
        
 
        protected function &__initTableGUI()
        {
                include_once "./Services/Table/classes/class.ilTableGUI.php";
 
                return new ilTableGUI(0,false);
        }
        
        protected function __setTableGUIBasicData(&$tbl,&$result_set,$a_from = "")
        {
                switch ($a_from)
                {
                        case "clipboardObject":
                                $offset = $_GET["offset"];
                                $order = $_GET["sort_by"];
                                $direction = $_GET["sort_order"];
                                $tbl->disable("footer");
                                break;
 
                        default:
                                $offset = $_GET["offset"];
                                $order = $_GET["sort_by"];
                                $direction = $_GET["sort_order"];
                                break;
                }
 
                $tbl->setOrderColumn($order);
                $tbl->setOrderDirection($direction);
                $tbl->setOffset($offset);
                $tbl->setLimit($_GET["limit"]);
                $tbl->setFooter("tblfooter",$this->lng->txt("previous"),$this->lng->txt("next"));
                $tbl->setData($result_set);
        }
 
        protected function redirectToRefId($a_ref_id, $a_cmd = "")
        {
                $obj_type = ilObject::_lookupType($a_ref_id,true);
                $class_name = $this->objDefinition->getClassName($obj_type);
                $class = strtolower("ilObj".$class_name."GUI");
                $this->ctrl->setParameterByClass("ilrepositorygui", "ref_id", $a_ref_id);
                $this->ctrl->redirectByClass(array("ilrepositorygui", $class), $a_cmd);
        }
        
        // Object Cloning
        protected function fillCloneTemplate($a_tpl_varname,$a_type)
        {
                include_once './Services/Object/classes/class.ilObjectCopyGUI.php';
                $cp = new ilObjectCopyGUI($this);
                $cp->setType($a_type);
                $cp->setTarget($_GET['ref_id']);
                if($a_tpl_varname)
                {
                        $cp->showSourceSearch($a_tpl_varname);
                }
                else
                {
                        return $cp->showSourceSearch(null);
                }
        }
        
        public function cloneAllObject()
        {
                include_once('./Services/Link/classes/class.ilLink.php');
                include_once('Services/CopyWizard/classes/class.ilCopyWizardOptions.php');
                
                global $ilErr,$ilUser;
                
                $new_type = $_REQUEST['new_type'];
                if(!$this->checkPermissionBool("create", "", $new_type))
                {
                        $ilErr->raiseError($this->lng->txt('permission_denied'));
                }
                if(!(int) $_REQUEST['clone_source'])
                {
                        ilUtil::sendFailure($this->lng->txt('select_one'));
                        $this->createObject();
                        return false;
                }
                if(!$this->checkPermissionBool("write", "", $new_type, (int)$_REQUEST['clone_source']))
                {
                        $ilErr->raiseError($this->lng->txt('permission_denied'));
                }
                
                // Save wizard options
                $copy_id = ilCopyWizardOptions::_allocateCopyId();
                $wizard_options = ilCopyWizardOptions::_getInstance($copy_id);
                $wizard_options->saveOwner($ilUser->getId());
                $wizard_options->saveRoot((int) $_REQUEST['clone_source']);
                
                $options = $_POST['cp_options'] ? $_POST['cp_options'] : array();
                foreach($options as $source_id => $option)
                {
                        $wizard_options->addEntry($source_id,$option);
                }
                $wizard_options->read();
                
                $orig = ilObjectFactory::getInstanceByRefId((int) $_REQUEST['clone_source']);
                $new_obj = $orig->cloneObject((int) $_GET['ref_id'],$copy_id);
                
                // Delete wizard options
                $wizard_options->deleteAll();
 
                ilUtil::sendSuccess($this->lng->txt("object_duplicated"),true);
                ilUtil::redirect(ilLink::_getLink($new_obj->getRefId()));
        }
        
        
        protected function getCenterColumnHTML()
        {
                global $ilCtrl;
 
                include_once("Services/Block/classes/class.ilColumnGUI.php");
 
                $obj_id = ilObject::_lookupObjId($this->object->getRefId());
                $obj_type = ilObject::_lookupType($obj_id);
 
                if ($ilCtrl->getNextClass() != "ilcolumngui")
                {
                        // normal command processing    
                        return $this->getContent();
                }
                else
                {
                        if (!$ilCtrl->isAsynch())
                        {
                                //if ($column_gui->getScreenMode() != IL_SCREEN_SIDE)
                                if (ilColumnGUI::getScreenMode() != IL_SCREEN_SIDE)
                                {
                                        // right column wants center
                                        if (ilColumnGUI::getCmdSide() == IL_COL_RIGHT)
                                        {
                                                $column_gui = new ilColumnGUI($obj_type, IL_COL_RIGHT);
                                                $this->setColumnSettings($column_gui);
                                                $this->html = $ilCtrl->forwardCommand($column_gui);
                                        }
                                        // left column wants center
                                        if (ilColumnGUI::getCmdSide() == IL_COL_LEFT)
                                        {
                                                $column_gui = new ilColumnGUI($obj_type, IL_COL_LEFT);
                                                $this->setColumnSettings($column_gui);
                                                $this->html = $ilCtrl->forwardCommand($column_gui);
                                        }
                                }
                                else
                                {
                                        // normal command processing    
                                        return $this->getContent();
                                }
                        }
                }
        }
        
        protected function getRightColumnHTML()
        {
                global $ilUser, $lng, $ilCtrl;
                
                $obj_id = ilObject::_lookupObjId($this->object->getRefId());
                $obj_type = ilObject::_lookupType($obj_id);
 
                include_once("Services/Block/classes/class.ilColumnGUI.php");
                $column_gui = new ilColumnGUI($obj_type, IL_COL_RIGHT);
                
                if ($column_gui->getScreenMode() == IL_SCREEN_FULL)
                {
                        return "";
                }
                
                $this->setColumnSettings($column_gui);
                
                if ($ilCtrl->getNextClass() == "ilcolumngui" &&
                        $column_gui->getCmdSide() == IL_COL_RIGHT &&
                        $column_gui->getScreenMode() == IL_SCREEN_SIDE)
                {
                        $html = $ilCtrl->forwardCommand($column_gui);
                }
                else
                {
                        if (!$ilCtrl->isAsynch())
                        {
                                $html = $ilCtrl->getHTML($column_gui);
                        }
                }
 
                return $html;
        }
 
        protected function setColumnSettings(ilColumnGUI $column_gui)
        {
                $column_gui->setRepositoryMode(true);
                $column_gui->setEnableEdit(false);
                if ($this->checkPermissionBool("write"))
                {
                        $column_gui->setEnableEdit(true);
                }
        }
 
        protected function checkPermission($a_perm, $a_cmd = "", $a_type = "", $a_ref_id = null)
        {
                if (!$this->checkPermissionBool($a_perm, $a_cmd, $a_type, $a_ref_id))
                {
                        if (!is_int(strpos($_SERVER["PHP_SELF"], "goto.php")))
                        {
                                // create: redirect to parent
                                if($a_perm == "create")
                                {
                                        if(!$a_ref_id)
                                        {
                                                $a_ref_id = $_GET["ref_id"];
                                        }
                                        $type = ilObject::_lookupType($a_ref_id, true);                                 
                                }
                                else
                                {
                                        // does this make sense?
                                        if (!is_object($this->object))
                                        {
                                                return;
                                        }
                                        if (!$a_ref_id)
                                        {
                                                $a_ref_id = $this->object->getRefId();
                                        }
                                        $type = $this->object->getType();
                                }
 
                                ilSession::clear("il_rep_ref_id");
                                
                                include_once "Services/Object/exceptions/class.ilObjectException.php";
                                throw new ilObjectException($this->lng->txt("permission_denied"));
                                
                                /*
                                ilUtil::sendFailure($this->lng->txt("permission_denied"), true);
                                ilUtil::redirect("goto.php?target=".$type."_".$a_ref_id);                               
                                */
                        }
                        // we should never be here
                        else    
                        {
                                die("Permission Denied.");
                        }
                }
        }
 
        protected function checkPermissionBool($a_perm, $a_cmd = "", $a_type = "", $a_ref_id = null)
        {
                global $ilAccess;
 
                if($a_perm == "create")
                {
                        if(!$a_ref_id)
                        {
                                $a_ref_id = $_GET["ref_id"];
                        }
                        return $ilAccess->checkAccess($a_perm."_".$a_type, $a_cmd, $a_ref_id);
                }
                else
                {
                        // does this make sense?
                        if (!is_object($this->object))
                        {
                                return false;
                        }
                        if (!$a_ref_id)
                        {
                                $a_ref_id = $this->object->getRefId();
                        }
                        return $ilAccess->checkAccess($a_perm, $a_cmd, $a_ref_id);
                }
        }
        
        static function _gotoRepositoryRoot($a_raise_error = false)
        {
                global $ilAccess, $ilErr, $lng;
                
                if ($ilAccess->checkAccess("read", "", ROOT_FOLDER_ID))
                {
                        $_GET["cmd"] = "frameset";
                        $_GET["target"] = "";
                        $_GET["ref_id"] = ROOT_FOLDER_ID;
                        $_GET["baseClass"] = "ilRepositoryGUI";
                        include("ilias.php");
                        exit;
                }
 
                if ($a_raise_error)
                {
                        $ilErr->raiseError($lng->txt("msg_no_perm_read"), $ilErr->FATAL);
                }
        }
        
        static function _gotoRepositoryNode($a_ref_id, $a_cmd = "frameset")
        {
                global $ilAccess, $ilErr;
 
                $_GET["cmd"] = $a_cmd;
                $_GET["target"] = "";
                $_GET["ref_id"] = $a_ref_id;
                $_GET["baseClass"] = "ilRepositoryGUI";
                include("ilias.php");
                exit;
        }
        
        protected function enableDragDropFileUpload()
        {
                include_once("./Services/FileUpload/classes/class.ilFileUploadGUI.php");
                ilFileUploadGUI::initFileUpload();
                
                $this->tpl->enableDragDropFileUpload($this->ref_id);
        }
        
        protected function handleAutoRating(ilObject $a_new_obj)
        {                               
                if(ilObject::hasAutoRating($a_new_obj->getType(), $a_new_obj->getRefId()) && 
                        method_exists($a_new_obj, "setRating"))
                {                                                       
                        $a_new_obj->setRating(true);
                        $a_new_obj->update();
                }               
        }
} // END class.ilObjectGUI (3.10: 2896 loc)
 
?>