Opcje

Wybierz platformę: Android iOS JavaScript

Omówienie elementów sterujących

Mapy wyświetlane za pomocą interfejsu Maps JavaScript API zawierają elementy interfejsu, które umożliwiają użytkownikom interakcję z mapą. Elementy te są nazywane elementami sterującymi. Możesz je uwzględnić w swojej aplikacji. Możesz też nie robić nic i pozwolić, by interfejs Maps JavaScript API zarządzał całymi działaniami sterującymi.

Ta mapa przedstawia domyślny zestaw elementów sterujących wyświetlany przez interfejs Maps JavaScript API:

Poniżej znajduje się lista wszystkich opcji, których możesz używać w swoich mapach:

• Element sterujący powiększenia wyświetla przyciski „+” i „-” do zmiany poziomu powiększenia mapy. Ten element sterujący pojawia się domyślnie w prawym dolnym rogu mapy.
• Element sterujący typu mapy jest dostępny w stylu menu rozwijanego lub poziomego paska z przyciskami i pozwala użytkownikowi wybrać typ mapy (ROADMAP, SATELLITE, HYBRID lub TERRAIN). Ten element sterujący jest domyślnie widoczny w lewym górnym rogu mapy.
• Element sterujący Street View zawiera ikonę Pegmana, którą można przeciągnąć na mapę, by włączyć Street View. Ten element sterujący jest domyślnie widoczny w prawym dolnym rogu mapy.
• Element sterujący obrotu łączy opcje przechylania i obracania w przypadku map zawierających zdjęcia ukośne. Ten element sterujący jest domyślnie widoczny w prawym dolnym rogu mapy. Więcej informacji znajdziesz w opisie zdjęć 45°.
• Element sterujący skali wyświetla element skali mapy. Ta opcja jest domyślnie wyłączona.
• Sterowanie pełnoekranowym umożliwia otwieranie mapy w trybie pełnoekranowym. To ustawienie jest domyślnie włączone na komputerach i urządzeniach mobilnych. Uwaga: iOS nie obsługuje funkcji pełnego ekranu. W związku z tym element sterujący trybem pełnoekranowym jest niewidoczny na urządzeniach z iOS.
• Sterowanie za pomocą skrótów klawiszowych wyświetla listę skrótów klawiszowych używanych do interakcji z mapą.

Nie masz bezpośredniego dostępu do tych elementów mapy ani nie możesz ich modyfikować. Zamiast tego modyfikujesz pola MapOptions mapy, co wpływa na widoczność i wygląd elementów sterujących. Możesz dostosować prezentację kontrolną podczas tworzenia instancji mapy (za pomocą odpowiednich elementów MapOptions) lub dynamicznie modyfikować mapę, wywołując funkcję setOptions(), aby zmienić jej opcje.

Nie wszystkie z tych ustawień są domyślnie włączone. Więcej informacji o domyślnym działaniu interfejsu (i o tym, jak je zmienić) znajdziesz w sekcji Domyślny interfejs poniżej.

Domyślny interfejs

Domyślnie wszystkie elementy sterujące znikają, jeśli mapa jest zbyt mała (200 x 200 pikseli). Możesz zastąpić to zachowanie, jawnie ustawiając opcję jako widoczną. Zapoznaj się z artykułem Dodawanie elementów sterujących do mapy.

Elementy sterujące działają i wyglądają tak samo na urządzeniach mobilnych i komputerach, z wyjątkiem opcji pełnoekranowej (zobacz działanie opisane na liście elementów sterujących).

Dodatkowo domyślnie obsługa klawiatury jest włączona na wszystkich urządzeniach.

Wyłączanie domyślnego interfejsu użytkownika

Być może chcesz całkowicie wyłączyć domyślne przyciski interfejsu API. Aby to zrobić, ustaw właściwość disableDefaultUI mapy (w obiekcie MapOptions) na true. Ta właściwość wyłącza wszystkie przyciski elementów sterujących UI z interfejsu Maps JavaScript API. Nie ma jednak wpływu na gesty myszy ani skróty klawiszowe na mapie podstawowej, które sterują odpowiednio właściwości gestureHandling i keyboardShortcuts.

Ten kod wyłącza przyciski interfejsu:

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

Uwaga: przeczytaj przewodnik po korzystaniu z TypeScriptu i Map Google.

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

Uwaga: JavaScript jest kompilowany na podstawie fragmentu kodu TypeScript.

Zobacz przykład

Zobacz próbkę

JSFiddle.net Google Cloud Shell

Dodawanie elementów sterujących do mapy

Możesz dostosować interfejs, usuwając, dodając lub modyfikując działanie bądź elementy interfejsu użytkownika. Dopilnuj też, aby przyszłe aktualizacje nie zmieniały tego działania. Jeśli chcesz tylko dodać lub zmienić dotychczasowy sposób działania, upewnij się, że element sterujący jest wyraźnie dodany do aplikacji.

Niektóre elementy sterujące pojawiają się domyślnie na mapie, a inne nie, chyba że o to poprosisz. Opcje dodawania i usuwania opcji z mapy określa się w polach obiektu MapOptions, które ustawisz na true, by je wyświetlać, lub false, by je ukryć:

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

Domyślnie wszystkie elementy sterujące znikają, jeśli mapa jest mniejsza niż 200 x 200 pikseli. Możesz zastąpić to zachowanie, jawnie ustawiając opcję jako widoczną. Na przykład w tabeli poniżej widać, czy suwak powiększenia jest widoczny, na podstawie rozmiaru mapy i ustawienia pola zoomControl:

Rozmiar mapy	zoomControl	Widoczna?
Dowolny	false	Nie
Dowolny	true	Tak
>= 200 x 200 pikseli	undefined	Tak
< 200 x 200 pikseli	undefined	Nie

Poniższy przykład pokazuje, jak ustawia się mapę tak, aby ukryć element sterujący powiększeniem i wyświetlić kontrolkę Skala. Pamiętaj, że nie wyłączamy wprost domyślnego interfejsu, więc wprowadzone zmiany sumują się do domyślnego działania interfejsu.

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

Uwaga: przeczytaj przewodnik po korzystaniu z TypeScriptu i Map Google.

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

Uwaga: JavaScript jest kompilowany na podstawie fragmentu kodu TypeScript.

Zobacz przykład

Zobacz próbkę

JSFiddle.net Google Cloud Shell

Opcje sterowania

Istnieje kilka ustawień, które możesz skonfigurować, zmieniając ich działanie lub wygląd. Element sterujący typu mapy może na przykład wyświetlać się jako poziomy pasek lub menu.

Te elementy sterujące są modyfikowane przez zmianę odpowiednich pól opcji w obiekcie MapOptions podczas tworzenia mapy.

Na przykład opcje zmiany ustawienia typu mapy są wskazane w polu mapTypeControlOptions. Kontrolka typu mapy może pojawić się w jednej z tych opcji style:

• google.maps.MapTypeControlStyle.HORIZONTAL_BAR wyświetla tablicę elementów sterujących w postaci przycisków na poziomym pasku, tak jak to widać w Mapach Google.
• google.maps.MapTypeControlStyle.DROPDOWN_MENU wyświetla przycisk, który pozwala wybrać typ mapy z menu.
• google.maps.MapTypeControlStyle.DEFAULT wyświetla działanie domyślne, które zależy od rozmiaru ekranu i może się zmienić w kolejnych wersjach interfejsu API.

Pamiętaj, że jeśli zmienisz jakiekolwiek opcje sterowania, musisz je też jawnie włączyć, ustawiając odpowiednią wartość MapOptions na true. Aby na przykład ustawić element sterujący typu mapy tak, aby był zgodny ze stylem DROPDOWN_MENU, użyj tego kodu w obiekcie MapOptions:

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

Poniższy przykład pokazuje, jak zmienić domyślną pozycję i styl elementów sterujących.

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

Uwaga: przeczytaj przewodnik po korzystaniu z TypeScriptu i Map Google.

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

Uwaga: JavaScript jest kompilowany na podstawie fragmentu kodu TypeScript.

Zobacz przykład

Zobacz próbkę

JSFiddle.net Google Cloud Shell

Elementy sterujące są zwykle konfigurowane podczas tworzenia mapy. Możesz jednak dynamicznie zmieniać wygląd elementów sterujących, wywołując metodę setOptions() obiektu Map, przekazując do niej nowe opcje ustawień.

Modyfikowanie ustawień

Prezentację elementu sterującego określasz podczas tworzenia mapy za pomocą pól w obiekcie MapOptions mapy. Te pola są oznaczone poniżej:

• zoomControl włącza/wyłącza powiększenie. Domyślnie ten element sterujący jest widoczny i widoczny w prawym dolnym rogu mapy. Pole zoomControlOptions dodatkowo określa ZoomControlOptions, który ma być używany z tym ustawieniem.
• mapTypeControl włącza/wyłącza ustawienie typu mapy, które umożliwia użytkownikowi przełączanie typów map (takich jak Mapa i Satelita). Domyślnie ten element sterujący jest widoczny i wyświetla się w lewym górnym rogu mapy. Pole mapTypeControlOptions dodatkowo określa MapTypeControlOptions, który ma być używany na potrzeby tego ustawienia.
• streetViewControl włącza/wyłącza element sterujący Pegmana, który umożliwia użytkownikowi aktywowanie panoramy Street View. Domyślnie ten element sterujący jest widoczny i znajduje się w prawym dolnym rogu mapy. Pole streetViewControlOptions dodatkowo określa StreetViewControlOptions, który ma być używany na potrzeby tego ustawienia.
• rotateControl włącza/wyłącza wyświetlanie elementów sterujących obrótem do sterowania orientacją zdjęć pod kątem 45°. Domyślnie obecność elementu sterującego jest określana na podstawie obecności lub braku zdjęć pod kątem prostym dla danego typu mapy w bieżącym powiększeniu i w bieżącej lokalizacji. Możesz zmienić działanie elementu sterującego, ustawiając rotateControlOptions mapy, aby określić RotateControlOptions, który ma być używany. Jeśli nie są dostępne zdjęcia pod kątem 45°, nie możesz wyświetlić elementu sterującego.
• scaleControl włącza/wyłącza ustawienie skali, które zapewnia prostą skalę mapy. Domyślnie ten element sterujący jest niewidoczny. Po włączeniu będzie zawsze wyświetlana w prawym dolnym rogu mapy. scaleControlOptions dodatkowo określa ScaleControlOptions, który ma być używany z tym ustawieniem.
• fullscreenControl włącza/wyłącza element sterujący, który otwiera mapę w trybie pełnoekranowym. Domyślnie to ustawienie jest włączone na komputerach i urządzeniach z Androidem. Po włączeniu pojawi się element sterujący w prawym górnym rogu mapy. fullscreenControlOptions dodatkowo określa FullscreenControlOptions, który ma być używany z tym ustawieniem.

Pamiętaj, że możesz określić opcje ustawień, które zostaną początkowo wyłączone.

Sterowanie pozycjonowaniem

Większość opcji sterujących zawiera właściwość position (typu ControlPosition), która wskazuje, gdzie na mapie ma zostać umieszczony element sterujący. Umiejscowienie tych elementów sterujących nie jest bezwzględne. Zamiast tego interfejs API będzie inteligentnie rozmieszczać elementy sterujące, opływając je wokół istniejących elementów mapy lub innych elementów sterujących zgodnie z określonymi ograniczeniami (takimi jak rozmiar mapy).

Uwaga: nie można zagwarantować, że elementy sterujące nie będą nakładać się na siebie w przypadku skomplikowanych układów, ale interfejs API spróbuje je rozmieścić w sposób inteligentny.

Obsługiwane są te pozycje elementów sterujących:

• TOP_CENTER oznacza, że element sterujący powinien znajdować się na środku u góry mapy.
• TOP_LEFT oznacza, że element sterujący powinien znajdować się w lewym górnym rogu mapy, a wszystkie podrzędne elementy elementu sterującego „przesuwają się” do środka u góry.
• TOP_RIGHT oznacza, że element sterujący powinien znajdować się w prawym górnym rogu mapy, a wszystkie podrzędne elementy elementu sterującego „przesuwają się” do środka u góry.
• LEFT_TOP oznacza, że element sterujący powinien znajdować się wzdłuż lewego górnego rogu mapy, ale pod wszystkimi elementami TOP_LEFT.
• RIGHT_TOP oznacza, że element sterujący powinien znajdować się wzdłuż górnego prawego rogu mapy, ale pod wszystkimi elementami TOP_RIGHT.
• LEFT_CENTER oznacza, że element sterujący powinien znajdować się po lewej stronie mapy, pośrodku między pozycjami TOP_LEFT i BOTTOM_LEFT.
• RIGHT_CENTER oznacza, że element sterujący powinien znajdować się po prawej stronie mapy, pośrodku między pozycjami TOP_RIGHT i BOTTOM_RIGHT.
• LEFT_BOTTOM oznacza, że element sterujący powinien znajdować się w lewym dolnym rogu mapy, ale nad wszystkimi elementami BOTTOM_LEFT.
• RIGHT_BOTTOM oznacza, że element sterujący powinien znajdować się w prawym dolnym rogu mapy, ale nad wszystkimi elementami BOTTOM_RIGHT.
• BOTTOM_CENTER oznacza, że element sterujący powinien znajdować się na środku u dołu mapy.
• BOTTOM_LEFT oznacza, że element sterujący powinien znajdować się w lewym dolnym rogu mapy, a wszystkie jego elementy podrzędne „przesuwają się” do środka u dołu.
• BOTTOM_RIGHT oznacza, że element sterujący powinien znajdować się w prawym dolnym rogu mapy, a wszystkie podrzędne elementy elementu sterującego „przesuwają się” do środka u dołu.

Pozycje te mogą się pokrywać z umiejscowieniem elementów interfejsu, których miejsc docelowych nie możesz zmieniać (np. związanych z prawami autorskimi i logo Google). W takich przypadkach elementy sterujące będą wyświetlane zgodnie z logiką określoną dla każdej pozycji i będą wyświetlane jak najbliżej ich wskazanej pozycji.

Poniższy przykład przedstawia prostą mapę z włączonymi wszystkimi elementami sterującymi w różnych miejscach.

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

Uwaga: przeczytaj przewodnik po korzystaniu z TypeScriptu i Map Google.

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

Uwaga: JavaScript jest kompilowany na podstawie fragmentu kodu TypeScript.

Zobacz przykład

Zobacz próbkę

JSFiddle.net Google Cloud Shell

Ustawienia niestandardowe

Oprócz modyfikowania stylu i pozycji istniejących elementów sterujących interfejsu API możesz tworzyć własne elementy sterujące do obsługi interakcji z użytkownikiem. Elementy sterujące to nieruchome widżety, które unoszą się po mapie w pozycji bezwzględnej, w przeciwieństwie do nakładek, które przesuwają się razem z mapą bazową. Zasadniczo element sterujący to element <div>, który ma stałe położenie na mapie, wyświetla interfejs użytkownika i obsługuje interakcję z użytkownikiem lub mapą, zwykle za pomocą modułu obsługi zdarzeń.

Do utworzenia własnego elementu sterującego potrzeba kilku reguł. Warto jednak skorzystać z tych wskazówek:

• Określ odpowiedni kod CSS dla elementów sterujących, które mają być wyświetlane.
• Obsługuj interakcję z użytkownikiem lub mapą za pomocą modułów obsługi zdarzeń w przypadku zmian właściwości mapy lub zdarzeń użytkownika (np. zdarzeń 'click').
• Utwórz element <div> do przechowywania elementu sterującego i dodaj ten element do właściwości controls Map.

Poniżej omawiamy każdy z tych problemów.

Rysowanie elementów sterujących niestandardowych

Sposób rysowania elementów sterujących zależy od Ciebie. Ogólnie zalecamy umieszczenie całej prezentacji kontrolnej w jednym elemencie <div>, dzięki czemu będzie można obsługiwać ją jak jedną jednostką. Wykorzystamy ten wzorzec projektowy w poniższych przykładach.

Zaprojektowanie atrakcyjnych elementów sterujących wymaga pewnej wiedzy o strukturze CSS i DOM. Poniższy kod przedstawia funkcję tworzenia przycisku, który przesuwa mapę w celu wyśrodkowania na 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;
}

Obsługa zdarzeń pochodzących z ustawień niestandardowych

Aby element sterujący był przydatny, musi faktycznie coś zrobić. Działanie opcji zależy od Ciebie. Element sterujący może reagować na dane wejściowe użytkownika lub na zmiany stanu Map.

Aby odpowiadać na dane wejściowe użytkownika, używaj zasady addEventListener(), która obsługuje obsługiwane zdarzenia DOM. Ten fragment kodu dodaje detektor zdarzenia 'click' przeglądarki. Zwróć uwagę, że to zdarzenie jest odbierane z interfejsu DOM, a nie z mapy.

// 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);
});

Udostępnianie ustawień niestandardowych

Aby mieć pewność, że elementy sterujące będą otrzymywać zdarzenia klawiatury i prawidłowo wyświetlać się czytnikom ekranu:

• W przypadku przycisków, elementów formularzy i etykiet zawsze używaj natywnych elementów HTML. Używaj elementu DIV tylko jako kontenera na natywne elementy sterujące – nigdy nie używaj go jako interaktywnego elementu interfejsu.
• Aby podać informacje o elemencie interfejsu, użyj elementu label, atrybutu title lub atrybutu aria-label.

Pozycjonowanie elementów sterujących niestandardowych

Niestandardowe elementy sterujące są pozycjonowane na mapie, umieszczając je w odpowiednich miejscach we właściwości controls obiektu Map. Ta właściwość zawiera tablicę elementów typu google.maps.ControlPosition. Aby dodać do mapy niestandardowy element sterujący, dodaj Node (zwykle <div>) do odpowiedniego elementu ControlPosition. (Informacje na temat tych pozycji znajdziesz w sekcji Kontrola pozycjonowania powyżej).

Każdy element ControlPosition zawiera element MVCArray z elementów sterujących wyświetlonych w danej pozycji. W związku z tym po dodaniu lub usunięciu elementów sterujących do pozycji interfejs API odpowiednio je zaktualizuje.

Interfejs API umieszcza elementy sterujące na każdej pozycji według kolejności właściwości index. Elementy sterujące o niższym indeksie znajdują się jako pierwsze. Na przykład zgodnie z tą kolejnością indeksów zostaną ustanowione 2 niestandardowe elementy sterujące w pozycji BOTTOM_RIGHT, przy czym niższe wartości indeksu będą miały pierwszeństwo. Domyślnie wszystkie niestandardowe elementy sterujące są umieszczane po domyślnych ustawieniach interfejsu API. Możesz zastąpić to zachowanie, ustawiając właściwość index elementu sterującego na wartość ujemną. Niestandardowe elementy sterujące nie mogą znajdować się po lewej stronie logo ani po prawej stronie praw autorskich.

Poniższy kod tworzy nowy niestandardowy element sterujący (jego konstruktor nie jest widoczny) i dodaje go do mapy w pozycji 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);

Przykład niestandardowego elementu sterującego

Poniższe ustawienie jest proste (ale nie szczególnie przydatne) i łączy w sobie wzorce pokazane powyżej. To ustawienie odpowiada na zdarzenia DOM 'click', wyśrodkowając mapę w określonej lokalizacji domyślnej:

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

Uwaga: przeczytaj przewodnik po korzystaniu z TypeScriptu i Map Google.

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

Uwaga: JavaScript jest kompilowany na podstawie fragmentu kodu TypeScript.

Zobacz przykład

Zobacz próbkę

JSFiddle.net Google Cloud Shell

Dodawanie stanu do elementów sterujących

Elementy sterujące mogą również zapisywać stan. Poniższy przykład jest podobny do pokazanego wcześniej, ale element sterujący zawiera dodatkowy przycisk „Ustaw dom”, który ustawia wyświetlanie nowej lokalizacji domu. Aby to zrobić, tworzymy w elemencie sterującym właściwość home_, która przechowuje ten stan oraz udostępnia dla niego elementy pobierające i ustawiające.

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

Uwaga: przeczytaj przewodnik po korzystaniu z TypeScriptu i Map Google.

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

Uwaga: JavaScript jest kompilowany na podstawie fragmentu kodu TypeScript.

Zobacz przykład

Zobacz próbkę

JSFiddle.net Google Cloud Shell