Controlli

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.
Seleziona piattaforma: Android iOS JavaScript

Panoramica dei controlli

Le mappe visualizzate tramite l'API Maps JavaScript contengono elementi UI per consentire l'interazione degli utenti con la mappa. Questi elementi sono noti come controlli e puoi includere varianti di questi controlli nella tua applicazione. In alternativa, non puoi fare nulla e lasciare che l'API Maps JavaScript gestisca tutti i comportamenti di controllo.

La seguente mappa mostra l'insieme predefinito di controlli visualizzati dall'API Maps JavaScript:

Di seguito è riportato un elenco di tutti i controlli che puoi utilizzare nelle tue mappe:

  • Il controllo Zoom mostra i pulsanti "+" e "-" per modificare il livello di zoom della mappa. Questo controllo viene visualizzato per impostazione predefinita nell'angolo in basso a destra della mappa.
  • Il controllo Tipo di mappa è disponibile in stile menu a discesa o nella barra dei pulsanti orizzontale per consentire all'utente di scegliere un tipo di mappa (ROADMAP, SATELLITE, HYBRID o TERRAIN). Questo controllo viene visualizzato per impostazione predefinita nell'angolo in alto a sinistra della mappa.
  • Il controllo Street View contiene un'icona Pegman che può essere trascinata sulla mappa per abilitare Street View. Per impostazione predefinita, questo controllo viene visualizzato nella parte in basso a destra della mappa.
  • Il controllo Ruota offre una combinazione di opzioni di inclinazione e rotazione per le mappe contenenti immagini obliche. Per impostazione predefinita, questo controllo viene visualizzato nella parte in basso a destra della mappa. Per ulteriori informazioni, consulta le immagini a 45°.
  • Il Controllo scala mostra un elemento scala in mappa. Questo controllo è disattivato per impostazione predefinita.
  • Il controllo a schermo intero offre la possibilità di aprire la mappa in modalità a schermo intero. Questo controllo è abilitato per impostazione predefinita su desktop e dispositivi mobili. Nota: iOS non supporta la funzionalità a schermo intero. Pertanto, il controllo a schermo intero non è visibile sui dispositivi iOS.
  • Il controllo delle scorciatoie da tastiera mostra un elenco di scorciatoie da tastiera per interagire con la mappa.

Non puoi accedere ai controlli per la mappa né modificarli direttamente. Puoi modificare i campi MapOptions della mappa che influiscono sulla visibilità e sulla presentazione dei controlli. Puoi modificare la presentazione dei controlli dopo aver creato un'istanza della mappa (con MapOptions appropriato) o modificare una mappa in modo dinamico chiamando setOptions() per modificare le opzioni della mappa.

Non tutti questi controlli sono attivi per impostazione predefinita. Per saperne di più sul comportamento dell'interfaccia utente predefinita e su come modificarlo, consulta la sezione L'interfaccia utente predefinita di seguito.

Interfaccia utente predefinita

Per impostazione predefinita, tutti i controlli scompaiono se la mappa è troppo piccola (200 x 200 px). Puoi ignorare questo comportamento impostando esplicitamente il controllo in modo che sia visibile. Consulta la sezione Aggiungi controlli alla mappa.

Il comportamento e l'aspetto dei controlli sono gli stessi per i dispositivi mobili e desktop, ad eccezione del controllo a schermo intero (consulta il comportamento descritto nell'elenco dei controlli).

Inoltre, la gestione della tastiera è attiva per impostazione predefinita su tutti i dispositivi.

Disattivare l'UI predefinita

Ti consigliamo di disattivare completamente i pulsanti predefiniti della UI dell'API. A tale scopo, imposta la proprietà disableDefaultUI della mappa (nell'oggetto MapOptions) su true. Questa proprietà disabilita i pulsanti di controllo dell'interfaccia utente dall'API Maps JavaScript. Tuttavia, non influisce sui gesti del mouse o sulle scorciatoie da tastiera sulla mappa di base, che sono controllate rispettivamente dalle proprietà gestureHandling e keyboardShortcuts.

Il codice seguente disattiva i pulsanti dell'interfaccia utente:

TypeScript

function initMap(): void {
  const map = new google.maps.Map(
    document.getElementById("map") as HTMLElement,
    {
      zoom: 4,
      center: { lat: -33, lng: 151 },
      disableDefaultUI: true,
    }
  );
}

declare global {
  interface Window {
    initMap: () => void;
  }
}
window.initMap = initMap;
index.ts

JavaScript

function initMap() {
  const map = new google.maps.Map(document.getElementById("map"), {
    zoom: 4,
    center: { lat: -33, lng: 151 },
    disableDefaultUI: true,
  });
}

window.initMap = initMap;
index.js
Visualizza esempio

Prova anteprima

Aggiungere controlli alla mappa

Ti consigliamo di personalizzare l'interfaccia rimuovendo, aggiungendo o modificando i controlli o il comportamento della UI e verifica che i futuri aggiornamenti non influiscano su questo comportamento. Se vuoi aggiungere o modificare solo il comportamento esistente, devi assicurarti che il controllo venga aggiunto esplicitamente all'applicazione.

Alcuni controlli vengono visualizzati sulla mappa per impostazione predefinita, mentre altri non vengono visualizzati, a meno che non vengano richiesti. L'aggiunta o la rimozione di controlli dalla mappa è specificata nei seguenti campi dell'oggetto MapOptions, che hai impostato su true per renderli visibili o che è impostato su false per nasconderli:

{
  zoomControl: boolean,
  mapTypeControl: boolean,
  scaleControl: boolean,
  streetViewControl: boolean,
  rotateControl: boolean,
  fullscreenControl: boolean
}

Per impostazione predefinita, tutti i controlli scompaiono se la mappa è di dimensioni inferiori a 200 x 200 px. Puoi ignorare questo comportamento impostando esplicitamente il controllo in modo che sia visibile. Ad esempio, la tabella seguente mostra se il controllo dello zoom è visibile o meno, in base alle dimensioni della mappa e all'impostazione del campo zoomControl:

Dimensioni mappa zoomControl Visibile?
Qualsiasi false No
Qualsiasi true Sì
>= 200 x 200 px undefined Sì
< 200 x 200 pixel undefined No

L'esempio seguente imposta la mappa per nascondere il controllo Zoom e visualizzare il controllo Scala. Tieni presente che non disattiviamo esplicitamente l'UI predefinita, pertanto queste modifiche sono cumulative rispetto al comportamento predefinito.

TypeScript

function initMap(): void {
  const map = new google.maps.Map(
    document.getElementById("map") as HTMLElement,
    {
      zoom: 4,
      center: { lat: -33, lng: 151 },
      zoomControl: false,
      scaleControl: true,
    }
  );
}

declare global {
  interface Window {
    initMap: () => void;
  }
}
window.initMap = initMap;
index.ts

JavaScript

function initMap() {
  const map = new google.maps.Map(document.getElementById("map"), {
    zoom: 4,
    center: { lat: -33, lng: 151 },
    zoomControl: false,
    scaleControl: true,
  });
}

window.initMap = initMap;
index.js
Visualizza esempio

Prova anteprima

Opzioni di controllo

Sono disponibili diversi controlli configurabili, che ti consentono di modificarne il comportamento o il loro aspetto. Il controllo Tipo di mappa, ad esempio, può apparire come una barra orizzontale o in un menu a discesa.

Questi controlli vengono modificati modificando i campi opzioni di controllo appropriati all'interno dell'oggetto MapOptions al momento della creazione della mappa.

Ad esempio, le opzioni per modificare il controllo Tipo di mappa sono indicate nel campo mapTypeControlOptions. Il controllo Tipo di mappa potrebbe essere visualizzato in una delle seguenti opzioni di style:

  • google.maps.MapTypeControlStyle.HORIZONTAL_BAR mostra l'array di controlli come pulsanti in una barra orizzontale, come mostrato su Google Maps.
  • google.maps.MapTypeControlStyle.DROPDOWN_MENU mostra un pulsante singolo che ti consente di selezionare il tipo di mappa tramite un menu a discesa.
  • google.maps.MapTypeControlStyle.DEFAULT mostra il comportamento predefinito, che dipende dalle dimensioni dello schermo, e potrebbe cambiare nelle versioni future dell'API.

Tieni presente che, se modifichi qualsiasi opzione di controllo, devi abilitarle esplicitamente impostando anche il valore MapOptions appropriato su true. Ad esempio, per impostare un controllo Tipo di mappa per visualizzare lo stile DROPDOWN_MENU, utilizza il seguente codice all'interno dell'oggetto MapOptions:

  ...
  mapTypeControl: true,
  mapTypeControlOptions: {
    style: google.maps.MapTypeControlStyle.DROPDOWN_MENU
  }
  ...

L'esempio seguente mostra come modificare la posizione e lo stile predefiniti dei controlli.

TypeScript

// You can set control options to change the default position or style of many
// of the map controls.

function initMap(): void {
  const map = new google.maps.Map(
    document.getElementById("map") as HTMLElement,
    {
      zoom: 4,
      center: { lat: -33, lng: 151 },
      mapTypeControl: true,
      mapTypeControlOptions: {
        style: google.maps.MapTypeControlStyle.DROPDOWN_MENU,
        mapTypeIds: ["roadmap", "terrain"],
      },
    }
  );
}

declare global {
  interface Window {
    initMap: () => void;
  }
}
window.initMap = initMap;
index.ts

JavaScript

// You can set control options to change the default position or style of many
// of the map controls.
function initMap() {
  const map = new google.maps.Map(document.getElementById("map"), {
    zoom: 4,
    center: { lat: -33, lng: 151 },
    mapTypeControl: true,
    mapTypeControlOptions: {
      style: google.maps.MapTypeControlStyle.DROPDOWN_MENU,
      mapTypeIds: ["roadmap", "terrain"],
    },
  });
}

window.initMap = initMap;
index.js
Visualizza esempio

Prova anteprima

In genere i controlli vengono configurati al momento della creazione della mappa. Tuttavia, puoi modificare in modo dinamico la presentazione dei controlli chiamando il metodo setOptions() di Map, trasmettendone nuove opzioni.

Modifica dei controlli

Puoi specificare la presentazione di un controllo quando crei la mappa tramite i campi all'interno dell'oggetto MapOptions della mappa. Questi campi sono indicati di seguito:

  • zoomControl attiva/disattiva il controllo Zoom. Per impostazione predefinita, questo controllo è visibile e viene visualizzato nella parte in basso a destra della mappa. Il campo zoomControlOptions specifica inoltre ZoomControlOptions da utilizzare per questo controllo.
  • mapTypeControl attiva/disattiva il controllo Tipo di mappa che consente all'utente di passare da un tipo di mappa all'altro (ad esempio Map e Satellite). Per impostazione predefinita, questo controllo è visibile e viene visualizzato nell'angolo in alto a sinistra della mappa. Il campo mapTypeControlOptions specifica inoltre MapTypeControlOptions da utilizzare per questo controllo.
  • streetViewControl attiva/disattiva il controllo di Pegman che consente all'utente di attivare una panoramica di Street View. Per impostazione predefinita, questo controllo è visibile e viene visualizzato nella parte inferiore destra della mappa. Il campo streetViewControlOptions specifica inoltre StreetViewControlOptions da utilizzare per questo controllo.
  • rotateControl attiva/disattiva l'aspetto di un controllo di rotazione per controllare l'orientamento delle immagini a 45°. Per impostazione predefinita, la presenza del controllo è determinata dalla presenza o dall'assenza di immagini a 45° per il tipo di mappa specificato allo zoom e alla posizione correnti. Puoi modificare il comportamento del controllo impostando rotateControlOptions sulla mappa per specificare RotateControlOptions da utilizzare. Non puoi mostrare il controllo se al momento non sono disponibili immagini a 45°.
  • scaleControl attiva/disattiva il controllo Scala che fornisce una semplice scalabilità della mappa. Per impostazione predefinita, questo controllo non è visibile. Una volta attivata, verrà sempre visualizzata nell'angolo in basso a destra della mappa. scaleControlOptions specifica inoltre ScaleControlOptions da utilizzare per questo controllo.
  • fullscreenControl attiva/disattiva il controllo che apre la mappa in modalità a schermo intero. Per impostazione predefinita, questo controllo è abilitato sui dispositivi desktop e Android. Quando è attivo, il controllo viene visualizzato nella parte in alto a destra della mappa. fullscreenControlOptions specifica inoltre FullscreenControlOptions da utilizzare per questo controllo.

Tieni presente che puoi specificare le opzioni dei controlli che disattivi inizialmente.

Controllo del posizionamento

La maggior parte delle opzioni di controllo contiene una proprietà position (di tipo ControlPosition) che indica dove posizionare il controllo sulla mappa. Il posizionamento di questi controlli non è assoluto. Piuttosto, l'API applicherà i controlli in modo intelligente facendoli scorrere intorno agli elementi mappa esistenti o ad altri controlli, all'interno dei vincoli (come le dimensioni della mappa).

Nota: non è possibile garantire che i controlli non si sovrappongano a causa di layout complessi, ma l'API tenterà di organizzarli in modo intelligente.

Sono supportate le seguenti posizioni di controllo:

  • TOP_CENTER indica che il controllo deve essere posizionato al centro in alto della mappa.
  • TOP_LEFT indica che il controllo deve essere posizionato lungo l'angolo in alto a sinistra della mappa, con gli elementi secondari del controllo che "scorrono" verso il centro in alto.
  • TOP_RIGHT indica che il controllo deve essere posizionato lungo la parte superiore destra della mappa, con eventuali elementi secondari del controllo che "scorrono" verso il centro in alto.
  • LEFT_TOP indica che il controllo deve essere posizionato lungo la parte superiore sinistra della mappa, ma sotto tutti gli elementi TOP_LEFT.
  • RIGHT_TOP indica che il controllo deve essere posizionato lungo l'angolo in alto a destra della mappa, ma sotto tutti gli elementi TOP_RIGHT.
  • LEFT_CENTER indica che il controllo deve essere posizionato sul lato sinistro della mappa, al centro tra le posizioni TOP_LEFT e BOTTOM_LEFT.
  • RIGHT_CENTER indica che il controllo deve essere posizionato sul lato destro della mappa, centrato tra le posizioni TOP_RIGHT e BOTTOM_RIGHT.
  • LEFT_BOTTOM indica che il controllo deve essere posizionato in basso a sinistra della mappa, ma sopra tutti gli elementi BOTTOM_LEFT.
  • RIGHT_BOTTOM indica che il controllo deve essere posizionato in basso a destra nella mappa, ma sopra gli elementi BOTTOM_RIGHT.
  • BOTTOM_CENTER indica che il controllo deve essere posizionato al centro in basso della mappa.
  • BOTTOM_LEFT indica che il controllo deve essere posizionato lungo la parte in basso a sinistra della mappa, con gli elementi secondari del controllo che "scorrono" verso il centro in basso.
  • BOTTOM_RIGHT indica che il controllo deve essere posizionato in basso a destra nella mappa, con gli elementi secondari del controllo che "scorrono" verso il centro in basso.

Tieni presente che queste posizioni potrebbero corrispondere alle posizioni degli elementi UI di cui non puoi modificare i posizionamenti (ad esempio copyright e logo Google). In questi casi, i controlli verranno applicati in base alla logica indicata per ogni posizione e verranno visualizzati il più vicino possibile alla posizione indicata.

L'esempio seguente mostra una mappa semplice con tutti i controlli abilitati, in posizioni diverse.

TypeScript

function initMap(): void {
  const map = new google.maps.Map(
    document.getElementById("map") as HTMLElement,
    {
      zoom: 12,
      center: { lat: -28.643387, lng: 153.612224 },
      mapTypeControl: true,
      mapTypeControlOptions: {
        style: google.maps.MapTypeControlStyle.HORIZONTAL_BAR,
        position: google.maps.ControlPosition.TOP_CENTER,
      },
      zoomControl: true,
      zoomControlOptions: {
        position: google.maps.ControlPosition.LEFT_CENTER,
      },
      scaleControl: true,
      streetViewControl: true,
      streetViewControlOptions: {
        position: google.maps.ControlPosition.LEFT_TOP,
      },
      fullscreenControl: true,
    }
  );
}

declare global {
  interface Window {
    initMap: () => void;
  }
}
window.initMap = initMap;
index.ts

JavaScript

function initMap() {
  const map = new google.maps.Map(document.getElementById("map"), {
    zoom: 12,
    center: { lat: -28.643387, lng: 153.612224 },
    mapTypeControl: true,
    mapTypeControlOptions: {
      style: google.maps.MapTypeControlStyle.HORIZONTAL_BAR,
      position: google.maps.ControlPosition.TOP_CENTER,
    },
    zoomControl: true,
    zoomControlOptions: {
      position: google.maps.ControlPosition.LEFT_CENTER,
    },
    scaleControl: true,
    streetViewControl: true,
    streetViewControlOptions: {
      position: google.maps.ControlPosition.LEFT_TOP,
    },
    fullscreenControl: true,
  });
}

window.initMap = initMap;
index.js
Visualizza esempio

Prova anteprima

Controlli personalizzati

Oltre a modificare lo stile e la posizione dei controlli API esistenti, puoi creare controlli personalizzati per gestire le interazioni con l'utente. I controlli sono widget fissi che galleggiano sopra una mappa in posizioni assolute, al contrario degli overlay, che si spostano con la mappa sottostante. Fondamentalmente, un controllo è un elemento <div> che ha una posizione assoluta sulla mappa, mostra una UI alla persona e gestisce l'interazione con l'utente o la mappa, solitamente tramite un gestore di eventi.

Per creare un tuo controllo personalizzato, sono necessarie alcune regole. Tuttavia, le seguenti linee guida possono fungere da best practice:

  • Definisci il CSS appropriato per gli elementi di controllo da visualizzare.
  • Gestisci l'interazione con l'utente o la mappa tramite gestori di eventi per le modifiche alla proprietà mappa o gli eventi utente (ad esempio eventi 'click').
  • Crea un elemento <div> per mantenere il controllo e aggiungilo alla proprietà controls di Map.

Ciascuno di questi problemi viene discusso di seguito.

Disegno dei controlli personalizzati

La modalità di progettazione del controllo dipende da te. In genere, consigliamo di inserire tutta la presentazione di controllo all'interno di un singolo elemento <div>, in modo da poter manipolare il controllo come una singola unità. Utilizzeremo questo pattern di progettazione negli esempi mostrati di seguito.

La progettazione di controlli accattivanti richiede una certa conoscenza della struttura CSS e DOM. Il seguente codice mostra una funzione per creare un elemento pulsante che esegue la panoramica della mappa da centrare su Chicago.

function createCenterControl(map) {
  const controlButton = document.createElement("button");

  // Set CSS for the control.
  controlButton.style.backgroundColor = "#fff";
  controlButton.style.border = "2px solid #fff";
  controlButton.style.borderRadius = "3px";
  controlButton.style.boxShadow = "0 2px 6px rgba(0,0,0,.3)";
  controlButton.style.color = "rgb(25,25,25)";
  controlButton.style.cursor = "pointer";
  controlButton.style.fontFamily = "Roboto,Arial,sans-serif";
  controlButton.style.fontSize = "16px";
  controlButton.style.lineHeight = "38px";
  controlButton.style.margin = "8px 0 22px";
  controlButton.style.padding = "0 5px";
  controlButton.style.textAlign = "center";

  controlButton.textContent = "Center Map";
  controlButton.title = "Click to recenter the map";
  controlButton.type = "button";

  // Setup the click event listeners: simply set the map to Chicago.
  controlButton.addEventListener("click", () => {
    map.setCenter(chicago);
  });

  return controlButton;
}

Gestione degli eventi dai controlli personalizzati

Affinché un controllo sia utile, in realtà deve fare qualcosa. La scelta dipende da te. Il controllo può rispondere all'input dell'utente o alle modifiche dello stato di Map.

Per rispondere all'input dell'utente, utilizza addEventListener(), che gestisce gli eventi DOM supportati. Il seguente snippet di codice aggiunge un listener per l'evento 'click' del browser. Tieni presente che questo evento viene ricevuto dal DOM, non dalla mappa.

// Setup the click event listener: set the map to center on Chicago
var chicago = {lat: 41.850, lng: -87.650};

controlButton.addEventListener('click', () => {
  map.setCenter(chicago);
});

Rendere accessibili i controlli personalizzati

Per assicurarti che i controlli ricevano gli eventi della tastiera e vengano visualizzati correttamente dagli screen reader:

  • Utilizza sempre gli elementi HTML nativi per pulsanti, elementi di modulo ed etichette. Utilizza un elemento DIV solo come container per contenere i controlli nativi; non riproporre mai un DIV come elemento UI interattivo.
  • Utilizza l'elemento label, l'attributo title o l'attributo aria-label ove opportuno per fornire informazioni su un elemento dell'interfaccia utente.

Posizionamento di controlli personalizzati

I controlli personalizzati vengono posizionati sulla mappa posizionandoli in posizioni appropriate all'interno della proprietà controls dell'oggetto Map. Questa proprietà contiene un array di google.maps.ControlPosition s. Puoi aggiungere un controllo personalizzato alla mappa aggiungendo Node (in genere <div>) a un ControlPosition appropriato. (per informazioni su queste posizioni, consulta la sezione Controllo del posizionamento sopra).

Ogni ControlPosition archivia un MVCArray dei controlli visualizzati in quella posizione. Di conseguenza, quando i controlli vengono aggiunti o rimossi dalla posizione, l'API aggiorna i controlli di conseguenza.

L'API inserisce i controlli in ogni posizione in base all'ordine di una proprietà index; quelli con un indice inferiore vengono posizionati per primi. Ad esempio, in questo ordine di indicizzazione verranno impostati due controlli personalizzati in posizione BOTTOM_RIGHT, con i valori di indicizzazione più bassi prevalenti. Per impostazione predefinita, tutti i controlli personalizzati vengono effettuati dopo il controllo di eventuali controlli predefiniti dell'API. Puoi ignorare questo comportamento impostando la proprietà index di un controllo come un valore negativo. I controlli personalizzati non possono essere posizionati a sinistra del logo o a destra del copyright.

Il codice riportato di seguito crea un nuovo controllo personalizzato (il suo costruttore non è mostrato) e lo aggiunge alla mappa nella posizione TOP_RIGHT.

var map = new google.maps.Map(document.getElementById('map'), mapOptions);

// Create a DIV to attach the control UI to the Map.
const centerControlDiv = document.createElement("div");

// Create the control. This code calls a function that
// creates a new instance of a button control.
const centerControl = createCenterControl(map);

// Append the control to the DIV.
centerControlDiv.appendChild(centerControl);

// Add the control to the map at a designated control position
// by pushing it on the position's array. This code will
// implicitly add the control to the DOM, through the Map
// object. You should not attach the control manually.
map.controls[google.maps.ControlPosition.TOP_CENTER].push(centerControlDiv);

Un esempio di controllo personalizzato

Il seguente controllo è semplice (anche se non particolarmente utile) e combina i pattern mostrati sopra. Questo controllo risponde agli eventi DOM 'click' centrando la mappa in una determinata posizione predefinita:

TypeScript

let map: google.maps.Map;

const chicago = { lat: 41.85, lng: -87.65 };

/**
 * Creates a control that recenters the map on Chicago.
 */
 function createCenterControl(map) {
  const controlButton = document.createElement('button');

  // Set CSS for the control.
  controlButton.style.backgroundColor = '#fff';
  controlButton.style.border = '2px solid #fff';
  controlButton.style.borderRadius = '3px';
  controlButton.style.boxShadow = '0 2px 6px rgba(0,0,0,.3)';
  controlButton.style.color = 'rgb(25,25,25)';
  controlButton.style.cursor = 'pointer';
  controlButton.style.fontFamily = 'Roboto,Arial,sans-serif';
  controlButton.style.fontSize = '16px';
  controlButton.style.lineHeight = '38px';
  controlButton.style.margin = '8px 0 22px';
  controlButton.style.padding = '0 5px';
  controlButton.style.textAlign = 'center';

  controlButton.textContent = 'Center Map';
  controlButton.title = 'Click to recenter the map';
  controlButton.type = 'button';

  // Setup the click event listeners: simply set the map to Chicago.
  controlButton.addEventListener('click', () => {
    map.setCenter(chicago);
  });

  return controlButton;
}

function initMap() {
  map = new google.maps.Map(document.getElementById('map') as HTMLElement, {
    zoom: 12,
    center: chicago,
  });

  // Create the DIV to hold the control.
  const centerControlDiv = document.createElement('div');
  // Create the control.
  const centerControl = createCenterControl(map);
  // Append the control to the DIV.
  centerControlDiv.appendChild(centerControl);

  map.controls[google.maps.ControlPosition.TOP_CENTER].push(centerControlDiv);
}

declare global {
  interface Window {
    initMap: () => void;
  }
}
window.initMap = initMap;
index.ts

JavaScript

let map;
const chicago = { lat: 41.85, lng: -87.65 };

/**
 * Creates a control that recenters the map on Chicago.
 */
function createCenterControl(map) {
  const controlButton = document.createElement("button");

  // Set CSS for the control.
  controlButton.style.backgroundColor = "#fff";
  controlButton.style.border = "2px solid #fff";
  controlButton.style.borderRadius = "3px";
  controlButton.style.boxShadow = "0 2px 6px rgba(0,0,0,.3)";
  controlButton.style.color = "rgb(25,25,25)";
  controlButton.style.cursor = "pointer";
  controlButton.style.fontFamily = "Roboto,Arial,sans-serif";
  controlButton.style.fontSize = "16px";
  controlButton.style.lineHeight = "38px";
  controlButton.style.margin = "8px 0 22px";
  controlButton.style.padding = "0 5px";
  controlButton.style.textAlign = "center";
  controlButton.textContent = "Center Map";
  controlButton.title = "Click to recenter the map";
  controlButton.type = "button";
  // Setup the click event listeners: simply set the map to Chicago.
  controlButton.addEventListener("click", () => {
    map.setCenter(chicago);
  });
  return controlButton;
}

function initMap() {
  map = new google.maps.Map(document.getElementById("map"), {
    zoom: 12,
    center: chicago,
  });

  // Create the DIV to hold the control.
  const centerControlDiv = document.createElement("div");
  // Create the control.
  const centerControl = createCenterControl(map);

  // Append the control to the DIV.
  centerControlDiv.appendChild(centerControl);
  map.controls[google.maps.ControlPosition.TOP_CENTER].push(centerControlDiv);
}

window.initMap = initMap;
index.js
Visualizza esempio

Prova anteprima

Aggiunta dello stato ai controlli

I controlli possono anche memorizzare lo stato. L'esempio seguente è simile a mostrato prima, ma il controllo contiene un pulsante "Imposta casa" aggiuntivo che imposta il controllo per mostrare una nuova posizione di casa. Per farlo, creiamo una proprietà home_ nel controllo per archiviare questo stato e fornire getter e setter per lo stato.

TypeScript

let map: google.maps.Map;

const chicago: google.maps.LatLngLiteral = { lat: 41.85, lng: -87.65 };

/**
 * The CenterControl adds a control to the map that recenters the map on
 * Chicago.
 */
class CenterControl {
  private map_: google.maps.Map;
  private center_: google.maps.LatLng;
  constructor(
    controlDiv: HTMLElement,
    map: google.maps.Map,
    center: google.maps.LatLngLiteral
  ) {
    this.map_ = map;
    // Set the center property upon construction
    this.center_ = new google.maps.LatLng(center);
    controlDiv.style.clear = "both";

    // Set CSS for the control border
    const goCenterUI = document.createElement("button");

    goCenterUI.id = "goCenterUI";
    goCenterUI.title = "Click to recenter the map";
    controlDiv.appendChild(goCenterUI);

    // Set CSS for the control interior
    const goCenterText = document.createElement("div");

    goCenterText.id = "goCenterText";
    goCenterText.innerHTML = "Center Map";
    goCenterUI.appendChild(goCenterText);

    // Set CSS for the setCenter control border
    const setCenterUI = document.createElement("button");

    setCenterUI.id = "setCenterUI";
    setCenterUI.title = "Click to change the center of the map";
    controlDiv.appendChild(setCenterUI);

    // Set CSS for the control interior
    const setCenterText = document.createElement("div");

    setCenterText.id = "setCenterText";
    setCenterText.innerHTML = "Set Center";
    setCenterUI.appendChild(setCenterText);

    // Set up the click event listener for 'Center Map': Set the center of
    // the map
    // to the current center of the control.
    goCenterUI.addEventListener("click", () => {
      const currentCenter = this.center_;

      this.map_.setCenter(currentCenter);
    });

    // Set up the click event listener for 'Set Center': Set the center of
    // the control to the current center of the map.
    setCenterUI.addEventListener("click", () => {
      const newCenter = this.map_.getCenter()!;

      if (newCenter) {
        this.center_ = newCenter;
      }
    });
  }
}

function initMap(): void {
  map = new google.maps.Map(document.getElementById("map") as HTMLElement, {
    zoom: 12,
    center: chicago,
  });

  // Create the DIV to hold the control and call the CenterControl()
  // constructor passing in this DIV.
  const centerControlDiv = document.createElement("div");
  const control = new CenterControl(centerControlDiv, map, chicago);

  // @ts-ignore
  centerControlDiv.index = 1;
  centerControlDiv.style.paddingTop = "10px";
  map.controls[google.maps.ControlPosition.TOP_CENTER].push(centerControlDiv);
}

declare global {
  interface Window {
    initMap: () => void;
  }
}
window.initMap = initMap;
index.ts

JavaScript

let map;
const chicago = { lat: 41.85, lng: -87.65 };

/**
 * The CenterControl adds a control to the map that recenters the map on
 * Chicago.
 */
class CenterControl {
  map_;
  center_;
  constructor(controlDiv, map, center) {
    this.map_ = map;
    // Set the center property upon construction
    this.center_ = new google.maps.LatLng(center);
    controlDiv.style.clear = "both";

    // Set CSS for the control border
    const goCenterUI = document.createElement("button");

    goCenterUI.id = "goCenterUI";
    goCenterUI.title = "Click to recenter the map";
    controlDiv.appendChild(goCenterUI);

    // Set CSS for the control interior
    const goCenterText = document.createElement("div");

    goCenterText.id = "goCenterText";
    goCenterText.innerHTML = "Center Map";
    goCenterUI.appendChild(goCenterText);

    // Set CSS for the setCenter control border
    const setCenterUI = document.createElement("button");

    setCenterUI.id = "setCenterUI";
    setCenterUI.title = "Click to change the center of the map";
    controlDiv.appendChild(setCenterUI);

    // Set CSS for the control interior
    const setCenterText = document.createElement("div");

    setCenterText.id = "setCenterText";
    setCenterText.innerHTML = "Set Center";
    setCenterUI.appendChild(setCenterText);
    // Set up the click event listener for 'Center Map': Set the center of
    // the map
    // to the current center of the control.
    goCenterUI.addEventListener("click", () => {
      const currentCenter = this.center_;

      this.map_.setCenter(currentCenter);
    });
    // Set up the click event listener for 'Set Center': Set the center of
    // the control to the current center of the map.
    setCenterUI.addEventListener("click", () => {
      const newCenter = this.map_.getCenter();

      if (newCenter) {
        this.center_ = newCenter;
      }
    });
  }
}

function initMap() {
  map = new google.maps.Map(document.getElementById("map"), {
    zoom: 12,
    center: chicago,
  });

  // Create the DIV to hold the control and call the CenterControl()
  // constructor passing in this DIV.
  const centerControlDiv = document.createElement("div");
  const control = new CenterControl(centerControlDiv, map, chicago);

  // @ts-ignore
  centerControlDiv.index = 1;
  centerControlDiv.style.paddingTop = "10px";
  map.controls[google.maps.ControlPosition.TOP_CENTER].push(centerControlDiv);
}

window.initMap = initMap;
index.js
Visualizza esempio

Prova anteprima