/**
  * @see ItemParameterManipulation::doManipulation
  *
  * @since 3.0
  */
 public function doManipulation(&$value, Parameter $parameter, array &$parameters)
 {
     // string to array describing layer parameters:
     $value = MapsLayers::parseLayerParameters($value, $this->itemSep, $this->keyValueSep);
 }
Esempio n. 2
0
 /**
  * Registers the layer.
  * 
  * @since 0.7.2
  */
 public static function register()
 {
     MapsLayers::registerLayer('image', __CLASS__, 'openlayers');
     return true;
 }
Esempio n. 3
0
 /**
  * Renders and returns the output.
  * @see ParserHook::renderTag
  *
  * @since 3.0
  *
  * @param array $parameters
  *
  * @return string
  */
 public function render(array $parameters)
 {
     global $wgLang;
     // Check whether parser tag is used in the right namespace context, abort if not
     if ($this->parser->getTitle()->getNamespace() !== Maps_NS_LAYER) {
         global $wgContLang;
         return $this->rawErrorbox(wfMessage('maps-layerdef-wrong-namespace', $wgContLang->getNsText(Maps_NS_LAYER))->inContentLanguage()->text());
     }
     $type = $parameters['type'];
     if ($type === false) {
         // no layer type specified
         $availableLayerTypes = MapsLayerTypes::getAvailableTypes();
         $out = $this->rawErrorbox(wfMessage('maps-error-no-layertype', $wgLang->listToText($availableLayerTypes), count($availableLayerTypes))->inContentLanguage()->text());
     } elseif (MapsLayerTypes::hasType($type)) {
         // get layer name if any:
         $name = $parameters['name'] !== false ? $parameters['name'] : null;
         // make sure the layer has a label, if no user data, make something up:
         if (empty($parameters['definition']['label'])) {
             if ($name !== null) {
                 $labelSuffix = "- {$name}";
             } else {
                 // label for unnamed layer:
                 $labelSuffix = '#' . (count($this->getLayerStore()->getLayers(MapsLayerGroup::LAYERS_NUMERIC)) + 1);
             }
             $parameters['definition']['label'] = $this->parser->getTitle()->getText() . ' ' . $labelSuffix;
         }
         // new layer from user input (could still be invalid):
         $layer = MapsLayers::newLayerFromDefinition($type, $parameters['definition'], $name);
         $out = $this->renderLayerInfo($layer);
     } else {
         // specified layer type is non-existant!
         $availableLayerTypes = MapsLayerTypes::getAvailableTypes();
         $out = $this->rawErrorbox(wfMessage('maps-error-invalid-layertype', $this->validator->getParameter('type')->getOriginalValue(), $wgLang->listToText($availableLayerTypes), count($availableLayerTypes))->inContentLanguage()->text());
     }
     // add the layer to the store after all info has been rendered:
     $this->addLayerToStore($layer);
     return $out;
 }
Esempio n. 4
0
 /**
  * Checks whether the parser output has some layer data which should be stored of the
  * given title and performs the task.
  *
  * @since 3.0
  *
  * @param ParserOutput $parserOutput
  * @param Title $title 
  */
 protected static function processLayersStoreCandidate(ParserOutput $parserOutput, Title $title)
 {
     // if site which is being parsed is in maps namespace:
     if ($title->getNamespace() === Maps_NS_LAYER) {
         if (!isset($parserOutput->mExtMapsLayers)) {
             $parserOutput->mExtMapsLayers = new MapsLayerGroup();
         }
         // get MapsLayerGroup object with layers to be stored:
         $mapsForStore = $parserOutput->mExtMapsLayers;
         // store layers in database (also deletes previous definitions still in db):
         MapsLayers::storeLayers($mapsForStore, $title);
     }
 }
Esempio n. 5
0
 /**
  * Returns a new MapsLayer object created from the data in the page.
  * 
  * @since 0.7.1
  * 
  * @return MapsLayer
  */
 public function getLayer()
 {
     if ($this->cachedLayer === false) {
         $this->cachedLayer = MapsLayers::getLayer($this->getLayerType(), $this->getProperties());
     }
     return $this->cachedLayer;
 }
Esempio n. 6
0
 /**
  * @see ParameterManipulation::manipulate
  *
  * @since 0.7
  */
 public function manipulate(Parameter &$parameter, array &$parameters)
 {
     global $egMapsOLLayerGroups, $egMapsOLAvailableLayers;
     $layerDefs = array();
     $usedLayers = array();
     foreach ($parameter->getValue() as $layerOrGroup) {
         $lcLayerOrGroup = strtolower($layerOrGroup);
         // Layer groups. Loop over all items and add them if not present yet.
         if (array_key_exists($lcLayerOrGroup, $egMapsOLLayerGroups)) {
             foreach ($egMapsOLLayerGroups[$lcLayerOrGroup] as $layerName) {
                 if (!in_array($layerName, $usedLayers)) {
                     if (is_array($egMapsOLAvailableLayers[$layerName])) {
                         $layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$layerName][0];
                     } else {
                         $layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$layerName];
                     }
                     $usedLayers[] = $layerName;
                 }
             }
         } elseif (array_key_exists($lcLayerOrGroup, $egMapsOLAvailableLayers)) {
             if (!in_array($lcLayerOrGroup, $usedLayers)) {
                 if (is_array($egMapsOLAvailableLayers[$lcLayerOrGroup])) {
                     $layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$lcLayerOrGroup][0];
                 } else {
                     $layerDefs[] = 'new ' . $egMapsOLAvailableLayers[$lcLayerOrGroup];
                 }
                 $usedLayers[] = $lcLayerOrGroup;
             }
         } else {
             $layerParts = explode($this->groupNameSep, $layerOrGroup, 2);
             $layerGroup = $layerParts[0];
             $layerName = count($layerParts) > 1 ? $layerParts[1] : null;
             $title = Title::newFromText($layerGroup, Maps_NS_LAYER);
             if ($title !== null && $title->getNamespace() == Maps_NS_LAYER) {
                 /**
                  * TODO/FIXME: This shouldn't be here and using $wgParser, instead it should
                  * be somewhere around MapsBaseMap::renderMap. But since we do a lot more than
                  * 'parameter manipulation' in here, we already diminish the information needed
                  * for this which will never arrive there. Perhaps the whole
                  * MapsLayer::getJavaScriptDefinition() shouldn't be done here.
                  */
                 global $wgParser;
                 // add dependency to the layer page so if the layer definition gets updated,
                 // the page where it is used will be updated as well:
                 $rev = Revision::newFromTitle($title);
                 $wgParser->getOutput()->addTemplate($title, $title->getArticleID(), $rev->getId());
                 // if the whole layer group is not yet loaded into the map and the group exists:
                 if (!in_array($layerGroup, $usedLayers) && $title->exists()) {
                     $layerPage = new MapsLayerPage($title);
                     if ($layerName !== null) {
                         // load specific layer with name:
                         $layer = MapsLayers::loadLayer($title, $layerName);
                         $layers = new MapsLayerGroup($layer);
                         $usedLayer = $layerOrGroup;
                     } else {
                         // load all layers from group:
                         $layers = MapsLayers::loadLayerGroup($title);
                         $usedLayer = $layerGroup;
                     }
                     foreach ($layers->getLayers() as $layer) {
                         if (($layer->getName() === null || !in_array($layerGroup . $this->groupNameSep . $layer->getName(), $usedLayers)) && $layer->isOk()) {
                             $layerDefs[] = $layer->getJavaScriptDefinition();
                         }
                     }
                     $usedLayers[] = $usedLayer;
                     // have to add this after loop of course!
                 }
             } else {
                 wfWarn("Invalid layer ({$layerOrGroup}) encountered after validation.");
             }
         }
     }
     $parameter->setValue($layerDefs);
     MapsMappingServices::getServiceInstance('openlayers')->addLayerDependencies($this->getDependencies($usedLayers));
 }
Esempio n. 7
0
 /**
  * Returns if the layer page has any layer defined which has a definition that is 'ok',
  * meaning, the layer can be used in a map.
  *
  * @since 3.0
  *
  * @param string $name if set, only for the layer definition with this name will be searched.
  * @param string $service if set, only layers supporthing this service will be taken in account.
  *
  * @return boolean
  */
 public function hasUsableLayer($name = null, $service = null)
 {
     // if name is given, get only that layer to check on, otherwise all:
     if ($name !== null) {
         $layer = MapsLayers::loadLayer($this->getTitle(), $name);
         if ($layer === null) {
             return false;
         }
         $layers = array($layer);
     } else {
         $layers = MapsLayers::loadLayerGroup($this->getTitle());
         $layers = $layers->getLayers();
     }
     // datermine whether any layer is usable:
     foreach ($layers as $layerName => $layer) {
         if ($layer->isOk() && ($service === null || $layer->isSupportingService($service))) {
             return true;
         }
     }
     return false;
 }
Esempio n. 8
0
 /**
  * Given a set of conditions, return a ResultWrapper
  * which will return matching database rows with the
  * fields necessary to build the group.
  *
  * @param Database $db
  * @param array $conditions
  *
  * @return ResultWrapper|false
  */
 protected static function fetchMembersFromConds($db, $conditions)
 {
     $fields = MapsLayers::databaseFields();
     $res = $db->select(array('maps_layers'), $fields, $conditions, __METHOD__);
     return $db->resultObject($res);
 }