Suchleiste unten automatisch ausblenden

// ==UserScript==
// @name           Schnell-Suche mit Auto-Close.uc.js
// @description    Tippe irgendwo einen Buchstaben – die VOLLSTÄNDIGE Firefox-Suchleiste
//                 (mit Pfeilen, Groß-/Kleinschreibung, Hervorheben usw.) öffnet sich,
//                 der Buchstabe steht bereits im Suchfeld, du tippst einfach weiter.
//                 Geschlossen wird nur noch per Klick auf die Seite (oder Escape/X).
// @compatibility  Firefox 157+
// @author         Mira Bellenbaum mit Hilfe von Mistral (KI)
// @version        2026.10.09
// ==/UserScript==
//
// =====================================================================
//  WIE ES FUNKTIONIERT (Quellcode: toolkit/content/widgets/findbar.js)
// =====================================================================
//
//  1. „Beim Tippen automatisch im Seitentext suchen“
//     (accessibility.typeaheadfind) lässt beim Tippen die Quick-Find-Leiste
//     aufgehen – der Buchstabe steht sofort im Suchfeld.
//
//  2. Die Quick-Find-Leiste sieht minimal aus, weil _updateFindUI() bei
//     findMode != FIND_NORMAL alle Elemente außer Textfeld und Trefferzähler
//     auf hidden setzt.
//     → Zwei unabhängige Mechanismen blenden alles wieder ein:
//       a) Prototyp-Patch: nach jedem Original-_updateFindUI
//       b) findbaropen-Event: direkt an der geöffneten Instanz
//
//  3. Scrollrad über der Leiste blättert durch die Treffer.
//
//  4. Ein Klick auf irgendeine Stelle der Seite schließt die Leiste.
//
//  FEHLERSUCHE: Alle Meldungen erscheinen IMMER in der Browser-Konsole
//  (Strg+Umschalt+J), gefiltert nach „Schnell-Suche“.
//
// =====================================================================

'use strict';

// =====================================================================
//  KONFIGURATION
// =====================================================================

const CONFIG = {

  // Beim Tippen im Seitentext suchen (Type-Ahead-Find) aktiviert lassen?
  enableTypeAhead: true,

  // Auto-Close-Timer abschalten? (true = Leiste bleibt offen bis Klick)
  disableAutoClose: true,

  // Nur relevant, falls disableAutoClose = false:
  autoCloseTimeoutMs: 5000,

  // Beim Klick auf die Seite schließen?
  closeOnPageClick: true,
};

// =====================================================================
//  AB HIER NICHTS MEHR ÄNDERN
// =====================================================================

(function SchnellSucheVollstaendigeLeiste() {

  const LOG = '[Schnell-Suche] ';
  const CE_NAME = 'findbar';
  const MAX_TRIES = 60;            // 60 × 500 ms = max. 30 Sekunden warten
  
  // In allen Fenstern ausführen
  if (window.gBrowser && !CustomizableUI.getWidget("ExtraConfigMenu-button"))
    return;
  console.log(LOG + 'v3.2 geladen, Initialisierung läuft …');

  function fail(aMsg, aErr) {
    console.error(LOG + aMsg, aErr);
  }

  // -----------------------------------------------------------------
  //  Kernroutine: an einer konkreten FindBar-Instanz alles einblenden
  // -----------------------------------------------------------------
  function showFullUI(aFb) {
    if (!aFb)
      return false;

    let ok = true;

    // a) Alle Kinder des Containers sichtbar schalten
    try {
      let container = aFb.getElement
        ? aFb.getElement('findbar-container')
        : aFb.querySelector('.findbar-container');
      if (!container) {
        fail('findbar-container nicht gefunden! Verfügbare Struktur:', aFb.outerHTML.slice(0, 600));
        ok = false;
      } else {
        for (let node of container.children) {
          node.hidden = false;
        }
      }
    } catch (err) {
      fail('Fehler beim Einblenden der Container-Kinder: ', err);
      ok = false;
    }

    // b) Pfeile „Weiter“ / „Zurück“
    try {
      let next = aFb.getElement ? aFb.getElement('find-next')
                                : aFb.querySelector('[anonid="find-next"], .findbar-find-next');
      let prev = aFb.getElement ? aFb.getElement('find-previous')
                                : aFb.querySelector('[anonid="find-previous"], .findbar-find-previous');
      if (next) next.hidden = false;
      if (prev) prev.hidden = false;
    } catch (err) {
      fail('Fehler beim Einblenden der Pfeile: ', err);
      ok = false;
    }

    // c) Die drei Options-Checkboxen werden NICHT vom Container-Durchlauf
    //     erfasst, weil _updateCaseSensitivity(), _updateDiacriticMatching()
    //     und _setEntireWord() sie im Quick-Find-Modus explizit auf
    //     hidden = true setzen (findbar.js: „Show the checkbox on the full
    //     Find bar in non-auto mode“). Deshalb hier einzeln einblenden:
    try {
      const TOGGLES = ['find-case-sensitive', 'find-match-diacritics',
                       'find-entire-word'];
      for (let id of TOGGLES) {
        let cb = aFb.getElement ? aFb.getElement(id)
                                : aFb.querySelector('[anonid="' + id + '"]');
        if (cb) cb.hidden = false;
      }
    } catch (err) {
      fail('Fehler beim Einblenden der Options-Checkboxen: ', err);
      ok = false;
    }

    // d) Schmalen Quick-Find-Look des Textfeldes zurücknehmen
    try {
      if (aFb._findField)
        aFb._findField.classList.remove('minimal');
    } catch (err) {
      fail('Fehler beim Zurücksetzen des Textfeld-Looks: ', err);
      ok = false;
    }

    // e) Leeren Trefferzähler nicht als leeres Element zeigen
    try {
      let fm = aFb._foundMatches;
      if (fm && !fm.value)
        fm.hidden = true;
    } catch (err) { /* unkritisch */ }

    return ok;
  }

  // -----------------------------------------------------------------
  //  1)  Prefs setzen (User-Zweig – gewinnt immer)
  // -----------------------------------------------------------------
  try {
    Services.prefs.setBoolPref('accessibility.typeaheadfind',
                               CONFIG.enableTypeAhead);
    Services.prefs.setIntPref('accessibility.typeaheadfind.timeout',
                              CONFIG.disableAutoClose ? 0 : CONFIG.autoCloseTimeoutMs);
    Services.prefs.setBoolPref('accessibility.typeaheadfind.enablesound',
                               false);
    console.log(LOG + 'Prefs gesetzt: typeaheadfind=' +
      Services.prefs.getBoolPref('accessibility.typeaheadfind') +
      ', timeout=' + Services.prefs.getIntPref('accessibility.typeaheadfind.timeout') + 'ms');
  } catch (err) {
    fail('Konnte Prefs nicht setzen: ', err);
  }

  // -----------------------------------------------------------------
  //  2a)  Mechanismus 1: Prototyp-Patch auf _updateFindUI
  // -----------------------------------------------------------------
  let patched = false;

  function patchFindbarClass() {
    let findbarClass = customElements.get(CE_NAME);
    if (!findbarClass)
      return false;

    const origUpdateFindUI = findbarClass.prototype._updateFindUI;
    if (typeof origUpdateFindUI !== 'function') {
      fail('findbar-Klasse gefunden, aber _updateFindUI fehlt – ' +
           'Firefox-Update mit umbenannter Methode?');
      return true; // nicht endlos weiterversuchen
    }

    findbarClass.prototype._updateFindUI = function (...aArgs) {
      try {
        origUpdateFindUI.apply(this, aArgs);
      } catch (err) {
        fail('Original-_updateFindUI warf einen Fehler: ', err);
      }
      showFullUI(this);
    };

    // ERGÄNZUNG v3.4: Die drei Checkboxen werden bei JEDEM Such-Update
    // (also jedem getippten Zeichen) durch updateControlState erneut
    // versteckt. Deshalb zusätzlich diese drei Methoden patchen –
    // nach dem Original-Aufruf die Checkbox immer wieder einblenden:
    const TOGGLE_METHODS = {
      _updateCaseSensitivity:  'find-case-sensitive',
      _updateDiacriticMatching: 'find-match-diacritics',
      _setEntireWord:          'find-entire-word',
    };
    for (let [methodName, anonId] of Object.entries(TOGGLE_METHODS)) {
      let orig = findbarClass.prototype[methodName];
      if (typeof orig !== 'function') {
        fail('Methode ' + methodName + ' nicht gefunden – umbenannt?');
        continue;
      }
      findbarClass.prototype[methodName] = function (...aArgs) {
        try {
          orig.apply(this, aArgs);
        } catch (err) {
          fail('Original-' + methodName + ' warf einen Fehler: ', err);
        }
        try {
          let cb = this.getElement ? this.getElement(anonId)
                                    : this.querySelector('[anonid="' + anonId + '"]');
          if (cb) cb.hidden = false;
          // zugehöriges Status-Label bleibt unsichtbar (nur für die
          // vollständige Leiste ohne Checkbox vorgesehen)
        } catch (err) { /* unkritisch */ }
      };
    }

    patched = true;
    console.log(LOG + 'Mechanismus 1 aktiv: _updateFindUI gepatcht.');
    return true;
  }

  function waitForFindbar(aTries) {
    if (patched)
      return;
    if (patchFindbarClass())
      return;
    if (aTries >= MAX_TRIES) {
      fail('findbar-Custom-Element wurde nach 30 Sekunden nicht registriert.');
      return;
    }
    setTimeout(() => waitForFindbar(aTries + 1), 500);
  }

  waitForFindbar(0);

  // -----------------------------------------------------------------
  //  2b)  Mechanismus 2: findbaropen-Event direkt abfangen.
  //       Das Event wird beim Öffnen auf der FindBar dispatched
  //       (findbar.js: event.initEvent("findbaropen", true, false)).
  // -----------------------------------------------------------------
  document.addEventListener('findbaropen', function (aEvent) {
    let fb = aEvent.target;
    console.log(LOG + 'findbaropen erkannt, blende vollständige Leiste ein …');
    showFullUI(fb);
    enableWheelScrolling(fb);   // 3) Scrollrad-Blättern aktivieren /* Mira */

    // Sicherheitsnetz: nochmals nach einem kurzen Moment, falls
    // interne Aufrufe die Elemente nach dem Öffnen erneut verstecken.
    setTimeout(() => showFullUI(fb), 100);
    setTimeout(() => showFullUI(fb), 400);
  }, true);

  // -----------------------------------------------------------------
  //  3)  Scrollrad über der Leiste = Treffer vor-/zurückblättern
  //      Verharrt der Mauszeiger auf der Suchleiste, springt
  //      Mausrad-runter zum nächsten und Mausrad-hoch zum vorherigen
  //      Treffer. Wird an jede geöffnete FindBar einmalig angehängt.
  // -----------------------------------------------------------------
  const WHEEL_FLAG = '_schnellSucheWheel';

  function enableWheelScrolling(aFb) {
    if (!aFb || aFb[WHEEL_FLAG])
      return;                       // Listener schon angehängt
    aFb[WHEEL_FLAG] = true;

    aFb.addEventListener('wheel', function (aEvent) {
      // Nur bei vorhandenem Suchbegriff blättern
      if (!aFb._findField || !aFb._findField.value)
        return;

      // Nicht blättern, wenn der Nutzer gerade im Textfeld markiert/
      // scrollt? Das Textfeld scrollt nicht – also einfach weiter:
      aEvent.preventDefault();
      aEvent.stopPropagation();

      if (aEvent.deltaY > 0) {
        // Rad nach unten → nächster Treffer
        try { aFb.findNext(); } catch (e) {
          let btn = aFb.getElement && aFb.getElement('find-next');
          if (btn) btn.click();
        }
      } else {
        // Rad nach oben → vorheriger Treffer
        try { aFb.findPrevious(); } catch (e) {
          let btn = aFb.getElement && aFb.getElement('find-previous');
          if (btn) btn.click();
        }
      }
    }, { passive: false });
  }

  // -----------------------------------------------------------------
  //  4)  Bei Klick auf die Seite schließen
  // -----------------------------------------------------------------
  if (CONFIG.closeOnPageClick) {
    window.addEventListener('mousedown', function (aEvent) {
      let fb = window.gFindBar || window.gBrowser.getCachedFindBar();
      if (!fb || fb.hidden)
        return;

      // Klicks INNERHALB der Suchleiste dürfen nicht schließen
      if (fb.contains(aEvent.target))
        return;

      fb.close();
      console.log(LOG + 'Suchleiste per Seitenklick geschlossen.');
    }, true);
  }

  console.log(LOG + 'Initialisierung abgeschlossen. Tippe einen Buchstaben zum Testen.');

})();