Controlli

Seleziona la piattaforma: Android iOS JavaScript

Panoramica dei controlli

Le mappe visualizzate tramite l'API Maps JavaScript contengono elementi UI per consentire all'utente di interagire con la mappa. Questi elementi sono noti come controlli e puoi includere varianti di questi controlli nella tua applicazione. In alternativa, puoi non fare nulla e lasciare che sia l'API Maps JavaScript a gestire tutto il comportamento di controllo.

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

Di seguito è riportato un elenco del set completo di 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 della fotocamera include i controlli di zoom e panoramica e viene visualizzato per impostazione predefinita al posto del controllo dello zoom quando utilizzi il canale beta.
  • Il controllo Tipo mappa è disponibile come menu a discesa o come barra di pulsanti orizzontale e consente all'utente di scegliere un tipo di mappa (ROADMAP, SATELLITE, HYBRID o TERRAIN). Per impostazione predefinita, questo controllo viene visualizzato nell'angolo in alto a sinistra della mappa.
  • Il controllo di Street View contiene un'icona di Pegman che può essere trascinata sulla mappa per attivare Street View. Questo controllo viene visualizzato per impostazione predefinita in basso a destra nella mappa.
  • Il controllo Rotazione offre una combinazione di opzioni di inclinazione e rotazione per le mappe contenenti immagini oblique. Per impostazione predefinita, questo controllo viene visualizzato in basso a destra nella mappa. Per saperne di più, consulta la sezione Immagini a 45°.
  • Il controllo della scala mostra un elemento della scala della 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 è attivo per impostazione predefinita su computer e dispositivi mobili. Nota:iOS non supporta la funzionalità a schermo intero. Il controllo dello 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 accedi o modifichi direttamente questi controlli della mappa. Devi invece modificare i campi MapOptions della mappa che influiscono sulla visibilità e sulla presentazione dei controlli. Puoi modificare la presentazione di controllo creare un'istanza della mappa (con i MapOptions appropriati) o modificare mappa in modo dinamico richiamando setOptions() per modificare le opzioni di CPU e memoria disponibili.

Non tutti questi controlli sono attivi per impostazione predefinita. Per scoprire di più sulla UI predefinita comportamento (e come modificarlo), consulta UI predefinita di seguito.

UI predefinita

Per impostazione predefinita, tutti i controlli scompaiono se la mappa è troppo piccola (200 x 200 px). Puoi ignorare questo comportamento impostando in modo esplicito il controllo su visibile. Consulta la sezione Aggiunta di controlli agli Mappa.

Il comportamento e l'aspetto dei controlli sono gli stessi su dispositivi mobili e dispositivi desktop, ad eccezione del controllo a schermo intero (vedi 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 dell'interfaccia utente predefiniti dell'API. Per farlo, imposta la proprietà disableDefaultUI della mappa (all'interno dell'oggetto MapOptions) su true. Questa proprietà disattiva eventuali pulsanti di controllo dell'interfaccia utente dall'API Maps JavaScript. it non influisce, tuttavia, sui gesti del mouse o sulle scorciatoie da tastiera sulla base mappa, che sono controllate da gestureHandling e rispettivamente keyboardShortcuts.

Il seguente codice 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 Sample

Aggiungere controlli alla mappa

Potresti voler personalizzare l'interfaccia rimuovendo, aggiungendo o modificando il comportamento o i controlli dell'interfaccia utente e assicurarti che gli aggiornamenti futuri non alterino questo comportamento. Se vuoi solo aggiungere o modificare il comportamento esistente, devi assicurati 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 tu non li richieda specificamente. L'aggiunta o la rimozione di controlli dal è specificata nel seguente oggetto MapOptions campi, che imposti su true per renderli visibili o su false per nasconderli:

{
  zoomControl: boolean,
  cameraControl: 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 su visibile. Ad esempio, la tabella seguente mostra se il controllo dello zoom è visibile o meno, in base alle dimensioni della mappa e all'impostazione Campo zoomControl:

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

L'esempio seguente imposta la mappa in modo da nascondere lo Zoom e visualizza il controllo Scala. Tieni presente che non disattiviamo esplicitamente l'interfaccia utente predefinita, pertanto queste modifiche si sommano al comportamento dell'interfaccia utente predefinita.

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 Sample

Opzioni di controllo

Sono configurabili diversi controlli configurabili che consentono di modificarne il comportamento o cambiarne l'aspetto. Ad esempio, il controllo Tipo di mappa può essere visualizzato come barra orizzontale o 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 mappa può essere visualizzato in una delle seguenti opzioni style:

  • google.maps.MapTypeControlStyle.HORIZONTAL_BAR mostra array di controlli sotto forma di pulsanti in una barra orizzontale come mostrato su Google Mappe.
  • google.maps.MapTypeControlStyle.DROPDOWN_MENU mostra un controllo con un singolo pulsante che consente di selezionare il tipo di mappa utilizzando un menu a discesa.
  • google.maps.MapTypeControlStyle.DEFAULT mostra comportamento predefinito, che dipende dalle dimensioni dello schermo e potrebbe cambiare in futuro o versioni successive dell'API.

Tieni presente che se modifichi le opzioni di controllo, devi abilitare esplicitamente anche il controllo impostando il valore MapOptions appropriato a true. Ad esempio, per impostare un controllo Tipo di mappa per mostrare lo stile DROPDOWN_MENU, utilizza il seguente codice all'interno l'oggetto MapOptions:

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

L'esempio seguente mostra come modificare la posizione predefinita e lo stile 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 Sample

I controlli vengono generalmente configurati al momento della creazione della mappa. Tuttavia, puoi modificare la presentazione dei controlli in modo dinamico chiamando il metodo setOptions() di Map, e passargli le nuove opzioni di controllo.

Modifica controlli

Specifichi 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 dello zoom. Per impostazione predefinita, questo controllo è visibile e compare in basso a destra sulla mappa. Il campo zoomControlOptions specifica inoltre il ZoomControlOptions da utilizzare per questo controllo.
  • cameraControl attiva/disattiva il controllo della videocamera. Questo controllo è visibile per impostazione predefinita nelle mappe che utilizzano il canale beta. Il campo cameraControlOptions specifica inoltre il CameraControlOptions da usare per questo controllo.
  • mapTypeControl attiva/disattiva il controllo Tipo di mappa. che permette all'utente di alternare tra i tipi di mappa (come Mappa e Satellite). Per impostazione predefinita, questo controllo è visibile e viene visualizzato nell'angolo in alto a sinistra della mappa. Il campo mapTypeControlOptions specifica inoltre il valore MapTypeControlOptions da utilizzare per questo controllo.
  • streetViewControl attiva/disattiva il controllo di Pegman che consente all'utente di attivare un panorama di Street View. Per impostazione predefinita, questo controllo è visibile e viene visualizzato in basso a destra della mappa. Il campo streetViewControlOptions specifica inoltre il valore StreetViewControlOptions da utilizzare per questo controllo.
  • rotateControl attiva/disattiva la visualizzazione di un controllo di rotazione per controllare l'orientamento delle immagini a 45°. Di predefinita, la presenza del controllo è determinata dalla presenza o dall'assenza di immagini a 45° per il tipo di mappa specificato con lo zoom corrente e in ogni località. Puoi modificare il comportamento del controllo impostando il valore rotateControlOptions della mappa per specificare il valore RotateControlOptions da utilizzare. Non puoi mostrare il controllo se non sono disponibili immagini a 45°.
  • scaleControl attiva/disattiva il controllo Scala che fornisce una scala per la mappa. Per impostazione predefinita, questo controllo non è visibile. Quando è attivata, viene visualizzata sempre nell'angolo in basso a destra della mappa. scaleControlOptions specifica inoltre il valore ScaleControlOptions da utilizzare per questo controllo.
  • fullscreenControl attiva/disattiva il controllo che apre la mappa in modalità a schermo intero. Questo controllo è abilitato per impostazione predefinita su computer e dispositivi Android. Se è attivato, il controllo viene visualizzato in alto a destra nella mappa. fullscreenControlOptions specifica inoltre il valore FullscreenControlOptions da utilizzare per questo controllo.

Tieni presente che puoi specificare le opzioni per i controlli che hai disattivato inizialmente.

Controlla posizionamento

La maggior parte delle opzioni di controllo contiene una proprietà position (di tipo ControlPosition) che indica il punto sulla mappa per il controllo. Il posizionamento di questi controlli non è assoluto. Al contrario, l'API disporrà i controlli in modo intelligente, facendoli scorrere intorno agli elementi della mappa esistenti o ad altri controlli, entro determinati vincoli (ad esempio le dimensioni della mappa).

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

Sono supportate le seguenti posizioni di controllo:

  • TOP_CENTER indica che il controllo deve essere posizionato lungo la parte superiore centrale della mappa.
  • TOP_LEFT indica che il controllo deve essere posizionato in alto a sinistra della mappa, con eventuali elementi secondari del controllo "che scorrono" verso il centro in alto.
  • TOP_RIGHT indica che il controllo deve essere posizionato in alto a destra nella mappa, con tutti gli elementi secondari del controllo "flowing" verso il centro in alto.
  • LEFT_TOP indica che il controllo deve essere posizionato in alto a sinistra della mappa, ma sotto eventuali elementi TOP_LEFT.
  • RIGHT_TOP indica che il controllo deve essere posizionato in alto a destra nella mappa, ma sotto qualsiasi TOP_RIGHT elementi.
  • 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, al centro tra le posizioni TOP_RIGHT e BOTTOM_RIGHT.
  • LEFT_BOTTOM indica che il controllo deve essere posizionato nella parte in basso a sinistra della mappa, ma sopra eventuali elementi BOTTOM_LEFT.
  • RIGHT_BOTTOM indica che il controllo deve essere posizionato in basso a destra nella mappa, ma sopra eventuali elementi BOTTOM_RIGHT.
  • BOTTOM_CENTER indica che il controllo deve essere posizionato nella parte inferiore al centro della mappa.
  • BOTTOM_LEFT indica che il controllo deve essere posizionato lungo la parte inferiore sinistra della mappa, con tutti gli elementi secondari del controllo "fluente" verso il basso al centro.
  • BOTTOM_RIGHT indica che il controllo deve essere posizionato in basso a destra nella mappa, con eventuali elementi secondari del controllo "che scorrono" verso il centro in basso.

Tieni presente che queste posizioni possono coincidere con quelle degli elementi UI i posizionamenti che non puoi modificare (come i copyright e il logo di Google). In questi casi, il flusso dei controlli avverrà secondo la logica indicata per in ciascuna posizione e apparire il più vicino possibile alle posizione.

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

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 Sample

Controlli personalizzati

Oltre a modificare lo stile e la posizione dei controlli API esistenti, puoi creare i tuoi controlli per gestire l'interazione con l'utente. I controlli sono widget fissi che galleggiano sopra una mappa in posizioni assolute, diversamente dagli overlay, che si spostano con la mappa sottostante. Altro fondamentalmente, un controllo è un elemento <div> che ha una posizione assoluta sulla mappa, mostra alcune UI all'utente e gestisce l'interazione con l'utente o con la mappa, solitamente attraverso un evento .

Per creare il tuo controllo personalizzato, sono necessarie poche regole. Tuttavia, le seguenti linee guida possono costituire una best practice:

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

Ciascuno di questi problemi viene discusso di seguito.

Disegno di controlli personalizzati

Sei tu a decidere il modo in cui trai il controllo. In genere, consigliamo di collocare tutta la presentazione di controllo in un unico Elemento <div> in modo da poter manipolare il controllo come un'unità. Utilizzeremo questo pattern di progettazione negli esempi mostrati di seguito.

La progettazione di controlli accattivanti richiede alcune conoscenze di CSS e della struttura DOM. Il codice seguente mostra una funzione per creare un elemento pulsante che esegue la panoramica della mappa per centrarla 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, deve fare qualcosa. Cosa viene visualizzato dipende da te. Il controllo potrebbe rispondere all'input dell'utente o potrebbe rispondere alle modifiche dello stato di Map.

Per rispondere all'input utente, utilizza addEventListener(), che gestisce gli eventi DOM supportati. La il seguente snippet di codice aggiunge un listener per l'elemento '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 agli screen reader:

  • Utilizza sempre elementi HTML nativi per pulsanti, elementi di modulo ed etichette. Utilizza un elemento DIV solo come contenitore per contenere i controlli nativi. Non riutilizzare mai un elemento DIV come elemento UI interattivo.
  • Utilizza l'elemento label, l'attributo title o aria-label ove appropriato, per fornire informazioni su un elemento UI.

Posizionamento dei controlli personalizzati

I controlli personalizzati vengono posizionati sulla mappa posizionandoli nella posizione appropriata posizioni all'interno del campo controls dell'oggetto Map proprietà. Questa proprietà contiene un array di google.maps.ControlPosition Aggiungi un controllo personalizzato alla mappa aggiungendo Node (in genere <div>) a un ControlPosition appropriato. Per informazioni su queste posizioni, consulta Controllare il posizionamento sopra.

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

L'API inserisce i controlli in ogni posizione in base all'ordine di una proprietà index. I controlli con un indice inferiore vengono inseriti per primi. Ad esempio, due controlli personalizzati nella posizione BOTTOM_RIGHT verranno disposti in base a questo ordine di indice, con i valori di indice inferiori che hanno la precedenza. Per impostazione predefinita, tutti i controlli personalizzati vengono posizionati dopo il posizionamento controlli predefiniti dell'API. Puoi ignorare questo comportamento impostando index del controllo come valore negativo. Controlli personalizzati non può essere posizionato a sinistra del logo o a destra del copyright.

Il codice seguente crea un nuovo controllo personalizzato (il suo costruttore non è l'immagine) e la 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);

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 Sample

Aggiunta dello stato ai controlli

I controlli possono anche memorizzare lo stato. L'esempio riportato di seguito è simile a quello mostrato in precedenza, ma il controllo contiene un pulsante aggiuntivo "Imposta casa" che imposta il controllo in modo da mostrare una nuova posizione della casa. Per farlo, creiamo Proprietà home_ all'interno del controllo per archiviare questo stato e forniscono getter e setter per quello 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 Sample