Beiträge von Rob

// ==UserScript==
// @name           MultiRowTabLiteforFx.uc.js
// @namespace      Based on Alice0775's zzzz-MultiRowTab_LiteforFx48.uc.js
// @description    Mehrzeilige Tableiste - Experimentelle CSS Version
// @include        main
// @compatibility  Firefox 140+
// @version        2025/06/30 12:00
// @note           Wenn Sie das Gefühl haben, dass Tab-Gruppen beim Reinziehen zu schnell 
//                 geöffnet und geschlossen werden, oder dass Tabs beim Reinziehen von Links 
//                 zu schnell ausgewählt werden, versuchen Sie, diese Werte in about:config 
//                 zu erhöhen, z. B. 
//                 browser.tabs.dragDrop.selectTab.delayMS:800, 
//                 browser.tabs.dragDrop.expandGroup.delayMS:1000.
// ==/UserScript==
"use strict";

MultiRowTabLiteforFx();
function MultiRowTabLiteforFx() {
if (!window.gBrowser) { return; }

    // -- Config --
							    // Vergleichbarer CSS Code in userChrome.css Datei wird vorrangig behandelt!

    const                                   	    	    // Mehrzeilige Tableiste Ein/Aus Anzahl der Tabzeilen
    MultiRowTab_OnOff_and_TabBar_Rows =     	-1         ,// [-1] = Mehrzeilige Tableiste aktiv unbegrenzte Anzahl von Zeilen.
                                            	    	    //  0   = Mehrzeilige Tableiste aus.
                                            	    	    //  1   = Mehrzeilige Tableiste aktiv. Standard = 1 Zeile. Bei Berührung
							    //        der Tableiste mit der der Maus, werden die zweite und die folgenden 
                                                            //        Zeilen bis zur angegebenen Anzahl von Zeilen angezeigt.
	                                                    //  2   = Mehrzeilige Tableiste aktiv. Anzahl der Tabzeilen angeben.
    TabBar_Rows_on_MouseOver =              	3   	   ,// Standard = 1 Zeile. Anzahl der Zeilen angeben, die angezeigt werden sollen, 
	                                                    // wenn der Mauszeiger über die Tableiste bewegt wird. Voraussetzung: 
							    // „MultiRowTab_OnOff_and_TabBar_Rows“ auf „1“ setzen.
	    
    TabBar_DisplayTime_on_MouseOver =       	1    	   ,// Sie können die Anzeigezeit (Sekunden) festlegen, wann die zweite und die 
	                                                    // folgenden Zeilen beim Mouseover angezeigt werden. Das Display zeigt den  
							    // eingestellten Wert(Sekunden) an und kehrt dann zur ersten Zeile zurück.

                                            	    	    // Position der Tab-Leiste.
    TabBar_Position =          	    	    	1    	   ,// [0] = Standard
							    // 1   = unter der Symbolleiste
							    // 2   = unter dem Fenster

							    // Positionen der Tab-Leiste und der Lesezeichen-Symbolleiste tauschen.
							    // sofern die Position der Tab-Leiste unterhalb der Symbolleiste festgelegt ist.
							    // Voraussetzung: "TabBar_Position" auf "1".
    Bookmark_Toolbar_Position =             	true	   ,// [true] = Menüleiste, Navigationsleiste, Lesezeichenleiste, Tableiste
							    // false = Menüleiste, Navigationsleiste, Tableiste, Lesezeichensymbolleiste

							    // Tab-Höhe „UI-Dichte“
    UI_Density_Compact =               		29	   ,// Standard = 29 Pixelbei Kompakt
    UI_Density_Normal =                		36	   ,// Standard = 36 Pixel bei Normal
    UI_Density_Touch =                 		41	   ,// Standard = 41 Pixel bei Touch

							    // Tab-Breite
    Tab_Min_Width =                    		76	   ,// Standard - Mindestwert = 76px
    Tab_Max_Width =                    		235	   ,// Standard - Maxwert = 225px
							    // Bei gleichen Werten bei Min und Max, wird die Tabbreite fixiert!

							    // „Tab schließen“ Schaltfläche
    Tab_Close_Button =                 		3	   ,// [0] = Standard
							    //  1  = Ausgeblendet
							    //  2  = Auf allen Tabs anzeigen
							    //  3  = Nur bei Mausberührung anzeigen
							    //  4  = Aktive Tabs werden immer angezeigt, inaktive Tabs
							    // werden beim Mouseover angezeigt. *Standard für vertikalen Tab-Modus.

							    // ProtonUI Erscheinungsbild der Tabs ändern
    Proton_Margins =                   		true       ,// [true] = Darstellung ProtonUI
					    		    // Die Höhe der Tab-Leiste entspricht der Höhe der UI-Dichte plus dem Leerraum darüber
							    // und darunter.                                                 
							    // false  = Darstellung wie bei browser.proton.enabled auf false, was man vor Firefox 90
							    // noch einstellen konnte.
							    // Wenn der Leerraum um die Tabs auf 0 und die Höhe auf die UI-Dichte eingestellt
							    // ist, ist sie 4 Pixel breiter und 8 Pixel niedriger als die Standardeinstellung.
 
							    // Ränder auf der linken und rechten Seite der Tabs
    Tab_Separators  =                  		false      ,// [false] = Nicht anzeigen
							    // true    = Anzeigen
							    // Rahmen CSS wurde extrahiert und angepasst, an Aussehen wie bei browser.proton.enabled
							    // auf false, was man vor Firefox 90 noch einstellen konnte.
	
							    // Voraussetzung: „TabBar_Position“ auf „0“ setzen.
    TitleBar_Button_Autohide =         		false	   ,// [false] = Aktiviert
							    // true    = Deaktiviert
	    
							    // Äußeren Rahmen der Titelleistenschaltfläche [-□×] reduzieren und transparent machen.
    TitleBar_Button_DisplayTime =       	0.6	   ,// Dauer der Anzeige in Sekunden, nach der Rückkehr zur Originalgröße und dem Aufheben
							    // der Transparenz per Mouseover angeben.

							    // Tab-Leiste von Anfang an auf die angegebene Höhe einstellen.
							    // Voraussetzung: „MultiRowTab_OnOff_and_TabBar_Rows“ auf „2“ oder höher setzen.
    Set_the_TabBar_to_the_Specified_Height =	false  	   ,// [false] = Die Tab-Leiste wird höher, wenn der nächsten Zeile weitere Tabs hinzugefügt werden.
                                            	    	    //  true   = Verwendung: Die Tab-Leiste wird von Anfang an auf die angegebene Höhe eingestellt 

                                         	    	    // „.tabDropIndicator“, der beim Ziehen und Ablegen eines Tabs angezeigt wird, ersetzen.
                                            	    	    // Voraussetzung: „MultiRowTab_OnOff_and_TabBar_Rows“ auf einen anderen Wert als „0“ setzen.
    Tab_Drop_Indicator =                    	false  	   ,// [false] = Stecknadel Symbol 📍
							    // true    = Rote Linie (2px × 29px) als Symbol

                                            	     	    // Position der angepinnten Tabs
                                            	    	    // Voraussetzung: „MultiRowTab_OnOff_and_TabBar_Rows“ auf einen Wert ungleich „0“ setzen.
    Separate_Tabs_and_PinnedTabs =     		false  	   ,// [false] = Standard
							    // true    = Angeheftete Tabs von der Tab-Leiste lösen und in die darüber liegende 
							    // Zeile verschieben. Breite der angehefteten Tabs für die Position der 
							    // angehefteten Tabs „true“ anpassen.

    PinnedTab_Width =                   	false	   ,// [false] = Kein Standard
							    //  true   = Breite angehefteter Tabs anpassen, z. B. „Tab-Breite“.

    PinnedTab_Min_Width =               	76   	   ,// Standard Mindestbreite =  76 Pixel
    PinnedTab_Max_Width =               	225   	   ,// Standard Maximalbreite = 225 Pixel
							    // Bei gleichen Werten ist die Breite fixiert.

                                            	    	    // Angeheftete Tab, Schließen Schaltfläche
                                            	    	    // Voraussetzung: „Separate_Tabs_and_PinnedTabs“ auf „true“ setzen.
    PinnedTab_Close_Button =                	0   	   ,// [0] = Standard
							    //  1  = auf allen Tabs sichtbar
							    //  2  = auf Tab bei Mouseover anzeigen
							    //  3  = Aktiver Tab immer sichtbar, inaktiver Tab bei Mouseover sichtbar 
							    // *Standard für vertikalen Tab-Modus.
 
							    // Tab-Leisten-Ziehbereich
    Left_Drag_Area =                   		0	   ,// Linker Ziehbereich Breite: Standard 40 Pixel
    Right_Drag_Area =                  		0	   ,// Rechter Ziehbereich Breite: Standard 40 Pixel
    Maximize_Left_Drag_Area =   	    	false      ,// true = Linken Ziehbereich bei maximiertem Fenster anzeigen. Standard ausgeblendet.
    Fullscreen_Drag_Area =             		false	   ,// true = Linken und rechten Ziehbereich bei Vollbild anzeigen. Standard ausgeblendet.
							    // Wenn die Titelleiste angezeigt wird, funktioniert sie nicht als Drag-Bereich, selbst
							    // wenn „.titlebar-spacer“ angezeigt wird. Daher habe ich dafür gesorgt, dass sie nichts bewirkt.
    // -- Config Ende --

    css = `

    #TabsToolbar:not([collapsed="true"]) {

      :root[uidensity="compact"] & {
        --tab-min-height: ${UI_Density_Compact}px;
      }
      :root:not([uidensity]) & {
        --tab-min-height: ${UI_Density_Normal}px;
      }
      :root[uidensity="touch"] & {
        --tab-min-height: ${UI_Density_Touch}px;
      }
      
&[dragtarget] {
    z-index: unset !important;
    position: unset !important;
    pointer-events: unset !important; /* avoid blocking dragover events on scroll buttons */
}
#tabbrowser-tabs[movingtab] & {
   position: unset !important;
}
#tabbrowser-tabs[movingtab] &:is(:active, [multiselected]) {
    position: relative;
    z-index: 2;
    pointer-events: none; /* avoid blocking dragover events on scroll buttons */
}

      #tabbrowser-tabs {
        min-height: calc(var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px);

        ${MultiRowTab_OnOff_and_TabBar_Rows != 0 ? `
          &[overflow] {
            padding-inline: 0 !important;
            & > #tabbrowser-arrowscrollbox {
              & > .tabbrowser-tab[pinned] {
                display: flex;
                margin-inline-start: 0 !important;
                position: static !important;
              }
              &::part(scrollbox) {
                padding-inline: 0;
              }
            }
            & + #new-tab-button {
              display: none;
            }
          }

          ${Tab_Drop_Indicator ? `
            & > .tab-drop-indicator {
              background: url(
                data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAAdCAIAAAAPVCo9AAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAAASSURBVBhXY3growJEQ5+SUQEAOb1EM8kwskcAAAAASUVORK5CYII=
              ) no-repeat center;
            }
          ` : ``}

          #tabbrowser-arrowscrollbox {
            &::part(scrollbox) {
              & > slot {
                flex-wrap: wrap;
              }

              ${MultiRowTab_OnOff_and_TabBar_Rows != -1 ? `
                ${MultiRowTab_OnOff_and_TabBar_Rows == 1 ? `
                  ${TabBar_Rows_on_MouseOver == 0 || TabBar_Rows_on_MouseOver == 1 ? `
                    max-height: calc((var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px) * 2);
                  ` : `
                    max-height: calc((var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px) * ${TabBar_Rows_on_MouseOver});
                  `}
                  &:not(:hover) {
                    max-height: calc(var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px) !important;
                    ${Proton_Margins ? `scrollbar-width: none;` : ``}
                    transition: all 0s ease-in-out ${TabBar_DisplayTime_on_MouseOver}s;
                  }
                ` : `
                  ${Set_the_TabBar_to_the_Specified_Height ? `
                    min-height: calc((var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px) * ${MultiRowTab_OnOff_and_TabBar_Rows});
                    & > slot {
                      max-height: calc(var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px);
                    }
                  ` : `
                    max-height: calc((var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px) * ${MultiRowTab_OnOff_and_TabBar_Rows});
                  `}
                `}

                overflow: hidden auto;
                & scrollbar {
                  -moz-window-dragging: no-drag;
                }
              ` : ``}

            }
            &::part(overflow-start-indicator),
            &::part(overflow-end-indicator),
            &::part(scrollbutton-up),
            &::part(scrollbutton-down) {
              display: none;
            }

            ${Separate_Tabs_and_PinnedTabs ? `
              &:has(> .tabbrowser-tab[fadein][pinned]) {
                &::part(scrollbox) {
                  & > slot::after {
                    display: flow-root list-item;
                    content: "";
                    flex-basis: -moz-available;
                    height: 0;
                    overflow: hidden;
                  }
                }
              }
              .tabbrowser-tab[fadein] {
                &:not([pinned]) {
                  #tabbrowser-tabs[haspinnedtabs] & {
                    &, & + :not(#tabs-newtab-button) {
                      order: 1;
                    }
                  }
                }
                &[pinned] {
                  .tab-background:after {
                    content: "📌";
                    font-size: 11px;
                    right: -2px;
                    position: absolute;
                    top: -2px;
                  }

                  ${PinnedTab_Width ? `
                    flex: 100 100;
                    max-width: ${PinnedTab_Max_Width}px;
                    min-width: ${PinnedTab_Min_Width}px;
                    .tab-throbber, .tab-icon-pending, .tab-icon-image, .tab-sharing-icon-overlay, .tab-icon-overlay {
                      margin-inline-end: 5.5px !important;
                    }

                    ${PinnedTab_Close_Button == 1 ? `
                      .tab-close-button {
                        display: flex;
                      }
                    ` : PinnedTab_Close_Button == 2 ? `
                      .tab-close-button {
                        display: none;
                      }
                      &:hover .tab-close-button {
                        display: flex;
                      }
                    ` : PinnedTab_Close_Button == 3 ? `
                      &:not([selected]):hover,
                      &[selected] {
                        .tab-close-button {
                          display: flex;
                        }
                      }
                    ` : ``}

                  ` : ``}

                }
              }
            ` : ``}

            #tabbrowser-tabs[haspinnedtabs]:not([positionpinnedtabs]):not([orient="vertical"]) > & {
              &  > .tabbrowser-tab:nth-child(1 of :not([pinned], [hidden])) {
                margin-inline-start: 0 !important;
              }
            }

          }
        ` : ``}
      }

      .tabbrowser-tab[fadein]:not([pinned]) {
        max-width: ${Tab_Max_Width}px;
        min-width: ${Tab_Min_Width}px;

        ${Tab_Close_Button == 1 ? `
          .tab-close-button {
            display: none;
          }
        ` : Tab_Close_Button == 2 ? `
          .tab-close-button {
            display: flex;
          }
        ` : Tab_Close_Button == 3 ? `
          .tab-close-button {
            display: none;
          }
          &:hover .tab-close-button {
            display: flex;
          }
        ` : Tab_Close_Button == 4 ? `
          &:not([selected]):hover {
            .tab-close-button {
              display: flex;
            }
          }
        ` : ``}

      }

      ${Tab_Separators ? `
        .titlebar-spacer[type="pre-tabs"] {
          border-inline-end: 1px solid color-mix(in srgb, currentColor 20%, transparent);
        }
        .tabbrowser-tab {
          &::after,
          &::before {
            border-left: 1px solid color-mix(in srgb, currentColor 50%, transparent);
            height: calc(var(--tab-min-height) - 15%);
            margin-block: auto;
          }
          &:hover::after,
          &[multiselected]::after,
          #tabbrowser-tabs:not([movingtab]) &:has(+ .tabbrowser-tab:hover)::after,
          #tabbrowser-tabs:not([movingtab]) &:has(+ [multiselected])::after {
            height: 100%;
          }
          &::after,
          #tabbrowser-tabs[movingtab] &[visuallyselected]::before {
            display: flex;
            content: "";
          }
        }
      ` : ``}

      ${Proton_Margins ? `` : `
        .tabbrowser-tab,
        .toolbarbutton-1 {
          padding: 0;
        }
        .tabbrowser-tab,
        #tabs-newtab-button {
          height: var(--tab-min-height);
        }
        .tabbrowser-tab {
          .tab-background {
            box-shadow: none;
            margin-block: 0;
          }
          .tab-label-container {
            height: var(--tab-min-height);
            max-height: 24px;
          }
          .tab-close-button {
            height: 20px !important;
            padding-block: 3px !important;
          }
          &[usercontextid] > .tab-stack > .tab-background > .tab-context-line {
            margin-block-start: 1px !important;
          }
        }
      `}

    ${TabBar_Position == 0 ? `
      .titlebar-buttonbox-container {
        height: calc(var(--tab-min-height) + ${Proton_Margins ? 8 : 0}px);
      }

      ${TitleBar_Button_Autohide ? `
        & > .titlebar-buttonbox-container {
          background-color: color-mix(in srgb, currentColor 20%, transparent);
          position: fixed;
          right: 0;
          &:not(:hover) {
            height: 6px;
            .titlebar-button {
              padding: 0;
            }
            &,& .titlebar-button {
              opacity: 0;
              transition: all 0s ease-in-out ${TitleBar_Button_DisplayTime}s;
            }
          }
        }
      ` : ``}

    }` : `

      ${TabBar_Position == 1 || TabBar_Position == 2 ? `
        & > .titlebar-buttonbox-container {
            display: none;
        }}
        #nav-bar {
          &:not(.browser-titlebar) {
            :root[customtitlebar] #toolbar-menubar[autohide="true"] ~ &,
            :root[inFullscreen] #toolbar-menubar ~ & {
              & > .titlebar-buttonbox-container {
                display: flex;
              }
            }
          }
          .titlebar-button {
            padding-block: 0;
          }
        }
      ` : ``}

      body:has(> #navigator-toolbox:not([tabs-hidden])) {
        ${TabBar_Position == 1 ? `
          script, toolbar:not(#TabsToolbar ${Bookmark_Toolbar_Position ? `` : `, #PersonalToolbar`}) {
            order: -1;
          }
        ` : TabBar_Position == 2 ? `
          & > #fullscr-toggler[hidden] + tabbox,
          :root[inFullscreen] & > tabbox:hover {
            border-top: 0.01px solid var(--chrome-content-separator-color);
          }
          & > tabbox > #navigator-toolbox {
            border-block: none !important;
          }
          :root[inFullscreen] & {
            & > #navigator-toolbox {
              transition: none;
              &:has(~ tabbox:hover) {
                margin-top: 0 !important;
              }
              &:hover ~ tabbox > #navigator-toolbox {
                display: flex;
              }
            }
            & > tabbox:not(:hover) {
              border-top: 0.01px solid transparent;
              & > #navigator-toolbox {
                display: none;
              }
            }
          }
        ` : ``}
      }

    `}

    toolbar[id$="bar"].browser-titlebar {
      .titlebar-spacer {
        &[type="pre-tabs"] {
          width: ${Left_Drag_Area}px;
        }
        &[type="post-tabs"] {
          width: ${Right_Drag_Area}px;
        }
        ${Maximize_Left_Drag_Area ? `
          :root[customtitlebar]:not([sizemode="normal"], [inFullscreen]) &[type="pre-tabs"] {
            display: flex;
          }
        ` : ``}
        ${Fullscreen_Drag_Area ? `
          :root[customtitlebar][inFullscreen] & {
            display: flex;
          }
        ` : ``}
      }
      #navigator-toolbox[tabs-hidden] & {
        #new-tab-button {
          display: none;
        }
      }
    }

    `,
    sss = Cc["@mozilla.org/content/style-sheet-service;1"].getService(Ci.nsIStyleSheetService),
    uri = Services.io.newURI("data:text/css;charset=UTF=8," + encodeURIComponent(css));
    ["0", "2", "dragend", "SSTabRestored", "TabAttrModified"].find(eventType => {
      if(!sss.sheetRegistered(uri, eventType)) sss.loadAndRegisterSheet(uri, eventType);
      if (MultiRowTab_OnOff_and_TabBar_Rows > 0) {
        gBrowser.tabContainer.addEventListener(eventType, (e) => {
          e.target.scrollIntoView({ behavior: "instant", block: "nearest" })
        })
      }
    })

    if (TabBar_Position == 2) {
      document.body.appendChild(
        document.createXULElement("tabbox")
      ).appendChild(
        document.importNode(document.getElementById("navigator-toolbox"))
      ).appendChild(
        document.adoptNode(document.getElementById("TabsToolbar"))
      )
    }

    gBrowser.tabContainer._getDropIndex = function(event) {
        let tabToDropAt = getTabFromEventTarget(event, false);
        if (tabToDropAt?.localName == "tab-group") {
          tabToDropAt = tabToDropAt.previousSibling;
          if (!tabToDropAt) {
            tabToDropAt = gBrowser.visibleTabs[0];
          }
        }
        if (!tabToDropAt) {
          tabToDropAt = gBrowser.visibleTabs[gBrowser.visibleTabs.length - 1];
        }
        const tabPos = gBrowser.tabContainer.getIndexOfItem(tabToDropAt);

        if (window.getComputedStyle(this).direction == "ltr") {
            let rect = tabToDropAt.getBoundingClientRect();
            if (event.clientX < rect.x + rect.width / 2)
                return tabPos;
            else 
                return tabPos + 1;
            
        } else {
            let rect = tabToDropAt.getBoundingClientRect();
            if (event.clientX > rect.x + rect.width / 2)
                return tabPos;
            else
                return tabPos + 1;
        }
    };

    // We set this to check if the listeners were added before
    let listenersActive = false;

gBrowser.tabContainer.startTabDrag = function    startTabDrag(event, tab, { fromTabList = false } = {}) {
  const isTab = element => gBrowser.isTab(element);
  const isTabGroup = element => gBrowser.isTabGroup(element);
  const isTabGroupLabel = element => gBrowser.isTabGroupLabel(element);
      if (tab.multiselected) {
        for (let multiselectedTab of gBrowser.selectedTabs.filter(
          t => t.pinned != tab.pinned
        )) {
          gBrowser.removeFromMultiSelectedTabs(multiselectedTab);
        }
      }

      let dataTransferOrderedTabs;
      if (fromTabList || isTabGroupLabel(tab)) {
        // Dragging a group label or an item in the all tabs menu doesn't
        // change the currently selected tabs, and it's not possible to select
        // multiple tabs from the list, thus handle only the dragged tab in
        // this case.
        dataTransferOrderedTabs = [tab];
      } else {
        this.selectedItem = tab;
        let selectedTabs = gBrowser.selectedTabs;
        let otherSelectedTabs = selectedTabs.filter(
          selectedTab => selectedTab != tab
        );
        dataTransferOrderedTabs = [tab].concat(otherSelectedTabs);
      }

      let dt = event.dataTransfer;
      for (let i = 0; i < dataTransferOrderedTabs.length; i++) {
        let dtTab = dataTransferOrderedTabs[i];
        dt.mozSetDataAt(TAB_DROP_TYPE, dtTab, i);
        if (isTab(dtTab)) {
          let dtBrowser = dtTab.linkedBrowser;

          // We must not set text/x-moz-url or text/plain data here,
          // otherwise trying to detach the tab by dropping it on the desktop
          // may result in an "internet shortcut"
          dt.mozSetDataAt(
            "text/x-moz-text-internal",
            dtBrowser.currentURI.spec,
            i
          );
        }
      }

      // Set the cursor to an arrow during tab drags.
      dt.mozCursor = "default";

      // Set the tab as the source of the drag, which ensures we have a stable
      // node to deliver the `dragend` event.  See bug 1345473.
      dt.addElement(tab);

      // Create a canvas to which we capture the current tab.
      // Until canvas is HiDPI-aware (bug 780362), we need to scale the desired
      // canvas size (in CSS pixels) to the window's backing resolution in order
      // to get a full-resolution drag image for use on HiDPI displays.
      let scale = window.devicePixelRatio;
      let canvas = this._dndCanvas;
      if (!canvas) {
        this._dndCanvas = canvas = document.createElementNS(
          "http://www.w3.org/1999/xhtml",
          "canvas"
        );
        canvas.style.width = "100%";
        canvas.style.height = "100%";
        canvas.mozOpaque = true;
      }

      canvas.width = 160 * scale;
      canvas.height = 90 * scale;
      let toDrag = canvas;
      let dragImageOffset = -16;
      let browser = isTab(tab) && tab.linkedBrowser;
      if (isTabGroupLabel(tab)) {
        toDrag = tab;
      } else if (gMultiProcessBrowser) {
        var context = canvas.getContext("2d");
        context.fillStyle = "white";
        context.fillRect(0, 0, canvas.width, canvas.height);

        let captureListener;
        let platform = AppConstants.platform;
        // On Windows and Mac we can update the drag image during a drag
        // using updateDragImage. On Linux, we can use a panel.
        if (platform == "win" || platform == "macosx") {
          captureListener = function () {
            dt.updateDragImage(canvas, dragImageOffset, dragImageOffset);
          };
        } else {
          // Create a panel to use it in setDragImage
          // which will tell xul to render a panel that follows
          // the pointer while a dnd session is on.
          if (!this._dndPanel) {
            this._dndCanvas = canvas;
            this._dndPanel = document.createXULElement("panel");
            this._dndPanel.className = "dragfeedback-tab";
            this._dndPanel.setAttribute("type", "drag");
            let wrapper = document.createElementNS(
              "http://www.w3.org/1999/xhtml",
              "div"
            );
            wrapper.style.width = "160px";
            wrapper.style.height = "90px";
            wrapper.appendChild(canvas);
            this._dndPanel.appendChild(wrapper);
            document.documentElement.appendChild(this._dndPanel);
          }
          toDrag = this._dndPanel;
        }
        // PageThumb is async with e10s but that's fine
        // since we can update the image during the dnd.
        PageThumbs.captureToCanvas(browser, canvas)
          .then(captureListener)
          .catch(e => console.error(e));
      } else {
        // For the non e10s case we can just use PageThumbs
        // sync, so let's use the canvas for setDragImage.
        PageThumbs.captureToCanvas(browser, canvas).catch(e =>
          console.error(e)
        );
        dragImageOffset = dragImageOffset * scale;
      }
      dt.setDragImage(toDrag, dragImageOffset, dragImageOffset);

      // _dragData.offsetX/Y give the coordinates that the mouse should be
      // positioned relative to the corner of the new window created upon
      // dragend such that the mouse appears to have the same position
      // relative to the corner of the dragged tab.
      let clientPos = ele => {
        const rect = ele.getBoundingClientRect();
        return this.verticalMode ? rect.top : rect.left;
      };

      let tabOffset = clientPos(tab) - clientPos(this);

      let movingTabs = tab.multiselected ? gBrowser.selectedTabs : [tab];
      let movingTabsSet = new Set(movingTabs);

      tab._dragData = {
        offsetX: this.verticalMode
          ? event.screenX - window.screenX
          : event.screenX - window.screenX - tabOffset,
        offsetY: this.verticalMode
          ? event.screenY - window.screenY - tabOffset
          : event.screenY - window.screenY,
        scrollPos:
          this.verticalMode && tab.pinned
            ? this.verticalPinnedTabsContainer.scrollPosition
            : this.arrowScrollbox.scrollPosition,
        screenX: event.screenX,
        screenY: event.screenY,
        movingTabs,
        movingTabsSet,
        fromTabList,
        tabGroupCreationColor: gBrowser.tabGroupMenu.nextUnusedColor,
        expandGroupOnDrop: false,
      };

      event.stopPropagation();

    }
    // This sets when to apply the fix (by default a new row starts after the 23th open tab, unless you changed the min-size of tabs)
    gBrowser.tabContainer.addEventListener("dragstart", () => {
        // Multiple tab select fix
        gBrowser.visibleTabs.forEach(t => t.style.transform = "");

        // Event handling
        if (!listenersActive) {
            gBrowser.tabContainer.getDropEffectForTabDrag = function(){};
            gBrowser.tabContainer._getDropEffectForTabDrag = function(){};
            gBrowser.tabContainer.on_dragover = (dragoverEvent) => performTabDragOver(dragoverEvent);
            gBrowser.tabContainer._onDragOver = (dragoverEvent) => performTabDragOver(dragoverEvent);
            gBrowser.tabContainer.ondrop = (dropEvent) => performTabDropEvent(dropEvent);
            gBrowser.tabContainer.ondragleave = (ondragleave) => {gBrowser.tabContainer._dragTime = 0};
            gBrowser.tabContainer.ondragend = (ondragend) => clearTimeout(dragovertimer);
            listenersActive = true;
        }
    });
}

var lastKnownIndex = null;
var lastGroupStart = null;
var lastGroupEnd = null;
let dragovertimer = null;
let lasttabgroup = null;

/**
 * Gets the tab from the event target.
 * @param {*} event The event.
 * @returns The tab if it was part of the target or its parents, otherwise null
 */
function getTabFromEventTarget(event, { ignoreTabSides = false } = {}) {
    let { target } = event;
    if (target.nodeType != Node.ELEMENT_NODE) {
        target = target.parentElement;
    }
    let tab = target?.closest("tab") || target?.closest("tab-group");
    const selectedTab = gBrowser.selectedTab;
    if (tab && ignoreTabSides) {
        let { width, height } = tab.getBoundingClientRect();
        if (
            event.screenX < tab.screenX + width * 0.25 ||
            event.screenX > tab.screenX + width * 0.75 ||
            ((event.screenY < tab.screenY + height * 0.25 ||
                event.screenY > tab.screenY + height * 0.75) &&
                gBrowser.tabContainer.verticalMode)
        ) {
            return selectedTab;
        }
    }
    return tab;
}

/**
 * Performs the tab drag over event.
 * @param {*} event The drag over event.
 */
function performTabDragOver(event) {
    event.preventDefault();
    event.stopPropagation();

    let ind = gBrowser.tabContainer._tabDropIndicator;

    let effects = orig_getDropEffectForTabDrag(event);
    let tab;
    if (effects == "link") {
      tab = getTabFromEventTarget(event, true);
      if (tab) {
        if (!gBrowser.tabContainer._dragTime)
          gBrowser.tabContainer._dragTime = Date.now();
        if (!tab.hasAttribute("pendingicon") && // annoying fix
            Date.now() >= gBrowser.tabContainer._dragTime + Services.prefs.getIntPref("browser.tabs.dragDrop.selectTab.delayMS")) {
            gBrowser.selectedTab = tab;
            ind.hidden = true;
            return;
        }
      }
    }

    if (!tab) {
        tab = getTabFromEventTarget(event, false);
    }
    if (tab?.nodeName == "tab-group") {
      if(lasttabgroup !== tab) {
        lasttabgroup = tab
        clearTimeout(dragovertimer);
        dragovertimer = setTimeout((tabgroup) => {
          tabgroup.collapsed = !tabgroup.collapsed
        }, Services.prefs.getIntPref("browser.tabs.dragDrop.expandGroup.delayMS"), tab);
      }
    } else {
      clearTimeout(dragovertimer);
      lasttabgroup = null;
    }



    let newIndex = gBrowser.tabContainer._getDropIndex(event);
    if (newIndex == null)
        return;

    // Update the last known index and group position
    lastKnownIndex = newIndex;
    
    if (tab?.nodeName == "tab-group" && !lastGroupStart) {
        lastGroupStart = tab.querySelector("tab:first-of-type")._tPos;
        lastGroupEnd = tab.querySelector("tab:last-of-type")._tPos;
    }

    let tabs = gBrowser.tabs;
    let ltr = (window.getComputedStyle(gBrowser.tabContainer).direction == "ltr");
    let rect = gBrowser.tabContainer.arrowScrollbox.getBoundingClientRect();
    let newMarginX, newMarginY;

   if (newIndex == tabs.length) {
        let tabRect = tabs[newIndex - 1].getBoundingClientRect();
        if (ltr)
            newMarginX = tabRect.right - rect.left;
        else
            newMarginX = rect.right - tabRect.left;
        newMarginY = tabRect.top + tabRect.height - rect.top - rect.height; // multirow fix

        if (CSS.supports("offset-anchor", "left bottom")) // Compatibility fix for FF72+
            newMarginY += rect.height / 2 - tabRect.height / 2;
        
    } else if (newIndex != null || newIndex != 0) {
        let tabRect = tabs[newIndex].getBoundingClientRect();
        if (ltr)
            newMarginX = tabRect.left - rect.left;
        else
            newMarginX = rect.right - tabRect.right;
        newMarginY = tabRect.top + tabRect.height - rect.top - rect.height; // multirow fix

        if (CSS.supports("offset-anchor", "left bottom")) // Compatibility fix for FF72+
            newMarginY += rect.height / 2 - tabRect.height / 2;
    }

    newMarginX += ind.clientWidth / 2;
    if (!ltr)
        newMarginX *= -1;

    ind.hidden = false;

    ind.style.transform = "translate(" + Math.round(newMarginX) + "px," + Math.round(newMarginY) + "px)"; // multirow fix
    ind.style.marginInlineStart = (-ind.clientWidth) + "px";
}

/**
 * Performs the tab drop event.
 * @param {*} event The drop event.
 */
function performTabDropEvent(event) {
    clearTimeout(dragovertimer);
    let newIndex;
    let dt = event.dataTransfer;
    let dropEffect = dt.dropEffect;
    let draggedTab;
    if (dt.mozTypesAt(0)[0] == TAB_DROP_TYPE) {
        draggedTab = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
        if (!draggedTab) {
            return;
        }
    }

    if (draggedTab && dropEffect != "copy" && draggedTab.container == gBrowser.tabContainer) {
        newIndex = gBrowser.tabContainer._getDropIndex(event);

        let selectedTabs = gBrowser.selectedTabs.length > 1 ? gBrowser.selectedTabs : [draggedTab];
        let tabToMoveAt = gBrowser.tabContainer.getItemAtIndex(newIndex);
        let tab = getTabFromEventTarget(event, false);
        let tabgroup = tab?.closest("tab-group");
        if (!tab) {
          newIndex = gBrowser.tabs.length;
          tabToMoveAt = null;
        }
        if (tab?.pinned && !selectedTabs[0].pinned) {
          selectedTabs.forEach(t => gBrowser.pinTab(t));
          if (tabToMoveAt == tab) {
            selectedTabs.forEach(t => {gBrowser.moveTabBefore(t, tab)});
          } else {
            selectedTabs.forEach(t => {gBrowser.moveTabBefore(t, tabToMoveAt)});
          }
          return;
        } else if(!tab?.pinned && selectedTabs[0].pinned) {
          selectedTabs.forEach(t => gBrowser.unpinTab(t));
        }

        if (tabgroup && !tabgroup.previousSibling) {
          newIndex = 0; 
          selectedTabs.forEach(t => {gBrowser.moveTabTo(t, { tabIndex: newIndex++,forceUngrouped:true});});
        } else if (!tab || 
            !tabgroup && !tabToMoveAt?.group || 
            tabgroup && tabToMoveAt?.group) {
          if (tab !== tabToMoveAt) {
            tabToMoveAt = gBrowser.tabContainer.getItemAtIndex(newIndex -1);
            selectedTabs.forEach(t => {gBrowser.moveTabAfter(t, tabToMoveAt); tabToMoveAt = t});
          } else {
            selectedTabs.forEach(t => {gBrowser.moveTabBefore(t, tabToMoveAt)});
          }
        } else  {
          tabToMoveAt = gBrowser.tabContainer.getItemAtIndex(newIndex -1);
          selectedTabs.forEach(t => {gBrowser.moveTabAfter(t, tabToMoveAt); tabToMoveAt = t});
        }

        // Restart global vars
        lastKnownIndex = null;
        lastGroupStart = null;
        lastGroupEnd = null;
    }
}

// copy of the original and overrided _getDropEffectForTabDrag method
function orig_getDropEffectForTabDrag(event) {
    let dt = event.dataTransfer;

    let isMovingTabs = dt.mozItemCount > 0;
    for (let i = 0; i < dt.mozItemCount; i++) {
        // tabs are always added as the first type
        let types = dt.mozTypesAt(0);
        if (types[0] != TAB_DROP_TYPE) {
            isMovingTabs = false;
            break;
        }
    }

    if (isMovingTabs) {
        let sourceNode = dt.mozGetDataAt(TAB_DROP_TYPE, 0);
        if (XULElement.isInstance(sourceNode) &&
            sourceNode.localName == "tab" &&
            sourceNode.ownerGlobal.isChromeWindow &&
            sourceNode.ownerDocument.documentElement.getAttribute("windowtype") ==
            "navigator:browser" &&
            sourceNode.ownerGlobal.gBrowser.tabContainer == sourceNode.container) {
            // Do not allow transfering a private tab to a non-private window
            // and vice versa.
            if (PrivateBrowsingUtils.isWindowPrivate(window) !=
                PrivateBrowsingUtils.isWindowPrivate(sourceNode.ownerGlobal))
                return "none";
        

            if (window.gMultiProcessBrowser !=
                sourceNode.ownerGlobal.gMultiProcessBrowser)
                return "none";
        

            if (window.gFissionBrowser != sourceNode.ownerGlobal.gFissionBrowser)
                return "none";
        

            return dt.dropEffect == "copy" ? "copy" : "move";
        }
    }

    if (Services.droppedLinkHandler.canDropLink(event, true)) 
        return "link";

    return "none";
}

// Add-on Bar script for Firefox 126+ by Aris
//
// no 'close' button
// 'toggle' toolbar with 'Ctr + /' on Windows/Linux or 'Cmd + /' on macOS
// no 'Add-on Bar' entry in toolbar context menu
//
// option: smaller buttons / reduced toolbar button height
//
// flexible spaces on add-on bar behave like on old Firefox versions

// [!] Fix for WebExtensions with own windows by 黒仪大螃蟹 (for 1-N scripts)


var appversion = parseInt(Services.appinfo.version);

var compact_buttons = false; // reduced toolbar height and smaller buttons

var AddAddonbar = {
  init: function() {

	if (location != 'chrome://browser/content/browser.xhtml')
      return;
	  
	/* blank tab workaround */
	try {
	  if(gBrowser.selectedBrowser.getAttribute('blank')) gBrowser.selectedBrowser.removeAttribute('blank');
	} catch(e) {}
	
	try {
	  Services.prefs.getDefaultBranch('browser.addonbar.').setBoolPref('enabled',true);
	} catch(e) {}

	var addonbar_label = 'Add-on Bar';
	var compact_buttons_code = '';
	
	if(compact_buttons)
	  compact_buttons_code = `
		#addonbar toolbarbutton .toolbarbutton-icon {
		  padding: 0 !important;
		  width: 16px !important;
		  height: 16px !important;
		}
		#addonbar .toolbarbutton-badge-stack {
		  padding: 0 !important;
		  margin: 0 !important;
		  width: 16px !important;
		  min-width: 16px !important;
		  height: 16px !important;
		  min-height: 16px !important;
		}
		#addonbar toolbarbutton .toolbarbutton-badge {
		  margin-top: 0px !important;
		  font-size: 5pt !important;
		  min-width: unset !important;
		  min-height: unset !important;
		  margin-inline-start: 0px !important;
		  margin-inline-end: 0px !important;
		}
		#addonbar .toolbaritem-combined-buttons {
		  margin-inline: 0px !important;
		}
		#addonbar toolbarbutton {
		  padding: 0 !important;
		}
	  `;

	// style sheet
	Components.classes['@mozilla.org/content/style-sheet-service;1'].getService(Components.interfaces.nsIStyleSheetService).loadAndRegisterSheet(
	  Services.io.newURI('data:text/css;charset=utf-8,' + encodeURIComponent(`
		  #addonbar toolbarpaletteitem[place=toolbar][id^=wrapper-customizableui-special-spring],
		  #addonbar toolbarspring {
			-moz-box-flex: 1 !important;
			min-width: unset !important;
			width: unset !important;
			max-width: unset !important;
		  }
		  #main-window[customizing] #addonbar {
			outline: 1px dashed !important;
			outline-offset: -2px !important;
		  }
		  #addonbar {
			border-top: 1px solid var(--sidebar-border-color,rgba(0,0,0,0.1)) !important;
			background-color: var(--toolbar-bgcolor);
			background-image: var(--toolbar-bgimage);
			-moz-window-dragging: no-drag !important;
		  }
		  :root[lwtheme] #addonbar {
			background: var(--lwt-accent-color) !important;
		  }
		  :root[lwtheme][lwtheme-image='true'] #addonbar {
			background: var(--lwt-header-image) !important;
			background-position: 0vw 50vh !important;
		  }
		  /* autohide add-on bar in fullscreen mode */
		  /*#main-window[sizemode='fullscreen']:not([inDOMFullscreen='true']) #addonbar {
			visibility: visible !important;
			display: block !important;
			min-height: 1px !important;
			height: 1px !important;
			max-height: 1px !important;
		  }
		  #main-window[sizemode='fullscreen']:not([inDOMFullscreen='true']) #addonbar:hover {
			min-height: 24px !important;
			height: 24px !important;
			max-height: 24px !important;
		  }*/
		  #unified-extensions-button[hidden]{
			visibility: visible !important;
			display: flex !important;
		  }
		  `+compact_buttons_code+`
	  `), null, null),
	  Components.classes['@mozilla.org/content/style-sheet-service;1'].getService(Components.interfaces.nsIStyleSheetService).AGENT_SHEET
	);

	// toolbar
	try {
	  if(document.getElementById('addonbar') == null) {
		var tb_addonbar = document.createXULElement('toolbar');
		tb_addonbar.setAttribute('id','addonbar');
		tb_addonbar.setAttribute('collapsed', 'false');
		tb_addonbar.setAttribute('toolbarname', addonbar_label);
		tb_addonbar.setAttribute('defaultset','spring,spring'); 
		tb_addonbar.setAttribute('customizable','true');
		tb_addonbar.setAttribute('mode','icons');
		tb_addonbar.setAttribute('iconsize','small');
		tb_addonbar.setAttribute('context','toolbar-context-menu');
		tb_addonbar.setAttribute('lockiconsize','true');
		tb_addonbar.setAttribute('class','toolbar-primary chromeclass-toolbar browser-toolbar customization-target');

		document.getElementById('browser').parentNode.appendChild(tb_addonbar);
		//tb_addonbar.insertBefore(document.querySelector('#statuspanel'),tb_addonbar.firstChild);
		
		CustomizableUI.registerArea('addonbar', {legacy: true});
		
		setTimeout(function(){
		  CustomizableUI.registerArea('addonbar', {legacy: true});
		},2000);
	  
		CustomizableUI.registerToolbarNode(tb_addonbar);
		
		// 'Ctr + /' on Windows/Linux or 'Cmd + /' on macOS to toggle add-on bar
		var key = document.createXULElement('key');
		key.id = 'key_toggleAddonBar';
		key.setAttribute('key', '/');
		key.setAttribute('modifiers', 'accel');
		/*key.setAttribute('oncommand',`
			var newAddonBar = document.getElementById('addonbar');
			setToolbarVisibility(newAddonBar, newAddonBar.collapsed);
			Services.prefs.getBranch('browser.addonbar.').setBoolPref('enabled',!newAddonBar.collapsed);
		  `);*/
		key.addEventListener("command", () => {var newAddonBar = document.getElementById('addonbar');
			setToolbarVisibility(newAddonBar, newAddonBar.collapsed);
			Services.prefs.getBranch('browser.addonbar.').setBoolPref('enabled',!newAddonBar.collapsed);} );
		document.getElementById('mainKeyset').appendChild(key);
		
		
		try {
		  setToolbarVisibility(document.getElementById('addonbar'), Services.prefs.getBranch('browser.addonbar.').getBoolPref('enabled'));
		} catch(e) {}
	  
	  }
	} catch(e) {}

  }

}

/* initialization delay workaround */
document.addEventListener('DOMContentLoaded', AddAddonbar.init(), false);
/* Use the below code instead of the one above this line, if issues occur */
/*
setTimeout(function(){
  AddAddonbar.init();
},2000);
*/

/* fix for downloads button on add-on bar - thanks to dimdamin */
/* https://github.com/Aris-t2/CustomJSforFx/issues/125#issuecomment-2506613776 */
(async url => !location.href.startsWith(url) || await delayedStartupPromise ||
	(async (scrNT, nTjs) => {
		if (scrNT.length >= 1) {
			nTjs.uri = "data:application/x-javascript;charset=UTF-8,";
			nTjs.res = await fetch(scrNT[0].src);
			nTjs.src = (await nTjs.res.text())
				.replace(/navigator-toolbox/, "addonbar_v")
				.replace(/widget-overflow/, "addonbar");
			(await ChromeUtils.compileScript(nTjs.uri + encodeURIComponent(nTjs.src))).executeInGlobal(this);
		};
	})(document.getElementById("navigator-toolbox").querySelectorAll(":scope > script"), {})
)("chrome://browser/content/browser.x");

// 'MultiRowTabs.uc.js' V02 by BrokenHeart
// based on 'MultiRowTab_LiteforFx48.uc.js' from 'http://space.geocities.yahoo.co.jp/gl/alice0775' (Alice0775)
// Thanks to aborix...

"use strict";

MultiRowTabs();
function MultiRowTabs() {
    
    if (!window.gBrowser){
        return;
    }

    // ----------------------------
    // --- User-Settings: Start ---
    // ----------------------------
                                                // Position der Tab-Leiste:
                                                //
    var nTabbarPosition         = 1;            // [1] Tab-Leiste ist oberhalb aller Symbolleisten
                                                // [2] Tab-Leiste ist unterhalb aller Symbolleisten, aber über dem Inhaltsbereich
                                                // [3] Tab-Leiste ist vertikal auf der linken Seite 
                                                // [4] Tab-Leiste ist vertikal auf der linken Seite - Tableiste wird erst angezeigt bei Mausbewegung an den linken Rand (Autohide/Autopopup) 
                                                // [5] Tab-Leiste ist vertikal auf der rechten Seite
                                                // [6] Tab-Leiste ist unterhalb des Inhaltsbereichs 

                                                // Tab-Größenangaben 
                                                //                                                
    var nTabWidth               = 190;          // Breite der einzelnen Tabs in Pixeln
    var nTabHeight              = 24;           // Höhe der einzelnen Tabs in Pixeln
    var nTabMargin              = 1;            // Abstand zwischen den Tab-Zeilen in Pixeln   
    
                                                // sonstige Einstellungen
                                                // 
    var nTabLines               = 3;            // Anzahl der sichtbaren Tab-Zeilen, darüber hinaus wird gescrollt <nur bei horizontaler Ausrichtung (Position:[1],[2],[6]) - sonst keine Funktion> 
    var bTabScrollbar           = true;            // [true] Scrollbar für Tab-Leiste anzeigen, [false] Keine Scrollbar für Tab-Leiste anzeigen (Achtung: [false] = kein Scrollen mehr bei 'drag&drop' von Tabs!)
    var bTabTooltips            = true;         // [true] Tab-Tooltips werden angezeigt, [false] Tab-Tooltips werden nicht angezeigt
    
                                                // Tab-Schließen-Button
                                                //
    var bTabCloseButton         = true;         // [true] Tab-Schließen-Button anzeigen, [false] Tab-Schließen-Button verbergen
    var bTabCloseButRounded     = false;        // [false] quadratische Darstellung, [true] abgerundete Darstellung
    var nTabCloseButTransparency= 0.85;         // Transparenzwert des Tab-Schließen-Button in Prozent. Wertebereich: [0]=vollständig durchscheinend bis [1]=vollständig deckend (z.B [0.75])
    var nTabCloseIconNr         = 1;            // [0] Standard-Icon wird angezeigt
                                                // [1] rotes Icon mit weißem Kreuz wird angezeigt
                                                // [2] schwarzes Icon mit weißem Kreuz wird angezeigt
    var nTabCloseButSize        = 18;           // Höhe und Breite des Tab-Schließen-Buttons in Pixeln
                                                
                                                // FavIcon
                                                //
    var nFavIconSize            = 16;           // Höhe und Breite des 'FavIcons' und der Ladeanimation,[16] = Standard    
    
                                                // 'Throbber'-Animation
                                                //
    var bNewThroberAnimation    = true;         // [true] Alternative 'Throbber'-Animation auswählen, [false] Standard 'Throbber'-Animation beibehalten
  
                                                // Hintergrundfarbe der Tabs (für einfarbige Darstellung müssen die RGB-Farbwerte 1 und 2 jeweils identisch sein)
                                                //
    var strTabSelColor1         = "103,171,224";// RGB-Farbwert1 selektierter Tab
    var strTabSelColor2         = "30,78,115";  // RGB-Farbwert2 selektierter Tab 
    var strTabNotSelColor1      = "54,72,86";    // RGB-Farbwert1 nicht selektierter Tab
    var strTabNotSelColor2      = "28,32,44";    // RGB-Farbwert2 nicht selektierter Tab
    var nTabTransparency        = 1;            // Transparenzwert des unselektierten Tab Hintergrundes. Wertebereich: [0]=vollständig durchscheinend bis [1]=vollständig deckend (z.B [0.75])
    
                                                // Schriftart und Textdarstellung der Tabs 
                                                //
    var strTabFontName          = "Arial";      // Name der Schriftart
    var strTabFontColorSel      = "255,255,255";// RGB-Farbwert der Schrift des selektierten Tabs
    var strTabFontColorNotSel   = "215,215,215";// RGB-Farbwert der Schrift des nicht selektierten Tabs
    var nTabFontWeight          = 500;          // Stärke der Schrift: Wertebereich: [100] = sehr dünn bis [900] = sehr dick(bold). [500] = normal
    var nTabFontSize            = 12;           // Größe/Höhe der Schrift in Pixeln
    var bTabFontTextShadow      = true;         // [true] Text wird mit Schatteneffekt ausgegeben, [false] Text wird ohne Schatteneffekt ausgegeben. (Effekt nur bei selektierten Tabs!)
    var bMarkUnreadTab          = false;        // [true] Kursive Schrift für ungelesene Tabs, [false] ungelesene Tabs werden nicht hervorgehoben
                                                    
                                                // Rahmen um einzelne Tabs
                                                //
    var nTabBorderWidth         = 0;            // Breite des Tab-Rahmen ([0] = kein sichtbarer Rahmen)
    var nTabBorderRadius        = 0;            // Radius für abgerundete Ecken des Tabs ([0] = rechteckig, [80] = ideal abgerundet ). 
    var strTabBorderColor       = "128,128,128";// RGB-Farbwert des Rahmens
    
                                                // Neuer-Tab-Button
                                                //
    var strNewTabButtonColor    = "255,255,255";// RGB-Farbwert des '+'-Zeichens
                                                
                                                // Hintergrund der Tab-Leiste (für einfarbige Darstellung müssen die RGB-Farbwerte 1 und 2 jeweils identisch sein)
                                                //
    //var strTabBarBgColor1       = "15,24,27";   // RGB-Farbwert1 für Hintergrund der Tab-Leiste
    //var strTabBarBgColor2       = "96,123,134"; // RGB-Farbwert2 für Hintergrund der Tab-Leiste
    
    var strTabBarBgColor1       = "21,21,12";   // RGB-Farbwert1 für Hintergrund der Tab-Leiste
    var strTabBarBgColor2       = "62,75,84";   // RGB-Farbwert2 für Hintergrund der Tab-Leiste
    
    
    var nTabBarTransparency     = 1;             // Transparenzwert des Tab-Leisten Hintergrundes. Wertebereich: [0]=vollständig durchscheinend bis [1]=vollständig deckend
    var strTabBarBgImagePath    = "";             // Absoluter Dateipfad zu einem gepeicherten Bild (z.B.: "D://Bilder//Firefox//Hintergrund.jpg" ) 
                                                // "D://Programme%20(Portable)//Firefox%20Portable//FireFox%20ESR%2091//Profilordner//chrome//image//NavToolbarBackground02.png"           
    var bTabBarBgImageRepeat    = false;        // [true] Bild wird für den gesamten Bereich mehrfach nebeneinander angezeigt, [false] Bild wird nur einmal angezeigt (Position: linke/obere Ecke)  
    
                                                // Einstellungen für vertikale Tab-Leiste
                                                //
    var nVerticalTabbarWidth    = 215;          // Breite der Vertikalen Tab-Leiste in Pixeln <nur bei vertikaler Ausrichtung (Position:[3],[4],[5]) - sonst keine Funktion> 
    var nVerticalAutoPopupHover = 2;            // Abstand zum linken Fensterrand in Pixeln, ab der die vertikale Tab-Leiste sichtbar gemacht wird <Position[4] - sonst keine Funktion> 
    var nVerticalAutoPopupAnim  = 0.5;          // Dauer der Animation beim 'Herausschieben' des vertikalen Tab-Leiste in Sekunden ([0] = keine Animation) <Position[4] - sonst keine Funktion>
    
                                                // Einstellungen für Maus-Bedienung
                                                //
    var bTabWheel               = false;        // [true]: Tab-Wheel-Selection(=Selektieren des nächsten/vorherigen Tabs mit dem Mausrad) einschalten, [false]: Tab-Wheel-Selection ausschalten 
    var bPageScroll             = true;         // [true]: seitenweises Scrollen, [false]: zeilenweises Scrollen
    var bDblclickOnTabbarNewTab = true;        // [true] Doppel-Klick über Tabbar öffnet neuen Tab, [false] Funktion wird nicht ausgeführt
    var bDblclickOnTabReloadTab = true;         // [true] Doppel-Klick über Tab lädt diesen neu, [false] Funktion wird nicht ausgeführt

    
    // ----------------------------
    // --- User-Settings: Ende     ---
    // ----------------------------