625 lines
20 KiB
JavaScript
625 lines
20 KiB
JavaScript
if(Debug.debug)
|
|
console.log("Loading: Resizer.js");
|
|
|
|
var _res_manual_autoar = function(siteProps){
|
|
if(! siteProps.autoar_imdb.enabled)
|
|
return;
|
|
|
|
if(siteProps.autoar_imdb.isClass)
|
|
var ntitle = document.querySelector("."+ siteProps.autoar_imdb.title); // NOTE: needs to be tested
|
|
else
|
|
var ntitle = document.querySelector("#"+ siteProps.autoar_imdb.title); // NOTE: needs to be tested
|
|
|
|
//querySelector lahko vrne null, zato moramo preveriti, kaj smo dobili — drugače se .textContent pritožuje.
|
|
//querySelector can return null, in which case .textContent will complain.
|
|
if(!ntitle)
|
|
return;
|
|
|
|
var title = ntitle.textContent;
|
|
|
|
char_got_ar = false;
|
|
last_whatdo = {type: "autoar", what_do:"autoar"};
|
|
|
|
var sending = browser.runtime.sendMessage({
|
|
type: "gibAspectRatio",
|
|
title: title
|
|
});
|
|
// sending.then( function(){}, function(err1, err2){console.log("uw::periodic: there was an error while sending a message", err1, err2)} );
|
|
}
|
|
|
|
var _res_changeCSS = function(type, action, lastAction, conf, debugmsg){
|
|
if(debugmsg)
|
|
console.log("uw::changeCSS | starting function. type:", type, "; what_do:",what_do,"\nPlayer element is this:",PLAYER);
|
|
// hideMenu("uw-armenu");
|
|
// hideMenu("uw-smenu");
|
|
|
|
var evideo = $("video")[0];
|
|
|
|
if(!evideo){
|
|
if(debugmsg)
|
|
console.log("uw::changeCSS | no video element found. Doing nothing.");
|
|
|
|
return;
|
|
}
|
|
|
|
var video = { width: evideo.videoWidth, height: evideo.videoHeight };
|
|
var nplayer = { width: PLAYER.clientWidth, height: PLAYER.clientHeight };
|
|
|
|
if(debugmsg)
|
|
console.log("uw::changeCSS | video dimensions:",video.width,"x",video.height,"; player:",nplayer.width,"x",nplayer.height);
|
|
|
|
// Youtube predvajalnik privzeto resetira CSS ob prehodu v/iz fullscreen. Tukaj shranimo zadnje dejanje,
|
|
// da ga lahko onFullscreenOff/onFullscreenOn uveljavita.
|
|
//
|
|
// Youtube player resets CSS on fullscreen state change. Here we save the last action taken, so
|
|
// onFullscreenOff/onFullscreenOn are able to preserve it (if we want).
|
|
lastAction = {type:type, what_do:what_do};
|
|
|
|
// -----------------------------------------------------------------------------------------
|
|
// Handlanje dejanj se zgodi pod to črto
|
|
//
|
|
// Handling actions happens below this line
|
|
// -----------------------------------------------------------------------------------------
|
|
|
|
if (type == "autoar"){
|
|
this.autochar();
|
|
return;
|
|
}
|
|
|
|
if (type == "char"){
|
|
if(debugmsg)
|
|
console.log("uw::changeCSS | trying to change aspect ratio.");
|
|
|
|
// char = CHange Aspect Ratio
|
|
char(what_do, video, nplayer);
|
|
return;
|
|
}
|
|
|
|
if (what_do == "reset"){
|
|
if(debugmsg)
|
|
console.log("uw::changeCSS | issuing reset.");
|
|
|
|
resetCSS(video, nplayer);
|
|
return;
|
|
}
|
|
|
|
// Velikost videa spreminjamo samo, če smo v celozaslonskem načinu ALI če NE pišemo komentarja
|
|
// Videa ne spreminjamo tudi, če uporabljamo vrstico za iskanje.
|
|
//
|
|
// We only change video size when we're in full screen OR if we are NOT writing a comment.
|
|
// We also leave video alone if we're using the search bar
|
|
|
|
if(FullScreenDetect.isFullScreen() || (
|
|
(document.activeElement.getAttribute("role") != "textbox") &&
|
|
(document.activeElement.getAttribute("type") != "text")
|
|
)){
|
|
if(debugmsg)
|
|
console.log("uw::changeCSS | trying to fit width or height");
|
|
|
|
changeCSS_nofs(what_do, video, nplayer);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
var _res_char = function(newAr, video, player){
|
|
|
|
// Kot vhodni argument dobimo razmerje stranic. Problem je, ker pri nekaterih ločljivostih lahko razmerje stranic
|
|
// videa/našega zaslona minimalno odstopa od idealnega razmerja — npr 2560x1080 ni natanko 21:9, 1920x1080 ni
|
|
// natanko 16:9. Zato ob podanem razmerju stranic izračunamo dejansko razmerje stranic.
|
|
//
|
|
// The aspect ratio we get as an argument is an ideal aspect ratio. Some (most) resolutions' aspect ratios differ
|
|
// from that ideal aspect ratio (by a minimal amount) — e.g. 2560x1080 isn't exactly 21:9, 1920x1080 isn't exactly
|
|
// 16:9. What is more, both 3440x1440 and 2560x1080 are considered "21:9", but their aspect ratios are slightly
|
|
// different. This has the potential to result in annoying black bars, so we correct the aspect ratio we're given
|
|
// to something that's slightly more correct.
|
|
|
|
var ar;
|
|
var res_219 = [ [2560,1080], [3440,1440] ];
|
|
var res_169 = [ [1920,1080], [1280,720], [1366,768] ];
|
|
|
|
if(newAr == (21/9)){
|
|
for (var i = 0; i < res_219.length; i++){
|
|
if( player.height == res_219[i][1]){
|
|
ar = res_219[i][0]/res_219[i][1];
|
|
set_video_ar( ar, video, player);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
else if(new_ar == (16/9)){
|
|
for (var i = 0; i < res_169.length; i++){
|
|
if( player.height == res_169[i][1]){
|
|
ar = res_169[i][0]/res_169[i][1];
|
|
setVideoAr( ar, video, player);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
_res_setVideoAr(new_ar, video, player);
|
|
}
|
|
|
|
// autochar: function(){
|
|
//
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::autochar | starting. Did we get ar?",char_got_ar,"What about arx and ary?",char_arx,char_ary);
|
|
//
|
|
// if(!char_got_ar)
|
|
// return;
|
|
//
|
|
// if(!char_arx || !char_ary)
|
|
// return;
|
|
//
|
|
// var ar = char_arx / char_ary;
|
|
// if(ar){
|
|
// setBestFit(ar);
|
|
// last_whatdo = {type: "autoar", what_do: "autoar"};
|
|
// }
|
|
// }
|
|
|
|
|
|
|
|
|
|
|
|
/* Tukaj povemo, kakšno razmerje stranic ima video.
|
|
/ Kaj to pomeni:
|
|
// Mi rečemo, da ima video razmerje stranic 16:9. Dejanski video
|
|
// ima razmerje 4:3. To pomeni, da ima video zgoraj in spodaj črno
|
|
// obrobo, ki je nočemo, zato video povečamo toliko, da se ta obroba odreže.
|
|
//
|
|
// OBROB TUKAJ NE DODAJAMO.
|
|
//
|
|
// With this function, we specify the aspect ratio of the video.
|
|
// What does this mean?
|
|
// If we specify that the aspect ratio of a video is 16:9 when video is
|
|
// actually 4:3, that means the video has black bars above and below.
|
|
// We zoom the video just enough for the black lines to disappear.
|
|
//
|
|
// WE DO NOT ADD ANY BLACK BORDERS. If we get to a scenario when we'd have to add
|
|
// black borders, we do nothing instead.
|
|
*/
|
|
|
|
var setVideoAr = function(aspect_ratio, video, player){
|
|
var video_ar = video.width / video.height;
|
|
var display_ar = player.width / player.height;
|
|
|
|
if(debugmsg){
|
|
console.log("uw::set_video_ar | aspect ratio: " + aspect_ratio + "; video_ar: " + video_ar + "; display_ar: " + display_ar);
|
|
console.log("uw::set_video_ar | player dimensions: " + player.width + "x" + player.height + "; video dimensions: " + video.width + "x" + video.height);
|
|
}
|
|
|
|
if( aspect_ratio*1.1 > video_ar && video_ar > aspect_ratio*0.9 ){
|
|
// Ta hack nas reši problema, ki ga predstavlja spodnji if stavek — če se legit 21:9 videu na 16:9 monitorju
|
|
// obreže na 16:9, potem ga s klicem te funkcije ne moremo spremeniti nazaj na 21:9. Vendar pa bi za tak primer
|
|
// radi imeli izjemo.
|
|
//
|
|
// This hack solves the problem that the bottom if statement presents. If we crop a 21:9 video on a 16:9 monitor,
|
|
// we can't change it back to 21:9 in this function, even though we kinda want that to happen — so we add an
|
|
// exception.
|
|
if( debugmsg)
|
|
console.log("uw::set_video_ar | ar matches our display ar. resetting");
|
|
|
|
resetCSS(video, player);
|
|
return;
|
|
}
|
|
|
|
// Širina, višina, top, left za nov video
|
|
// Width, height, top and left for the new video
|
|
var nv = { "w":0, "h":0, "top":0, "left":0 };
|
|
|
|
/*
|
|
* // Video hočemo pretvoriti v video z drugačnim razmerjem stranic.
|
|
* // To storimo tako, da širino videa nastavimo relativno na višino prikazovalnika, torej:
|
|
* //
|
|
* // širina = višina_prikazovalnika * razmerje_stranic
|
|
* // višina = širina / video_ar
|
|
* //
|
|
* //
|
|
* //
|
|
* // ----------------------------------------------------------------------------------------------
|
|
* //
|
|
* // In this case, the video is narrower than we want (think 4:3, which we want to make into 16:9)
|
|
* // We achieve this by setting video width relative to the display width, so:
|
|
* //
|
|
* // width = display_height * aspect_ratio
|
|
* // height = width / video_ar
|
|
* //
|
|
*/
|
|
|
|
if( video_ar <= aspect_ratio ){
|
|
if(debugmsg){
|
|
console.log("uw::set_video_ar | reached pre-calc. Video is taller than ar. target ar: " + aspect_ratio );
|
|
}
|
|
|
|
nv.w = player.height * aspect_ratio;
|
|
nv.h = nv.w / video_ar;
|
|
|
|
nv.top = (player.height - nv.h)/2;
|
|
nv.left = (player.width - nv.w)/2;
|
|
}
|
|
else{
|
|
if(debugmsg){
|
|
console.log("uw::set_video_ar | reached pre-calc. Video is wider than ar. target ar: " + aspect_ratio );
|
|
}
|
|
nv.h = player.width / aspect_ratio;
|
|
nv.w = nv.h * video_ar;
|
|
|
|
nv.top = (player.height - nv.h)/2;
|
|
nv.left = (player.width - nv.w)/2;
|
|
}
|
|
|
|
if(nv.w > (player.width * 1.1) && nv.h > (player.height * 1.1))
|
|
return;
|
|
|
|
this._res_applyCss(nv);
|
|
}
|
|
|
|
|
|
|
|
// // Ta funkcija ugotovi, kako se kvadrat s podanim razmerjem stranic najbolj prilega ekranu
|
|
// // Predpostavimo, da so ćrne obrobe vselej zgoraj in spodaj, nikoli levo in desno.
|
|
// //
|
|
// // This function determines how a rectangle with a given aspect ratio best fits the monitor
|
|
// // We assume letterbox is always letterbox, never pillarbox.
|
|
// var _res_setBestFit = function(ar){
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | got ar:",ar);
|
|
//
|
|
// var player = {width: PLAYER.clientWidth, height: PLAYER.clientHeight};
|
|
// var player_ar = player.width / player.height;
|
|
//
|
|
// var evideo = $("video")[0];
|
|
// var video = {width: evideo.videoWidth, height: evideo.videoHeight};
|
|
// var video_ar = video.width / video.height;
|
|
//
|
|
// // Ob predpostavki, da je argument 'ar' pravilen, naračunamo dimenzije videa glede na širino in višino predvajalnika
|
|
// // Kot rezultat laho dobimo dve možnosti:
|
|
// // A: naračunana širina je širša, kot naš zaslon —> za računanje uporabimo širino (letterbox zgoraj/spodaj,
|
|
// // levo/desno pa ne)
|
|
// // B: naračunana širina je ožja, kot naš zaslon —> za računanje uporabimo višino (letterbox levo/desno,
|
|
// // zgoraj/spodaj pa ne)
|
|
//
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | here's all we got. ar:",ar,"player:",player,"video:",video);
|
|
//
|
|
// var tru_width = player.height * ar;
|
|
// var tru_height = player.width / ar;
|
|
//
|
|
// var nv = {w: "", h: "", top: "", left: ""};
|
|
//
|
|
// if(ar >= video_ar){
|
|
// if(ar >= player_ar){
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | aspect ratio is wider than player ar.")
|
|
// nv.h = player.width / video_ar;
|
|
// nv.w = nv.h * ar;
|
|
// }
|
|
// else{
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | aspect ratio is narrower than player ar.", (player.height * ar), nv)
|
|
// nv.w = player.height * ar;
|
|
// nv.h = nv.w / video_ar;
|
|
// }
|
|
// }
|
|
// else{
|
|
// if(ar >= player_ar){
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | aspect ratio is wider than player ar.")
|
|
// nv.h = player.width / ar;
|
|
// nv.w = nv.h * video_ar;
|
|
// }
|
|
// else{
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | aspect ratio is narrower than player ar.", (player.height * ar), nv)
|
|
// nv.w = player.height * video_ar;
|
|
// nv.h = nv.w / ar;
|
|
// }
|
|
// }
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | new video width and height processed. nv so far:", nv)
|
|
//
|
|
// nv.top = (player.height - nv.h)/2;
|
|
// nv.left = (player.width - nv.w)/2;
|
|
//
|
|
// if(debugmsg || debugmsg_autoar)
|
|
// console.log("uw::setBestFit | tru width:",tru_width,"(player width:",player.width,"); new video size:",nv);
|
|
//
|
|
// _res_applyCss(nv);
|
|
// console.log("uw::setBestFit | css applied");
|
|
// }
|
|
|
|
|
|
|
|
var _res_reset = function(force){
|
|
dimensions = {top: "", left: "", width: "100%", height: "100%"};
|
|
|
|
$("video").css({"position": "relative", "width": dimensions.width,"height": dimensions.height,"top": dimensions.top, "left": dimensions.left});
|
|
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_reset] css applied. Dimensions/pos: w:",dimensions.width,"; h:",dimensions.height,"; top:",dimensions.top,"; left:",dimensions.left);
|
|
|
|
if(force)
|
|
this._currentAr = -1;
|
|
}
|
|
|
|
// Skrbi za "stare" možnosti, kot na primer "na širino zaslona", "na višino zaslona" in "ponastavi". Približevanje opuščeno.
|
|
// handles "legacy" options, such as 'fit to widht', 'fit to height' and 'reset'. No zoom tho
|
|
var _res_legacyAr = function(action){
|
|
var vid = $("video")[0];
|
|
var ar = screen.width / screen.height;
|
|
var fileAr = vid.videoWidth / vid.videoHeight;
|
|
|
|
if(action == "fitw"){
|
|
_res_setAr_kbd( ar > fileAr ? ar : fileAr);
|
|
return;
|
|
}
|
|
if(action == "fith"){
|
|
_res_setAr_kbd( ar < fileAr ? ar : fileAr);
|
|
return;
|
|
}
|
|
if(action == "reset"){
|
|
// _res_setAr_kbd(fileAr);
|
|
this.reset(true);
|
|
return;
|
|
}
|
|
if(action == "autoar"){
|
|
ArDetect.init();
|
|
}
|
|
}
|
|
|
|
var _res_setAr_kbd = function(ar){
|
|
if(FullScreenDetect.isFullScreen()){
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_setAr_kbd] We're in full screen. Setting ar to ", ar);
|
|
|
|
_res_setAr(ar, {width: screen.width, height: screen.height} );
|
|
}
|
|
// else
|
|
// _res_setAr_nonfs(ar);
|
|
// TODO: check if site supports non-fs ar
|
|
}
|
|
|
|
var _res_setAr = function(ar, playerDimensions){
|
|
var vid = $("video")[0];
|
|
|
|
// Dejansko razmerje stranic datoteke/<video> značke
|
|
// Actual aspect ratio of the file/<video> tag
|
|
var fileAr = vid.videoWidth / vid.videoHeight;
|
|
|
|
if(ar == "default")
|
|
ar = fileAr;
|
|
|
|
// Zabavno dejstvo: ta funkcija se kliče samo v fullscreen. Za ne-fs verzijo bo posebna funkcija, ker bo včasih verjetno treba
|
|
// spremeniti velikost predvajalnika
|
|
//
|
|
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_setArFs] ar is " ,ar, ", playerDimensions are ", playerDimensions);
|
|
|
|
var videoDimensions = {
|
|
width: 0,
|
|
height: 0
|
|
}
|
|
|
|
if(Debug.debug){
|
|
console.log("[Resizer::_res_setArFs] Player dimensions?",playerDimensions);
|
|
}
|
|
|
|
if(playerDimensions === undefined){
|
|
playerDimensions = {
|
|
width: screen.width,
|
|
height: screen.height
|
|
}
|
|
}
|
|
|
|
if( fileAr < ar ){
|
|
// imamo letterbox zgoraj in spodaj -> spremenimo velikost videa (ampak nikoli na več, kot je širina zaslona)
|
|
// letterbox -> change video size (but never to wider than monitor width)
|
|
videoDimensions.width = Math.min(playerDimensions.height * ar, playerDimensions.width);
|
|
videoDimensions.height = videoDimensions.width * (1/fileAr);
|
|
}
|
|
else{
|
|
videoDimensions.height = Math.min(playerDimensions.width * (1/ar), playerDimensions.height);
|
|
videoDimensions.width = videoDimensions.height * fileAr;
|
|
}
|
|
|
|
if(Debug.debug){
|
|
console.log("[Resizer::_res_setArFs] Video dimensions: ",videoDimensions, "playerDimensions:",playerDimensions);
|
|
}
|
|
|
|
var cssValues = _res_computeOffsets(videoDimensions, playerDimensions);
|
|
|
|
if(Debug.debug){
|
|
console.log("[Resizer::_res_setArFs] Offsets for css are: ",cssValues);
|
|
}
|
|
|
|
_res_applyCss(cssValues);
|
|
}
|
|
|
|
var _res_computeOffsets = function(vidDim, playerDim){
|
|
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_computeOffsets] video will be aligned to ", Settings.miscFullscreenSettings.videoFloat);
|
|
|
|
var offsets = {
|
|
width: vidDim.width,
|
|
height: vidDim.height,
|
|
left: 0,
|
|
top: ((playerDim.height - vidDim.height) / 2)
|
|
}
|
|
|
|
if( Settings.miscFullscreenSettings.videoFloat == "center" ){
|
|
offsets.left = (playerDim.width - vidDim.width ) / 2;
|
|
|
|
}
|
|
else if( Settings.miscFullscreenSettings.videoFloat == "right" ){
|
|
offsets.left = (playerDim.width - vidDim.width);
|
|
}
|
|
|
|
return offsets;
|
|
}
|
|
|
|
var _res_setAr_nonfs = function(ar){
|
|
var player = SitesConf.getPlayerTag();
|
|
|
|
SitesConf.prepareNonfsPlayer();
|
|
|
|
if(! player)
|
|
player = $("video")[0].parentNode;
|
|
|
|
var playerDimensions = {
|
|
width: player.offsetWidth,
|
|
height: player.offsetHeight
|
|
}
|
|
|
|
_res_setAr(ar, playerDimensions);
|
|
}
|
|
|
|
var _res_align = function(float){
|
|
if(! float)
|
|
float = Settings.miscFullscreenSettings.videoFloat;
|
|
|
|
var dimensions = {left: 0};
|
|
|
|
if(float == "left"){
|
|
_res_applyCss(dimensions);
|
|
return;
|
|
}
|
|
if(float == "center"){
|
|
// dimensions.left =
|
|
// _res_applyCss(
|
|
}
|
|
}
|
|
|
|
function _res_applyCss(dimensions){
|
|
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_applyCss] Starting to apply css. this is what we're getting in:", dimensions);
|
|
|
|
if(dimensions.top !== undefined)
|
|
dimensions.top = "top: " + Math.round(dimensions.top) + "px !important";
|
|
|
|
if(dimensions.left !== undefined)
|
|
dimensions.left = "left: " + Math.round(dimensions.left) + "px !important";
|
|
|
|
if(dimensions.width !== undefined)
|
|
dimensions.width = "width: " + Math.round(dimensions.width) + "px !important";
|
|
|
|
if(dimensions.height !== undefined)
|
|
dimensions.height = "height: " + Math.round(dimensions.height) + "px !important";
|
|
|
|
// misc.
|
|
dimensions.position = "position: absolute !important";
|
|
// dimensions.objectFit = "object-fit: cover !important";
|
|
|
|
var vid = $("video")[0];
|
|
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_applyCss] trying to apply css. Css strings: ", dimensions, "video tag: ", vid);
|
|
|
|
|
|
var styleArrayStr = vid.getAttribute('style');
|
|
|
|
if (styleArrayStr !== null && styleArrayStr !== undefined){
|
|
|
|
var styleArray = styleArrayStr.split(";");
|
|
for(var i in styleArray){
|
|
|
|
styleArray[i] = styleArray[i].trim();
|
|
|
|
if (styleArray[i].startsWith("top:")){
|
|
styleArray[i] = dimensions.top;
|
|
delete dimensions.top;
|
|
}
|
|
else if(styleArray[i].startsWith("left:")){
|
|
styleArray[i] = dimensions.left;
|
|
delete dimensions.left;
|
|
}
|
|
else if(styleArray[i].startsWith("width:")){
|
|
styleArray[i] = dimensions.width;
|
|
delete dimensions.width;
|
|
}
|
|
else if(styleArray[i].startsWith("height:")){
|
|
styleArray[i] = dimensions.height;
|
|
delete dimensions.height;
|
|
}
|
|
else if(styleArray[i].startsWith("position:")){
|
|
styleArray[i] = dimensions.position;
|
|
}
|
|
else if(styleArray[i].startsWith("object-fit:")){
|
|
styleArray[i] = dimensions.objectFit;
|
|
}
|
|
}
|
|
}
|
|
else{
|
|
var styleArray = [];
|
|
}
|
|
|
|
// add remaining elements
|
|
for(var key in dimensions)
|
|
styleArray.push( dimensions[key] );
|
|
|
|
// problem: last element can get duplicated a lot.
|
|
// solution: check if last element is a duplicate. if it is, remove first occurence (keep last)
|
|
// repeat until no element is removed
|
|
var dups = false;
|
|
|
|
// debugger;
|
|
|
|
|
|
do{
|
|
dups = false;
|
|
var last = styleArray.length - 1;
|
|
var i = last;
|
|
while(i --> 0){
|
|
if(styleArray[i] === styleArray[last]){
|
|
dups = true;
|
|
styleArray.splice(i, 1);
|
|
|
|
--last; // correct the index
|
|
}
|
|
}
|
|
} while(dups);
|
|
|
|
|
|
// build style string back
|
|
var styleString = "";
|
|
for(var i in styleArray)
|
|
if(styleArray[i] !== undefined && styleArray[i] !== "")
|
|
styleString += styleArray[i] + "; ";
|
|
|
|
vid.setAttribute("style", styleString);
|
|
|
|
if(Debug.debug)
|
|
console.log("[Resizer::_res_applyCss] css applied. Style string:", styleString);
|
|
}
|
|
|
|
var _res_setFsAr = function(ar){
|
|
this._currentAr = ar;
|
|
}
|
|
|
|
var _res_restore = function(){
|
|
if(Debug.debug){
|
|
console.log("[Resizer::_res_restore] attempting to restore aspect ratio. this & settings:", {'this': this, "settings": Settings} );
|
|
}
|
|
|
|
if(this._currentAr > 0)
|
|
_res_setAr_kbd(this._currentAr);
|
|
else
|
|
_res_setAr_kbd("default");
|
|
}
|
|
|
|
var Resizer = {
|
|
_currentAr: -1,
|
|
align: _res_align,
|
|
setAr: _res_setAr_kbd,
|
|
setAr_fs: _res_setAr,
|
|
setAr_nonfs: _res_setAr_nonfs,
|
|
legacyAr: _res_legacyAr,
|
|
reset: _res_reset,
|
|
restore: _res_restore,
|
|
setFsAr: _res_setFsAr
|
|
}
|