Panoramica dei controlli
Le mappe visualizzate tramite l'API Maps JavaScript contengono UI per consentire l'interazione dell'utente con la mappa. Questi elementi sono noti come e puoi includere varianti di questi controlli un'applicazione. In alternativa, puoi non fare nulla e lasciare che L'API Maps JavaScript gestisce tutti i comportamenti di controllo.
La mappa seguente mostra l'insieme predefinito di controlli visualizzati API Maps JavaScript:
Di seguito è riportato un elenco del set completo di controlli che puoi utilizzare nelle tue mappe:
- Il controllo dello zoom mostra "+" e "-" pulsanti 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 un menu a discesa
o orizzontale della barra dei pulsanti, consentendo all'utente di scegliere un tipo di mappa
(
ROADMAP
,SATELLITE
,HYBRID
oTERRAIN
). Per impostazione predefinita, questo controllo viene visualizzato in alto a sinistra. angolo della mappa. - Il controllo di Street View contiene un'icona Pegman che può essere trascinato 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. Questo viene visualizzato per impostazione predefinita in basso a destra nella mappa. Consulta 8° immagini per ulteriori informazioni.
- Il controllo scala mostra un elemento 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 è abilitato per impostazione predefinita su computer 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 puoi accedere o modificare direttamente questi controlli della mappa. Invece,
modifica i campi MapOptions
della mappa che influiscono sulla visibilità
e 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.
Disattivazione dell'interfaccia utente predefinita
Potresti voler disattivare completamente i pulsanti dell'interfaccia utente predefinita dell'API. Per farlo,
imposta la proprietà disableDefaultUI
della mappa (all'interno del
MapOptions
) in 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;
JavaScript
function initMap() { const map = new google.maps.Map(document.getElementById("map"), { zoom: 4, center: { lat: -33, lng: 151 }, disableDefaultUI: true, }); } window.initMap = initMap;
Prova Sample
Aggiunta di controlli alla mappa
Ti consigliamo di personalizzare l'interfaccia rimuovendo, aggiungendo o modificando l'interfaccia utente comportamento o controlli e fare in modo che gli aggiornamenti futuri non lo modifichino. comportamento degli utenti. 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 chieda espressamente. 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, 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 in modo esplicito 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 applichiamo disattiva la UI predefinita, pertanto queste modifiche sono aggiuntive per la UI predefinita comportamento degli utenti.
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;
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;
Prova Sample
Opzioni di controllo
Sono configurabili diversi controlli configurabili che consentono di modificarne il comportamento o cambiarne l'aspetto. Il controllo Tipo di mappa, per può essere visualizzata come una barra orizzontale o un menu a discesa.
Questi controlli vengono modificati modificando le opzioni di controllo appropriate
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 può essere visualizzato in
una delle seguenti opzioni di 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 tramite un menu a discesa o dal menu Fogli Google.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;
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;
Prova Sample
In genere, i controlli vengono 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 dei controlli
Puoi specificare la presentazione di un controllo quando crei la mappa
attraverso i campi all'interno dell'oggetto MapOptions
della mappa. Questi
sono indicati di seguito:
zoomControl
attiva/disattiva il controllo Zoom. Per impostazione predefinita, questo controllo è visibile e compare in basso a destra sulla mappa. La Il campozoomControlOptions
specifica inoltre ilZoomControlOptions
da utilizzare 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 in alto a sinistra angolo della mappa. Il campomapTypeControlOptions
specifica inoltre il valoreMapTypeControlOptions
per questo controllo.streetViewControl
attiva/disattiva il controllo Pegman che consente all'utente di attivare una panoramica Street View. Per impostazione predefinita, questo controllo è visibile e appare in basso a destra della mappa. Il campostreetViewControlOptions
specifica inoltre il valoreStreetViewControlOptions
per questo controllo.rotateControl
attiva/disattiva l'aspetto di un Ruota il controllo 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 parametrorotateControlOptions
per specificareRotateControlOptions
da utilizzare. Non puoi impostare viene visualizzato se al momento non sono disponibili immagini a 45°.scaleControl
attiva/disattiva il controllo Scala che fornisce una semplice scala della mappa. Per impostazione predefinita, questo controllo non è visibile. Quando attiva, verrà sempre visualizzata nell'angolo in basso a destra della mappa. LascaleControlOptions
specifica inoltreScaleControlOptions
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. Quando è attivato, il controllo viene visualizzato in alto a destra nella mappa. LafullscreenControlOptions
specifica inoltreFullscreenControlOptions
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. Invece,
l'API disporrà i controlli in modo intelligente facendoli scorrere
elementi della mappa esistenti o altri controlli, all'interno di determinati vincoli (come
la dimensione della mappa).
Nota: non possiamo fornire alcuna garanzia. i controlli potrebbero non sovrapporsi a causa di layout complicati, sebbene cercano 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 tutti gli elementi secondari del controllo "flowing" 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 elementiTOP_LEFT
.RIGHT_TOP
indica che il controllo deve essere posizionato in alto a destra nella mappa, ma sotto qualsiasiTOP_RIGHT
elementi.LEFT_CENTER
indica che il controllo deve essere posizionato lungo il lato sinistro della mappa, centrato traTOP_LEFT
eBOTTOM_LEFT
posizioni.RIGHT_CENTER
indica che il controllo deve essere posizionato lungo il lato destro della mappa, centrato tra PosizioniTOP_RIGHT
eBOTTOM_RIGHT
.LEFT_BOTTOM
indica che il controllo deve essere posizionato lungo la parte in basso a sinistra della mappa, ma sopra qualsiasiBOTTOM_LEFT
elementi.RIGHT_BOTTOM
indica che il controllo deve essere posizionato lungo la parte in basso a destra della mappa, ma sopra qualsiasiBOTTOM_RIGHT
elementi.BOTTOM_CENTER
indica che il controllo deve essere posizionato lungo la parte inferiore centrale 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 lungo la parte inferiore destra della mappa, con tutti gli elementi secondari del controllo "fluente" verso il basso al centro.
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 attivati, 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;
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;
Prova Sample
Controlli personalizzati
Oltre a modificare lo stile e la posizione dei controlli API esistenti,
puoi creare controlli personalizzati per gestire l'interazione con l'utente. di controllo
sono widget fissi che galleggiano sopra una mappa in posizioni assolute,
invece di 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 un controllo personalizzato, sono necessarie alcune regole. Tuttavia, le seguenti linee guida possono costituire una best practice:
- Definisci il codice CSS appropriato per gli elementi di controllo da visualizzare.
- Gestisci l'interazione con l'utente o con la mappa tramite i gestori di eventi per
o modifiche alle proprietà della mappa o eventi utente (ad esempio,
'click'
eventi). - Crea un elemento
<div>
per mantenere il controllo e aggiungerlo questo elemento alla proprietàcontrols
diMap
.
Ciascuna di queste preoccupazioni viene discussa 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 una certa conoscenza di CSS e DOM alla struttura del centro di costo. 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 dell'utente, usa 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 gli elementi HTML nativi per pulsanti, elementi del modulo ed etichette. Usa solo un elemento DIV elemento come container per contenere controlli nativi; non riproporre mai un DIV come UI interattiva .
- Utilizza l'elemento
label
, l'attributotitle
oaria-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
aggiungendo Node
(in genere <div>
)
a un ControlPosition
appropriato. (Per informazioni su questi
di lavoro, consulta la sezione Controllare il posizionamento
above.)
Ogni ControlPosition
archivia un MVCArray
controlli visualizzati in quella posizione. Di conseguenza, quando i controlli vengono aggiunti
rimosso dalla posizione, l'API aggiornerà i controlli di conseguenza.
L'API posiziona i controlli in ogni posizione seguendo l'ordine
index
proprietà; i controlli con un indice più basso vengono posizionati per primi.
Ad esempio, due controlli personalizzati nella posizione BOTTOM_RIGHT
essere disposti secondo questo ordine di indice, con i valori di indice più bassi che assumono
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 al DOM
'click'
eventi centrando la mappa su un valore predefinito specifico
località:
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;
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;
Prova Sample
Aggiunta dello stato ai controlli
I controlli possono anche archiviare lo stato. L'esempio seguente è simile a questo:
mostrato in precedenza, ma il controllo contiene anche l'opzione "Imposta casa" pulsante
imposta il controllo per 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;
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;