mirror of
https://github.com/moodle/moodle.git
synced 2025-01-17 21:49:15 +01:00
29a541724f
This has been generated running the following Sniff, part of the Moodle's CodeSniffer standard: - PSR2.Methods.MethodDeclaration It just ensures all the function declarations have the correct order for: - abstract and final. - visibility (public, protected, private). - static. So, all the lines modified by this commit are function declarations and the only changes are in the positions of those keywords.
644 lines
23 KiB
PHP
644 lines
23 KiB
PHP
<?php
|
|
|
|
// This file is part of Moodle - http://moodle.org/
|
|
//
|
|
// Moodle is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// Moodle is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with Moodle. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
/**
|
|
* Classes for displaying and editing a nested list of items.
|
|
*
|
|
* Handles functionality for :
|
|
*
|
|
* Construction of nested list from db records with some key pointing to a parent id.
|
|
* Display of list with or without editing icons with optional pagination.
|
|
* Reordering of items works across pages.
|
|
* Processing of editing actions on list.
|
|
*
|
|
* @package core
|
|
* @subpackage lib
|
|
* @copyright Jamie Pratt
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
|
|
defined('MOODLE_INTERNAL') || die();
|
|
|
|
/**
|
|
* Clues to reading this code:
|
|
*
|
|
* The functions that move things around the tree structure just update the
|
|
* database - they don't update the in-memory structure, instead they trigger a
|
|
* page reload so everything is rebuilt from scratch.
|
|
*
|
|
* @package moodlecore
|
|
* @copyright Jamie Pratt
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
abstract class moodle_list {
|
|
public $attributes;
|
|
public $listitemclassname = 'list_item';
|
|
|
|
/** @var array of $listitemclassname objects. */
|
|
public $items = array();
|
|
|
|
/** @var string 'ol' or 'ul'. */
|
|
public $type;
|
|
|
|
/** @var list_item or derived class. */
|
|
public $parentitem = null;
|
|
public $table;
|
|
public $fieldnamesparent = 'parent';
|
|
|
|
/** @var array Records from db, only used in top level list. */
|
|
public $records = array();
|
|
|
|
public $editable;
|
|
|
|
/** @var array keys are child ids, values are parents. */
|
|
public $childparent;
|
|
|
|
//------------------------------------------------------
|
|
//vars used for pagination.
|
|
public $page = 0; // 0 means no pagination
|
|
public $firstitem = 1;
|
|
public $lastitem = 999999;
|
|
public $pagecount;
|
|
public $paged = false;
|
|
public $offset = 0;
|
|
//------------------------------------------------------
|
|
public $pageurl;
|
|
public $pageparamname;
|
|
|
|
/** @var int no of top level items. */
|
|
private $itemsperpage;
|
|
|
|
/**
|
|
* Constructor.
|
|
*
|
|
* @param string $type
|
|
* @param string $attributes
|
|
* @param boolean $editable
|
|
* @param moodle_url $pageurl url for this page
|
|
* @param integer $page if 0 no pagination. (These three params only used in top level list.)
|
|
* @param string $pageparamname name of url param that is used for passing page no
|
|
* @param integer $itemsperpage no of top level items.
|
|
*/
|
|
public function __construct($type='ul', $attributes='', $editable = false, $pageurl=null, $page = 0, $pageparamname = 'page', $itemsperpage = 20) {
|
|
global $PAGE;
|
|
|
|
$this->editable = $editable;
|
|
$this->attributes = $attributes;
|
|
$this->type = $type;
|
|
$this->page = $page;
|
|
$this->pageparamname = $pageparamname;
|
|
$this->itemsperpage = $itemsperpage;
|
|
if ($pageurl === null) {
|
|
$this->pageurl = new moodle_url($PAGE->url);
|
|
$this->pageurl->params(array($this->pageparamname => $this->page));
|
|
} else {
|
|
$this->pageurl = $pageurl;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns html string.
|
|
*
|
|
* @param integer $indent depth of indentation.
|
|
*/
|
|
public function to_html($indent=0, $extraargs=array()) {
|
|
if (count($this->items)) {
|
|
$tabs = str_repeat("\t", $indent);
|
|
$first = true;
|
|
$itemiter = 1;
|
|
$lastitem = '';
|
|
$html = '';
|
|
|
|
foreach ($this->items as $item) {
|
|
$last = (count($this->items) == $itemiter);
|
|
if ($this->editable) {
|
|
$item->set_icon_html($first, $last, $lastitem);
|
|
}
|
|
if ($itemhtml = $item->to_html($indent+1, $extraargs)) {
|
|
$html .= "$tabs\t<li".((!empty($item->attributes))?(' '.$item->attributes):'').">";
|
|
$html .= $itemhtml;
|
|
$html .= "</li>\n";
|
|
}
|
|
$first = false;
|
|
$lastitem = $item;
|
|
$itemiter++;
|
|
}
|
|
} else {
|
|
$html = '';
|
|
}
|
|
if ($html) { //if there are list items to display then wrap them in ul / ol tag.
|
|
$tabs = str_repeat("\t", $indent);
|
|
$html = $tabs.'<'.$this->type.((!empty($this->attributes))?(' '.$this->attributes):'').">\n".$html;
|
|
$html .= $tabs."</".$this->type.">\n";
|
|
} else {
|
|
$html ='';
|
|
}
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Recurse down the tree and find an item by it's id.
|
|
*
|
|
* @param integer $id
|
|
* @param boolean $suppresserror error if not item found?
|
|
* @return list_item *copy* or null if item is not found
|
|
*/
|
|
public function find_item($id, $suppresserror = false) {
|
|
if (isset($this->items)) {
|
|
foreach ($this->items as $key => $child) {
|
|
if ($child->id == $id) {
|
|
return $this->items[$key];
|
|
}
|
|
}
|
|
foreach (array_keys($this->items) as $key) {
|
|
$thischild = $this->items[$key];
|
|
$ref = $thischild->children->find_item($id, true);//error always reported at top level
|
|
if ($ref !== null) {
|
|
return $ref;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!$suppresserror) {
|
|
throw new \moodle_exception('listnoitem');
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public function add_item($item) {
|
|
$this->items[] = $item;
|
|
}
|
|
|
|
public function set_parent($parent) {
|
|
$this->parentitem = $parent;
|
|
}
|
|
|
|
/**
|
|
* Produces a hierarchical tree of list items from a flat array of records.
|
|
* 'parent' field is expected to point to a parent record.
|
|
* records are already sorted.
|
|
* If the parent field doesn't point to another record in the array then this is
|
|
* a top level list
|
|
*
|
|
* @param integer $offset how many list toplevel items are there in lists before this one
|
|
* @return array(boolean, integer) whether there is more than one page, $offset + how many toplevel items where there in this list.
|
|
*
|
|
*/
|
|
public function list_from_records($paged = false, $offset = 0) {
|
|
$this->paged = $paged;
|
|
$this->offset = $offset;
|
|
$this->get_records();
|
|
$records = $this->records;
|
|
$page = $this->page;
|
|
if (!empty($page)) {
|
|
$this->firstitem = ($page - 1) * $this->itemsperpage;
|
|
$this->lastitem = $this->firstitem + $this->itemsperpage - 1;
|
|
}
|
|
$itemiter = $offset;
|
|
//make a simple array which is easier to search
|
|
$this->childparent = array();
|
|
foreach ($records as $record) {
|
|
$this->childparent[$record->id] = $record->parent;
|
|
}
|
|
|
|
//create top level list items and they're responsible for creating their children
|
|
foreach ($records as $record) {
|
|
if (array_key_exists($record->parent, $this->childparent)) {
|
|
// This record is a child of another record, so it will be dealt
|
|
// with by a call to list_item::create_children, not here.
|
|
continue;
|
|
}
|
|
|
|
$inpage = $itemiter >= $this->firstitem && $itemiter <= $this->lastitem;
|
|
|
|
// Make list item for top level for all items
|
|
// we need the info about the top level items for reordering peers.
|
|
if ($this->parentitem !== null) {
|
|
$newattributes = $this->parentitem->attributes;
|
|
} else {
|
|
$newattributes = '';
|
|
}
|
|
|
|
$this->items[$itemiter] = new $this->listitemclassname($record, $this, $newattributes, $inpage);
|
|
|
|
if ($inpage) {
|
|
$this->items[$itemiter]->create_children($records, $this->childparent, $record->id);
|
|
} else {
|
|
// Don't recurse down the tree for items that are not on this page
|
|
$this->paged = true;
|
|
}
|
|
|
|
$itemiter++;
|
|
}
|
|
return array($this->paged, $itemiter);
|
|
}
|
|
|
|
/**
|
|
* Should be overriden to return an array of records of list items.
|
|
*/
|
|
abstract public function get_records();
|
|
|
|
/**
|
|
* display list of page numbers for navigation
|
|
*/
|
|
public function display_page_numbers() {
|
|
$html = '';
|
|
$topcount = count($this->items);
|
|
$this->pagecount = (integer) ceil(($topcount + $this->offset)/ QUESTION_PAGE_LENGTH );
|
|
if (!empty($this->page) && ($this->paged)) {
|
|
$html = "<div class=\"paging\">".get_string('page').":\n";
|
|
foreach (range(1,$this->pagecount) as $currentpage) {
|
|
if ($this->page == $currentpage) {
|
|
$html .= " $currentpage \n";
|
|
}
|
|
else {
|
|
$html .= "<a href=\"".$this->pageurl->out(true, array($this->pageparamname => $currentpage))."\">";
|
|
$html .= " $currentpage </a>\n";
|
|
}
|
|
}
|
|
$html .= "</div>";
|
|
}
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of ids of peers of an item.
|
|
*
|
|
* @param int itemid - if given, restrict records to those with this parent id.
|
|
* @return array peer ids
|
|
*/
|
|
public function get_items_peers($itemid) {
|
|
$itemref = $this->find_item($itemid);
|
|
$peerids = $itemref->parentlist->get_child_ids();
|
|
return $peerids;
|
|
}
|
|
|
|
/**
|
|
* Returns an array of ids of child items.
|
|
*
|
|
* @return array peer ids
|
|
*/
|
|
public function get_child_ids() {
|
|
$childids = array();
|
|
foreach ($this->items as $child) {
|
|
$childids[] = $child->id;
|
|
}
|
|
return $childids;
|
|
}
|
|
|
|
/**
|
|
* Returns the value to be used as the parent for the $item when it goes to the top level.
|
|
* Override if needed.
|
|
*
|
|
* @param list_item $item The item which its top level parent is going to be returned.
|
|
* @return int
|
|
*/
|
|
public function get_top_level_parent_id($item) {
|
|
return 0; // Top level items have no parent.
|
|
}
|
|
|
|
/**
|
|
* Move a record up or down
|
|
*
|
|
* @param string $direction up / down
|
|
* @param integer $id
|
|
*/
|
|
public function move_item_up_down($direction, $id) {
|
|
$peers = $this->get_items_peers($id);
|
|
$itemkey = array_search($id, $peers);
|
|
switch ($direction) {
|
|
case 'down' :
|
|
if (isset($peers[$itemkey+1])) {
|
|
$olditem = $peers[$itemkey+1];
|
|
$peers[$itemkey+1] = $id;
|
|
$peers[$itemkey] = $olditem;
|
|
} else {
|
|
throw new \moodle_exception('listcantmoveup');
|
|
}
|
|
break;
|
|
|
|
case 'up' :
|
|
if (isset($peers[$itemkey-1])) {
|
|
$olditem = $peers[$itemkey-1];
|
|
$peers[$itemkey-1] = $id;
|
|
$peers[$itemkey] = $olditem;
|
|
} else {
|
|
throw new \moodle_exception('listcantmovedown');
|
|
}
|
|
break;
|
|
}
|
|
$this->reorder_peers($peers);
|
|
}
|
|
|
|
public function reorder_peers($peers) {
|
|
global $DB;
|
|
foreach ($peers as $key => $peer) {
|
|
$DB->set_field($this->table, "sortorder", $key, array("id"=>$peer));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Moves the item one step up in the tree.
|
|
*
|
|
* @param int $id an item index.
|
|
* @return list_item the item that used to be the parent of the item moved.
|
|
*/
|
|
public function move_item_left($id) {
|
|
global $DB;
|
|
|
|
$item = $this->find_item($id);
|
|
if (!isset($item->parentlist->parentitem->parentlist)) {
|
|
throw new \moodle_exception('listcantmoveleft');
|
|
} else {
|
|
$newpeers = $this->get_items_peers($item->parentlist->parentitem->id);
|
|
if (isset($item->parentlist->parentitem->parentlist->parentitem)) {
|
|
$newparent = $item->parentlist->parentitem->parentlist->parentitem->id;
|
|
} else {
|
|
$newparent = $this->get_top_level_parent_id($item);
|
|
}
|
|
$DB->set_field($this->table, "parent", $newparent, array("id"=>$item->id));
|
|
$oldparentkey = array_search($item->parentlist->parentitem->id, $newpeers);
|
|
$neworder = array_merge(array_slice($newpeers, 0, $oldparentkey+1), array($item->id), array_slice($newpeers, $oldparentkey+1));
|
|
$this->reorder_peers($neworder);
|
|
}
|
|
return $item->parentlist->parentitem;
|
|
}
|
|
|
|
/**
|
|
* Make item with id $id the child of the peer that is just above it in the sort order.
|
|
*
|
|
* @param integer $id
|
|
*/
|
|
public function move_item_right($id) {
|
|
global $DB;
|
|
|
|
$peers = $this->get_items_peers($id);
|
|
$itemkey = array_search($id, $peers);
|
|
if (!isset($peers[$itemkey-1])) {
|
|
throw new \moodle_exception('listcantmoveright');
|
|
} else {
|
|
$DB->set_field($this->table, "parent", $peers[$itemkey-1], array("id"=>$peers[$itemkey]));
|
|
$newparent = $this->find_item($peers[$itemkey-1]);
|
|
if (isset($newparent->children)) {
|
|
$newpeers = $newparent->children->get_child_ids();
|
|
}
|
|
if ($newpeers) {
|
|
$newpeers[] = $peers[$itemkey];
|
|
$this->reorder_peers($newpeers);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* process any actions.
|
|
*
|
|
* @param integer $left id of item to move left
|
|
* @param integer $right id of item to move right
|
|
* @param integer $moveup id of item to move up
|
|
* @param integer $movedown id of item to move down
|
|
* @return unknown
|
|
*/
|
|
public function process_actions($left, $right, $moveup, $movedown) {
|
|
//should this action be processed by this list object?
|
|
if (!(array_key_exists($left, $this->records) || array_key_exists($right, $this->records) || array_key_exists($moveup, $this->records) || array_key_exists($movedown, $this->records))) {
|
|
return false;
|
|
}
|
|
if (!empty($left)) {
|
|
$oldparentitem = $this->move_item_left($left);
|
|
if ($this->item_is_last_on_page($oldparentitem->id)) {
|
|
// Item has jumped onto the next page, change page when we redirect.
|
|
$this->page ++;
|
|
$this->pageurl->params(array($this->pageparamname => $this->page));
|
|
}
|
|
} else if (!empty($right)) {
|
|
$this->move_item_right($right);
|
|
if ($this->item_is_first_on_page($right)) {
|
|
// Item has jumped onto the previous page, change page when we redirect.
|
|
$this->page --;
|
|
$this->pageurl->params(array($this->pageparamname => $this->page));
|
|
}
|
|
} else if (!empty($moveup)) {
|
|
$this->move_item_up_down('up', $moveup);
|
|
if ($this->item_is_first_on_page($moveup)) {
|
|
// Item has jumped onto the previous page, change page when we redirect.
|
|
$this->page --;
|
|
$this->pageurl->params(array($this->pageparamname => $this->page));
|
|
}
|
|
} else if (!empty($movedown)) {
|
|
$this->move_item_up_down('down', $movedown);
|
|
if ($this->item_is_last_on_page($movedown)) {
|
|
// Item has jumped onto the next page, change page when we redirect.
|
|
$this->page ++;
|
|
$this->pageurl->params(array($this->pageparamname => $this->page));
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
redirect($this->pageurl);
|
|
}
|
|
|
|
/**
|
|
* @param integer $itemid an item id.
|
|
* @return boolean Is the item with the given id the first top-level item on
|
|
* the current page?
|
|
*/
|
|
public function item_is_first_on_page($itemid) {
|
|
return $this->page && isset($this->items[$this->firstitem]) &&
|
|
$itemid == $this->items[$this->firstitem]->id;
|
|
}
|
|
|
|
/**
|
|
* @param integer $itemid an item id.
|
|
* @return boolean Is the item with the given id the last top-level item on
|
|
* the current page?
|
|
*/
|
|
public function item_is_last_on_page($itemid) {
|
|
return $this->page && isset($this->items[$this->lastitem]) &&
|
|
$itemid == $this->items[$this->lastitem]->id;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @package moodlecore
|
|
* @copyright Jamie Pratt
|
|
* @license http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
|
|
*/
|
|
abstract class list_item {
|
|
/** @var integer id of record, used if list is editable. */
|
|
public $id;
|
|
|
|
/** @var string name of this item, used if list is editable. */
|
|
public $name;
|
|
|
|
/** @var mixed The object or string representing this item. */
|
|
public $item;
|
|
public $fieldnamesname = 'name';
|
|
public $attributes;
|
|
public $display;
|
|
public $icons = array();
|
|
|
|
/** @var moodle_list */
|
|
public $parentlist;
|
|
|
|
/** @var moodle_list Set if there are any children of this listitem. */
|
|
public $children;
|
|
|
|
/**
|
|
* Constructor
|
|
* @param mixed $item fragment of html for list item or record
|
|
* @param object $parent reference to parent of this item
|
|
* @param string $attributes attributes for li tag
|
|
* @param boolean $display whether this item is displayed. Some items may be loaded so we have a complete
|
|
* structure in memory to work with for actions but are not displayed.
|
|
* @return list_item
|
|
*/
|
|
public function __construct($item, $parent, $attributes = '', $display = true) {
|
|
$this->item = $item;
|
|
if (is_object($this->item)) {
|
|
$this->id = $this->item->id;
|
|
$this->name = $this->item->{$this->fieldnamesname};
|
|
}
|
|
$this->set_parent($parent);
|
|
$this->attributes = $attributes;
|
|
$parentlistclass = get_class($parent);
|
|
$this->children = new $parentlistclass($parent->type, $parent->attributes, $parent->editable, $parent->pageurl, 0);
|
|
$this->children->set_parent($this);
|
|
$this->display = $display;
|
|
}
|
|
|
|
/**
|
|
* Output the html just for this item. Called by to_html which adds html for children.
|
|
*
|
|
*/
|
|
public function item_html($extraargs = array()) {
|
|
if (is_string($this->item)) {
|
|
$html = $this->item;
|
|
} elseif (is_object($this->item)) {
|
|
//for debug purposes only. You should create a sub class to
|
|
//properly handle the record
|
|
$html = join(', ', (array)$this->item);
|
|
}
|
|
return $html;
|
|
}
|
|
|
|
/**
|
|
* Returns html
|
|
*
|
|
* @param integer $indent
|
|
* @param array $extraargs any extra data that is needed to print the list item
|
|
* may be used by sub class.
|
|
* @return string html
|
|
*/
|
|
public function to_html($indent = 0, $extraargs = array()) {
|
|
if (!$this->display) {
|
|
return '';
|
|
}
|
|
$tabs = str_repeat("\t", $indent);
|
|
|
|
if (isset($this->children)) {
|
|
$childrenhtml = $this->children->to_html($indent+1, $extraargs);
|
|
} else {
|
|
$childrenhtml = '';
|
|
}
|
|
return $this->item_html($extraargs).' '.(join('', $this->icons)).(($childrenhtml !='')?("\n".$childrenhtml):'');
|
|
}
|
|
|
|
public function set_icon_html($first, $last, $lastitem) {
|
|
global $CFG;
|
|
$strmoveup = get_string('moveup');
|
|
$strmovedown = get_string('movedown');
|
|
$strmoveleft = get_string('maketoplevelitem', 'question');
|
|
|
|
if (right_to_left()) { // Exchange arrows on RTL
|
|
$rightarrow = 'left';
|
|
$leftarrow = 'right';
|
|
} else {
|
|
$rightarrow = 'right';
|
|
$leftarrow = 'left';
|
|
}
|
|
|
|
if (isset($this->parentlist->parentitem)) {
|
|
$parentitem = $this->parentlist->parentitem;
|
|
if (isset($parentitem->parentlist->parentitem)) {
|
|
$action = get_string('makechildof', 'question', $parentitem->parentlist->parentitem->name);
|
|
} else {
|
|
$action = $strmoveleft;
|
|
}
|
|
$url = new moodle_url($this->parentlist->pageurl, (array('sesskey'=>sesskey(), 'left'=>$this->id)));
|
|
$this->icons['left'] = $this->image_icon($action, $url, $leftarrow);
|
|
} else {
|
|
$this->icons['left'] = $this->image_spacer();
|
|
}
|
|
|
|
if (!$first) {
|
|
$url = new moodle_url($this->parentlist->pageurl, (array('sesskey'=>sesskey(), 'moveup'=>$this->id)));
|
|
$this->icons['up'] = $this->image_icon($strmoveup, $url, 'up');
|
|
} else {
|
|
$this->icons['up'] = $this->image_spacer();
|
|
}
|
|
|
|
if (!$last) {
|
|
$url = new moodle_url($this->parentlist->pageurl, (array('sesskey'=>sesskey(), 'movedown'=>$this->id)));
|
|
$this->icons['down'] = $this->image_icon($strmovedown, $url, 'down');
|
|
} else {
|
|
$this->icons['down'] = $this->image_spacer();
|
|
}
|
|
|
|
if (!empty($lastitem)) {
|
|
$makechildof = get_string('makechildof', 'question', $lastitem->name);
|
|
$url = new moodle_url($this->parentlist->pageurl, (array('sesskey'=>sesskey(), 'right'=>$this->id)));
|
|
$this->icons['right'] = $this->image_icon($makechildof, $url, $rightarrow);
|
|
} else {
|
|
$this->icons['right'] = $this->image_spacer();
|
|
}
|
|
}
|
|
|
|
public function image_icon($action, $url, $icon) {
|
|
global $OUTPUT;
|
|
return '<a title="' . s($action) .'" href="'.$url.'">' .
|
|
$OUTPUT->pix_icon('t/' . $icon, $action) . '</a> ';
|
|
}
|
|
|
|
public function image_spacer() {
|
|
global $OUTPUT;
|
|
return $OUTPUT->spacer();
|
|
}
|
|
|
|
/**
|
|
* Recurse down tree creating list_items, called from moodle_list::list_from_records
|
|
*
|
|
* @param array $records
|
|
* @param array $children
|
|
* @param integer $thisrecordid
|
|
*/
|
|
public function create_children(&$records, &$children, $thisrecordid) {
|
|
//keys where value is $thisrecordid
|
|
$thischildren = moodle_array_keys_filter($children, $thisrecordid);
|
|
foreach ($thischildren as $child) {
|
|
$thisclass = get_class($this);
|
|
$newlistitem = new $thisclass($records[$child], $this->children, $this->attributes);
|
|
$this->children->add_item($newlistitem);
|
|
$newlistitem->create_children($records, $children, $records[$child]->id);
|
|
}
|
|
}
|
|
|
|
public function set_parent($parent) {
|
|
$this->parentlist = $parent;
|
|
}
|
|
}
|