Kurs JavaScript i TypeScript · Moduł 8: Zdarzenia i DOM

Wydarzenia myszy i klawiatury

12 min czytania ·
W tej lekcji5

"W systemach bezpieczeństwa Parku Jurajskiego," Ray Arnold pokazuje wielki panel kontrolny, "mamy różne typy sensorów. Czujniki ruchu reagują na ruch, czujniki ciśnienia na dotyk, czujniki dźwięku na hałas. Każdy typ wymaga innej reakcji. W JavaScript mamy podobną sytuację - różne typy wejścia wymagają różnej obsługi."

Ray wskazuje na monitor i klawiaturę. "Mysz i klawiatura to dwa podstawowe źródła interakcji użytkownika. Każde ma swoje unikalne wydarzenia i zachowania."

Wydarzenia myszy - pełny zakres interakcji

Mysz generuje kilkanaście różnych typów wydarzeń, od prostych kliknięć po zaawansowane gesty przeciągania. Jedno kliknięcie to trzy sygnały: mousedown, mouseup i dopiero na końcu click.

Podstawowe wydarzenia kliknięć

Obszar obserwacyjny rozróżnia pojedyncze i podwójne kliknięcie.

const dinosaurViewingArea = document.getElementById('viewing-area');

// click - pojedyncze kliknięcie (najpopularniejsze)
dinosaurViewingArea.addEventListener('click', (event) => {
  console.log('Pojedyncze kliknięcie w obszar obserwacyjny');
  console.log('Pozycja:', event.clientX, event.clientY);

  selectDinosaurAtPosition(event.clientX, event.clientY);
});

// dblclick - podwójne kliknięcie
dinosaurViewingArea.addEventListener('dblclick', (event) => {
  console.log('Podwójne kliknięcie - zbliżenie');

  // Uwaga: to NIE blokuje zaznaczania tekstu, które startuje już przy mousedown
  event.preventDefault();

  zoomInOnDinosaur(event.clientX, event.clientY);
});

Pola clientX i clientY to pozycja kursora w oknie. Uwaga: preventDefault() w dblclick nie zablokuje zaznaczania tekstu, bo startuje ono już przy mousedown. Do tego służy reguła CSS user-select: none.

// auxclick - kliknięcie środkowym/innym przyciskiem (nie lewy)
dinosaurViewingArea.addEventListener('auxclick', (event) => {
  if (event.button === 1) {
    console.log('Środkowy przycisk - otwieranie w nowym oknie');
    openInNewWindow(event.target);
  }
});

// contextmenu - prawy przycisk myszy (menu kontekstowe)
dinosaurViewingArea.addEventListener('contextmenu', (event) => {
  event.preventDefault(); // Zablokuj domyślne menu

  console.log('Prawy przycisk - własne menu kontekstowe');
  showCustomContextMenu(event.clientX, event.clientY);
});

function selectDinosaurAtPosition(x, y) {
  console.log(`Sprawdzanie czy dinozaur znajduje się na pozycji (${x}, ${y})`);
  // Logika selekcji
}

function zoomInOnDinosaur(x, y) {
  console.log(`Zbliżenie na pozycję (${x}, ${y})`);
  // Logika zoom
}

function showCustomContextMenu(x, y) {
  const menu = document.getElementById('custom-menu');
  menu.style.left = x + 'px';
  menu.style.top = y + 'px';
  menu.style.display = 'block';

  console.log('Menu kontekstowe wyświetlone');
}

Wartość event.button równa 1 to środkowy przycisk, a preventDefault() przy contextmenu chowa menu przeglądarki, robiąc miejsce dla własnego.

Wydarzenia przycisków myszy

Między wciśnięciem a puszczeniem przycisku trwa przeciąganie, więc zapamiętujemy punkt startu.

const controlPanel = document.getElementById('control-panel');

// mousedown - naciśnięcie przycisku myszy (przed puszczeniem)
controlPanel.addEventListener('mousedown', (event) => {
  console.log('Przycisk myszy wciśnięty');
  console.log('Który przycisk:', event.button); // 0=lewy, 1=środek, 2=prawy

  if (event.button === 0) {
    console.log('Lewy przycisk - rozpoczynam przeciąganie');
    startDragging(event);
  }
});

// mouseup - puszczenie przycisku myszy
controlPanel.addEventListener('mouseup', (event) => {
  console.log('Przycisk myszy puszczony');

  if (isDragging) {
    console.log('Kończę przeciąganie');
    stopDragging(event);
  }
});

let isDragging = false;
let dragStartX = 0;
let dragStartY = 0;

function startDragging(event) {
  isDragging = true;
  dragStartX = event.clientX;
  dragStartY = event.clientY;

  console.log(`Rozpoczęcie przeciągania z pozycji (${dragStartX}, ${dragStartY})`);
}

function stopDragging(event) {
  const deltaX = event.clientX - dragStartX;
  const deltaY = event.clientY - dragStartY;

  console.log(`Przeciągnięto o: X=${deltaX}px, Y=${deltaY}px`);

  isDragging = false;
}

Flaga isDragging łączy oba wydarzenia w jedną historię, a różnica współrzędnych mówi, jak daleko przesunięto kursor.

Wydarzenia ruchu myszy

Ruch kursora nad mapą parku śledzi mousemove, czujnik odzywający się przy każdym drgnięciu myszy.

const parkMap = document.getElementById('interactive-park-map');

// mousemove - ruch myszy (UWAGA: bardzo częste!)
// Używaj z rozwagą - może generować setki eventów na sekundę

let mouseMoveCount = 0;

parkMap.addEventListener('mousemove', (event) => {
  mouseMoveCount++;

  // Aktualizuj pozycję kursora
  updateCursorPosition(event.clientX, event.clientY);

  // Jeśli przeciągamy, aktualizuj pozycję
  if (isDragging) {
    updateDragPosition(event.clientX, event.clientY);
  }

  // Log co 10-te wydarzenie (żeby nie zaśmiecać konsoli)
  if (mouseMoveCount % 10 === 0) {
    console.log(`Ruch myszy #${mouseMoveCount}: (${event.clientX}, ${event.clientY})`);
  }
});

function updateCursorPosition(x, y) {
  const coordsDisplay = document.getElementById('mouse-coords');
  if (coordsDisplay) {
    coordsDisplay.textContent = `X: ${x}, Y: ${y}`;
  }
}

function updateDragPosition(x, y) {
  const draggableElement = document.getElementById('draggable');
  if (draggableElement) {
    draggableElement.style.left = x + 'px';
    draggableElement.style.top = y + 'px';
  }
}

Dlatego log trafia do konsoli co dziesiąte wydarzenie, a lekcja o throttlingu pokaże, jak ograniczać takie lawiny. Teraz wejście i wyjście kursora.

// mouseenter - mysz wchodzi w obszar elementu (nie bąbelkuje!)
parkMap.addEventListener('mouseenter', (event) => {
  console.log('Mysz weszła na mapę parku');
  parkMap.classList.add('mouse-active');
  showMapControls();
});

// mouseleave - mysz opuszcza obszar elementu (nie bąbelkuje!)
parkMap.addEventListener('mouseleave', (event) => {
  console.log('Mysz opuściła mapę parku');
  parkMap.classList.remove('mouse-active');
  hideMapControls();
});

// mouseover - mysz wchodzi (bąbelkuje - uruchamia się też dla dzieci!)
parkMap.addEventListener('mouseover', (event) => {
  if (event.target.classList.contains('enclosure-marker')) {
    const enclosureName = event.target.dataset.name;
    console.log(`Najechano na marker zagrody: ${enclosureName}`);
    showEnclosureTooltip(event.target, enclosureName);
  }
});

// mouseout - mysz wychodzi (bąbelkuje)
parkMap.addEventListener('mouseout', (event) => {
  if (event.target.classList.contains('enclosure-marker')) {
    console.log('Opuszczono marker zagrody');
    hideEnclosureTooltip();
  }
});

function showMapControls() {
  const controls = document.getElementById('map-controls');
  if (controls) {
    controls.style.display = 'block';
  }
}

function hideMapControls() {
  const controls = document.getElementById('map-controls');
  if (controls) {
    controls.style.display = 'none';
  }
}

Para mouseenter i mouseleave nie bąbelkuje, więc reaguje tylko na samą mapę, a mouseover i mouseout bąbelkują z każdego dziecka, stąd sprawdzanie event.target.

Praktyczny przykład - system przeciągania

"Jedną z najbardziej użytecznych funkcji," mówi Ray, "jest drag & drop." Pierwsza część klasy zaczyna przeciąganie.

class DinosaurCardDragSystem {
  constructor() {
    this.draggedElement = null;
    this.dragOffsetX = 0;
    this.dragOffsetY = 0;
    this.initialize();
  }

  initialize() {
    const cards = document.querySelectorAll('.dinosaur-card');

    cards.forEach(card => {
      card.addEventListener('mousedown', (e) => this.handleDragStart(e));
    });

    document.addEventListener('mousemove', (e) => this.handleDragMove(e));
    document.addEventListener('mouseup', (e) => this.handleDragEnd(e));

    console.log('System drag & drop zainicjalizowany');
  }

  handleDragStart(event) {
    this.draggedElement = event.currentTarget;

    const rect = this.draggedElement.getBoundingClientRect();
    this.dragOffsetX = event.clientX - rect.left;
    this.dragOffsetY = event.clientY - rect.top;

    this.draggedElement.style.position = 'fixed';
    this.draggedElement.style.zIndex = '1000';
    this.draggedElement.classList.add('dragging');

    const dinoName = this.draggedElement.dataset.dinoName;
    console.log(`Rozpoczęto przeciąganie karty: ${dinoName}`);

    event.preventDefault(); // Prevent text selection
  }

Listenery mousemove i mouseup wiszą na dokumencie, bo szybki ruch wyprowadzi kursor poza kartę. Tu preventDefault() w mousedown naprawdę blokuje zaznaczanie tekstu, a getBoundingClientRect() pozwala wyliczyć punkt chwytu.

  handleDragMove(event) {
    if (!this.draggedElement) return;

    const x = event.clientX - this.dragOffsetX;
    const y = event.clientY - this.dragOffsetY;

    this.draggedElement.style.left = x + 'px';
    this.draggedElement.style.top = y + 'px';
  }

  handleDragEnd(event) {
    if (!this.draggedElement) return;

    const dinoName = this.draggedElement.dataset.dinoName;
    console.log(`Zakończono przeciąganie karty: ${dinoName}`);

    // Sprawdź czy karta została upuszczona w odpowiedniej strefie
    const dropZone = this.findDropZone(event.clientX, event.clientY);

    if (dropZone) {
      console.log('Karta upuszczona w strefie:', dropZone.id);
      this.handleDrop(this.draggedElement, dropZone);
    } else {
      console.log('Karta upuszczona poza strefą - powrót do pozycji początkowej');
      this.returnToOriginalPosition();
    }

    this.draggedElement.classList.remove('dragging');
    this.draggedElement = null;
  }

Karta podąża za kursorem, a po puszczeniu przycisku klasa szuka strefy, w której wylądowała.

  findDropZone(x, y) {
    const dropZones = document.querySelectorAll('.drop-zone');

    for (const zone of dropZones) {
      const rect = zone.getBoundingClientRect();

      if (x >= rect.left && x <= rect.right &&
          y >= rect.top && y <= rect.bottom) {
        return zone;
      }
    }

    return null;
  }

  handleDrop(card, dropZone) {
    console.log('Dodawanie karty do strefy drop');
    dropZone.appendChild(card);

    // Reset stylów
    card.style.position = '';
    card.style.left = '';
    card.style.top = '';
    card.style.zIndex = '';
  }

  returnToOriginalPosition() {
    // Powrót na miejsce - bez animacji, bo zmiany position nie da się animować.
    // Bez setTimeout: handleDragEnd zaraz potem ustawia this.draggedElement na null
    this.draggedElement.style.position = '';
    this.draggedElement.style.left = '';
    this.draggedElement.style.top = '';
    this.draggedElement.style.zIndex = '';
  }
}

// Inicjalizacja
const dragSystem = new DinosaurCardDragSystem();

Karta upuszczona w strefie przenosi się do nowej zagrody, a poza nią wraca na miejsce.

Przeciąganie wbudowane w przeglądarkę

Przeglądarka ma też własne API Drag and Drop. Element z atrybutem draggable="true" wysyła dragstart, a strefa docelowa dostaje dragover i drop.

// HTML: <div class="dino-item" draggable="true">T-Rex</div>
const dino = document.querySelector('.dino-item');
const zone = document.getElementById('zone-c');

dino.addEventListener('dragstart', (e) => {
  e.dataTransfer.setData('text/plain', dino.textContent);
  dino.classList.add('dragging');
});
dino.addEventListener('dragend', () => dino.classList.remove('dragging'));

zone.addEventListener('dragover', (e) => {
  e.preventDefault(); // bez tego strefa nie przyjmie upuszczenia
});

zone.addEventListener('drop', (e) => {
  e.preventDefault(); // blokuje domyślną akcję, np. otwarcie linku
  zone.appendChild(dino);
});

Kluczowy jest preventDefault() w dragover, bo bez niego upuszczenie jest zabronione, a dragend sprząta po każdym przeciąganiu.

Wydarzenia klawiatury - kontrola z klawiatury

"Klawiatura," Ray wskazuje na panel kontrolny, "to drugi kluczowy sposób interakcji. Skróty klawiszowe, nawigacja, wprowadzanie danych."

Podstawowe wydarzenia klawiatury

Każde naciśnięcie zostawia w obiekcie wydarzenia pełny raport.

// keydown - klawisz naciśnięty (powtarza się gdy trzymany)
document.addEventListener('keydown', (event) => {
  console.log('=== KEYDOWN ===');
  console.log('Klawisz:', event.key); // 'a', 'Enter', 'ArrowUp', etc.
  console.log('Kod:', event.code); // 'KeyA', 'Enter', 'ArrowUp', etc.
  console.log('KeyCode (deprecated):', event.keyCode);
  console.log('Czy to powtórzenie:', event.repeat);
  console.log('Ctrl:', event.ctrlKey);
  console.log('Shift:', event.shiftKey);
  console.log('Alt:', event.altKey);
  console.log('Meta (Cmd/Win):', event.metaKey);
});

// keyup - klawisz puszczony
document.addEventListener('keyup', (event) => {
  console.log(`Puszczono klawisz: ${event.key}`);
});

// keypress - DEPRECATED! Nie używaj (użyj keydown zamiast tego)
// keypress jest przestarzały i nie odpala np. dla strzałek ani Escape

event.key to znak lub nazwa klawisza, a event.code to fizyczny klawisz, niezależny od układu klawiatury. Trzymany klawisz wysyła kolejne keydown z event.repeat równym true, a keyup przychodzi raz.

Praktyczne skróty klawiszowe

Skróty obsługuje jeden listener na dokumencie. Najpierw zapis, wyszukiwanie i Escape.

// System skrótów klawiszowych dla parku
document.addEventListener('keydown', (event) => {
  // Ctrl/Cmd + S - Zapisz
  if ((event.ctrlKey || event.metaKey) && event.key === 's') {
    event.preventDefault();
    console.log('Zapisywanie konfiguracji parku...');
    saveParkConfiguration();
    return;
  }

  // Ctrl/Cmd + F - Szukaj
  if ((event.ctrlKey || event.metaKey) && event.key === 'f') {
    event.preventDefault();
    console.log('Otwieranie wyszukiwarki dinozaurów');
    openSearchDialog();
    return;
  }

  // Escape - Zamknij wszystkie okna
  if (event.key === 'Escape') {
    console.log('Zamykanie wszystkich okien dialogowych');
    closeAllModals();
    return;
  }

Sprawdzamy ctrlKey albo metaKey, żeby skrót działał też z Cmd na Macu, a preventDefault() zatrzymuje zapis strony przez przeglądarkę. Dalej strzałki, spacja, F1 i cyfry.

  // Strzałki - Nawigacja po mapie
  const arrowKeys = ['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'];
  if (arrowKeys.includes(event.key)) {
    event.preventDefault();

    const direction = {
      'ArrowUp': 'north',
      'ArrowDown': 'south',
      'ArrowLeft': 'west',
      'ArrowRight': 'east'
    }[event.key];

    console.log(`Przesunięcie mapy w kierunku: ${direction}`);
    moveMap(direction);
    return;
  }

  // Spacja - Pauza/Wznów monitoring
  if (event.key === ' ') {
    event.preventDefault();
    console.log('Toggle pauzy monitoringu');
    toggleMonitoringPause();
    return;
  }

  // F1 - Pomoc
  if (event.key === 'F1') {
    event.preventDefault();
    console.log('Otwieranie pomocy');
    openHelp();
    return;
  }

  // Cyfry 1-9 - Szybki dostęp do zagród
  if (event.key >= '1' && event.key <= '9') {
    const enclosureNumber = parseInt(event.key);
    console.log(`Przełączanie na zagrodę #${enclosureNumber}`);
    jumpToEnclosure(enclosureNumber);
    return;
  }
});

Spacja ma nazwę ' ', a mapa kierunków zamienia klawisz na stronę świata. Dalej proste funkcje wykonawcze.

function saveParkConfiguration() {
  console.log('Konfiguracja zapisana');
}

function openSearchDialog() {
  console.log('Dialog wyszukiwania otwarty');
}

function closeAllModals() {
  document.querySelectorAll('.modal').forEach(modal => {
    modal.style.display = 'none';
  });
  console.log('Wszystkie okna zamknięte');
}

function moveMap(direction) {
  console.log(`Mapa przesunięta w kierunku: ${direction}`);
}

function toggleMonitoringPause() {
  console.log('Monitoring wstrzymany/wznowiony');
}

function openHelp() {
  console.log('Pomoc otwarta');
}

function jumpToEnclosure(number) {
  console.log(`Przejście do zagrody #${number}`);
}

Listener rozpoznaje skrót, a logika żyje w funkcjach.

Walidacja wejścia z klawiatury

Listener keydown może odrzucić znak, zanim trafi do pola: kod bezpieczeństwa przyjmuje tylko cyfry, telefon także spacje, nawiasy i myślniki, a imię dostaje wielką literę.

const securityCodeInput = document.getElementById('security-code');
const phoneInput = document.getElementById('phone-number');
const nameInput = document.getElementById('visitor-name');

// Tylko cyfry - kod bezpieczeństwa
securityCodeInput.addEventListener('keydown', (event) => {
  // Zezwól na klawisze funkcyjne
  const allowedKeys = [
    'Backspace', 'Delete', 'Tab', 'Escape', 'Enter',
    'ArrowLeft', 'ArrowRight', 'Home', 'End'
  ];

  if (allowedKeys.includes(event.key)) {
    return; // Pozwól
  }

  // Tylko cyfry
  if (event.key >= '0' && event.key <= '9') {
    // Maksymalnie 6 cyfr
    if (securityCodeInput.value.length >= 6 && !event.ctrlKey && !event.metaKey) {
      event.preventDefault();
      console.log('Maksymalnie 6 cyfr');
    }
    return;
  }

  // Wszystko inne - blokuj
  event.preventDefault();
  console.log('Tylko cyfry są dozwolone');
});

// Formatowanie numeru telefonu
phoneInput.addEventListener('keydown', (event) => {
  const allowedKeys = [
    'Backspace', 'Delete', 'Tab', 'Escape', 'Enter',
    'ArrowLeft', 'ArrowRight', 'Home', 'End'
  ];

  if (allowedKeys.includes(event.key)) return;

  // Tylko cyfry, spacje, myślniki, nawiasy
  const phoneChars = /^[0-9 ()-]$/;

  if (!phoneChars.test(event.key)) {
    event.preventDefault();
    console.log('Niedozwolony znak w numerze telefonu');
  }
});

// Auto-kapitalizacja pierwszej litery
nameInput.addEventListener('keyup', (event) => {
  const value = nameInput.value;

  if (value.length === 1) {
    nameInput.value = value.toUpperCase();
  }
});

Taki filtr to tylko wygoda, bo tekst da się wkleić z menu kontekstowego, więc wartość sprawdzaj też przy input lub submit.

Kombinacja myszy i klawiatury

"Najlepsze interfejsy," mówi Ray, "łączą oba typy wejścia." Klawisze modyfikujące zmieniają znaczenie kliknięcia.

const enclosureCards = document.querySelectorAll('.enclosure-card');
let selectedCards = new Set();

enclosureCards.forEach(card => {
  card.addEventListener('click', (event) => {
    const enclosureId = card.dataset.enclosureId;

    // Różne zachowania w zależności od klawiszy modyfikujących
    if (event.ctrlKey || event.metaKey) {
      // Ctrl + Click = Toggle selekcji
      console.log('Ctrl+Click: Toggle selekcji');

      if (selectedCards.has(enclosureId)) {
        selectedCards.delete(enclosureId);
        card.classList.remove('selected');
      } else {
        selectedCards.add(enclosureId);
        card.classList.add('selected');
      }
    } else if (event.shiftKey) {
      // Shift + Click = Wybór zakresu
      console.log('Shift+Click: Wybór zakresu');
      selectRange(lastSelected, enclosureId);
    } else {
      // Zwykłe kliknięcie = Tylko ta jedna karta
      console.log('Zwykłe kliknięcie: Pojedyncza selekcja');

      selectedCards.clear();
      document.querySelectorAll('.enclosure-card.selected').forEach(c => {
        c.classList.remove('selected');
      });

      selectedCards.add(enclosureId);
      card.classList.add('selected');
    }

    lastSelected = enclosureId;
    updateSelectionInfo();
  });
});

let lastSelected = null;

function selectRange(startId, endId) {
  console.log(`Wybieranie zakresu od ${startId} do ${endId}`);
  // Logika wyboru zakresu
}

function updateSelectionInfo() {
  console.log(`Wybrano ${selectedCards.size} zagród`);
}

Ctrl lub Cmd przełącza zaznaczenie, Shift wybiera zakres, zwykłe kliknięcie zostawia jedną kartę. Dalej strzałki.

// Nawigacja klawiaturą przez karty
let focusedCardIndex = 0;
const cards = Array.from(enclosureCards);

document.addEventListener('keydown', (event) => {
  // Tylko gdy żadne pole input nie jest aktywne
  if (document.activeElement.tagName === 'INPUT') return;

  switch(event.key) {
    case 'ArrowRight':
    case 'ArrowDown':
      event.preventDefault();
      focusedCardIndex = Math.min(focusedCardIndex + 1, cards.length - 1);
      focusCard(focusedCardIndex);
      break;

    case 'ArrowLeft':
    case 'ArrowUp':
      event.preventDefault();
      focusedCardIndex = Math.max(focusedCardIndex - 1, 0);
      focusCard(focusedCardIndex);
      break;

    case 'Enter':
    case ' ':
      event.preventDefault();
      cards[focusedCardIndex].click();
      break;
  }
});

function focusCard(index) {
  cards.forEach(card => card.classList.remove('focused'));
  cards[index].classList.add('focused');
  cards[index].scrollIntoView({ behavior: 'smooth', block: 'nearest' });

  console.log(`Fokus na karcie #${index}: ${cards[index].dataset.enclosureName}`);
}

Warunek z activeElement nie przeszkadza w pisaniu w polach, a click() na karcie uruchamia ten sam listener co mysz.

Wydarzenia okna i dotyku

DOMContentLoaded odpala, gdy HTML jest wczytany, choć obrazy mogą się jeszcze ładować. load na window czeka na całą stronę z zasobami. Przewijanie zgłasza scroll, a window.scrollY podaje przewinięte piksele, więc większa wartość niż poprzednio oznacza ruch w dół. Na ekranach dotykowych palec wysyła po kolei touchstart, touchmove i touchend, do których wrócimy przy gestach.

Podsumowanie

"Wydarzenia myszy i klawiatury," podsumowuje Ray, "to fundament interaktywności. Podobnie jak różne sensory w Parku Jurajskim wykrywają różne typy zagrożeń, tak różne wydarzenia pozwalają na różnorodne interakcje użytkownika. Kluczem jest używanie odpowiednich wydarzeń do odpowiednich zadań."

Kluczowe wydarzenia myszy:

  • click, dblclick, contextmenu - kliknięcia
  • mousedown, mouseup - kontrola przycisków
  • mousemove - śledzenie pozycji (używaj ostrożnie!)
  • mouseenter, mouseleave - najechanie (nie bąbelkują)
  • mouseover, mouseout - najechanie (bąbelkują)

Kluczowe wydarzenia klawiatury:

  • keydown - naciśnięcie klawisza (użyj tego)
  • keyup - puszczenie klawisza
  • event.key - znak/nazwa klawisza ('a', 'Enter', 'ArrowUp')
  • event.code - fizyczny klawisz ('KeyA', 'Enter', 'ArrowUp')
  • Klawisze modyfikujące: ctrlKey, shiftKey, altKey, metaKey

Moja rada: skróty opieraj na keydown, a przenoszenie między strefami na wbudowanym Drag and Drop. Następna lekcja: formularze.

Pamiętaj: każdy czujnik w parku reaguje na inny sygnał, więc dobieraj wydarzenie do zadania.

Kod do tej lekcji: index.html
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Wydarzenia myszy i klawiatury - Sterowanie kamerą</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
            margin: 0;
            padding: 20px;
            color: white;
        }

        .container {
            max-width: 1000px;
            margin: 0 auto;
        }

        h1 {
            text-align: center;
            margin-bottom: 20px;
        }

        .instructions {
            background: rgba(52, 152, 219, 0.2);
            border: 1px solid #3498db;
            border-radius: 10px;
            padding: 15px;
            margin-bottom: 20px;
            text-align: center;
        }

        .instructions kbd {
            background: rgba(255, 255, 255, 0.2);
            padding: 2px 8px;
            border-radius: 4px;
            font-family: monospace;
            margin: 0 3px;
        }

        .camera-viewport {
            position: relative;
            width: 100%;
            height: 400px;
            background: linear-gradient(180deg, #34495e 0%, #2c3e50 100%);
            border-radius: 15px;
            overflow: hidden;
            cursor: move;
            margin-bottom: 20px;
            border: 3px solid #7f8c8d;
        }

        .camera-content {
            position: absolute;
            width: 200%;
            height: 200%;
            transition: transform 0.3s ease;
        }

        .dinosaur {
            position: absolute;
            font-size: 60px;
            cursor: pointer;
            transition: transform 0.2s ease;
            user-select: none;
        }

        .dinosaur:hover {
            transform: scale(1.2);
            filter: drop-shadow(0 0 10px rgba(255, 255, 255, 0.5));
        }

        .dinosaur.clicked {
            animation: bounce 0.5s ease;
        }

        @keyframes bounce {
            0%, 100% { transform: scale(1); }
            50% { transform: scale(1.3); }
        }

        .controls-panel {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 20px;
            margin-bottom: 20px;
        }

        .control-box {
            background: rgba(0, 0, 0, 0.6);
            border-radius: 10px;
            padding: 20px;
            border: 1px solid #34495e;
        }

        .control-box h3 {
            margin-top: 0;
            color: #3498db;
        }

        .stats {
            display: grid;
            grid-template-columns: repeat(2, 1fr);
            gap: 10px;
        }

        .stat-item {
            background: rgba(255, 255, 255, 0.1);
            padding: 10px;
            border-radius: 5px;
        }

        .stat-label {
            color: #bdc3c7;
            font-size: 12px;
        }

        .stat-value {
            color: #ecf0f1;
            font-size: 18px;
            font-weight: bold;
        }

        .arrow-buttons {
            display: grid;
            grid-template-areas:
                ". up ."
                "left . right"
                ". down .";
            gap: 5px;
            justify-content: center;
            align-items: center;
        }

        .arrow-btn {
            width: 60px;
            height: 60px;
            background: linear-gradient(45deg, #3498db, #2980b9);
            border: none;
            border-radius: 10px;
            color: white;
            font-size: 24px;
            cursor: pointer;
            transition: all 0.2s ease;
        }

        .arrow-btn:hover {
            background: linear-gradient(45deg, #2980b9, #21618c);
            transform: scale(1.05);
        }

        .arrow-btn:active {
            transform: scale(0.95);
        }

        .arrow-btn.up { grid-area: up; }
        .arrow-btn.down { grid-area: down; }
        .arrow-btn.left { grid-area: left; }
        .arrow-btn.right { grid-area: right; }

        .event-log {
            background: rgba(0, 0, 0, 0.8);
            border-radius: 10px;
            padding: 15px;
            max-height: 200px;
            overflow-y: auto;
            font-family: 'Courier New', monospace;
            font-size: 12px;
        }

        .log-entry {
            padding: 5px;
            border-bottom: 1px solid rgba(255, 255, 255, 0.1);
            color: #bdc3c7;
        }

        .log-entry.mouse {
            color: #3498db;
        }

        .log-entry.keyboard {
            color: #e74c3c;
        }

        .log-entry.click {
            color: #f39c12;
        }

        @media (max-width: 768px) {
            .controls-panel {
                grid-template-columns: 1fr;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Sterowanie Kamerą w Parku Jurajskim</h1>

        <div class="instructions">
            <strong>Sterowanie:</strong> Strzałki <kbd>↑</kbd> <kbd>↓</kbd> <kbd>←</kbd> <kbd>→</kbd> |
            <strong>Pauza:</strong> <kbd>Space</kbd> |
            <strong>Zoom:</strong> Podwójne kliknięcie |
            <strong>Zamknij:</strong> <kbd>Escape</kbd>
        </div>

        <div class="camera-viewport" id="viewport">
            <div class="camera-content" id="camera">
                <div class="dinosaur" style="top: 50px; left: 100px;" data-name="T-Rex">T</div>
                <div class="dinosaur" style="top: 150px; left: 400px;" data-name="Velociraptor">V</div>
                <div class="dinosaur" style="top: 300px; left: 200px;" data-name="Triceratops">Tr</div>
                <div class="dinosaur" style="top: 100px; left: 600px;" data-name="Brachiosaurus">B</div>
                <div class="dinosaur" style="top: 250px; left: 700px;" data-name="Stegosaurus">S</div>
            </div>
        </div>

        <div class="controls-panel">
            <div class="control-box">
                <h3>Statystyki</h3>
                <div class="stats">
                    <div class="stat-item">
                        <div class="stat-label">Pozycja myszy</div>
                        <div class="stat-value" id="mouse-pos">0, 0</div>
                    </div>
                    <div class="stat-item">
                        <div class="stat-label">Kliknięcia</div>
                        <div class="stat-value" id="click-count">0</div>
                    </div>
                    <div class="stat-item">
                        <div class="stat-label">Pozycja kamery</div>
                        <div class="stat-value" id="camera-pos">0, 0</div>
                    </div>
                    <div class="stat-item">
                        <div class="stat-label">Ostatni klawisz</div>
                        <div class="stat-value" id="last-key">-</div>
                    </div>
                </div>
            </div>

            <div class="control-box">
                <h3>Sterowanie kamerą</h3>
                <div class="arrow-buttons">
                    <button class="arrow-btn up" data-direction="up">↑</button>
                    <button class="arrow-btn left" data-direction="left">←</button>
                    <button class="arrow-btn right" data-direction="right">→</button>
                    <button class="arrow-btn down" data-direction="down">↓</button>
                </div>
            </div>
        </div>

        <div class="control-box">
            <h3>Log wydarzeń</h3>
            <div class="event-log" id="event-log"></div>
        </div>
    </div>

    <script>
        // Referencje do elementów
        const camera = document.getElementById('camera');
        const viewport = document.getElementById('viewport');
        const mousePosDisplay = document.getElementById('mouse-pos');
        const clickCountDisplay = document.getElementById('click-count');
        const cameraPosDisplay = document.getElementById('camera-pos');
        const lastKeyDisplay = document.getElementById('last-key');
        const eventLog = document.getElementById('event-log');

        // Stan kamery
        let cameraX = 0;
        let cameraY = 0;
        let clickCount = 0;
        let isPaused = false;
        const moveSpeed = 50;

        // Funkcja logowania wydarzeń
        function logEvent(message, type = 'mouse') {
            const logEntry = document.createElement('div');
            logEntry.className = `log-entry ${type}`;
            logEntry.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
            eventLog.insertBefore(logEntry, eventLog.firstChild);

            // Ograniczamy liczbę wpisów
            if (eventLog.children.length > 20) {
                eventLog.removeChild(eventLog.lastChild);
            }
        }

        // Funkcja przesuwania kamery
        function moveCamera(direction) {
            if (isPaused) {
                logEvent('Kamera wstrzymana! Naciśnij Space aby wznowić', 'keyboard');
                return;
            }

            switch(direction) {
                case 'up':
                    cameraY = Math.max(cameraY - moveSpeed, -200);
                    break;
                case 'down':
                    cameraY = Math.min(cameraY + moveSpeed, 200);
                    break;
                case 'left':
                    cameraX = Math.max(cameraX - moveSpeed, -200);
                    break;
                case 'right':
                    cameraX = Math.min(cameraX + moveSpeed, 200);
                    break;
            }

            camera.style.transform = `translate(${cameraX}px, ${cameraY}px)`;
            cameraPosDisplay.textContent = `${cameraX}, ${cameraY}`;
            logEvent(`Przesunięcie kamery: ${direction}`, 'keyboard');
        }

        // OBSŁUGA MYSZY

        // Mousemove - śledzenie pozycji myszy
        viewport.addEventListener('mousemove', function(e) {
            const rect = viewport.getBoundingClientRect();
            const x = Math.floor(e.clientX - rect.left);
            const y = Math.floor(e.clientY - rect.top);
            mousePosDisplay.textContent = `${x}, ${y}`;
        });

        // Click - pojedyncze kliknięcie
        viewport.addEventListener('click', function(e) {
            clickCount++;
            clickCountDisplay.textContent = clickCount;

            const rect = viewport.getBoundingClientRect();
            const x = Math.floor(e.clientX - rect.left);
            const y = Math.floor(e.clientY - rect.top);

            logEvent(`Kliknięcie w pozycji: (${x}, ${y})`, 'click');
        });

        // Double click - podwójne kliknięcie (zoom)
        viewport.addEventListener('dblclick', function(e) {
            const currentScale = camera.style.transform.includes('scale') ? 1 : 1.5;
            const newScale = currentScale === 1 ? 1.5 : 1;

            camera.style.transform = `translate(${cameraX}px, ${cameraY}px) scale(${newScale})`;
            logEvent(`Zoom: ${newScale === 1 ? 'Wyłączony' : 'Włączony'}`, 'click');
        });

        // Mouseenter/mouseleave - najechanie na viewport
        viewport.addEventListener('mouseenter', function() {
            viewport.style.borderColor = '#3498db';
            logEvent('Mysz weszła w obszar kamery', 'mouse');
        });

        viewport.addEventListener('mouseleave', function() {
            viewport.style.borderColor = '#7f8c8d';
            logEvent('Mysz opuściła obszar kamery', 'mouse');
        });

        // Kliknięcie na dinozaura
        document.querySelectorAll('.dinosaur').forEach(dino => {
            dino.addEventListener('click', function(e) {
                e.stopPropagation(); // Zatrzymujemy propagację do viewport

                const name = this.dataset.name;
                this.classList.add('clicked');

                setTimeout(() => {
                    this.classList.remove('clicked');
                }, 500);

                logEvent(`Kliknięto dinozaura: ${name}`, 'click');
                console.log(`Obserwacja: ${name}`);
            });

            dino.addEventListener('mouseenter', function() {
                const name = this.dataset.name;
                logEvent(`Najechano na: ${name}`, 'mouse');
            });
        });

        // OBSŁUGA KLAWIATURY

        // Keydown - naciśnięcie klawisza
        document.addEventListener('keydown', function(e) {
            lastKeyDisplay.textContent = e.key;

            switch(e.key) {
                case 'ArrowUp':
                    e.preventDefault();
                    moveCamera('up');
                    break;
                case 'ArrowDown':
                    e.preventDefault();
                    moveCamera('down');
                    break;
                case 'ArrowLeft':
                    e.preventDefault();
                    moveCamera('left');
                    break;
                case 'ArrowRight':
                    e.preventDefault();
                    moveCamera('right');
                    break;
                case ' ':
                    e.preventDefault();
                    isPaused = !isPaused;
                    logEvent(`Pauza: ${isPaused ? 'WŁĄCZONA' : 'WYŁĄCZONA'}`, 'keyboard');
                    viewport.style.opacity = isPaused ? '0.5' : '1';
                    break;
                case 'Escape':
                    logEvent('Naciśnięto Escape - zamykanie widoku', 'keyboard');
                    alert('Widok kamery zostanie zamknięty');
                    break;
                case 'r':
                case 'R':
                    // Reset kamery
                    cameraX = 0;
                    cameraY = 0;
                    camera.style.transform = 'translate(0px, 0px)';
                    cameraPosDisplay.textContent = '0, 0';
                    logEvent('Reset pozycji kamery', 'keyboard');
                    break;
                default:
                    logEvent(`Naciśnięto klawisz: ${e.key}`, 'keyboard');
            }
        });

        // Obsługa przycisków strzałek
        document.querySelectorAll('.arrow-btn').forEach(btn => {
            btn.addEventListener('click', function() {
                const direction = this.dataset.direction;
                moveCamera(direction);
            });
        });

        // Inicjalizacja
        logEvent('System kamery uruchomiony', 'keyboard');
        console.log('System monitoringu Parku Jurajskiego - ONLINE');
        console.log('Użyj strzałek do poruszania kamerą');
        console.log('Kliknij na dinozaury, aby je obserwować');
    </script>
</body>
</html>

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Które zdarzenie klawiatury przeglądarka wysyła po wciśnięciu każdego klawisza (także Shift, Ctrl czy strzałek) i powtarza, dopóki klawisz jest przytrzymany?

  2. 2. Które wydarzenie wywoływane jest po całkowitym załadowaniu strony?

Zadania praktyczne w grze

  • Edytor kodu

    W pliku index.html są dwie zagrody (.enclosure) i karty dinozaurów z atrybutem draggable="true". Przy dragstart karta zapisuje swoje id w dataTransfer. Uzupełnij luki: ___BLANK1___ to zdarzenie, które zagroda dostaje, gdy przeciągana karta jest nad nią (w nim preventDefault() zezwala na upuszczenie), a ___BLANK2___ to metoda dataTransfer, która w drop odczytuje zapisane id. Upuszczona karta ma trafić do zagrody, nad którą ją upuszczono.

  • Układanie w pionie

    Ułóż wydarzenia myszy w kolejności ich następowania podczas kliknięcia:

  • Klikanie w kolejności

    Ułóż kod sprawdzający kombinację Ctrl+S.

  • Układanie w pionie

    Ułóż wydarzenia dotykowe w kolejności ich występowania:

  1. PytanieQuiz: Keyboard events
  2. PytanieQuiz: Window events
  3. Zadanie z kodemĆwiczenie: Drag and Drop
  4. Ułóż w kolejnościSortowanie pionowe: zdarzenia myszy
  5. Kliknij w kolejnościSortowanie: Kombinacje klawiszy
  6. Ułóż w kolejnościSortowanie pionowe: Touch events

Przydatne artykuły