FF Menü reagiert nicht

// JavaScript Document
// == UserScript ==
// @name zzzz - MultiRowTab_LiteforFx48.uc.js
// @namespace http : // space.geocities.yahoo.co.jp / gl / alice0775
// @description ? ? ? ? ? ? ? ? ? ? CSS ? ? ? ? ? ? ? Lite ? ? ? ? ?
// @include main
// @compatibility Firefox 71
// @author Alice0775
// @version 2016 / 08 / 05 00 : 00 Firefox 48
// @version 2016 / 05 / 01 00 : 01 hide favicon if busy
// @version 2016 / 03 / 09 00 : 01 Bug 1222490 - Actually remove panorama for Fx45 +
// @version 2016 / 02 / 09 00 : 01 workaround css for lwt
// @version 2016 / 02 / 09 00 : 00
// == /UserScript==
"use strict";
MultiRowTabLiteforFx();
function MultiRowTabLiteforFx()
{
 var sss = Cc['@mozilla.org/content/style-sheet-service;1'].getService(Ci.nsIStyleSheetService);
 var uri = makeURI('data:text/css;charset=UTF=8,');
 sss.loadAndRegisterSheet(uri, sss.AGENT_SHEET);
 var css = tabs tab
 {
  border - left : solid 1px hsla(0, 0 % , 50 % , .5) ! important;
  border - right : solid 1px hsla(0, 0 % , 50 % , .5) ! important;
 }
 
 tabs tab : after, tabs tab : before
 {
  display : none ! important;
 };
 
 var sss = Cc['@mozilla.org/content/style-sheet-service;1'].getService(Ci.nsIStyleSheetService);
 var uri = makeURI('data:text/css;charset=UTF=8,' + encodeURIComponent(css));
 sss.loadAndRegisterSheet(uri, sss.AUTHOR_SHEET);
 gBrowser.tabContainer.clearDropIndicator = function()
 {
  var tabs = this.allTabs;
  for (let i = 0, len = tabs.length; i < len; i ++ )
  {
   tabs[i].style.removeProperty("border-left-color");
   tabs[i].style.removeProperty("border-right-color");
  }
 }
 gBrowser.tabContainer.addEventListener("dragleave", function(event)
 {
  this.clearDropIndicator(event);
 }
 , true);
 gBrowser.tabContainer.on_dragover = function(event)
 {
  this.clearDropIndicator();
  var effects = this._getDropEffectForTabDrag(event);
  var ind = this._tabDropIndicator;
  if (effects == "" || effects == "none")
  {
   ind.hidden = true;
   return;
  }
  event.preventDefault();
  event.stopPropagation();
  var arrowScrollbox = this.arrowScrollbox;
  // autoscroll the tab strip if we drag over the scroll
  // buttons, even if we aren't dragging a tab, but then
  // return to avoid drawing the drop indicator
  var pixelsToScroll = 0;
  if (this.getAttribute("overflow") == "true")
  {
   switch (event.originalTarget)
   {
    case arrowScrollbox._scrollButtonUp :
     pixelsToScroll = arrowScrollbox.scrollIncrement * - 1;
     break;
    case arrowScrollbox._scrollButtonDown :
     pixelsToScroll = arrowScrollbox.scrollIncrement;
     break;
   }
   if (pixelsToScroll)
   {
    arrowScrollbox.scrollByPixels(
    (RTL_UI ? - 1 : 1) * pixelsToScroll,
    true
    );
   }
  }
  /*
  let draggedTab = event.dataTransfer.mozGetDataAt(TAB_DROP_TYPE, 0);
  if (
  (effects == "move" || effects == "copy") &&
  this == draggedTab.container
  ) {
  ind.hidden = true;
  if ( ! this._isGroupTabsAnimationOver()) {
  // Wait for grouping tabs animation to finish
  return;
  }
  this._finishGroupSelectedTabs(draggedTab);
  if (effects == "move") {
  this._animateTabMove(event);
  return;
  }
  }
  this._finishAnimateTabMove();
  */
  if (effects == "link")
  {
   let tab = this._getDragTargetTab(event, true);
   if (tab)
   {
    if ( ! this._dragTime)
    {
     this._dragTime = Date.now();
    }
    if (Date.now() >= this._dragTime + this._dragOverDelay)
    {
     this.selectedItem = tab;
    }
    ind.hidden = true;
    return;
   }
  }
  
  var rect = arrowScrollbox.getBoundingClientRect();
  var newMargin;
  if (pixelsToScroll)
  {
   // if we are scrolling, put the drop indicator at the edge
   // so that it doesn't jump while scrolling
   let scrollRect = arrowScrollbox.scrollClientRect;
   let minMargin = scrollRect.left - rect.left;
   let maxMargin = Math.min(
   minMargin + scrollRect.width,
   scrollRect.right
   );
   
   if (RTL_UI)
   {
    [minMargin, maxMargin] = [
    this.clientWidth - maxMargin,
    this.clientWidth - minMargin,
    ];
   }
   newMargin = pixelsToScroll > 0 ? maxMargin : minMargin;
  }
  else
  {
   let newIndex = this._getDropIndex(event, effects == "link");
   let children = this.allTabs;
   if (newIndex == children.length)
   {
    let tabRect = children[newIndex - 1].getBoundingClientRect();
    if (RTL_UI)
    {
     newMargin = rect.right - tabRect.left;
    }
    else
    {
     newMargin = tabRect.right - rect.left;
    }
    children[newIndex - 1].style.setProperty("border-right-color", "red", "important");
   }
   else
   {
    let tabRect = children[newIndex].getBoundingClientRect();
    if (RTL_UI)
    {
     newMargin = rect.right - tabRect.right;
    }
    else
    {
     newMargin = tabRect.left - rect.left;
    }
    children[newIndex].style.setProperty("border-left-color", "red", "important");
   }
  }
  
  // ind.hidden = false;
  ind.hidden = true;
  newMargin += ind.clientWidth / 2;
  if (RTL_UI)
  {
   newMargin *= - 1;
  }
  ind.style.transform = "translate(" + Math.round(newMargin) + "px)";
  ind.style.marginInlineStart = - ind.clientWidth + "px";
 }
 
 gBrowser.tabContainer.on_drop = function(event)
 {
  this.clearDropIndicator();
  var dt = event.dataTransfer;
  var dropEffect = dt.dropEffect;
  var draggedTab;
  let movingTabs;
  if (dt.mozTypesAt(0)[0] == TAB_DROP_TYPE)
  {
   // tab copy or move
   draggedTab = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
   // not our drop then
   if ( ! draggedTab)
   {
    return;
   }
   movingTabs = draggedTab._dragData.movingTabs;
   draggedTab.container._finishGroupSelectedTabs(draggedTab);
  }
  this._tabDropIndicator.hidden = true;
  event.stopPropagation();
  if (draggedTab && dropEffect == "copy")
  {
   // copy the dropped tab (wherever it's from)
   let newIndex = this._getDropIndex(event, false);
   let draggedTabCopy;
   for (let tab of movingTabs)
   {
    let newTab = gBrowser.duplicateTab(tab);
    gBrowser.moveTabTo(newTab, newIndex ++ );
    if (tab == draggedTab)
    {
     draggedTabCopy = newTab;
    }
   }
   if (draggedTab.container != this || event.shiftKey)
   {
    this.selectedItem = draggedTabCopy;
   }
  }
  else if (draggedTab && draggedTab.container == this)
  {
   let oldTranslateX = Math.round(draggedTab._dragData.translateX);
   let tabWidth = Math.round(draggedTab._dragData.tabWidth);
   let translateOffset = oldTranslateX % tabWidth;
   let newTranslateX = oldTranslateX - translateOffset;
   if (oldTranslateX > 0 && translateOffset > tabWidth / 2)
   {
    newTranslateX += tabWidth;
   }
   else if (oldTranslateX < 0 && - translateOffset > tabWidth / 2)
   {
    newTranslateX -= tabWidth;
   }
   let dropIndex = this._getDropIndex(event, false);
   // "animDropIndex" in draggedTab._dragData &&
   // draggedTab._dragData.animDropIndex;
   let incrementDropIndex = true;
   if (dropIndex && dropIndex > movingTabs[0]._tPos)
   {
    dropIndex -- ;
    incrementDropIndex = false;
   }
   let animate = gBrowser.animationsEnabled;
   if (oldTranslateX && oldTranslateX != newTranslateX && animate)
   {
    for (let tab of movingTabs)
    {
     tab.setAttribute("tabdrop-samewindow", "true");
     tab.style.transform = "translateX(" + newTranslateX + "px)";
     let onTransitionEnd = transitionendEvent = >
     {
      if (
      transitionendEvent.propertyName != "transform" ||
      transitionendEvent.originalTarget != tab
      )
      {
       return;
      }
      tab.removeEventListener("transitionend", onTransitionEnd);
      tab.removeAttribute("tabdrop-samewindow");
      this._finishAnimateTabMove();
      if (dropIndex !== false)
      {
       gBrowser.moveTabTo(tab, dropIndex);
       if (incrementDropIndex)
       {
        dropIndex ++ ;
       }
      }
      gBrowser.syncThrobberAnimations(tab);
     }
     ;
     tab.addEventListener("transitionend", onTransitionEnd);
    }
   }
   else
   {
    this._finishAnimateTabMove();
    if (dropIndex !== false)
    {
     for (let tab of movingTabs)
     {
      gBrowser.moveTabTo(tab, dropIndex);
      if (incrementDropIndex)
      {
       dropIndex ++ ;
      }
     }
    }
   }
  }
  else if (draggedTab)
  {
   let newIndex = this._getDropIndex(event, false);
   let newTabs = [];
   for (let tab of movingTabs)
   {
    let newTab = gBrowser.adoptTab(tab, newIndex ++ , tab == draggedTab);
    newTabs.push(newTab);
   }
   // Restore tab selection
   gBrowser.addRangeToMultiSelectedTabs(
   newTabs[0],
   newTabs[newTabs.length - 1]
   );
  }
  else
  {
   // Pass true to disallow dropping javascript : or data : urls
   let links;
   try
   {
    links = browserDragAndDrop.dropLinks(event, true);
   }
   catch (ex)
   {
   }
   if ( ! links || links.length === 0)
   {
    return;
   }
   let inBackground = Services.prefs.getBoolPref(
   "browser.tabs.loadInBackground"
   );
   if (event.shiftKey)
   {
    inBackground = ! inBackground;
   }
   let targetTab = this._getDragTargetTab(event, true);
   let userContextId = this.selectedItem.getAttribute("usercontextid");
   let replace = ! ! targetTab;
   let newIndex = this._getDropIndex(event, true);
   let urls = links.map(link = > link.url);
   let csp = browserDragAndDrop.getCSP(event);
   let triggeringPrincipal = browserDragAndDrop.getTriggeringPrincipal(
   event
   );
   (async () = >
   {
    if (
    urls.length >=
    Services.prefs.getIntPref("browser.tabs.maxOpenBeforeWarn")
    )
    {
     // Sync dialog cannot be used inside drop event handler.
     let answer = await OpenInTabsUtils.promiseConfirmOpenInTabs(
     urls.length,
     window
     );
     if ( ! answer)
     {
      return;
     }
    }
    gBrowser.loadTabs(urls,
    {
     inBackground,
     replace,
     allowThirdPartyFixup : true,
     targetTab,
     newIndex,
     userContextId,
     triggeringPrincipal,
     csp,
    }
    );
   }
   )();
  }
  if (draggedTab)
  {
   delete draggedTab._dragData;
  }
 }
 gBrowser.tabContainer._getDropIndex = function(event, isLink)
 {
  var tabs = this.allTabs;
  var tab = this._getDragTargetTab(event, isLink);
  if ( ! RTL_UI)
  {
   for (let i = tab ? tab._tPos : 0; i < tabs.length; i ++ )
   {
    if (
    event.screenY <
    tabs[i].screenY + tabs[i].getBoundingClientRect().height
    )
    {
     if (
     event.screenX <
     tabs[i].screenX + tabs[i].getBoundingClientRect().width / 2
     )
     {
      return i;
     }
     if (
     event.screenX >
     tabs[i].screenX + tabs[i].getBoundingClientRect().width / 2 &&
     event.screenX <
     tabs[i].screenX + tabs[i].getBoundingClientRect().width
     )
     {
      return i + 1;
     }
    }
   }
  }
  else
  {
   for (let i = tab ? tab._tPos : 0; i < tabs.length; i ++ )
   {
    if (
    event.screenY <
    tabs[i].screenY + tabs[i].getBoundingClientRect().height
    )
    {
     if (
     event.screenX <
     tabs[i].screenX + tabs[i].getBoundingClientRect().width &&
     event.screenX >
     tabs[i].screenX + tabs[i].getBoundingClientRect().width / 2
     )
     {
      return i;
     }
     if (
     event.screenX <
     tabs[i].screenX + tabs[i].getBoundingClientRect().width / 2
     )
     {
      return i + 1;
     }
    }
   }
  }
  return tabs.length;
 }
}

/* Tableiste mehrreihig oben */
#tabbrowser-tabs, #tabbrowser-arrowscrollbox, #tabbrowser-tabs[positionpinnedtabs] > #tabbrowser-arrowscrollbox > .tabbrowser-tab[pinned]
{
    margin-top: -15px !important;
    margin-bottom: -5px !important;
}

[tabsintitlebar="true"][sizemode="maximized"] #navigator-toolbox
{
 padding-top: 10px !important;
}

#titlebar,#tabbrowser-tabs
{
 appearance: none !important;
}

[tabsintitlebar="true"] #TabsToolbar > .titlebar-buttonbox-container,
#main-window[inFullscreen="true"] #window-controls
{
 display: block;
}

/* Mehrreihige Tableiste, Anzahl der angezeigten Tabreihen = 3 Zeilen, weitere per Scrollbar */
box[class="scrollbox-clip"][orient="horizontal"],
tabs > arrowscrollbox
{
 display: block;
 contain: none !important;
}

scrollbox[part][orient="horizontal"]
{
    display: flex;
    flex-wrap: wrap;
    max-height: calc(var(--tab-min-height) * 5); /* Anzahl der angezeigten Tabreihen = 4 Zeilen */
    overflow-x: hidden;
    overflow-y: auto;
}

#tabbrowser-arrowscrollbox /* Geändert nach Update-Fehler 2203 */
{
    margin-top: 7px !important;      /*margin-top: -3px !important; */
    margin-bottom: 5px !important; /* margin-bottom: -10px !important;  */
}

:root
{
 --tab-min-height: 25px !important; 
}

:root #tabbrowser-tabs
{
 --tab-min-height: 25px !important; 
}
    
/* Feste Breite der einzelnen Tabs wenn gewünscht, sonst entfernen bzw. verbreitern */
tabs tab[fadein]:not([pinned])
{
 min-width: 110px !important;/* Minimale Tabbreite 76px */
 max-width: 110px !important;/* Maximale Tabbreite 225px */
}

.tabbrowser-tab .tab-close-button
{
 display: block !important; 
}

tabs tab[fadein]:not([pinned])
{
 flex-grow: 1;
}

/* Buttons/Zwischenräume Ausblenden */
hbox.titlebar-spacer,
#alltabs-button,tabs tab:not([fadein]), 
[class="scrollbutton-up"],
[class="scrollbutton-up"] + spacer,
scrollbox[part][orient="horizontal"] + spacer,
[class="scrollbutton-down"]
{ 
 display: none; 
}

tab.tabbrowser-tab .tab-background
{
 margin-top: -2px !important;
 border: solid 1px hsla(0,0%,50%,.5) !important;
}

tabs tab:after,tabs tab:before
{ 
 display: none;
}

#TabsToolbar > .titlebar-buttonbox-container
{
 display: none !important;
}    

#TabsToolbar:not(:-moz-lwtheme)
{ 
 color:pink !important;
 margin-top:-11px !important;
}

#TabsToolbar:-moz-lwtheme
{ 
 margin-bottom: -7px !important;
 margin-top:-10px !important;
}

#TabsToolbar
{ 
 margin-bottom: 0px !important;
 padding-top: 4px !important;
} 
 
#menubar-items :not([fokus]), #tabbrowser-tabs :not([fokus])
{
 opacity:1 !important;
}

/* Button for scrolling tabs to the left */
.scrollbutton-up
{
 display:none;
}

/* Button for scrolling tabs to the right */
.scrollbutton-down
{
 display:none;
}

/* Höhe für '+'-Button (newtab) */
.tabs-newtab-button
{
 vertical-align:bottom !important;
 /*vertical-align:top !important;*/
 height:var(--tab-min-height:) !important;
}

/*Drop-down menu for all tabs */
#alltabs-button
{
 display:none;
}

/* Darstellung Tabs aus alter UserChrome   ####################################################### */
#TabsToolbar .tabbrowser-tab
{
 margin:1px 1px 0 0 !important;
 padding:0 !important; 
 height:22px !important;
 border:1px solid #0081FD !important;
 /*border-bottom:0 !important; */
 border-top-left-radius:8px !important;
 border-top-right-radius:8px !important;
 /* alt: margin:1px 1px auto 0 !important;*/
 font:11px 500 Arial, sans-serif !important;
 color:#FFD700 !important;
 -moz-box-flex:0 !important;
}

/* TAB bei Mauskontakt: * Hintergrundfarbe, Rahmen */
#TabsToolbar .tabbrowser-tab:hover
{
 border:1px solid #FFF !important;
 background:#2896FF !important;
 color:#00478A !important;
}

/* TAB aktiv */
#TabsToolbar .tabbrowser-tab[selected="true"]
{
 background:#002344 !important;
 font-weight:bold !important;
 color:#FF0 !important;
 border-color:#FF0 !important;
}

/* Tab-Icons */
#TabsToolbar .tab-icon-image
{
 height:16px !important;
 width:16px !important;
 margin-left:-8px !important;
 margin-bottom:1px !important;
}
  
/* Tab-Close X */
#TabsToolbar .tab-close-button
{
 margin-right:-14px !important;
 /*margin-left:auto !important;*/
 /*padding:0 !important;*/
 color:#FFD700 !important;
}

#TabsToolbar .tab-close-button .toolbarbutton-icon
{
 height:16px !important;
 width:16px !important;
 /*background-color:#BDFEFF !important;*/
 /*border-radius:5px !important;*/
}

/* Close-Button inaktiver Tab */
tab:not([selected]) .tab-close-button
{
 display:block !important;
 color:#72B7F9 !important;
 /*margin-right:-5px !important;*/
}

/* Alle anderen Elemente in TABs */
#TabsToolbar .tabbrowser-tab *
{
 background:none !important;
}

/* Tab-Rahmenelemente entfernen (obere Linie aktiver Tab, Seitentrennlinien) */
#toolbar-menubar:not([autohide="true"]) + #TabsToolbar .tabbrowser-tab > .tab-stack > .tab-background,
:root:not([tabsintitlebar]) .tab-background,
:root[extradragspace] .tab-background
{
 border-top-style:none !important;
}

.tabbrowser-tab::AFTER,
.tabbrowser-tab::BEFORE
{
 border-left:none !important;
}

.searchbar-textbox, #urlbar
{
 border-radius:10px !important;
 min-height:30px !important;
 padding:0 !important;
 margin:0 !important;
 background:#002344;
}

/* Schrift Tabs nachträglich */
.tab-text
{
 font-size:11px !important;
 font-weight:500;
 color:#FFF !important;
}

.tab-label-container[textoverflow][labeldirection=ltr]:not([pinned]),
.tab-label-container[textoverflow]:not([labeldirection]):not([pinned]):-moz-locale-dir(ltr)
{
 direction:ltr;
 mask-image:linear-gradient(to left, transparent, black 0em) !important;
}