This repository has been archived on 2024-07-27. You can view files and clone it, but cannot push or open issues or pull requests.
keksAccountGUI/node_modulesOLD/vuetify/es5/components/VTimePicker/VTimePickerClock.js
2019-08-11 20:48:02 +02:00

274 lines
No EOL
9.1 KiB
JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
require("../../../src/components/VTimePicker/VTimePickerClock.sass");
var _colorable = _interopRequireDefault(require("../../mixins/colorable"));
var _themeable = _interopRequireDefault(require("../../mixins/themeable"));
var _mixins = _interopRequireDefault(require("../../util/mixins"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var _default2 = (0, _mixins.default)(_colorable.default, _themeable.default
/* @vue/component */
).extend({
name: 'v-time-picker-clock',
props: {
allowedValues: Function,
ampm: Boolean,
disabled: Boolean,
double: Boolean,
format: {
type: Function,
default: function _default(val) {
return val;
}
},
max: {
type: Number,
required: true
},
min: {
type: Number,
required: true
},
scrollable: Boolean,
readonly: Boolean,
rotate: {
type: Number,
default: 0
},
step: {
type: Number,
default: 1
},
value: Number
},
data: function data() {
return {
inputValue: this.value,
isDragging: false,
valueOnMouseDown: null,
valueOnMouseUp: null
};
},
computed: {
count: function count() {
return this.max - this.min + 1;
},
degreesPerUnit: function degreesPerUnit() {
return 360 / this.roundCount;
},
degrees: function degrees() {
return this.degreesPerUnit * Math.PI / 180;
},
displayedValue: function displayedValue() {
return this.value == null ? this.min : this.value;
},
innerRadiusScale: function innerRadiusScale() {
return 0.62;
},
roundCount: function roundCount() {
return this.double ? this.count / 2 : this.count;
}
},
watch: {
value: function value(_value) {
this.inputValue = _value;
}
},
methods: {
wheel: function wheel(e) {
e.preventDefault();
var delta = Math.sign(-e.deltaY || 1);
var value = this.displayedValue;
do {
value = value + delta;
value = (value - this.min + this.count) % this.count + this.min;
} while (!this.isAllowed(value) && value !== this.displayedValue);
if (value !== this.displayedValue) {
this.update(value);
}
},
isInner: function isInner(value) {
return this.double && value - this.min >= this.roundCount;
},
handScale: function handScale(value) {
return this.isInner(value) ? this.innerRadiusScale : 1;
},
isAllowed: function isAllowed(value) {
return !this.allowedValues || this.allowedValues(value);
},
genValues: function genValues() {
var children = [];
for (var value = this.min; value <= this.max; value = value + this.step) {
var color = value === this.value && (this.color || 'accent');
children.push(this.$createElement('span', this.setBackgroundColor(color, {
staticClass: 'v-time-picker-clock__item',
class: {
'v-time-picker-clock__item--active': value === this.displayedValue,
'v-time-picker-clock__item--disabled': this.disabled || !this.isAllowed(value)
},
style: this.getTransform(value),
domProps: {
innerHTML: "<span>".concat(this.format(value), "</span>")
}
})));
}
return children;
},
genHand: function genHand() {
var scale = "scaleY(".concat(this.handScale(this.displayedValue), ")");
var angle = this.rotate + this.degreesPerUnit * (this.displayedValue - this.min);
var color = this.value != null && (this.color || 'accent');
return this.$createElement('div', this.setBackgroundColor(color, {
staticClass: 'v-time-picker-clock__hand',
class: {
'v-time-picker-clock__hand--inner': this.isInner(this.value)
},
style: {
transform: "rotate(".concat(angle, "deg) ").concat(scale)
}
}));
},
getTransform: function getTransform(i) {
var _this$getPosition = this.getPosition(i),
x = _this$getPosition.x,
y = _this$getPosition.y;
return {
left: "".concat(50 + x * 50, "%"),
top: "".concat(50 + y * 50, "%")
};
},
getPosition: function getPosition(value) {
var rotateRadians = this.rotate * Math.PI / 180;
return {
x: Math.sin((value - this.min) * this.degrees + rotateRadians) * this.handScale(value),
y: -Math.cos((value - this.min) * this.degrees + rotateRadians) * this.handScale(value)
};
},
onMouseDown: function onMouseDown(e) {
e.preventDefault();
this.valueOnMouseDown = null;
this.valueOnMouseUp = null;
this.isDragging = true;
this.onDragMove(e);
},
onMouseUp: function onMouseUp(e) {
e.stopPropagation();
this.isDragging = false;
if (this.valueOnMouseUp !== null && this.isAllowed(this.valueOnMouseUp)) {
this.$emit('change', this.valueOnMouseUp);
}
},
onDragMove: function onDragMove(e) {
e.preventDefault();
if (!this.isDragging && e.type !== 'click') return;
var _this$$refs$clock$get = this.$refs.clock.getBoundingClientRect(),
width = _this$$refs$clock$get.width,
top = _this$$refs$clock$get.top,
left = _this$$refs$clock$get.left;
var _this$$refs$innerCloc = this.$refs.innerClock.getBoundingClientRect(),
innerWidth = _this$$refs$innerCloc.width;
var _ref = 'touches' in e ? e.touches[0] : e,
clientX = _ref.clientX,
clientY = _ref.clientY;
var center = {
x: width / 2,
y: -width / 2
};
var coords = {
x: clientX - left,
y: top - clientY
};
var handAngle = Math.round(this.angle(center, coords) - this.rotate + 360) % 360;
var insideClick = this.double && this.euclidean(center, coords) < (innerWidth + innerWidth * this.innerRadiusScale) / 4;
var value = (Math.round(handAngle / this.degreesPerUnit) + (insideClick ? this.roundCount : 0)) % this.count + this.min; // Necessary to fix edge case when selecting left part of the value(s) at 12 o'clock
var newValue;
if (handAngle >= 360 - this.degreesPerUnit / 2) {
newValue = insideClick ? this.max - this.roundCount + 1 : this.min;
} else {
newValue = value;
}
if (this.isAllowed(value)) {
if (this.valueOnMouseDown === null) {
this.valueOnMouseDown = newValue;
}
this.valueOnMouseUp = newValue;
this.update(newValue);
}
},
update: function update(value) {
if (this.inputValue !== value) {
this.inputValue = value;
this.$emit('input', value);
}
},
euclidean: function euclidean(p0, p1) {
var dx = p1.x - p0.x;
var dy = p1.y - p0.y;
return Math.sqrt(dx * dx + dy * dy);
},
angle: function angle(center, p1) {
var value = 2 * Math.atan2(p1.y - center.y - this.euclidean(center, p1), p1.x - center.x);
return Math.abs(value * 180 / Math.PI);
}
},
render: function render(h) {
var _this = this;
var data = {
staticClass: 'v-time-picker-clock',
class: _objectSpread({
'v-time-picker-clock--indeterminate': this.value == null
}, this.themeClasses),
on: this.readonly || this.disabled ? undefined : Object.assign({
mousedown: this.onMouseDown,
mouseup: this.onMouseUp,
mouseleave: function mouseleave(e) {
return _this.isDragging && _this.onMouseUp(e);
},
touchstart: this.onMouseDown,
touchend: this.onMouseUp,
mousemove: this.onDragMove,
touchmove: this.onDragMove
}, this.scrollable ? {
wheel: this.wheel
} : {}),
ref: 'clock'
};
return h('div', data, [h('div', {
staticClass: 'v-time-picker-clock__inner',
ref: 'innerClock'
}, [this.genHand(), this.genValues()])]);
}
});
exports.default = _default2;
//# sourceMappingURL=VTimePickerClock.js.map