silverstripe-framework/forms/GridFieldPresenter.php
Stig Lindqvist 83e90aaafe ENHANCEMENT Release of DataGridPagination
This class extends the DataGridPresenter with the behaviour and looks of a paginated Datagrid.
2011-10-28 17:34:15 +13:00

418 lines
9.4 KiB
PHP

<?php
/**
* The GridFieldPresenter is responsible for rendering and attach user behaviour
* to a GridField.
*
* You can create a GridFieldPresenter and inject that into a GridField to
* customise look and feel of GridField.
*
* It also have the possibility to let extensions to modify the look and feel of
* the GridField if you dont want to make a fully blown GridFieldPresenter.
*
* In the following example we configure the GridField to sort the DataList in
* the GridField by Title. This will override the sorting on the DataList.
*
* <code>
* $presenter = new GridFieldPresenter();
* $presenter->sort('Title', 'desc');
* $gridField = new GridField('ExampleGrid', 'Example grid', new DataList('Page'),null, $presenter);
* </code>
*
* Another example is to change the template for the rendering
*
* <code>
* $presenter = new GridFieldPresenter();
* $presenter->setTemplate('MyNiftyGridTemplate');
* $gridField = new GridField('ExampleGrid', 'Example grid', new DataList('Page'),null, $presenter);
* </code>
*
* There is also a possibility to add extensions to the GridPresenter. An
* example is the DataGridPagination that decorates the GridField with
* pagination. Look in the GridFieldPresenter::Items() and the filterList extend
* and GridFieldPresenter::Footers()
*
* <code>
* GridFieldPresenter::add_extension('GridFieldPaginator_Extension');
* $presenter = new GridFieldPresenter();
* // This is actually calling GridFieldPaginator_Extension::paginationLimit()
* $presenter->paginationLimit(3);
* $gridField = new GridField('ExampleGrid', 'Example grid', new DataList('Page'),null, $presenter);
* </code>
*
* @see GridField
* @see GridFieldPaginator
* @package sapphire
*/
class GridFieldPresenter extends ViewableData {
/**
* Template override
*
* @var string $template
*/
protected $template = 'GridFieldPresenter';
/**
* Class name for each item/row
*
* @var string $itemClass
*/
protected $itemClass = 'GridFieldPresenter_Item';
/**
* @var GridField
*/
protected $GridField = null;
/**
* @var array
*/
public $fieldCasting = array();
/**
* @var array
*/
public $fieldFormatting = array();
/**
* List of columns and direction that the {@link GridFieldPresenter} is
* sorted in.
*
* @var array
*/
protected $sorting = array();
/**
* @param string $template
*/
public function setTemplate($template){
$this->template = $template;
}
/**
* The name of the Field
*
* @return string
*/
public function Name() {
return $this->getGridField()->Name();
}
/**
* @param GridField $GridField
*/
public function setGridField(GridField $grid){
$this->GridField = $grid;
}
/**
* @return GridField
*/
public function getGridField(){
return $this->GridField;
}
/**
*
* @param type $extension
*/
public static function add_extension($extension) {
parent::add_extension(__CLASS__, $extension);
}
/**
* Sort the grid by columns
*
* @param string $column
* @param string $direction
*/
public function sort($column, $direction = 'asc') {
$this->sorting[$column] = $direction;
return $this;
}
/**
* Return an {@link ArrayList} of {@link GridField_Item} objects, suitable for display in the template.
*
* @return ArrayList
*/
public function Items() {
$items = new ArrayList();
if($this->sorting) {
$this->setSortingOnList($this->sorting);
}
//empty for now
$list = $this->getGridField()->getList();
$parameters = new stdClass();
$parameters->Controller = Controller::curr();
$parameters->Request = Controller::curr()->getRequest();
$this->extend('filterList', $list, $parameters);
if($list) {
$numberOfRows = $list->count();
$counter = 0;
foreach($list as $item) {
$itemPresenter = new $this->itemClass($item, $this);
$itemPresenter->iteratorProperties($counter++, $numberOfRows);
$items->push($itemPresenter);
}
}
return $items;
}
/**
* Get the headers or column names for this grid
*
* The returning array will have the format of
*
* <code>
* array(
* 'FirstName' => 'First name',
* 'Description' => 'A nice description'
* )
* </code>
*
* @return ArrayList
* @throws Exception
*/
public function Headers() {
if(!$this->getList()) {
throw new Exception(sprintf(
'%s needs an data source to be able to render the form', get_class($this->getGridField())
));
}
return $this->summaryFieldsToList($this->FieldList());
}
/**
*
* @return ArrayList
*/
public function Footers() {
$arrayList = new ArrayList();
$footers = $this->extend('Footer');
foreach($footers as $footer) {
$arrayList->push($footer);
}
return $arrayList;
}
/**
* @return SS_List
*/
public function getList() {
return $this->getGridField()->getList();
}
/**
* @return string - name of model
*/
protected function getModelClass() {
return $this->getGridField()->getModelClass();
}
/**
* Add the combined sorting on the datasource
*
* If the sorting isn't set in the datasource, only the latest sort
* will be executed.
*
* @param array $sortColumns
*/
protected function setSortingOnList(array $sortColumns) {
$resultColumns = array();
foreach($sortColumns as $column => $sortOrder) {
$resultColumns[] = sprintf("%s %s", $column ,$sortOrder);
}
$sort = implode(', ', $resultColumns);
$this->getList()->sort($sort);
}
/**
* @return array
*/
public function FieldList() {
return singleton($this->getModelClass())->summaryFields();
}
/**
* Translate the summaryFields from a model into a format that is understood
* by the Form renderer
*
* @param array $summaryFields
*
* @return ArrayList
*/
protected function summaryFieldsToList($summaryFields) {
$headers = new ArrayList();
if(is_array($summaryFields)) {
$counter = 0;
foreach ($summaryFields as $name => $title) {
$data = array(
'Name' => $name,
'Title' => $title,
'IsSortable' => true,
'IsSorted' => false,
'SortedDirection' => 'asc'
);
if(array_key_exists($name, $this->sorting)) {
$data['IsSorted'] = true;
$data['SortedDirection'] = $this->sorting[$name];
}
$result = new ArrayData($data);
$result->iteratorProperties($counter++, count($summaryFields));
$headers->push($result);
}
}
return $headers;
}
/**
* @param array $casting
*/
function setFieldCasting($casting) {
$this->fieldCasting = $casting;
}
/**
*
* @param type $formatting
*/
function setFieldFormatting($formatting) {
$this->fieldFormatting = $formatting;
}
/**
* @return string - html
*/
function render(){
return $this->renderWith(array($this->template));
}
}
/**
* A single record in a GridField.
*
* @package sapphire
* @see GridField
*/
class GridFieldPresenter_Item extends ViewableData {
/**
* @var Object The underlying record, usually an element of
* {@link GridField->datasource()}.
*/
protected $item;
/**
* @var GridFieldPresenter
*/
protected $parent;
/**
* @param Object $item
* @param GridFieldPresenter $parent
*/
public function __construct($item, $parent) {
$this->failover = $this->item = $item;
$this->parent = $parent;
parent::__construct();
}
/**
* @return int
*/
public function ID() {
return $this->item->ID;
}
/**
* @return type
*/
public function Parent() {
return $this->parent;
}
/**
* @param bool $xmlSafe
*
* @return ArrayList
*/
public function Fields($xmlSafe = true) {
$list = $this->parent->FieldList();
$counter = 0;
foreach($list as $fieldName => $fieldTitle) {
$value = "";
// TODO Delegates that to DataList
// This supports simple FieldName syntax
if(strpos($fieldName,'.') === false) {
$value = ($this->item->XML_val($fieldName) && $xmlSafe) ? $this->item->XML_val($fieldName) : $this->item->RAW_val($fieldName);
// This support the syntax fieldName = Relation.RelatedField
} else {
$fieldNameParts = explode('.', $fieldName) ;
$tmpItem = $this->item;
for($j=0;$j<sizeof($fieldNameParts);$j++) {
$relationMethod = $fieldNameParts[$j];
$idField = $relationMethod . 'ID';
if($j == sizeof($fieldNameParts)-1) {
if($tmpItem) $value = $tmpItem->$relationMethod;
} else {
if($tmpItem) $tmpItem = $tmpItem->$relationMethod();
}
}
}
// casting
if(array_key_exists($fieldName, $this->parent->fieldCasting)) {
$value = $this->parent->getCastedValue($value, $this->parent->fieldCasting[$fieldName]);
} elseif(is_object($value) && method_exists($value, 'Nice')) {
$value = $value->Nice();
}
// formatting
$item = $this->item;
if(array_key_exists($fieldName, $this->parent->fieldFormatting)) {
$format = str_replace('$value', "__VAL__", $this->parent->fieldFormatting[$fieldName]);
$format = preg_replace('/\$([A-Za-z0-9-_]+)/','$item->$1', $format);
$format = str_replace('__VAL__', '$value', $format);
eval('$value = "' . $format . '";');
}
//escape
if($escape = $this->parent->getGridField()->fieldEscape){
foreach($escape as $search => $replace){
$value = str_replace($search, $replace, $value);
}
}
$arrayData = new ArrayData(array(
"Name" => $fieldName,
"Title" => $fieldTitle,
"Value" => $value
));
$arrayData->iteratorProperties($counter++, count($list));
$fields[] = $arrayData;
}
return new ArrayList($fields);
}
}