SemanticMediaWiki/includes/datavalues/SMW_DV_Property.php

Go to the documentation of this file.

<?php
class SMWPropertyValue extends SMWDataValue {

        protected $m_wikipage = null;

        private $mPropTypeValue;

        static public function makeUserProperty( $propertyName ) {
                $property = new SMWPropertyValue( '__pro' );
                $property->setUserValue( $propertyName );
                return $property;
        }

        static public function makeProperty( $propertyid ) {
                $diProperty = new SMWDIProperty( $propertyid );
                $dvProperty = new SMWPropertyValue( '__pro' );
                $dvProperty->setDataItem( $diProperty );
                return $dvProperty;
        }

        public function __clone() {
                if ( !is_null( $this->m_wikipage ) ) $this->m_wikipage = clone $this->m_wikipage;
        }

        protected function parseUserValue( $value ) {
                $this->mPropTypeValue = null;
                $this->m_wikipage = null;

                if ( $this->m_caption === false ) { // always use this as caption
                        $this->m_caption = $value;
                }
                $propertyName = smwfNormalTitleText( ltrim( rtrim( $value, ' ]' ), ' [' ) ); // slightly normalise label
                $inverse = false;
                if ( ( $propertyName !== '' ) && ( $propertyName { 0 } == '-' ) ) { // property refers to an inverse
                        $propertyName = (string)substr( $value, 1 );
                        $inverse = true;
                }

                try {
                        $this->m_dataitem = SMWDIProperty::newFromUserLabel( $propertyName, $inverse, $this->m_typeid );
                } catch ( SMWDataItemException $e ) { // happens, e.g., when trying to sort queries by property "-"
                        $this->addError( wfMsgForContent( 'smw_noproperty', $value ) );
                        $this->m_dataitem = new SMWDIProperty( 'ERROR', false ); // just to have something
                }
        }

        protected function loadDataItem( SMWDataItem $dataItem ) {
                if ( $dataItem->getDIType() == SMWDataItem::TYPE_PROPERTY ) {
                        $this->m_dataitem = $dataItem;
                        $this->mPropTypeValue = null;
                        unset( $this->m_wikipage );
                        $this->m_caption = false;
                        return true;
                } else {
                        return false;
                }
        }

        public function setCaption( $caption ) {
                parent::setCaption( $caption );
                if ( $this->getWikiPageValue() instanceof SMWDataValue ) { // pass caption to embedded datavalue (used for printout)
                        $this->m_wikipage->setCaption( $caption );
                }
        }

        public function setOutputFormat( $formatstring ) {
                $this->m_outformat = $formatstring;
                if ( $this->m_wikipage instanceof SMWDataValue ) {
                        $this->m_wikipage->setOutputFormat( $formatstring );
                }
        }

        public function setInverse( $isinverse ) {
                return $this->m_dataitem = new SMWDIProperty( $this->m_dataitem->getKey(), ( $isinverse == true ) );
        }

        public function getWikiPageValue() {
                if ( !isset( $this->m_wikipage ) ) {
                        $diWikiPage = $this->m_dataitem->getDiWikiPage();
                        if ( !is_null( $diWikiPage ) ) {
                                $this->m_wikipage = SMWDataValueFactory::newDataItemValue( $diWikiPage, null, $this->m_caption );
                                $this->m_wikipage->setOutputFormat( $this->m_outformat );
                                $this->addError( $this->m_wikipage->getErrors() );
                        } else { // should rarely happen ($value is only changed if the input $value really was a label for a predefined prop)
                                $this->m_wikipage = null;
                        }
                }
                return $this->m_wikipage;
        }

        public function isVisible() {
                return $this->isValid() && ( $this->m_dataitem->isUserDefined() || $this->m_dataitem->getLabel() !== '' );
        }

        public function getShortWikiText( $linked = null ) {
                if ( $this->isVisible() ) {
                        $wikiPageValue = $this->getWikiPageValue();
                        return is_null( $wikiPageValue ) ? '' : $this->highlightText( $wikiPageValue->getShortWikiText( $linked ) );
                } else {
                        return '';
                }
        }

        public function getShortHTMLText( $linked = null ) {
                if ( $this->isVisible() ) {
                        $wikiPageValue = $this->getWikiPageValue();
                        return is_null( $wikiPageValue ) ? '' : $this->highlightText( $wikiPageValue->getShortHTMLText( $linked ) );
                } else {
                        return '';
                }
        }

        public function getLongWikiText( $linked = null ) {
                if ( $this->isVisible() ) {
                        $wikiPageValue = $this->getWikiPageValue();
                        return is_null( $wikiPageValue ) ? '' : $this->highlightText( $wikiPageValue->getLongWikiText( $linked ) );
                } else {
                        return '';
                }
        }

        public function getLongHTMLText( $linked = null ) {
                if ( $this->isVisible() ) {
                        $wikiPageValue = $this->getWikiPageValue();
                        return is_null( $wikiPageValue ) ? '' : $this->highlightText( $wikiPageValue->getLongHTMLText( $linked ) );
                } else {
                        return '';
                }
        }

        public function getWikiValue() {
                return $this->isVisible() ? ( ( $this->isInverse() ? '-' : '' ) . $this->m_dataitem->getLabel() ) : '';
        }

        public function getPropertyID() {
                return $this->m_dataitem->isUserDefined() ? false : $this->m_dataitem->getKey();
        }

        public function getTypesValue() {
                $result = SMWTypesValue::newFromTypeId( $this->getPropertyTypeID() );
                if ( !$this->isValid() ) {
                        $result->addError( $this->getErrors() );
                }
                return $result;
        }

        public function getPropertyTypeID() {
                if ( $this->isValid() ) {
                        return $this->m_dataitem->findPropertyTypeId();
                } else {
                        return '__err';
                }
        }

        protected function highlightText( $text ) {
                if ( $this->m_dataitem->isUserDefined() ) {
                        return $text;
                } else {
                        SMWOutputs::requireResource( 'ext.smw.tooltips' );
                        return '<span class="smwttinline"><span class="smwbuiltin">' . $text .
                        '</span><span class="smwttcontent">' . wfMsgForContent( 'smw_isspecprop' ) . '</span></span>';
                }
        }

        static public function registerProperty( $id, $typeid, $label = false, $show = false ) {
                SMWDIProperty::registerProperty( $id, $typeid, $label, $show );
        }

        static public function registerPropertyAlias( $id, $label ) {
                SMWDIProperty::registerPropertyAlias( $id, $label );
        }

        public function isUserDefined() {
                return $this->m_dataitem->isUserDefined();
        }

        public function isShown() {
                return $this->m_dataitem->isShown();
        }

        public function isInverse() {
                return $this->m_dataitem->isInverse();
        }

        public function getDBkey() {
                return $this->m_dataitem->getKey();
        }

        public function getText() {
                return $this->m_dataitem->getLabel();
        }

}

---