HtmlTable.php

Go to the documentation of this file.

<?php
namespace Ajax\semantic\html\collections\table;
 
use Ajax\semantic\html\base\HtmlSemDoubleElement;
use Ajax\semantic\html\content\table\HtmlTableContent;
use Ajax\semantic\html\base\constants\Variation;
use Ajax\JsUtils;
use Ajax\service\JArray;
use Ajax\semantic\html\content\table\HtmlTR;
use Ajax\semantic\html\collections\table\traits\TableTrait;
use Ajax\semantic\html\content\table\HtmlTD;
use Ajax\semantic\html\base\constants\TextAlignment;
use Ajax\common\html\BaseHtml;
 
class HtmlTable extends HtmlSemDoubleElement ,  TableTrait {
 
    private $_colCount;
 
    private $_compileParts;
 
    private $_footer;
 
    private $_afterCompileEvents;
 
    private $_activeRowSelector;
 
    private $_focusable = false;
 
    public function getActiveRowSelector() {
        return $this->_activeRowSelector;
    }
 
    protected $_innerScript;
 
    public function __construct($identifier, $rowCount, $colCount) {
        parent::__construct($identifier, "table", "ui table");
        $this->content = array();
        $this->setRowCount($rowCount, $colCount);
        $this->_variations = [
            Variation::CELLED,
            Variation::PADDED,
            Variation::COMPACT
        ];
        $this->_compileParts = [
            "thead",
            "tbody",
            "tfoot"
        ];
        $this->_afterCompileEvents = [];
    }
 
    public function getPart($key) {
        if (\array_key_exists($key, $this->content) === false) {
            $this->content[$key] = new HtmlTableContent("", $key);
            if ($key !== "tbody") {
                $this->content[$key]->setRowCount(1, $this->_colCount);
            }
        }
        return $this->content[$key];
    }
 
    protected function _getFirstPart() {
        if (isset($this->content["thead"])) {
            return $this->content["thead"];
        }
        return $this->content["tbody"];
    }
 
    public function getBody() {
        return $this->getPart("tbody");
    }
 
    public function getRowCount() {
        return $this->getPart("tbody")->count();
    }
 
    public function getHeader() {
        return $this->getPart("thead");
    }
 
    public function getFooter() {
        return $this->getPart("tfoot");
    }
 
    public function hasPart($key) {
        return \array_key_exists($key, $this->content) === true;
    }
 
    public function setRowCount($rowCount, $colCount) {
        $this->_colCount = $colCount;
        return $this->getBody()->setRowCount($rowCount, $colCount);
    }
 
    public function getCell($row, $col) {
        return $this->getBody()->getCell($row, $col);
    }
 
    public function getRow($rowIndex) {
        return $this->getBody()->getRow($rowIndex);
    }
 
    public function addRow($values = array()) {
        $row = $this->getBody()->addRow($this->_colCount);
        $row->setValues(\array_values($values));
        return $row;
    }
 
    public function newRow() {
        return $this->getBody()->newRow($this->_colCount);
    }
 
    public function setValues($values = array()) {
        $this->getBody()->setValues($values);
        return $this;
    }
 
    public function setHeaderValues($values = array()) {
        return $this->getHeader()->setValues($values);
    }
 
    public function setFooterValues($values = array()) {
        return $this->getFooter()->setValues($values);
    }
 
    public function setColValues($colIndex, $values = array()) {
        $this->getBody()->setColValues($colIndex, $values);
        return $this;
    }
 
    public function setRowValues($rowIndex, $values = array()) {
        $this->getBody()->setRowValues($rowIndex, $values);
        return $this;
    }
 
    public function addColVariations($colIndex, $variations = array()) {
        return $this->getBody()->addColVariations($colIndex, $variations);
    }
 
    public function colCenter($colIndex) {
        return $this->colAlign($colIndex, "colCenter");
    }
 
    public function colRight($colIndex) {
        return $this->colAlign($colIndex, "colRight");
    }
 
    public function colLeft($colIndex) {
        return $this->colAlign($colIndex, "colLeft");
    }
 
    public function colCenterFromRight($colIndex) {
        return $this->colAlign($colIndex, "colCenterFromRight");
    }
 
    public function colRightFromRight($colIndex) {
        return $this->colAlign($colIndex, "colRightFromRight");
    }
 
    public function colLeftFromRight($colIndex) {
        return $this->colAlign($colIndex, "colLeftFromRight");
    }
 
    public function setColAlignment($colIndex, $alignment) {
        switch ($alignment) {
            case TextAlignment::LEFT:
                $function = "colLeft";
                break;
 
            case TextAlignment::RIGHT:
                $function = "colRight";
                break;
 
            case TextAlignment::CENTER:
                $function = "colCenter";
                break;
 
            default:
                $function = "colLeft";
        }
        $this->colAlign($colIndex, $function);
        return $this;
    }
 
    public function setColAlignmentFromRight($colIndex, $alignment) {
        switch ($alignment) {
            case TextAlignment::LEFT:
                $function = "colLeftFromRight";
                break;
 
            case TextAlignment::RIGHT:
                $function = "colRightFromRight";
                break;
 
            case TextAlignment::CENTER:
                $function = "colCenterFromRight";
                break;
 
            default:
                $function = "colLeftFromRight";
        }
        $this->colAlign($colIndex, $function);
        return $this;
    }
 
    private function colAlign($colIndex, $function) {
        if (\is_array($colIndex)) {
            foreach ($colIndex as $cIndex) {
                $this->colAlign($cIndex, $function);
            }
        } else {
            if ($this->hasPart("thead")) {
                $this->getHeader()->$function($colIndex);
            }
            $this->getBody()->$function($colIndex);
        }
        return $this;
    }
 
    public function conditionalCellFormat($callback, $format) {
        $this->getBody()->conditionalCellFormat($callback, $format);
        return $this;
    }
 
    public function conditionalRowFormat($callback, $format) {
        $this->getBody()->conditionalRowFormat($callback, $format);
        return $this;
    }
 
    public function applyCells($callback) {
        $this->getBody()->applyCells($callback);
        return $this;
    }
 
    public function applyRows($callback) {
        $this->getBody()->applyRows($callback);
        return $this;
    }
 
    public function compile(JsUtils $js = NULL, &$view = NULL) {
        if (\sizeof($this->_compileParts) < 3) {
            $this->_template = "%content%";
            $this->refresh($js);
        }
        $this->content = JArray::sortAssociative($this->content, $this->_compileParts);
        return parent::compile($js, $view);
    }
 
    protected function compile_once(JsUtils $js = NULL, &$view = NULL) {
        parent::compile_once($js, $view);
        if ($this->propertyContains("class", "sortable")) {
            $this->addEvent("execute", "$('#" . $this->identifier . "').tablesort().data('tablesort').sort($('th.default-sort'));");
        }
    }
 
    public function fromDatabaseObject($object, $function) {
        $result = $function($object);
        if (\is_array($result)) {
            $result = $this->addRow($function($object));
        } else {
            $result = $this->getBody()->_addRow($result);
        }
        if (isset($this->_afterCompileEvents["onNewRow"])) {
            if (\is_callable($this->_afterCompileEvents["onNewRow"]))
                $this->_afterCompileEvents["onNewRow"]($result, $object);
        }
        return $result;
    }
 
    public function setCompileParts($parts = [
        "tbody"
    ]) {
        $this->_compileParts = $parts;
        return $this;
    }
 
    public function refreshTR() {
        $this->setCompileParts();
        $this->getPart("tbody")->refreshTR();
    }
 
    public function refresh($js) {
        $this->_footer = $this->getFooter();
        if (isset($js)) {
            $js->exec('$("#' . $this->identifier . ' tfoot").replaceWith("' . \addslashes($this->_footer) . '");', true);
        }
    }
 
    public function run(JsUtils $js) {
        if (! $this->_runned) {
            if (isset($this->_activeRowSelector)) {
                $this->_activeRowSelector->run();
            }
        }
        $result = parent::run($js);
        if (isset($this->_footer))
            $this->_footer->run($js);
        $this->_runned = true;
        return $result;
    }
 
    public function onNewRow($callback) {
        $this->_afterCompileEvents["onNewRow"] = $callback;
        return $this;
    }
 
    public function setActiveRowSelector($class = "active", $event = "click", $multiple = false) {
        $this->_activeRowSelector = new ActiveRow($this, $class, $event, $multiple);
        return $this;
    }
 
    public function getActiveRowClass() {
        if (isset($this->_activeRowSelector)) {
            return $this->_activeRowSelector->getClass();
        }
        return 'active';
    }
 
    public function hasActiveRowSelector() {
        return isset($this->_activeRowSelector);
    }
 
    public function hideColumn($colIndex) {
        if (isset($this->content["thead"])) {
            $this->content["thead"]->hideColumn($colIndex);
        }
        $this->content["tbody"]->hideColumn($colIndex);
        if (isset($this->content["tfoot"])) {
            $this->content["tfoot"]->hideColumn($colIndex);
        }
        return $this;
    }
 
    public function setColWidth($colIndex, $width) {
        $part = $this->_getFirstPart();
        if ($part !== null && $part->count() > 0)
            $part->getCell(0, $colIndex)->setWidth($width);
        return $this;
    }
 
    public function setColWidths($widths) {
        $part = $this->_getFirstPart();
        if ($part !== null && $part->count() > 0) {
            $count = $part->getColCount();
            if (! \is_array($widths)) {
                $widths = \array_fill(0, $count, $widths);
            }
            $max = \min(\sizeof($widths), $count);
            for ($i = 0; $i < $max; $i ++) {
                $part->getCell(0, $i)->setWidth($widths[$i]);
            }
        }
        return $this;
    }
 
    public function mergeIdentiqualValues($colIndex, $function = "strip_tags") {
        $body = $this->getBody();
        $body->mergeIdentiqualValues($colIndex, $function);
        return $this;
    }
 
    public function getInnerScript() {
        return $this->_innerScript;
    }
 
    public function setInnerScript($_innerScript) {
        $this->_innerScript = $_innerScript;
    }
 
    public function onActiveRowChange($jsCode) {
        $this->on("activeRowChange", $jsCode);
        return $this;
    }
 
    public function addMergeRow($colCount, $value = null) {
        return $this->getBody()->addMergeRow($colCount, $value);
    }
 
    public function setFocusable(bool $focusable): void {
        $this->getBody()->setFocusable($focusable);
    }
}