File Source for View.php

<?php
/**
* The window through which the map is viewed
*
* SMap requires at least PHP version 5, but there are important bug fixes in
* more recent versions of PHP. Try to stay current.
*
* <b>License</b>:
*
* Copyright (c) 2006-2007, Seth Price <{@link mailto:seth@pricepages.org}
* seth@pricepages.org}> All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
* - The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
* THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* @copyright Copyright (c) 2006-2007, Seth Price
* @author Seth Price <seth@pricepages.org>
* @license http://opensource.org/licenses/bsd-license.php New BSD License
* @access public
* @package SMap
* @version 0.1
*/
/**
* A view of the map
*
* Multiple views can be controlled at the same time. A view is like a porthole
* through which you can see the map, but only part of it at a time. The view
* has controls associated with it to pan, zoom, etc.
*
* @package SMap
* @subpackage Views
*/
abstract class SMap_View {
/**
* Id of this view
*
* A view with id 0 is the main view. All others are negotiable.
*
* @var integer
*/
protected $id = 0;
/**
* All of the layers in this view
*
* @var array
*/
protected $layers = array();
/**
* The map that contains this view
*
* @var object
*/
protected $map;
/**
* A cached copy of all of the tiles
*
* @var array
*/
protected $tiles;
/**
* The bounds of this view
*
* @var array
*/
protected $bounds;
/**
* The zoom of this view
*
* @var integer
*/
protected $zoom;
/**
* What is the scale in each direction?
*
* This is SMap Units per one pixel.
*
* @var array
*/
protected $scale;
/**
* Background color for this view
*
* @var array
*/
protected $bkCol;
/**
* Registered layers
*
* @var array
*/
static protected $regLayers = array(
'group' => array(false, 'SMap_Layer_Group'),
'points' => array(false, 'SMap_Layer_Points'),
'polygon' => array(false, 'SMap_Layer_Polygon'),
'ogr' => array(false, 'SMap_Layer_OGR'),
'images' => array(false, 'SMap_Layer_Images'),
'grid' => array(false, 'SMap_Layer_Grid'),
'zoom' => array(false, 'SMap_Layer_Zoom'),
'pan' => array(false, 'SMap_Layer_Pan'));
/**
* Give this view an identity
*
* @param object The controlling map
* @param integer This view's ID
* @param array View's background color
*/
public function __construct(SMap $map, $viewId, $bkCol = null){
$this->id = (int) $viewId;
$this->map = $map;
if(empty($bkCol)){
$this->bkCol = SMap::getOption('backgroundColor');
} else {
$this->bkCol = $bkCol;
}
//Calculate/save the view's bounds
$tv = $map->form->getTileVars();
if($tv['isTile']){
$this->bounds = $this->getAdjViewBounds($map, $tv['tileGrid']);
} else {
$this->bounds = $map->bounds;
}
//Save the zoom
$this->zoom = $map->zoom;
$this->scale = $map->scale;
}
/**
* Access useful vars read-only
*
* @param string Name of member
* @return mixed Value of member
*/
public function __get($nm){
if(isset($this->$nm)){
return $this->$nm;
} else {
throw new SMap_Ex('Attempted to read non-existant member '.$nm);
}
}
/**
* Adjust the view coords if we are in an image
*
* Uses the current bounds and the tile grid to calculate the view bounds of
* the original image. Sometimes it's missing data, so it does the best it
* can.
*
* @param object The map we are in
* @param array The tile grid
* @return array The overall view bounds
*/
protected function getAdjViewBounds(SMap $map, $tG){
$B = $map->bounds;
if( !isset($tG[SMap_Tile::POSX]) ||
!isset($tG[SMap_Tile::POSY]) ||
!isset($tG[SMap_Tile::VIEWX]) ||
!isset($tG[SMap_Tile::VIEWY]) ){
return false;
}
$diffX = $B[SMap::MAXX] - $B[SMap::MINX];
$diffY = $B[SMap::MAXY] - $B[SMap::MINY];
$B[SMap::MAXX] = $B[SMap::MAXX] + $diffX *
($tG[SMap_Tile::VIEWX] - $tG[SMap_Tile::POSX] - 1);
$B[SMap::MINX] = $B[SMap::MINX] - $diffX * $tG[SMap_Tile::POSX];
$B[SMap::MAXY] = $B[SMap::MAXY] + $diffY * $tG[SMap_Tile::POSY];
$B[SMap::MINY] = $B[SMap::MINY] - $diffY *
($tG[SMap_Tile::VIEWY] - $tG[SMap_Tile::POSY] - 1);
return $B;
}
/**
* Adds a layer.
*
* If there are no layers, then this layer becomes the bottom most layer.
* If there is a layer, then this layer is composited on top of it.
*
* @param mixed SMap_Layer subclass or layer to create
* @param integer Normally a Layer ID
* @param mixed Additional arguments passed to layer constructor
* @return object The added layer
* @see SMap_Layer
*/
public function addLayer( $layer, $arg1 = null, $arg2 = null,
$arg3 = null, $arg4 = null, $arg5 = null,
$arg6 = null, $arg7 = null, $arg8 = null){
//Check if we've already been rendered
if($this->tiles){
throw new SMap_Ex('You can\'t add a layer after the tiles have been ' .
'created.');
}
//Do we need to create the layer?
elseif(is_string($layer)){
$layer = $this->createLayer($layer, $this->map, $arg1, $arg2, $arg3, $arg4, $arg5, $arg6, $arg7, $arg8);
}
//Was the layer passed to us?
elseif(!($layer instanceof SMap_Layer)){
throw new SMap_Ex('Passed $layer not an instance of SMap_Layer.');
}
$lid = $layer->getID();
//Make sure it dosen't exist
if(!empty($this->layers[$lid])){
throw new SMap_Ex( 'SMap_Layer of ID '.$lid.' already exists',
SMap_Ex::DUP_LAYER);
}
//Only add enabled layers
if(!in_array($lid, $this->map->visibleLayers)){
return $layer;
}
//Store layer
$this->layers[$lid] = $layer;
return $layer;
}
/**
* Creates a view
*
* Serves as a view factory. The first argument is the name of a view that
* is registered with, and the rest of the arguments are passed to the view.
*
* @param string View name
* @param integer Normally the Layer ID
* @param mixed Additional arguments...
* @return object The created view
*/
public static function createLayer( $layer, $arg1, $arg2 = null, $arg3 = null,
$arg4 = null, $arg5 = null, $arg6 = null,
$arg7 = null, $arg8 = null, $arg9 = null){
$layer = strtolower($layer);
if(empty(self::$regLayers[$layer])){
throw new Exception('The given layer type "'.$layer.'" is not built in. ' .
'If you have created a custom layer, please simply ' .
'pass the object to addLayer().');
}
$meta = self::$regLayers[$layer];
if($meta[0] && !class_exists($meta[1])){
include_once($meta[0]);
}
$lr = new $meta[1]($arg1, $arg2, $arg3, $arg4, $arg5, $arg6, $arg7, $arg8, $arg9);
if(!($lr instanceof SMap_Layer)){
throw new SMap_Ex('Layer not a subclass of SMap_Layer.');
}
return $lr;
}
/**
* Send an object to another tile
*
* Used to create an object in another tile dynamically. This is intended to
* only be used by methods in {@link SMap_Object} during rendering. The
* normal method of adding an object to a tile is to include it in the
* return value of {@link SMap_Layer::getMapObjs()} or {@link }
* SMap_Layer::getImgObjs()}.
*
* @param object New object
* @param integer X location of tile in tile grid
* @param integer Y location of tile in tile grid
*/
public function sendObj(SMap_Object $newObj, $newX, $newY){
if(!isset($this->tiles[$newY][$newX])){
return;
}
$this->tiles[$newY][$newX]->addObject($newObj);
}
/**
* Return the name of this view
*
* The name is defined by {@link SMap_Lang}, so this method simply uses that
* value.
*
* @return string View name
*/
public function getName(){
$defs = $this->map->lang->genViewDefs();
if(isset($defs[$this->id])){
return $defs[$this->id];
} else {
return 'Untitled';
}
}
/**
* Creates and returns the set of tiles that represent this view
*
* This constructs a set of tiles that fully represent this view.
* {@link SMap_Object Objects} have been added to each tile, and they have
* been {@link SMap_Tile::flatten() flattened} and {@link }
* SMap_Tile::constrain() constrained}.
*
* @return array The tiles in this view
* @see getXHTML()
*/
public function getTiles(){
//Cache a copy of the cached tiles
if($this->tiles){
return $this->tiles;
}
//Are we constructed correctly?
if(empty($this->map)){
throw new SMap_Ex('View not added to a map. ID: '.$this->id);
}
//Save some local vars
$viewT = $this->bounds[SMap::MAXY];
$viewL = $this->bounds[SMap::MINX];
//PreCalc the offset of each cell
$widthPx = SMap::getOption('tileWidthPx');
$heightPx = SMap::getOption('tileHeightPx');
$lrDiff = $widthPx * $this->scale[0];
$tbDiff = $heightPx * $this->scale[1];
//Save these vars locally for speed
$tilesX = $this->map->tilesX;
$tilesY = $this->map->tilesY;
//Count starting at the bottom
$top = $viewT;
//Create the tiles
$tiles = array();
for($y = 0; $y < $tilesY; $y++){
$bottom = $top - $tbDiff;
//Count starting on the left
$left = $viewL;
for($x = 0; $x < $tilesX; $x++){
$right = $left + $lrDiff;
//Create new tile with correct bounds and grid position
$bounds = array( SMap::MAXY => $top,
SMap::MAXX => $right,
SMap::MINY => $bottom,
SMap::MINX => $left);
$grid = array( SMap_Tile::POSX => $x,
SMap_Tile::VIEWX => $tilesX,
SMap_Tile::POSY => $y,
SMap_Tile::VIEWY => $tilesY );
$tile = new SMap_Tile($this->map, $this, $bounds, $grid, $this->bkCol);
//Build the layers
foreach($this->layers as $layer){
$tile->addLayer($layer);
}
//Flatten into objects
$tile->flatten(false);
$tiles[$y][$x] = $tile;
$left = $right;
}
$top = $bottom;
}
//Set the member so sendObj() can work
$this->tiles = $tiles;
//Constrain the object bounds
foreach($this->layers as $lid => $layer){
for($y = 0; $y < $tilesY; $y++){
for($x = 0; $x < $tilesX; $x++){
$tiles[$y][$x]->constrain($lid);
}
}
}
return $tiles;
}
/**
* Handle getting the XHTML
*
* @param array The array of tiles
* @return string XHTML of the map
* @see getTiles()
*/
abstract public function getXHTML($tiles);
}
/**
* A view composed of images
*
* @package SMap
* @subpackage Views
*/
class SMap_View_Raster extends SMap_View {
/**
* Display a tiled image
*
* This is intended to be called from an image script.
*
* @param object SMap_Tile
*/
public function dispTileImg(SMap_Tile $tile){
//Add layers as needed
foreach($this->layers as $layer){
$tile->addLayer($layer);
}
$tile->flatten(true);
foreach($this->layers as $lid => $layer){
$tile->constrain($lid);
}
//Display the tile
$tile->display();
}
/**
* Renders and returns the view XHTML
*
* @param array Tiles to render
* @return string Rendered XHTML
* @uses SMap_Form::getMapXHTML()
*/
public function getXHTML($tiles){
return $this->map->form->getMapXHTML($this, $tiles);
}
}
/**
* A view intended to be inset in a layer
*
* The purpose of this view is to appear as an object inside of a layer (which
* is inside another view).
*
* @package SMap
* @subpackage Views
*/
class SMap_View_Inset extends SMap_View {
/**
* Tile to draw the view onto
*
* If the tile is null, then no drawing is done, and no inset is created.
* This is probably because we can't zoom out far enough to create a useful
* inset.
*
* @var object
*/
protected $tile = null;
/**
* Construct & adjust the view bounds
*
* @param object
* @param integer
* @param object Tile to draw the inset onto
*/
public function __construct(SMap $map, $viewId, SMap_Tile $tile){
parent::__construct($map, $viewId);
$vB = $this->bounds;
$xSpan = ($vB[SMap::MAXX] - $vB[SMap::MINX])*3;
$ySpan = ($vB[SMap::MAXY] - $vB[SMap::MINY])*3;
//Adjust the zoom & scale
for($zoom = $this->zoom - 2; $zoom >= 0; --$zoom){
$scale = $map->geo->zoomFctr($this->zoom);
$wMu = $tile->

	SMap Views

[ class tree: SMap ] [ index: SMap ] [ all elements ]

Source for file View.php