Commit c6e0bb25b54026988d862f212ab906aab9bd5caf

Authored by Edmar Moretti
1 parent db418bc3

--no commit message

admin/html/estat_editor.html
@@ -33,7 +33,7 @@ body { @@ -33,7 +33,7 @@ body {
33 <div id="ajuda" style="display: none"> 33 <div id="ajuda" style="display: none">
34 <div class="hd">Ajuda</div> 34 <div class="hd">Ajuda</div>
35 <div class="bd" style="height: 144px; overflow: auto"> 35 <div class="bd" style="height: 144px; overflow: auto">
36 - <p>Este formul&aacute;rio permite editar as tabelas de dados utilizadas pelo 36 + <p>Este formul&aacute;rio permite editar as tabelas que cont&eacute;m os dados utilizadas pelo
37 sistema de metadados estat&iacute;sticos 37 sistema de metadados estat&iacute;sticos
38 </div> 38 </div>
39 <div class="ft"></div> 39 <div class="ft"></div>
admin/html/estat_variavel.html
@@ -48,7 +48,9 @@ body { @@ -48,7 +48,9 @@ body {
48 <div id="estatVariavelajuda"> 48 <div id="estatVariavelajuda">
49 <div class="hd">Ajuda</div> 49 <div class="hd">Ajuda</div>
50 <div class="bd" style="height: 144px; overflow: auto"> 50 <div class="bd" style="height: 144px; overflow: auto">
51 - <p> 51 + <p>Esse formul&aacute;rio permite editar as var&iacute;&aacute;veis e suas medidas, definindo-se as fontes dos dados, tipos de classifica&ccedil;&atilde;o,
  52 + forma de representa&ccedil;&atilde;o etc. As v&aacute;ri&aacute;veis s&atilde;o fen&ocirc;menos que possuem medidas estat&iacute;sticas. Os par&acirc;metros definem como
  53 + as vari&aacute;veis s&atilde;o acessadas para a montagem dos cartogramas.
52 </div> 54 </div>
53 <div class="ft"></div> 55 <div class="ft"></div>
54 </div> 56 </div>
@@ -107,7 +109,7 @@ body { @@ -107,7 +109,7 @@ body {
107 locaplic : window.location.href.replace("/admin/html/estat_variavel.html","") 109 locaplic : window.location.href.replace("/admin/html/estat_variavel.html","")
108 }; 110 };
109 // 111 //
110 - cabecalhoMetaestat("cabecalhoPrincipal", "arvore"); 112 + cabecalhoMetaestat("cabecalhoPrincipal", "variavel");
111 temp = function() { 113 temp = function() {
112 document.getElementById("formulario").style.display = "block"; 114 document.getElementById("formulario").style.display = "block";
113 i3GEOadmin.variaveis.inicia(); 115 i3GEOadmin.variaveis.inicia();
admin/js/core.js
@@ -79,6 +79,7 @@ function cabecalhoMetaestat(id,excluir){ @@ -79,6 +79,7 @@ function cabecalhoMetaestat(id,excluir){
79 {id:"fonteinfo",titulo:"Fonte",link:"estat_fonteinfo.html"}, 79 {id:"fonteinfo",titulo:"Fonte",link:"estat_fonteinfo.html"},
80 {id:"editor",titulo:"Editor",link:"estat_editor.html"}, 80 {id:"editor",titulo:"Editor",link:"estat_editor.html"},
81 {id:"uploaddados",titulo:"Upload",link:"estat_uploaddados.html"}, 81 {id:"uploaddados",titulo:"Upload",link:"estat_uploaddados.html"},
  82 + {id:"mapa",titulo:"Publicador",link:"estat_mapa.html"},
82 {id:"login",titulo:"Login",js:"i3GEO.login.dialogo.abreLogin()"} 83 {id:"login",titulo:"Login",js:"i3GEO.login.dialogo.abreLogin()"}
83 ]; 84 ];
84 n = botoes.length; 85 n = botoes.length;
classesjs/classe_interface.js
@@ -715,7 +715,7 @@ i3GEO.Interface = { @@ -715,7 +715,7 @@ i3GEO.Interface = {
715 //corrigido na vers&atilde;o 4.7 do i3geo (n&atilde;o tinha o if) 715 //corrigido na vers&atilde;o 4.7 do i3geo (n&atilde;o tinha o if)
716 if(i3GEO.arvoreDeCamadas.ATIVATEMA === "") 716 if(i3GEO.arvoreDeCamadas.ATIVATEMA === "")
717 {i3GEO.arvoreDeCamadas.ATIVATEMA = "i3GEO.Interface.ligaDesliga(this);i3GEO.eventos.executaEventos(i3GEO.eventos.ATUALIZAARVORECAMADAS);";} 717 {i3GEO.arvoreDeCamadas.ATIVATEMA = "i3GEO.Interface.ligaDesliga(this);i3GEO.eventos.executaEventos(i3GEO.eventos.ATUALIZAARVORECAMADAS);";}
718 - 718 +
719 i3GEO.util.multiStep([ 719 i3GEO.util.multiStep([
720 i3GEO.coordenadas.mostraCoordenadas, 720 i3GEO.coordenadas.mostraCoordenadas,
721 montaMapa, 721 montaMapa,
@@ -1479,7 +1479,7 @@ i3GEO.Interface = { @@ -1479,7 +1479,7 @@ i3GEO.Interface = {
1479 //carrega o javascript que permite fazer o zoom por box 1479 //carrega o javascript que permite fazer o zoom por box
1480 // 1480 //
1481 if(!$i("keydragzoom_script")){ 1481 if(!$i("keydragzoom_script")){
1482 - js = i3GEO.configura.locaplic+"/pacotes/google/keydragzoom.js.php"; 1482 + js = i3GEO.configura.locaplic+"/pacotes/google/keydragzoom.js";
1483 i3GEO.util.scriptTag(js,"i3GEO.Interface.googlemaps.ativaZoomBox()","keydragzoom_script"); 1483 i3GEO.util.scriptTag(js,"i3GEO.Interface.googlemaps.ativaZoomBox()","keydragzoom_script");
1484 } 1484 }
1485 i3GeoMapOverlay = new google.maps.OverlayView(); 1485 i3GeoMapOverlay = new google.maps.OverlayView();
pacotes/google/keydragzoom.js 0 → 100644
@@ -0,0 +1,564 @@ @@ -0,0 +1,564 @@
  1 +/**
  2 + * @name Key Drag Zoom for V3
  3 + * @version 1.0
  4 + * @author: Nianwei Liu [nianwei at gmail dot com] e Gary Little [gary at luxcentral dot com]
  5 + * @fileoverview This library adds a drag zoom capability to a Google map.
  6 + * When drag zoom is enabled, holding down a user-defined hot key <code>(shift | ctrl | alt)</code>
  7 + * while dragging a box around an area of interest will zoom the map
  8 + * to that area when the hot key is released.
  9 + * Only one line of code is needed: <code>google.maps.Map.enableKeyDragZoom();</code>
  10 + * <p>
  11 + * Note that if the map's container has a border around it, the border widths must be specified
  12 + * in pixel units (or as thin, medium, or thick). This is required because of an MSIE limitation.
  13 + * <p>NL: 2009-05-28: initial port to core API V3.
  14 + */
  15 +/*!
  16 + *
  17 + * Licensed under the Apache License, Version 2.0 (the "License");
  18 + * you may not use this file except in compliance with the License.
  19 + * You may obtain a copy of the License at
  20 + *
  21 + * http://www.apache.org/licenses/LICENSE-2.0
  22 + *
  23 + * Unless required by applicable law or agreed to in writing, software
  24 + * distributed under the License is distributed on an "AS IS" BASIS,
  25 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  26 + * See the License for the specific language governing permissions and
  27 + * limitations under the License.
  28 + */
  29 +(function () {
  30 + /*jslint browser:true */
  31 + /*global google */
  32 + /**
  33 + * Converts 'thin', 'medium', and 'thick' to pixel widths
  34 + * in an MSIE environment. Not called for other browsers
  35 + * because getComputedStyle() returns pixel widths automatically.
  36 + * @param {String} widthValue
  37 + */
  38 + var toPixels = function (widthValue) {
  39 + var px;
  40 + switch (widthValue) {
  41 + case 'thin':
  42 + px = "2px";
  43 + break;
  44 + case 'medium':
  45 + px = "4px";
  46 + break;
  47 + case 'thick':
  48 + px = "6px";
  49 + break;
  50 + default:
  51 + px = widthValue;
  52 + }
  53 + return px;
  54 + };
  55 + /**
  56 + * Get the widths of the borders of an HTML element.
  57 + *
  58 + * @param {Object} h HTML element
  59 + * @return {Object} widths object (top, bottom left, right)
  60 + */
  61 + var getBorderWidths = function (h) {
  62 + var computedStyle;
  63 + var bw = {};
  64 + if (document.defaultView && document.defaultView.getComputedStyle) {
  65 + computedStyle = h.ownerDocument.defaultView.getComputedStyle(h, "");
  66 + if (computedStyle) {
  67 + // The computed styles are always in pixel units (good!)
  68 + bw.top = parseInt(computedStyle.borderTopWidth, 10) || 0;
  69 + bw.bottom = parseInt(computedStyle.borderBottomWidth, 10) || 0;
  70 + bw.left = parseInt(computedStyle.borderLeftWidth, 10) || 0;
  71 + bw.right = parseInt(computedStyle.borderRightWidth, 10) || 0;
  72 + return bw;
  73 + }
  74 + } else if (document.documentElement.currentStyle) { // MSIE
  75 + if (h.currentStyle) {
  76 + // The current styles may not be in pixel units so try to convert (bad!)
  77 + bw.top = parseInt(toPixels(h.currentStyle.borderTopWidth), 10) || 0;
  78 + bw.bottom = parseInt(toPixels(h.currentStyle.borderBottomWidth), 10) || 0;
  79 + bw.left = parseInt(toPixels(h.currentStyle.borderLeftWidth), 10) || 0;
  80 + bw.right = parseInt(toPixels(h.currentStyle.borderRightWidth), 10) || 0;
  81 + return bw;
  82 + }
  83 + }
  84 + // Shouldn't get this far for any modern browser
  85 + bw.top = parseInt(h.style["border-top-width"], 10) || 0;
  86 + bw.bottom = parseInt(h.style["border-bottom-width"], 10) || 0;
  87 + bw.left = parseInt(h.style["border-left-width"], 10) || 0;
  88 + bw.right = parseInt(h.style["border-right-width"], 10) || 0;
  89 + return bw;
  90 + };
  91 +
  92 + /**
  93 + * Get the position of the mouse relative to the document.
  94 + * @param {Object} e Mouse event
  95 + * @return {Object} left & top position
  96 + */
  97 + var getMousePosition = function (e) {
  98 + var posX = 0, posY = 0;
  99 + e = e || window.event;
  100 + if (typeof e.pageX !== "undefined") {
  101 + posX = e.pageX;
  102 + posY = e.pageY;
  103 + } else if (typeof e.clientX !== "undefined") {
  104 + posX = e.clientX +
  105 + (typeof document.documentElement.scrollLeft !== "undefined" ? document.documentElement.scrollLeft : document.body.scrollLeft);
  106 + posY = e.clientY +
  107 + (typeof document.documentElement.scrollTop !== "undefined" ? document.documentElement.scrollTop : document.body.scrollTop);
  108 + }
  109 + return {
  110 + left: posX,
  111 + top: posY
  112 + };
  113 + };
  114 +
  115 + /**
  116 + * Get the position of an HTML element relative to the document.
  117 + * @param {Object} h HTML element
  118 + * @return {Object} left & top position
  119 + */
  120 + var getElementPosition = function (h) {
  121 + var posX = h.offsetLeft;
  122 + var posY = h.offsetTop;
  123 + var parent = h.offsetParent;
  124 + // Add offsets for all ancestors in the hierarchy
  125 + while (parent !== null) {
  126 + // Adjust for scrolling elements which may affect the map position.
  127 + //
  128 + // See http://www.howtocreate.co.uk/tutorials/javascript/browserspecific
  129 + //
  130 + // "...make sure that every element [on a Web page] with an overflow
  131 + // of anything other than visible also has a position style set to
  132 + // something other than the default static..."
  133 + if (parent !== document.body && parent !== document.documentElement) {
  134 + posX -= parent.scrollLeft;
  135 + posY -= parent.scrollTop;
  136 + }
  137 + posX += parent.offsetLeft;
  138 + posY += parent.offsetTop;
  139 + parent = parent.offsetParent;
  140 + }
  141 + return {
  142 + left: posX,
  143 + top: posY
  144 + };
  145 + };
  146 + /**
  147 + * Set the properties of an object to those from another object.
  148 + * @param {Object} obj target object
  149 + * @param {Object} vals source object
  150 + */
  151 + var setVals = function (obj, vals) {
  152 + if (obj && vals) {
  153 + for (var x in vals) {
  154 + if (vals.hasOwnProperty(x)) {
  155 + obj[x] = vals[x];
  156 + }
  157 + }
  158 + }
  159 + return obj;
  160 + };
  161 + /**
  162 + * Set the opacity. If op is not passed in, this function just performs an MSIE fix.
  163 + * @param {Node} div
  164 + * @param {Number} op (0-1)
  165 + */
  166 + var setOpacity = function (div, op) {
  167 + if (typeof op !== 'undefined') {
  168 + div.style.opacity = op;
  169 + }
  170 + if (typeof div.style.opacity !== 'undefined') {
  171 + div.style.filter = "alpha(opacity=" + (div.style.opacity * 100) + ")";
  172 + }
  173 + };
  174 +
  175 + /**
  176 + * @name KeyDragZoomOptions
  177 + * @class This class represents the optional parameter passed into <code>google.maps.Map.enableDragBoxZoom</code>.
  178 + * @property {String} [key] the hot key to hold down to activate a drag zoom, <code>shift | ctrl | alt</code>.
  179 + * The default is <code>shift</code>.
  180 + * @property {Object} [boxStyle] the css style of the zoom box.
  181 + * The default is <code>{border: 'thin solid #FF0000'}</code>.
  182 + * Border widths must be specified in pixel units (or as thin, medium, or thick).
  183 + * @property {Object} [paneStyle] the css style of the pane which overlays the map when a drag zoom is activated.
  184 + * The default is <code>{backgroundColor: 'white', opacity: 0.0, cursor: 'crosshair'}</code>.
  185 + */
  186 + /**
  187 + * @name DragZoom
  188 + * @class This class represents a drag zoom object for a map. The object is activated by holding down the hot key.
  189 + * This object is created when <code>google.maps.Map.enableKeyDragZoom</code> is called; it cannot be created directly.
  190 + * Use <code>google.maps.Map.getDragZoomObject</code> to gain access to this object in order to attach event listeners.
  191 + * @param {google.maps.Map} map
  192 + * @param {KeyDragZoomOptions} opt_zoomOpts
  193 + */
  194 + function DragZoom(map, opt_zoomOpts) {
  195 + var ov = new google.maps.OverlayView();
  196 + var me = this;
  197 + ov.onAdd = function () {
  198 + me.init_(map, opt_zoomOpts);
  199 + };
  200 + ov.draw = function () {
  201 + };
  202 + ov.onRemove = function () {
  203 + };
  204 + ov.setMap(map);
  205 + this.prjov_ = ov;
  206 + }
  207 + /**
  208 + * Init the tool.
  209 + * @param {google.maps.Map} map
  210 + * @param {KeyDragZoomOptions} opt_zoomOpts
  211 + */
  212 + DragZoom.prototype.init_ = function (map, opt_zoomOpts) {
  213 + this.map_ = map;
  214 + opt_zoomOpts = opt_zoomOpts || {};
  215 + this.key_ = opt_zoomOpts.key || 'shift';
  216 + this.key_ = this.key_.toLowerCase();
  217 + this.borderWidths_ = getBorderWidths(this.map_.getDiv());//Container());
  218 + this.paneDiv_ = document.createElement("div");
  219 + this.paneDiv_.onselectstart = function () {
  220 + return false;
  221 + };
  222 + // default style
  223 + setVals(this.paneDiv_.style, {
  224 + backgroundColor: 'white',
  225 + opacity: 0.0,
  226 + cursor: 'crosshair'
  227 + });
  228 + // allow overwrite
  229 + setVals(this.paneDiv_.style, opt_zoomOpts.paneStyle);
  230 + // stuff that cannot be overwritten
  231 + setVals(this.paneDiv_.style, {
  232 + position: 'absolute',
  233 + overflow: 'hidden',
  234 + zIndex: 10001,
  235 + display: 'none'
  236 + });
  237 + if (this.key_ === 'shift') { // Workaround for Firefox Shift-Click problem
  238 + this.paneDiv_.style.MozUserSelect = "none";
  239 + }
  240 + setOpacity(this.paneDiv_);
  241 + // An IE fix: if the background is transparent, it cannot capture mousedown events
  242 + if (this.paneDiv_.style.backgroundColor === 'transparent') {
  243 + this.paneDiv_.style.backgroundColor = 'white';
  244 + setOpacity(this.paneDiv_, 0);
  245 + }
  246 + this.map_.getDiv().appendChild(this.paneDiv_);//Container()
  247 + this.boxDiv_ = document.createElement('div');
  248 + setVals(this.boxDiv_.style, {
  249 + border: 'thin solid #FF0000'
  250 + });
  251 + setVals(this.boxDiv_.style, opt_zoomOpts.boxStyle);
  252 + setVals(this.boxDiv_.style, {
  253 + position: 'absolute',
  254 + display: 'none'
  255 + });
  256 + setOpacity(this.boxDiv_);
  257 + this.map_.getDiv().appendChild(this.boxDiv_);
  258 + this.boxBorderWidths_ = getBorderWidths(this.boxDiv_);
  259 + var me = this;
  260 + this.keyDownListener_ = google.maps.event.addDomListener(document, 'keydown', function (e) {
  261 + me.onKeyDown_(e);
  262 + });
  263 + this.keyUpListener_ = google.maps.event.addDomListener(document, 'keyup', function (e) {
  264 + me.onKeyUp_(e);
  265 + });
  266 + this.mouseDownListener_ = google.maps.event.addDomListener(this.paneDiv_, 'mousedown', function (e) {
  267 + me.onMouseDown_(e);
  268 + });
  269 + this.mouseDownListenerDocument_ = google.maps.event.addDomListener(document, 'mousedown', function (e) {
  270 + me.onMouseDownDocument_(e);
  271 + });
  272 + this.mouseMoveListener_ = google.maps.event.addDomListener(document, 'mousemove', function (e) {
  273 + me.onMouseMove_(e);
  274 + });
  275 + this.mouseUpListener_ = google.maps.event.addDomListener(document, 'mouseup', function (e) {
  276 + me.onMouseUp_(e);
  277 + });
  278 +
  279 + this.hotKeyDown_ = false;
  280 + this.dragging_ = false;
  281 + this.startPt_ = null;
  282 + this.endPt_ = null;
  283 + this.boxMaxX_ = null;
  284 + this.boxMaxY_ = null;
  285 + this.mousePosn_ = null;
  286 + this.mapPosn_ = getElementPosition(this.map_.getDiv());
  287 + this.mouseDown_ = false;
  288 + };
  289 +
  290 + /**
  291 + * Returns true if the hot key is being pressed when an event occurs.
  292 + * @param {Event} e
  293 + * @return {Boolean}
  294 + */
  295 + DragZoom.prototype.isHotKeyDown_ = function (e) {
  296 + var isHot;
  297 + e = e || window.event;
  298 + isHot = (e.shiftKey && this.key_ === 'shift') || (e.altKey && this.key_ === 'alt') || (e.ctrlKey && this.key_ === 'ctrl');
  299 + if (!isHot) {
  300 + // Need to look at keyCode for Opera because it
  301 + // doesn't set the shiftKey, altKey, ctrlKey properties
  302 + // unless a non-modifier event is being reported.
  303 + //
  304 + // See http://cross-browser.com/x/examples/shift_mode.php
  305 + // Also see http://unixpapa.com/js/key.html
  306 + switch (e.keyCode) {
  307 + case 16:
  308 + if (this.key_ === 'shift') {
  309 + isHot = true;
  310 + }
  311 + break;
  312 + case 17:
  313 + if (this.key_ === 'ctrl') {
  314 + isHot = true;
  315 + }
  316 + break;
  317 + case 18:
  318 + if (this.key_ === 'alt') {
  319 + isHot = true;
  320 + }
  321 + break;
  322 + }
  323 + }
  324 + return isHot;
  325 + };
  326 +
  327 + /**
  328 + * Checks if the mouse is on top of the map. The position is captured
  329 + * in onMouseMove_.
  330 + * @return true if mouse is on top of the map div.
  331 + */
  332 + DragZoom.prototype.isMouseOnMap_ = function () {
  333 + var mousePos = this.mousePosn_;
  334 + if (mousePos) {
  335 + var mapPos = this.mapPosn_;
  336 + var mapDiv = this.map_.getDiv();
  337 + return mousePos.left > mapPos.left && mousePos.left < mapPos.left + mapDiv.offsetWidth &&
  338 + mousePos.top > mapPos.top && mousePos.top < mapPos.top + mapDiv.offsetHeight;
  339 + } else {
  340 + // if user never moved mouse
  341 + return false;
  342 + }
  343 + };
  344 +
  345 + /**
  346 + * Show or hide the overlay pane, depending on whether the mouse is over the map.
  347 + */
  348 + DragZoom.prototype.setPaneVisibility_ = function () {
  349 + if (this.map_ && this.hotKeyDown_ && this.isMouseOnMap_()) {
  350 + var mapDiv = this.map_.getDiv();
  351 + this.paneDiv_.style.left = 0 + 'px';
  352 + this.paneDiv_.style.top = 0 + 'px';
  353 + this.paneDiv_.style.width = mapDiv.offsetWidth - (this.borderWidths_.left + this.borderWidths_.right) + 'px';
  354 + this.paneDiv_.style.height = mapDiv.offsetHeight - (this.borderWidths_.top + this.borderWidths_.bottom) + 'px';
  355 + this.paneDiv_.style.display = 'block';
  356 + this.boxMaxX_ = parseInt(this.paneDiv_.style.width, 10) - (this.boxBorderWidths_.left + this.boxBorderWidths_.right);
  357 + this.boxMaxY_ = parseInt(this.paneDiv_.style.height, 10) - (this.boxBorderWidths_.top + this.boxBorderWidths_.bottom);
  358 + } else {
  359 + this.paneDiv_.style.display = 'none';
  360 + }
  361 + };
  362 + /**
  363 + * Handle key down. Activate the tool only if the mouse is on top of the map.
  364 + * @param {Event} e
  365 + */
  366 + DragZoom.prototype.onKeyDown_ = function (e) {
  367 + var me = this;
  368 + if (this.map_ && !this.hotKeyDown_ && this.isHotKeyDown_(e)) {
  369 + //desativa o clique permanente
  370 + i3GEO.eventos.cliquePerm.desativa();
  371 + me.hotKeyDown_ = true;
  372 + me.setPaneVisibility_();
  373 + /**
  374 + * This event is fired when the hot key is pressed.
  375 + * @name DragZoom#activate
  376 + * @event
  377 + */
  378 + google.maps.event.trigger(me, 'activate');
  379 + }
  380 + };
  381 + /**
  382 + * Get the <code>google.maps.Point</code> of the mouse position.
  383 + * @param {Object} e
  384 + * @return {google.maps.Point} point
  385 + * @private
  386 + */
  387 + DragZoom.prototype.getMousePoint_ = function (e) {
  388 + var mousePosn = getMousePosition(e);
  389 + var p = new google.maps.Point();
  390 + p.x = mousePosn.left - this.mapPosn_.left - this.borderWidths_.left;
  391 + p.y = mousePosn.top - this.mapPosn_.top - this.borderWidths_.top;
  392 + p.x = Math.min(p.x, this.boxMaxX_);
  393 + p.y = Math.min(p.y, this.boxMaxY_);
  394 + p.x = Math.max(p.x, 0);
  395 + p.y = Math.max(p.y, 0);
  396 + return p;
  397 + };
  398 + /**
  399 + * Handle mouse down.
  400 + * @param {Event} e
  401 + */
  402 + DragZoom.prototype.onMouseDown_ = function (e) {
  403 + if (this.map_ && this.hotKeyDown_) {
  404 + this.mapPosn_ = getElementPosition(this.map_.getDiv());
  405 + this.dragging_ = true;
  406 + this.startPt_ = this.endPt_ = this.getMousePoint_(e);
  407 + var prj = this.prjov_.getProjection();
  408 + var latlng = prj.fromDivPixelToLatLng(this.startPt_);
  409 + /**
  410 + * This event is fired when the drag operation begins.
  411 + * @name DragZoom#dragstart
  412 + * @param {GLatLng} startLatLng
  413 + * @event
  414 + */
  415 + google.maps.event.trigger(this, 'dragstart', latlng);
  416 + }
  417 + };
  418 + /**
  419 + * Handle mouse down at the document level.
  420 + * @param {Event} e
  421 + */
  422 + DragZoom.prototype.onMouseDownDocument_ = function (e) {
  423 + this.mouseDown_ = true;
  424 + };
  425 + /**
  426 + * Handle mouse move.
  427 + * @param {Event} e
  428 + */
  429 + DragZoom.prototype.onMouseMove_ = function (e) {
  430 + this.mousePosn_ = getMousePosition(e);
  431 + if (this.dragging_) {
  432 + this.endPt_ = this.getMousePoint_(e);
  433 + var left = Math.min(this.startPt_.x, this.endPt_.x);
  434 + var top = Math.min(this.startPt_.y, this.endPt_.y);
  435 + var width = Math.abs(this.startPt_.x - this.endPt_.x);
  436 + var height = Math.abs(this.startPt_.y - this.endPt_.y);
  437 + this.boxDiv_.style.left = left + 'px';
  438 + this.boxDiv_.style.top = top + 'px';
  439 + this.boxDiv_.style.width = width + 'px';
  440 + this.boxDiv_.style.height = height + 'px';
  441 + this.boxDiv_.style.display = 'block';
  442 + /**
  443 + * This event is repeatedly fired while the user drags the box. The southwest and northeast
  444 + * point are passed as parameters of type <code>google.maps.Point</code> (for performance reasons),
  445 + * relative to the map container. Note: the event listener is responsible
  446 + * for converting Pixel to LatLng, if necessary.
  447 + * @name DragZoom#drag
  448 + * @param {google.maps.Point} southwestPixel
  449 + * @param {google.maps.Point} northeastPixel
  450 + * @event
  451 + */
  452 + google.maps.event.trigger(this, 'drag', new google.maps.Point(left, top + height), new google.maps.Point(left + width, top));
  453 + } else if (!this.mouseDown_) {
  454 + this.setPaneVisibility_();
  455 + }
  456 + };
  457 + /**
  458 + * Handle mouse up.
  459 + * @param {Event} e
  460 + */
  461 + DragZoom.prototype.onMouseUp_ = function (e) {
  462 + this.mouseDown_ = false;
  463 + if (this.dragging_) {
  464 + //desativa o clique permanente
  465 + i3GEO.eventos.cliquePerm.ativa();
  466 + var left = Math.min(this.startPt_.x, this.endPt_.x);
  467 + var top = Math.min(this.startPt_.y, this.endPt_.y);
  468 + var width = Math.abs(this.startPt_.x - this.endPt_.x);
  469 + var height = Math.abs(this.startPt_.y - this.endPt_.y);
  470 + var prj = this.prjov_.getProjection();
  471 + // 2009-05-29: since V3 does not have fromContainerPixel,
  472 + //needs find offset here
  473 + var containerPos = getElementPosition(this.map_.getDiv());
  474 + var mapPanePos = getElementPosition(this.prjov_.getPanes().mapPane);
  475 + left = left + (containerPos.left - mapPanePos.left);
  476 + top = top + (containerPos.top - mapPanePos.top);
  477 + var sw = prj.fromDivPixelToLatLng(new google.maps.Point(left, top + height));
  478 + var ne = prj.fromDivPixelToLatLng(new google.maps.Point(left + width, top));
  479 + var bnds = new google.maps.LatLngBounds(sw, ne);
  480 + this.map_.fitBounds(bnds);
  481 + this.dragging_ = false;
  482 + this.boxDiv_.style.display = 'none';
  483 + /**
  484 + * This event is fired when the drag operation ends.
  485 + * Note that the event is not fired if the hot key is released before the drag operation ends.
  486 + * @name DragZoom#dragend
  487 + * @param {GLatLngBounds} newBounds
  488 + * @event
  489 + */
  490 + google.maps.event.trigger(this, 'dragend', bnds);
  491 + }
  492 + };
  493 +
  494 + /**
  495 + * Handle key up.
  496 + * @param {Event} e
  497 + */
  498 + DragZoom.prototype.onKeyUp_ = function (e) {
  499 + if (this.map_ && this.hotKeyDown_) {
  500 + this.hotKeyDown_ = false;
  501 + this.dragging_ = false;
  502 + this.boxDiv_.style.display = 'none';
  503 + this.paneDiv_.style.display = "none";
  504 + /**
  505 + * This event is fired while the user release the key
  506 + * @name DragZoom#deactivate
  507 + * @event
  508 + */
  509 + google.maps.event.trigger(this, 'deactivate');
  510 + }
  511 + };
  512 +
  513 +
  514 +
  515 +
  516 + /**
  517 + * @name google.maps.Map
  518 + * @class These are new methods added to the Google Maps API's
  519 + * <a href = 'http://code.google.com/apis/maps/documentation/v3/reference.html#Map'>Map</a>
  520 + * class.
  521 + */
  522 + /**
  523 + * Enable drag zoom. The user can zoom to an area of interest by holding down the hot key
  524 + * <code>(shift | ctrl | alt )</code> while dragging a box around the area.
  525 + * @param {KeyDragZoomOptions} opt_zoomOpts
  526 + */
  527 +
  528 + google.maps.Map.prototype.enableKeyDragZoom = function (opt_zoomOpts) {
  529 + this.dragZoom_ = new DragZoom(this, opt_zoomOpts);
  530 + };
  531 + /**
  532 + * Disable drag zoom.
  533 + */
  534 + google.maps.Map.prototype.disableKeyDragZoom = function () {
  535 + var d = this.dragZoom_;
  536 + if (d) {
  537 + google.maps.event.removeListener(d.mouseDownListener_);
  538 + google.maps.event.removeListener(d.mouseDownListenerDocument_);
  539 + google.maps.event.removeListener(d.mouseMoveListener_);
  540 + google.maps.event.removeListener(d.mouseUpListener_);
  541 + google.maps.event.removeListener(d.keyUpListener_);
  542 + google.maps.event.removeListener(d.keyDownListener_);
  543 + this.getDiv().removeChild(d.boxDiv_);
  544 + this.getDiv().removeChild(d.paneDiv_);
  545 + this.dragZoom_ = null;
  546 + }
  547 + };
  548 + /**
  549 + * Returns true if the drag zoom feature has been enabled.
  550 + * @return {Boolean}
  551 + */
  552 + google.maps.Map.prototype.keyDragZoomEnabled = function () {
  553 + return this.dragZoom_ !== null;
  554 + };
  555 + /**
  556 + * Returns the DragZoom object which is created when <code>google.maps.Map.enableKeyDragZoom</code> is called.
  557 + * With this object you can use <code>google.maps.event.addListener</code> to attach event listeners
  558 + * for the 'activate', 'deactivate', 'dragstart', 'drag', and 'dragend' events.
  559 + * @return {DragZoom}
  560 + */
  561 + google.maps.Map.prototype.getDragZoomObject = function () {
  562 + return this.dragZoom_;
  563 + };
  564 +})();
pacotes/google/keydragzoom.js.php
@@ -1,566 +0,0 @@ @@ -1,566 +0,0 @@
1 -<?php error_reporting(0);if(extension_loaded('zlib')){ob_start('ob_gzhandler');} header("Content-type: text/javascript"); ?>  
2 -/**  
3 - * @name Key Drag Zoom for V3  
4 - * @version 1.0  
5 - * @author: Nianwei Liu [nianwei at gmail dot com] e Gary Little [gary at luxcentral dot com]  
6 - * @fileoverview This library adds a drag zoom capability to a Google map.  
7 - * When drag zoom is enabled, holding down a user-defined hot key <code>(shift | ctrl | alt)</code>  
8 - * while dragging a box around an area of interest will zoom the map  
9 - * to that area when the hot key is released.  
10 - * Only one line of code is needed: <code>google.maps.Map.enableKeyDragZoom();</code>  
11 - * <p>  
12 - * Note that if the map's container has a border around it, the border widths must be specified  
13 - * in pixel units (or as thin, medium, or thick). This is required because of an MSIE limitation.  
14 - * <p>NL: 2009-05-28: initial port to core API V3.  
15 - */  
16 -/*!  
17 - *  
18 - * Licensed under the Apache License, Version 2.0 (the "License");  
19 - * you may not use this file except in compliance with the License.  
20 - * You may obtain a copy of the License at  
21 - *  
22 - * http://www.apache.org/licenses/LICENSE-2.0  
23 - *  
24 - * Unless required by applicable law or agreed to in writing, software  
25 - * distributed under the License is distributed on an "AS IS" BASIS,  
26 - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  
27 - * See the License for the specific language governing permissions and  
28 - * limitations under the License.  
29 - */  
30 -(function () {  
31 - /*jslint browser:true */  
32 - /*global google */  
33 - /**  
34 - * Converts 'thin', 'medium', and 'thick' to pixel widths  
35 - * in an MSIE environment. Not called for other browsers  
36 - * because getComputedStyle() returns pixel widths automatically.  
37 - * @param {String} widthValue  
38 - */  
39 - var toPixels = function (widthValue) {  
40 - var px;  
41 - switch (widthValue) {  
42 - case 'thin':  
43 - px = "2px";  
44 - break;  
45 - case 'medium':  
46 - px = "4px";  
47 - break;  
48 - case 'thick':  
49 - px = "6px";  
50 - break;  
51 - default:  
52 - px = widthValue;  
53 - }  
54 - return px;  
55 - };  
56 - /**  
57 - * Get the widths of the borders of an HTML element.  
58 - *  
59 - * @param {Object} h HTML element  
60 - * @return {Object} widths object (top, bottom left, right)  
61 - */  
62 - var getBorderWidths = function (h) {  
63 - var computedStyle;  
64 - var bw = {};  
65 - if (document.defaultView && document.defaultView.getComputedStyle) {  
66 - computedStyle = h.ownerDocument.defaultView.getComputedStyle(h, "");  
67 - if (computedStyle) {  
68 - // The computed styles are always in pixel units (good!)  
69 - bw.top = parseInt(computedStyle.borderTopWidth, 10) || 0;  
70 - bw.bottom = parseInt(computedStyle.borderBottomWidth, 10) || 0;  
71 - bw.left = parseInt(computedStyle.borderLeftWidth, 10) || 0;  
72 - bw.right = parseInt(computedStyle.borderRightWidth, 10) || 0;  
73 - return bw;  
74 - }  
75 - } else if (document.documentElement.currentStyle) { // MSIE  
76 - if (h.currentStyle) {  
77 - // The current styles may not be in pixel units so try to convert (bad!)  
78 - bw.top = parseInt(toPixels(h.currentStyle.borderTopWidth), 10) || 0;  
79 - bw.bottom = parseInt(toPixels(h.currentStyle.borderBottomWidth), 10) || 0;  
80 - bw.left = parseInt(toPixels(h.currentStyle.borderLeftWidth), 10) || 0;  
81 - bw.right = parseInt(toPixels(h.currentStyle.borderRightWidth), 10) || 0;  
82 - return bw;  
83 - }  
84 - }  
85 - // Shouldn't get this far for any modern browser  
86 - bw.top = parseInt(h.style["border-top-width"], 10) || 0;  
87 - bw.bottom = parseInt(h.style["border-bottom-width"], 10) || 0;  
88 - bw.left = parseInt(h.style["border-left-width"], 10) || 0;  
89 - bw.right = parseInt(h.style["border-right-width"], 10) || 0;  
90 - return bw;  
91 - };  
92 -  
93 - /**  
94 - * Get the position of the mouse relative to the document.  
95 - * @param {Object} e Mouse event  
96 - * @return {Object} left & top position  
97 - */  
98 - var getMousePosition = function (e) {  
99 - var posX = 0, posY = 0;  
100 - e = e || window.event;  
101 - if (typeof e.pageX !== "undefined") {  
102 - posX = e.pageX;  
103 - posY = e.pageY;  
104 - } else if (typeof e.clientX !== "undefined") {  
105 - posX = e.clientX +  
106 - (typeof document.documentElement.scrollLeft !== "undefined" ? document.documentElement.scrollLeft : document.body.scrollLeft);  
107 - posY = e.clientY +  
108 - (typeof document.documentElement.scrollTop !== "undefined" ? document.documentElement.scrollTop : document.body.scrollTop);  
109 - }  
110 - return {  
111 - left: posX,  
112 - top: posY  
113 - };  
114 - };  
115 -  
116 - /**  
117 - * Get the position of an HTML element relative to the document.  
118 - * @param {Object} h HTML element  
119 - * @return {Object} left & top position  
120 - */  
121 - var getElementPosition = function (h) {  
122 - var posX = h.offsetLeft;  
123 - var posY = h.offsetTop;  
124 - var parent = h.offsetParent;  
125 - // Add offsets for all ancestors in the hierarchy  
126 - while (parent !== null) {  
127 - // Adjust for scrolling elements which may affect the map position.  
128 - //  
129 - // See http://www.howtocreate.co.uk/tutorials/javascript/browserspecific  
130 - //  
131 - // "...make sure that every element [on a Web page] with an overflow  
132 - // of anything other than visible also has a position style set to  
133 - // something other than the default static..."  
134 - if (parent !== document.body && parent !== document.documentElement) {  
135 - posX -= parent.scrollLeft;  
136 - posY -= parent.scrollTop;  
137 - }  
138 - posX += parent.offsetLeft;  
139 - posY += parent.offsetTop;  
140 - parent = parent.offsetParent;  
141 - }  
142 - return {  
143 - left: posX,  
144 - top: posY  
145 - };  
146 - };  
147 - /**  
148 - * Set the properties of an object to those from another object.  
149 - * @param {Object} obj target object  
150 - * @param {Object} vals source object  
151 - */  
152 - var setVals = function (obj, vals) {  
153 - if (obj && vals) {  
154 - for (var x in vals) {  
155 - if (vals.hasOwnProperty(x)) {  
156 - obj[x] = vals[x];  
157 - }  
158 - }  
159 - }  
160 - return obj;  
161 - };  
162 - /**  
163 - * Set the opacity. If op is not passed in, this function just performs an MSIE fix.  
164 - * @param {Node} div  
165 - * @param {Number} op (0-1)  
166 - */  
167 - var setOpacity = function (div, op) {  
168 - if (typeof op !== 'undefined') {  
169 - div.style.opacity = op;  
170 - }  
171 - if (typeof div.style.opacity !== 'undefined') {  
172 - div.style.filter = "alpha(opacity=" + (div.style.opacity * 100) + ")";  
173 - }  
174 - };  
175 -  
176 - /**  
177 - * @name KeyDragZoomOptions  
178 - * @class This class represents the optional parameter passed into <code>google.maps.Map.enableDragBoxZoom</code>.  
179 - * @property {String} [key] the hot key to hold down to activate a drag zoom, <code>shift | ctrl | alt</code>.  
180 - * The default is <code>shift</code>.  
181 - * @property {Object} [boxStyle] the css style of the zoom box.  
182 - * The default is <code>{border: 'thin solid #FF0000'}</code>.  
183 - * Border widths must be specified in pixel units (or as thin, medium, or thick).  
184 - * @property {Object} [paneStyle] the css style of the pane which overlays the map when a drag zoom is activated.  
185 - * The default is <code>{backgroundColor: 'white', opacity: 0.0, cursor: 'crosshair'}</code>.  
186 - */  
187 - /**  
188 - * @name DragZoom  
189 - * @class This class represents a drag zoom object for a map. The object is activated by holding down the hot key.  
190 - * This object is created when <code>google.maps.Map.enableKeyDragZoom</code> is called; it cannot be created directly.  
191 - * Use <code>google.maps.Map.getDragZoomObject</code> to gain access to this object in order to attach event listeners.  
192 - * @param {google.maps.Map} map  
193 - * @param {KeyDragZoomOptions} opt_zoomOpts  
194 - */  
195 - function DragZoom(map, opt_zoomOpts) {  
196 - var ov = new google.maps.OverlayView();  
197 - var me = this;  
198 - ov.onAdd = function () {  
199 - me.init_(map, opt_zoomOpts);  
200 - };  
201 - ov.draw = function () {  
202 - };  
203 - ov.onRemove = function () {  
204 - };  
205 - ov.setMap(map);  
206 - this.prjov_ = ov;  
207 - }  
208 - /**  
209 - * Init the tool.  
210 - * @param {google.maps.Map} map  
211 - * @param {KeyDragZoomOptions} opt_zoomOpts  
212 - */  
213 - DragZoom.prototype.init_ = function (map, opt_zoomOpts) {  
214 - this.map_ = map;  
215 - opt_zoomOpts = opt_zoomOpts || {};  
216 - this.key_ = opt_zoomOpts.key || 'shift';  
217 - this.key_ = this.key_.toLowerCase();  
218 - this.borderWidths_ = getBorderWidths(this.map_.getDiv());//Container());  
219 - this.paneDiv_ = document.createElement("div");  
220 - this.paneDiv_.onselectstart = function () {  
221 - return false;  
222 - };  
223 - // default style  
224 - setVals(this.paneDiv_.style, {  
225 - backgroundColor: 'white',  
226 - opacity: 0.0,  
227 - cursor: 'crosshair'  
228 - });  
229 - // allow overwrite  
230 - setVals(this.paneDiv_.style, opt_zoomOpts.paneStyle);  
231 - // stuff that cannot be overwritten  
232 - setVals(this.paneDiv_.style, {  
233 - position: 'absolute',  
234 - overflow: 'hidden',  
235 - zIndex: 10001,  
236 - display: 'none'  
237 - });  
238 - if (this.key_ === 'shift') { // Workaround for Firefox Shift-Click problem  
239 - this.paneDiv_.style.MozUserSelect = "none";  
240 - }  
241 - setOpacity(this.paneDiv_);  
242 - // An IE fix: if the background is transparent, it cannot capture mousedown events  
243 - if (this.paneDiv_.style.backgroundColor === 'transparent') {  
244 - this.paneDiv_.style.backgroundColor = 'white';  
245 - setOpacity(this.paneDiv_, 0);  
246 - }  
247 - this.map_.getDiv().appendChild(this.paneDiv_);//Container()  
248 - this.boxDiv_ = document.createElement('div');  
249 - setVals(this.boxDiv_.style, {  
250 - border: 'thin solid #FF0000'  
251 - });  
252 - setVals(this.boxDiv_.style, opt_zoomOpts.boxStyle);  
253 - setVals(this.boxDiv_.style, {  
254 - position: 'absolute',  
255 - display: 'none'  
256 - });  
257 - setOpacity(this.boxDiv_);  
258 - this.map_.getDiv().appendChild(this.boxDiv_);  
259 - this.boxBorderWidths_ = getBorderWidths(this.boxDiv_);  
260 - var me = this;  
261 - this.keyDownListener_ = google.maps.event.addDomListener(document, 'keydown', function (e) {  
262 - me.onKeyDown_(e);  
263 - });  
264 - this.keyUpListener_ = google.maps.event.addDomListener(document, 'keyup', function (e) {  
265 - me.onKeyUp_(e);  
266 - });  
267 - this.mouseDownListener_ = google.maps.event.addDomListener(this.paneDiv_, 'mousedown', function (e) {  
268 - me.onMouseDown_(e);  
269 - });  
270 - this.mouseDownListenerDocument_ = google.maps.event.addDomListener(document, 'mousedown', function (e) {  
271 - me.onMouseDownDocument_(e);  
272 - });  
273 - this.mouseMoveListener_ = google.maps.event.addDomListener(document, 'mousemove', function (e) {  
274 - me.onMouseMove_(e);  
275 - });  
276 - this.mouseUpListener_ = google.maps.event.addDomListener(document, 'mouseup', function (e) {  
277 - me.onMouseUp_(e);  
278 - });  
279 -  
280 - this.hotKeyDown_ = false;  
281 - this.dragging_ = false;  
282 - this.startPt_ = null;  
283 - this.endPt_ = null;  
284 - this.boxMaxX_ = null;  
285 - this.boxMaxY_ = null;  
286 - this.mousePosn_ = null;  
287 - this.mapPosn_ = getElementPosition(this.map_.getDiv());  
288 - this.mouseDown_ = false;  
289 - };  
290 -  
291 - /**  
292 - * Returns true if the hot key is being pressed when an event occurs.  
293 - * @param {Event} e  
294 - * @return {Boolean}  
295 - */  
296 - DragZoom.prototype.isHotKeyDown_ = function (e) {  
297 - var isHot;  
298 - e = e || window.event;  
299 - isHot = (e.shiftKey && this.key_ === 'shift') || (e.altKey && this.key_ === 'alt') || (e.ctrlKey && this.key_ === 'ctrl');  
300 - if (!isHot) {  
301 - // Need to look at keyCode for Opera because it  
302 - // doesn't set the shiftKey, altKey, ctrlKey properties  
303 - // unless a non-modifier event is being reported.  
304 - //  
305 - // See http://cross-browser.com/x/examples/shift_mode.php  
306 - // Also see http://unixpapa.com/js/key.html  
307 - switch (e.keyCode) {  
308 - case 16:  
309 - if (this.key_ === 'shift') {  
310 - isHot = true;  
311 - }  
312 - break;  
313 - case 17:  
314 - if (this.key_ === 'ctrl') {  
315 - isHot = true;  
316 - }  
317 - break;  
318 - case 18:  
319 - if (this.key_ === 'alt') {  
320 - isHot = true;  
321 - }  
322 - break;  
323 - }  
324 - }  
325 - return isHot;  
326 - };  
327 -  
328 - /**  
329 - * Checks if the mouse is on top of the map. The position is captured  
330 - * in onMouseMove_.  
331 - * @return true if mouse is on top of the map div.  
332 - */  
333 - DragZoom.prototype.isMouseOnMap_ = function () {  
334 - var mousePos = this.mousePosn_;  
335 - if (mousePos) {  
336 - var mapPos = this.mapPosn_;  
337 - var mapDiv = this.map_.getDiv();  
338 - return mousePos.left > mapPos.left && mousePos.left < mapPos.left + mapDiv.offsetWidth &&  
339 - mousePos.top > mapPos.top && mousePos.top < mapPos.top + mapDiv.offsetHeight;  
340 - } else {  
341 - // if user never moved mouse  
342 - return false;  
343 - }  
344 - };  
345 -  
346 - /**  
347 - * Show or hide the overlay pane, depending on whether the mouse is over the map.  
348 - */  
349 - DragZoom.prototype.setPaneVisibility_ = function () {  
350 - if (this.map_ && this.hotKeyDown_ && this.isMouseOnMap_()) {  
351 - var mapDiv = this.map_.getDiv();  
352 - this.paneDiv_.style.left = 0 + 'px';  
353 - this.paneDiv_.style.top = 0 + 'px';  
354 - this.paneDiv_.style.width = mapDiv.offsetWidth - (this.borderWidths_.left + this.borderWidths_.right) + 'px';  
355 - this.paneDiv_.style.height = mapDiv.offsetHeight - (this.borderWidths_.top + this.borderWidths_.bottom) + 'px';  
356 - this.paneDiv_.style.display = 'block';  
357 - this.boxMaxX_ = parseInt(this.paneDiv_.style.width, 10) - (this.boxBorderWidths_.left + this.boxBorderWidths_.right);  
358 - this.boxMaxY_ = parseInt(this.paneDiv_.style.height, 10) - (this.boxBorderWidths_.top + this.boxBorderWidths_.bottom);  
359 - } else {  
360 - this.paneDiv_.style.display = 'none';  
361 - }  
362 - };  
363 - /**  
364 - * Handle key down. Activate the tool only if the mouse is on top of the map.  
365 - * @param {Event} e  
366 - */  
367 - DragZoom.prototype.onKeyDown_ = function (e) {  
368 - var me = this;  
369 - if (this.map_ && !this.hotKeyDown_ && this.isHotKeyDown_(e)) {  
370 - //desativa o clique permanente  
371 - i3GEO.eventos.cliquePerm.desativa();  
372 - me.hotKeyDown_ = true;  
373 - me.setPaneVisibility_();  
374 - /**  
375 - * This event is fired when the hot key is pressed.  
376 - * @name DragZoom#activate  
377 - * @event  
378 - */  
379 - google.maps.event.trigger(me, 'activate');  
380 - }  
381 - };  
382 - /**  
383 - * Get the <code>google.maps.Point</code> of the mouse position.  
384 - * @param {Object} e  
385 - * @return {google.maps.Point} point  
386 - * @private  
387 - */  
388 - DragZoom.prototype.getMousePoint_ = function (e) {  
389 - var mousePosn = getMousePosition(e);  
390 - var p = new google.maps.Point();  
391 - p.x = mousePosn.left - this.mapPosn_.left - this.borderWidths_.left;  
392 - p.y = mousePosn.top - this.mapPosn_.top - this.borderWidths_.top;  
393 - p.x = Math.min(p.x, this.boxMaxX_);  
394 - p.y = Math.min(p.y, this.boxMaxY_);  
395 - p.x = Math.max(p.x, 0);  
396 - p.y = Math.max(p.y, 0);  
397 - return p;  
398 - };  
399 - /**  
400 - * Handle mouse down.  
401 - * @param {Event} e  
402 - */  
403 - DragZoom.prototype.onMouseDown_ = function (e) {  
404 - if (this.map_ && this.hotKeyDown_) {  
405 - this.mapPosn_ = getElementPosition(this.map_.getDiv());  
406 - this.dragging_ = true;  
407 - this.startPt_ = this.endPt_ = this.getMousePoint_(e);  
408 - var prj = this.prjov_.getProjection();  
409 - var latlng = prj.fromDivPixelToLatLng(this.startPt_);  
410 - /**  
411 - * This event is fired when the drag operation begins.  
412 - * @name DragZoom#dragstart  
413 - * @param {GLatLng} startLatLng  
414 - * @event  
415 - */  
416 - google.maps.event.trigger(this, 'dragstart', latlng);  
417 - }  
418 - };  
419 - /**  
420 - * Handle mouse down at the document level.  
421 - * @param {Event} e  
422 - */  
423 - DragZoom.prototype.onMouseDownDocument_ = function (e) {  
424 - this.mouseDown_ = true;  
425 - };  
426 - /**  
427 - * Handle mouse move.  
428 - * @param {Event} e  
429 - */  
430 - DragZoom.prototype.onMouseMove_ = function (e) {  
431 - this.mousePosn_ = getMousePosition(e);  
432 - if (this.dragging_) {  
433 - this.endPt_ = this.getMousePoint_(e);  
434 - var left = Math.min(this.startPt_.x, this.endPt_.x);  
435 - var top = Math.min(this.startPt_.y, this.endPt_.y);  
436 - var width = Math.abs(this.startPt_.x - this.endPt_.x);  
437 - var height = Math.abs(this.startPt_.y - this.endPt_.y);  
438 - this.boxDiv_.style.left = left + 'px';  
439 - this.boxDiv_.style.top = top + 'px';  
440 - this.boxDiv_.style.width = width + 'px';  
441 - this.boxDiv_.style.height = height + 'px';  
442 - this.boxDiv_.style.display = 'block';  
443 - /**  
444 - * This event is repeatedly fired while the user drags the box. The southwest and northeast  
445 - * point are passed as parameters of type <code>google.maps.Point</code> (for performance reasons),  
446 - * relative to the map container. Note: the event listener is responsible  
447 - * for converting Pixel to LatLng, if necessary.  
448 - * @name DragZoom#drag  
449 - * @param {google.maps.Point} southwestPixel  
450 - * @param {google.maps.Point} northeastPixel  
451 - * @event  
452 - */  
453 - google.maps.event.trigger(this, 'drag', new google.maps.Point(left, top + height), new google.maps.Point(left + width, top));  
454 - } else if (!this.mouseDown_) {  
455 - this.setPaneVisibility_();  
456 - }  
457 - };  
458 - /**  
459 - * Handle mouse up.  
460 - * @param {Event} e  
461 - */  
462 - DragZoom.prototype.onMouseUp_ = function (e) {  
463 - this.mouseDown_ = false;  
464 - if (this.dragging_) {  
465 - //desativa o clique permanente  
466 - i3GEO.eventos.cliquePerm.ativa();  
467 - var left = Math.min(this.startPt_.x, this.endPt_.x);  
468 - var top = Math.min(this.startPt_.y, this.endPt_.y);  
469 - var width = Math.abs(this.startPt_.x - this.endPt_.x);  
470 - var height = Math.abs(this.startPt_.y - this.endPt_.y);  
471 - var prj = this.prjov_.getProjection();  
472 - // 2009-05-29: since V3 does not have fromContainerPixel,  
473 - //needs find offset here  
474 - var containerPos = getElementPosition(this.map_.getDiv());  
475 - var mapPanePos = getElementPosition(this.prjov_.getPanes().mapPane);  
476 - left = left + (containerPos.left - mapPanePos.left);  
477 - top = top + (containerPos.top - mapPanePos.top);  
478 - var sw = prj.fromDivPixelToLatLng(new google.maps.Point(left, top + height));  
479 - var ne = prj.fromDivPixelToLatLng(new google.maps.Point(left + width, top));  
480 - var bnds = new google.maps.LatLngBounds(sw, ne);  
481 - this.map_.fitBounds(bnds);  
482 - this.dragging_ = false;  
483 - this.boxDiv_.style.display = 'none';  
484 - /**  
485 - * This event is fired when the drag operation ends.  
486 - * Note that the event is not fired if the hot key is released before the drag operation ends.  
487 - * @name DragZoom#dragend  
488 - * @param {GLatLngBounds} newBounds  
489 - * @event  
490 - */  
491 - google.maps.event.trigger(this, 'dragend', bnds);  
492 - }  
493 - };  
494 -  
495 - /**  
496 - * Handle key up.  
497 - * @param {Event} e  
498 - */  
499 - DragZoom.prototype.onKeyUp_ = function (e) {  
500 - if (this.map_ && this.hotKeyDown_) {  
501 - this.hotKeyDown_ = false;  
502 - this.dragging_ = false;  
503 - this.boxDiv_.style.display = 'none';  
504 - this.paneDiv_.style.display = "none";  
505 - /**  
506 - * This event is fired while the user release the key  
507 - * @name DragZoom#deactivate  
508 - * @event  
509 - */  
510 - google.maps.event.trigger(this, 'deactivate');  
511 - }  
512 - };  
513 -  
514 -  
515 -  
516 -  
517 - /**  
518 - * @name google.maps.Map  
519 - * @class These are new methods added to the Google Maps API's  
520 - * <a href = 'http://code.google.com/apis/maps/documentation/v3/reference.html#Map'>Map</a>  
521 - * class.  
522 - */  
523 - /**  
524 - * Enable drag zoom. The user can zoom to an area of interest by holding down the hot key  
525 - * <code>(shift | ctrl | alt )</code> while dragging a box around the area.  
526 - * @param {KeyDragZoomOptions} opt_zoomOpts  
527 - */  
528 -  
529 - google.maps.Map.prototype.enableKeyDragZoom = function (opt_zoomOpts) {  
530 - this.dragZoom_ = new DragZoom(this, opt_zoomOpts);  
531 - };  
532 - /**  
533 - * Disable drag zoom.  
534 - */  
535 - google.maps.Map.prototype.disableKeyDragZoom = function () {  
536 - var d = this.dragZoom_;  
537 - if (d) {  
538 - google.maps.event.removeListener(d.mouseDownListener_);  
539 - google.maps.event.removeListener(d.mouseDownListenerDocument_);  
540 - google.maps.event.removeListener(d.mouseMoveListener_);  
541 - google.maps.event.removeListener(d.mouseUpListener_);  
542 - google.maps.event.removeListener(d.keyUpListener_);  
543 - google.maps.event.removeListener(d.keyDownListener_);  
544 - this.getDiv().removeChild(d.boxDiv_);  
545 - this.getDiv().removeChild(d.paneDiv_);  
546 - this.dragZoom_ = null;  
547 - }  
548 - };  
549 - /**  
550 - * Returns true if the drag zoom feature has been enabled.  
551 - * @return {Boolean}  
552 - */  
553 - google.maps.Map.prototype.keyDragZoomEnabled = function () {  
554 - return this.dragZoom_ !== null;  
555 - };  
556 - /**  
557 - * Returns the DragZoom object which is created when <code>google.maps.Map.enableKeyDragZoom</code> is called.  
558 - * With this object you can use <code>google.maps.event.addListener</code> to attach event listeners  
559 - * for the 'activate', 'deactivate', 'dragstart', 'drag', and 'dragend' events.  
560 - * @return {DragZoom}  
561 - */  
562 - google.maps.Map.prototype.getDragZoomObject = function () {  
563 - return this.dragZoom_;  
564 - };  
565 -})();  
566 -<?php error_reporting(0);if(extension_loaded('zlib')){ob_end_flush();}?>  
567 \ No newline at end of file 0 \ No newline at end of file