custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/base/browser/ui/scrollbar/scrollbarArrow.js

@@ -1,106 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ScrollbarArrow = exports.ARROW_IMG_SIZE = void 0;
-
-const globalMouseMoveMonitor_1 = require("../../globalMouseMoveMonitor");
-
-const widget_1 = require("../widget");
-
-const async_1 = require("../../../common/async");
-
-const dom_1 = require("../../dom");
-/**
- * The arrow image size.
- */
-
-
-exports.ARROW_IMG_SIZE = 11;
-
-class ScrollbarArrow extends widget_1.Widget {
-  constructor(opts) {
-    super();
-    this._onActivate = opts.onActivate;
-    this.bgDomNode = document.createElement('div');
-    this.bgDomNode.className = 'arrow-background';
-    this.bgDomNode.style.position = 'absolute';
-    this.bgDomNode.style.width = opts.bgWidth + 'px';
-    this.bgDomNode.style.height = opts.bgHeight + 'px';
-
-    if (typeof opts.top !== 'undefined') {
-      this.bgDomNode.style.top = '0px';
-    }
-
-    if (typeof opts.left !== 'undefined') {
-      this.bgDomNode.style.left = '0px';
-    }
-
-    if (typeof opts.bottom !== 'undefined') {
-      this.bgDomNode.style.bottom = '0px';
-    }
-
-    if (typeof opts.right !== 'undefined') {
-      this.bgDomNode.style.right = '0px';
-    }
-
-    this.domNode = document.createElement('div');
-    this.domNode.className = opts.className;
-    dom_1.addClasses(this.domNode, opts.icon.classNames);
-    this.domNode.style.position = 'absolute';
-    this.domNode.style.width = exports.ARROW_IMG_SIZE + 'px';
-    this.domNode.style.height = exports.ARROW_IMG_SIZE + 'px';
-
-    if (typeof opts.top !== 'undefined') {
-      this.domNode.style.top = opts.top + 'px';
-    }
-
-    if (typeof opts.left !== 'undefined') {
-      this.domNode.style.left = opts.left + 'px';
-    }
-
-    if (typeof opts.bottom !== 'undefined') {
-      this.domNode.style.bottom = opts.bottom + 'px';
-    }
-
-    if (typeof opts.right !== 'undefined') {
-      this.domNode.style.right = opts.right + 'px';
-    }
-
-    this._mouseMoveMonitor = this._register(new globalMouseMoveMonitor_1.GlobalMouseMoveMonitor());
-    this.onmousedown(this.bgDomNode, e => this._arrowMouseDown(e));
-    this.onmousedown(this.domNode, e => this._arrowMouseDown(e));
-    this._mousedownRepeatTimer = this._register(new async_1.IntervalTimer());
-    this._mousedownScheduleRepeatTimer = this._register(new async_1.TimeoutTimer());
-  }
-
-  _arrowMouseDown(e) {
-    let scheduleRepeater = () => {
-      this._mousedownRepeatTimer.cancelAndSet(() => this._onActivate(), 1000 / 24);
-    };
-
-    this._onActivate();
-
-    this._mousedownRepeatTimer.cancel();
-
-    this._mousedownScheduleRepeatTimer.cancelAndSet(scheduleRepeater, 200);
-
-    this._mouseMoveMonitor.startMonitoring(e.target, e.buttons, globalMouseMoveMonitor_1.standardMouseMoveMerger, mouseMoveData => {
-      /* Intentional empty */
-    }, () => {
-      this._mousedownRepeatTimer.cancel();
-
-      this._mousedownScheduleRepeatTimer.cancel();
-    });
-
-    e.preventDefault();
-  }
-
-}
-
-exports.ScrollbarArrow = ScrollbarArrow;

package/lib/vs/base/browser/ui/scrollbar/scrollbarState.js

@@ -1,184 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ScrollbarState = void 0;
-/**
- * The minimal size of the slider (such that it can still be clickable) -- it is artificially enlarged.
- */
-
-const MINIMUM_SLIDER_SIZE = 20;
-
-class ScrollbarState {
-  constructor(arrowSize, scrollbarSize, oppositeScrollbarSize, visibleSize, scrollSize, scrollPosition) {
-    this._scrollbarSize = Math.round(scrollbarSize);
-    this._oppositeScrollbarSize = Math.round(oppositeScrollbarSize);
-    this._arrowSize = Math.round(arrowSize);
-    this._visibleSize = visibleSize;
-    this._scrollSize = scrollSize;
-    this._scrollPosition = scrollPosition;
-    this._computedAvailableSize = 0;
-    this._computedIsNeeded = false;
-    this._computedSliderSize = 0;
-    this._computedSliderRatio = 0;
-    this._computedSliderPosition = 0;
-
-    this._refreshComputedValues();
-  }
-
-  clone() {
-    return new ScrollbarState(this._arrowSize, this._scrollbarSize, this._oppositeScrollbarSize, this._visibleSize, this._scrollSize, this._scrollPosition);
-  }
-
-  setVisibleSize(visibleSize) {
-    let iVisibleSize = Math.round(visibleSize);
-
-    if (this._visibleSize !== iVisibleSize) {
-      this._visibleSize = iVisibleSize;
-
-      this._refreshComputedValues();
-
-      return true;
-    }
-
-    return false;
-  }
-
-  setScrollSize(scrollSize) {
-    let iScrollSize = Math.round(scrollSize);
-
-    if (this._scrollSize !== iScrollSize) {
-      this._scrollSize = iScrollSize;
-
-      this._refreshComputedValues();
-
-      return true;
-    }
-
-    return false;
-  }
-
-  setScrollPosition(scrollPosition) {
-    let iScrollPosition = Math.round(scrollPosition);
-
-    if (this._scrollPosition !== iScrollPosition) {
-      this._scrollPosition = iScrollPosition;
-
-      this._refreshComputedValues();
-
-      return true;
-    }
-
-    return false;
-  }
-
-  setScrollbarSize(scrollbarSize) {
-    this._scrollbarSize = scrollbarSize;
-  }
-
-  static _computeValues(oppositeScrollbarSize, arrowSize, visibleSize, scrollSize, scrollPosition) {
-    const computedAvailableSize = Math.max(0, visibleSize - oppositeScrollbarSize);
-    const computedRepresentableSize = Math.max(0, computedAvailableSize - 2 * arrowSize);
-    const computedIsNeeded = scrollSize > 0 && scrollSize > visibleSize;
-
-    if (!computedIsNeeded) {
-      // There is no need for a slider
-      return {
-        computedAvailableSize: Math.round(computedAvailableSize),
-        computedIsNeeded: computedIsNeeded,
-        computedSliderSize: Math.round(computedRepresentableSize),
-        computedSliderRatio: 0,
-        computedSliderPosition: 0
-      };
-    } // We must artificially increase the size of the slider if needed, since the slider would be too small to grab with the mouse otherwise
-
-
-    const computedSliderSize = Math.round(Math.max(MINIMUM_SLIDER_SIZE, Math.floor(visibleSize * computedRepresentableSize / scrollSize))); // The slider can move from 0 to `computedRepresentableSize` - `computedSliderSize`
-    // in the same way `scrollPosition` can move from 0 to `scrollSize` - `visibleSize`.
-
-    const computedSliderRatio = (computedRepresentableSize - computedSliderSize) / (scrollSize - visibleSize);
-    const computedSliderPosition = scrollPosition * computedSliderRatio;
-    return {
-      computedAvailableSize: Math.round(computedAvailableSize),
-      computedIsNeeded: computedIsNeeded,
-      computedSliderSize: Math.round(computedSliderSize),
-      computedSliderRatio: computedSliderRatio,
-      computedSliderPosition: Math.round(computedSliderPosition)
-    };
-  }
-
-  _refreshComputedValues() {
-    const r = ScrollbarState._computeValues(this._oppositeScrollbarSize, this._arrowSize, this._visibleSize, this._scrollSize, this._scrollPosition);
-
-    this._computedAvailableSize = r.computedAvailableSize;
-    this._computedIsNeeded = r.computedIsNeeded;
-    this._computedSliderSize = r.computedSliderSize;
-    this._computedSliderRatio = r.computedSliderRatio;
-    this._computedSliderPosition = r.computedSliderPosition;
-  }
-
-  getArrowSize() {
-    return this._arrowSize;
-  }
-
-  getScrollPosition() {
-    return this._scrollPosition;
-  }
-
-  getRectangleLargeSize() {
-    return this._computedAvailableSize;
-  }
-
-  getRectangleSmallSize() {
-    return this._scrollbarSize;
-  }
-
-  isNeeded() {
-    return this._computedIsNeeded;
-  }
-
-  getSliderSize() {
-    return this._computedSliderSize;
-  }
-
-  getSliderPosition() {
-    return this._computedSliderPosition;
-  }
-  /**
-   * Compute a desired `scrollPosition` such that `offset` ends up in the center of the slider.
-   * `offset` is based on the same coordinate system as the `sliderPosition`.
-   */
-
-
-  getDesiredScrollPositionFromOffset(offset) {
-    if (!this._computedIsNeeded) {
-      // no need for a slider
-      return 0;
-    }
-
-    let desiredSliderPosition = offset - this._arrowSize - this._computedSliderSize / 2;
-    return Math.round(desiredSliderPosition / this._computedSliderRatio);
-  }
-  /**
-   * Compute a desired `scrollPosition` such that the slider moves by `delta`.
-   */
-
-
-  getDesiredScrollPositionFromDelta(delta) {
-    if (!this._computedIsNeeded) {
-      // no need for a slider
-      return 0;
-    }
-
-    let desiredSliderPosition = this._computedSliderPosition + delta;
-    return Math.round(desiredSliderPosition / this._computedSliderRatio);
-  }
-
-}
-
-exports.ScrollbarState = ScrollbarState;

package/lib/vs/base/browser/ui/scrollbar/scrollbarVisibilityController.js

@@ -1,116 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ScrollbarVisibilityController = void 0;
-
-const async_1 = require("../../../common/async");
-
-const lifecycle_1 = require("../../../common/lifecycle");
-
-class ScrollbarVisibilityController extends lifecycle_1.Disposable {
-  constructor(visibility, visibleClassName, invisibleClassName) {
-    super();
-    this._visibility = visibility;
-    this._visibleClassName = visibleClassName;
-    this._invisibleClassName = invisibleClassName;
-    this._domNode = null;
-    this._isVisible = false;
-    this._isNeeded = false;
-    this._shouldBeVisible = false;
-    this._revealTimer = this._register(new async_1.TimeoutTimer());
-  } // ----------------- Hide / Reveal
-
-
-  applyVisibilitySetting(shouldBeVisible) {
-    if (this._visibility === 2
-    /* Hidden */
-    ) {
-        return false;
-      }
-
-    if (this._visibility === 3
-    /* Visible */
-    ) {
-        return true;
-      }
-
-    return shouldBeVisible;
-  }
-
-  setShouldBeVisible(rawShouldBeVisible) {
-    let shouldBeVisible = this.applyVisibilitySetting(rawShouldBeVisible);
-
-    if (this._shouldBeVisible !== shouldBeVisible) {
-      this._shouldBeVisible = shouldBeVisible;
-      this.ensureVisibility();
-    }
-  }
-
-  setIsNeeded(isNeeded) {
-    if (this._isNeeded !== isNeeded) {
-      this._isNeeded = isNeeded;
-      this.ensureVisibility();
-    }
-  }
-
-  setDomNode(domNode) {
-    this._domNode = domNode;
-
-    this._domNode.setClassName(this._invisibleClassName); // Now that the flags & the dom node are in a consistent state, ensure the Hidden/Visible configuration
-
-
-    this.setShouldBeVisible(false);
-  }
-
-  ensureVisibility() {
-    if (!this._isNeeded) {
-      // Nothing to be rendered
-      this._hide(false);
-
-      return;
-    }
-
-    if (this._shouldBeVisible) {
-      this._reveal();
-    } else {
-      this._hide(true);
-    }
-  }
-
-  _reveal() {
-    if (this._isVisible) {
-      return;
-    }
-
-    this._isVisible = true; // The CSS animation doesn't play otherwise
-
-    this._revealTimer.setIfNotSet(() => {
-      if (this._domNode) {
-        this._domNode.setClassName(this._visibleClassName);
-      }
-    }, 0);
-  }
-
-  _hide(withFadeAway) {
-    this._revealTimer.cancel();
-
-    if (!this._isVisible) {
-      return;
-    }
-
-    this._isVisible = false;
-
-    if (this._domNode) {
-      this._domNode.setClassName(this._invisibleClassName + (withFadeAway ? ' fade' : ''));
-    }
-  }
-
-}
-
-exports.ScrollbarVisibilityController = ScrollbarVisibilityController;

package/lib/vs/base/browser/ui/scrollbar/verticalScrollbar.js

@@ -1,114 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.VerticalScrollbar = void 0;
-
-const mouseEvent_1 = require("../../mouseEvent");
-
-const abstractScrollbar_1 = require("./abstractScrollbar");
-
-const scrollbarArrow_1 = require("./scrollbarArrow");
-
-const scrollbarState_1 = require("./scrollbarState");
-
-const codicons_1 = require("../../../common/codicons");
-
-const scrollbarButtonUpIcon = codicons_1.registerIcon('scrollbar-button-up', codicons_1.Codicon.triangleUp);
-const scrollbarButtonDownIcon = codicons_1.registerIcon('scrollbar-button-down', codicons_1.Codicon.triangleDown);
-
-class VerticalScrollbar extends abstractScrollbar_1.AbstractScrollbar {
-  constructor(scrollable, options, host) {
-    const scrollDimensions = scrollable.getScrollDimensions();
-    const scrollPosition = scrollable.getCurrentScrollPosition();
-    super({
-      lazyRender: options.lazyRender,
-      host: host,
-      scrollbarState: new scrollbarState_1.ScrollbarState(options.verticalHasArrows ? options.arrowSize : 0, options.vertical === 2
-      /* Hidden */
-      ? 0 : options.verticalScrollbarSize, // give priority to vertical scroll bar over horizontal and let it scroll all the way to the bottom
-      0, scrollDimensions.height, scrollDimensions.scrollHeight, scrollPosition.scrollTop),
-      visibility: options.vertical,
-      extraScrollbarClassName: 'vertical',
-      scrollable: scrollable
-    });
-
-    if (options.verticalHasArrows) {
-      let arrowDelta = (options.arrowSize - scrollbarArrow_1.ARROW_IMG_SIZE) / 2;
-      let scrollbarDelta = (options.verticalScrollbarSize - scrollbarArrow_1.ARROW_IMG_SIZE) / 2;
-
-      this._createArrow({
-        className: 'scra',
-        icon: scrollbarButtonUpIcon,
-        top: arrowDelta,
-        left: scrollbarDelta,
-        bottom: undefined,
-        right: undefined,
-        bgWidth: options.verticalScrollbarSize,
-        bgHeight: options.arrowSize,
-        onActivate: () => this._host.onMouseWheel(new mouseEvent_1.StandardWheelEvent(null, 0, 1))
-      });
-
-      this._createArrow({
-        className: 'scra',
-        icon: scrollbarButtonDownIcon,
-        top: undefined,
-        left: scrollbarDelta,
-        bottom: arrowDelta,
-        right: undefined,
-        bgWidth: options.verticalScrollbarSize,
-        bgHeight: options.arrowSize,
-        onActivate: () => this._host.onMouseWheel(new mouseEvent_1.StandardWheelEvent(null, 0, -1))
-      });
-    }
-
-    this._createSlider(0, Math.floor((options.verticalScrollbarSize - options.verticalSliderSize) / 2), options.verticalSliderSize, undefined);
-  }
-
-  _updateSlider(sliderSize, sliderPosition) {
-    this.slider.setHeight(sliderSize);
-    this.slider.setTop(sliderPosition);
-  }
-
-  _renderDomNode(largeSize, smallSize) {
-    this.domNode.setWidth(smallSize);
-    this.domNode.setHeight(largeSize);
-    this.domNode.setRight(0);
-    this.domNode.setTop(0);
-  }
-
-  onDidScroll(e) {
-    this._shouldRender = this._onElementScrollSize(e.scrollHeight) || this._shouldRender;
-    this._shouldRender = this._onElementScrollPosition(e.scrollTop) || this._shouldRender;
-    this._shouldRender = this._onElementSize(e.height) || this._shouldRender;
-    return this._shouldRender;
-  }
-
-  _mouseDownRelativePosition(offsetX, offsetY) {
-    return offsetY;
-  }
-
-  _sliderMousePosition(e) {
-    return e.posy;
-  }
-
-  _sliderOrthogonalMousePosition(e) {
-    return e.posx;
-  }
-
-  _updateScrollbarSize(size) {
-    this.slider.setWidth(size);
-  }
-
-  writeScrollPosition(target, scrollPosition) {
-    target.scrollTop = scrollPosition;
-  }
-
-}
-
-exports.VerticalScrollbar = VerticalScrollbar;

package/lib/vs/base/browser/ui/selectBox/selectBox.js

@@ -1,85 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SelectBox = exports.defaultStyles = void 0;
-
-require("../../../../css!./selectBox");
-
-const widget_1 = require("../widget");
-
-const color_1 = require("../../../common/color");
-
-const objects_1 = require("../../../common/objects");
-
-const selectBoxNative_1 = require("./selectBoxNative");
-
-const selectBoxCustom_1 = require("./selectBoxCustom");
-
-const platform_1 = require("../../../common/platform");
-
-exports.defaultStyles = {
-  selectBackground: color_1.Color.fromHex('#3C3C3C'),
-  selectForeground: color_1.Color.fromHex('#F0F0F0'),
-  selectBorder: color_1.Color.fromHex('#3C3C3C')
-};
-
-class SelectBox extends widget_1.Widget {
-  constructor(options, selected, contextViewProvider, styles = objects_1.deepClone(exports.defaultStyles), selectBoxOptions) {
-    super(); // Default to native SelectBox for OSX unless overridden
-
-    if (platform_1.isMacintosh && !(selectBoxOptions === null || selectBoxOptions === void 0 ? void 0 : selectBoxOptions.useCustomDrawn)) {
-      this.selectBoxDelegate = new selectBoxNative_1.SelectBoxNative(options, selected, styles, selectBoxOptions);
-    } else {
-      this.selectBoxDelegate = new selectBoxCustom_1.SelectBoxList(options, selected, contextViewProvider, styles, selectBoxOptions);
-    }
-
-    this._register(this.selectBoxDelegate);
-  } // Public SelectBox Methods - routed through delegate interface
-
-
-  get onDidSelect() {
-    return this.selectBoxDelegate.onDidSelect;
-  }
-
-  setOptions(options, selected) {
-    this.selectBoxDelegate.setOptions(options, selected);
-  }
-
-  select(index) {
-    this.selectBoxDelegate.select(index);
-  }
-
-  setAriaLabel(label) {
-    this.selectBoxDelegate.setAriaLabel(label);
-  }
-
-  focus() {
-    this.selectBoxDelegate.focus();
-  }
-
-  blur() {
-    this.selectBoxDelegate.blur();
-  } // Public Widget Methods - routed through delegate interface
-
-
-  render(container) {
-    this.selectBoxDelegate.render(container);
-  }
-
-  style(styles) {
-    this.selectBoxDelegate.style(styles);
-  }
-
-  applyStyles() {
-    this.selectBoxDelegate.applyStyles();
-  }
-
-}
-
-exports.SelectBox = SelectBox;