krpano Actions / Scripting Reference Version 1.22

Select Version:

• 1.22
• 1.21
• 1.20.11
• 1.20.10
• 1.20.9
• 1.20.8
• 1.20.7
• 1.20.6
• 1.20.5
• 1.20.4
• 1.20.2
• 1.20.1
• 1.20
• 1.19-pr16
• 1.19-pr15
• 1.19-pr14
• 1.19-pr13
• 1.19-pr12
• 1.18
• 1.17.1
• 1.16.2
• 1.0.8.15
• 1.0.8.14
• 1.0.8.12
• 1.0.7

• variable
  
  • The variable name.
  • The variable will be created when it doesn't exists.
• type
  
  • The type of the variable.
  • Available types:
    
    • boolean - true or false
    • number - a numeric value
    • integer or int - an integer value
    • uint - an unsigned integer value
    • string - text characters
    • object - a Javascript Object with custom properties
    • array - a Javascript-Array / Value-Array
• value (optionally)
  
  • The new value for this variable.
  • When no value will be given and the variable already exsits, then the variable with its current value will be converted to the given type.
  • When no value will be given and the variable doesn't exsits, then these the default values are used: boolean=false, number=NaN (Not a Number), integer=0, string=null.
  • When the type is object or array, then either no value must be set (to create an empty Object or Array) or a String with the Object properties or Array values (in Javascript syntax).

def(b, boolean, true);

def(n, number, 123.456);

def(s, string, 'text');

def(obj, object);
def(obj.x, number, 0.0);
def(obj.y, number, 0.0);

def(obj, object, "{num:123, str:'hello'}");

def(obj, array, "[1,2,3,4,5]");

• When called with two arguments:
  • This is a normal set of one variable to a value.
• When called with three or more arguments:
  • This is a multiple-set of several variables at once.
  • Here the variables will be set or added to an object.
  • Optionally it will be also possible to specify the type of the variable.

• object (optionally - for the three or more arguments call)
  
  • The object for the multiple set call - at this object the variables will be set.
  • When the object doesn't exists, it will be created.
  • To define variables at a specific scope, it would be e.g. possible to use the global or local objects here.
• variable
  
  • The variable name.
  • The variable will be created when it doesn't exists.
• type (optionally - for the three or more arguments call)
  
  • The type of the variable.
  • Available types:
    
    • boolean - true or false
    • number - a numeric value
    • integer or int - an integer value
    • uint - an unsigned integer value
    • string - text characters
• value
  
  • The new value for this variable.
  • When the variable already exists, then the value will be converted to the type of that variable (when no explicit type was be defined).
    
  • To get here the value of other variables use
    • get(variable) or
    • calc(expression).
  • To link here to variables use  (for the three or more arguments call only)
    • link(variable) or
    • link(var1,var2:expression).

set(var1, 'hello');

set(var2, get(var1));

set(fullscreen, true);

set(layer[p1].visible, false);

set(hotspot[h1].scale, 2.5);

set(contextmenu.item[0].caption, 'hello item');

set(events.onxmlcomplete, null);

set(layer[p1], visible=false, alpha=0.5);

set(hotspot[hs1],
    type='text',
    ath=0.0,
    atv=0.0,
    html='Test Text',
    css='text-align:center',
    bg=false
);

set(global,
    test='Test text',
    havesomething:boolean=true,
    var2:string=get(var1),
    value:number=calc(1 + 2*3)
);

set(style[skin_thumb],
    width=link(skin.thumbs_width),
    height=link(skin.thumbs_height:skin.thumbs_height + 30),
    bgborder=0
);

• variable
  • Any variable.
  • When the variable doesn't exists, get() will return null.

set(dstvar, get(srcvar));

looktohotspot(get(name));

lookto(get(h), get(v), get(f));

showtext(get(msg));

tween(var,get(dstval));

set(pic, spot1);
set(hotspot[get(pic)].visible, false);

trace('xyz=', xyz, ' get(xyz)=', get(xyz));

txtadd(msg, 'fov=', get(view.fov));

• variable
  
  • The variable where the result will be stored.
  • The variable will be created when it doesn't exists.
• expression
  
  • The mathematical or logical expression.

set(y_new, calc(y_old - offset1 + offset2));

set(animationtime, calc('%1' == 'instant' ? 0.0 : 0.5));

<layer url="calc:'%CURRENTXML%/skin/' + settings.image1" />

• destination
  
  • The destination variable.
  • When the variable doesn't exists, it will be created.
• source
  
  • The source variable.
  • When the variable doesn't exists, null will be set to the destination variable.
• typeconversion (optionally)
  
  • When set to true (the default):
    When both variables have different types, then the value of the source variable will be converted to the type of the destination variable.
  • When set to false:
    Copy the value and the type of the source variable to the destination variable.

copy(dstvar, srcvar);

copy(cur_hlookat, view.hlookat);

copy(layer[text].x, mouse.x);
copy(layer[text].y, mouse.y);

• varA, varB
  
  • Two existing variables.

• variables
  
  • Any variable name.
  • It's possible to delete several variables at once - just pass several variables names (separated by a comma).

set(tmp1, ...);
set(tmp2, ...);
... do something ...
delete(tmp1, tmp2);

• condition
  
  • A logical expression.
• then-actions
  
  • The actions that will be executed when the evaluation of the condition will be true.
• else-actions (optionally)
  
  • The actions that will be executed when the evaluation of the condition will be false.

if(fullscreen, fullscreensetup(), windowsetup() );

if(fullscreen, set(layer[controls].visible, false) );

if(i LT 10, loop(next) );

if(var === null, set(var,0));

if(hotspot[spot1] === null, trace(there is no spot1 hotspot));

if((varA GT 5) AND (varA LT 10),
    trace('varA is between 5 and 10')
  );

if(varA AND varB AND varC, trace('all vars are true') );

if(var1 GT var2,
    trace('condition is true');
    lookto(100,20,50);
  ,
    trace('condition is false');
    lookto(0,0,100);
  );

if(a*2+b GT (c+3)*1.5 OR teststring == '123', ...);

if(
    test == 1, trace('test is 1'),
    test == 2, trace('test is 2'),
    test == 3, trace('test is 3'),
    trace('test is someting else')
);

• id (optionally)
  
  • An optional unique id for the delayedcall.
  • This id can be used to stop the delayedcall by calling stopdelayedcall(id).
  • When no id is given as parameter, an automatic one will be generated and returned.
• delay
  
  • The number of seconds to wait before executing the actions.
• actions
  
  • The actions to call after the delay.
  • Can be also a Javascript Function.

delayedcall(5.0, hidelogo() );

delayedcall(10, looktohotspot(spot1);loadpano(pano2.xml); );

delayedcall(1, showtext('hello');       );
delayedcall(4, showtext('to the pano'); );

<action name="updatemousepos">
  copy(layer[cursor].x, mouse.x);
  copy(layer[cursor].y, mouse.y);
  delayedcall(0.02, updatemousepos() );
</action>

• id
  
  • The id of the delayedcall that should be stopped.

<events name="introimage_events"
        onnewpano="delayedcall(introimage, 5.0, hide_introimage() );"
        onremovepano="stopdelayedcall(introimage);"
        />

• actions
  
  • The actions to call.

• id (optionally)
  
  • An optional unique id for the callwhen.
  • This id can be used to stop a waiting callwhen by calling stopcallwhen(id).
• condition
  
  • A logical expression.
  • The callwhen() action will check this condition constantly every frame until it will become true.
• actions
  
  • The actions to call when the condition is true.
  • Can be a krpano action-code string or a Javascript function.

callwhen(plugin[video].loaded, plugin[video].playvideo(...); );

callwhen(plugin[maps].loaded, plugin[maps].setcenter(...); );

• id
  
  • The id of the callwhen that should be stopped.

• startactions
  • The actions that will be called / executed before the for loop starts.
• condition
  • A logical expression.
• nextactions
  • The actions that will be called / executed after one loop (after the loopaction).
• loopactions
  • The actions that will be repeatedly called / executed as long as the condition is true.

for(set(i,0), i LT 10, inc(i), trace('i=',i) );.

for(set(i,0), i LT layer.count, inc(i), 
  trace('layer[',i,'].name=',layer[get(i)].name);
);  

• array
  • A krpano Array.
• itemvar
  • Name of the variable that will contain the Array item in the actions code.
• actions
  • The actions that will be called / executed for each item.
  • The current Array item will be available here as itemvar-named variable.

forall(scene, s, trace(s.name); );

forall(hotspot, h, h.visible=false; );

• condition
  • A logical expression.
  • Or a Javascript function that returns true (=keep looping) or false (=stop looping).
• loopactions
  • The actions or a Javascript function that will be repeatedly called / executed as long as the condition is true.
• doneactions (optionally, asyncloop only)
  • The actions or a Javascript function that will be called when the condition becomes false and the looping stops.

ondown="asyncloop(pressed, layer[scrollarea].scrollby(+2,0) );"

onover="asyncloop(hovering, updatemousepos(), hideinfo() );"

asyncloop(true, framehandler() );

var hs = krpano.get("hotspot[spotname]");
hs.ondown = function(){
  krpano.asyncloop(function(){
    if (hs.pressed) some_drag_hotspot_function(hs);
    return hs.pressed;
  });
};

• loopactions
  • The actions that will be repeatedly called / executed every frame.
  • Can be a krpano action-code string or a Javascript function that returns true (=keep looping) or false (=stop looping).

renderloop(
    ... do something ...
    if(...done with rendering...,
      stoprenderloop();
    );
);

krpano.actions.renderloop(function(){
    ... do something ...
    return done_with_rendering ? false : true;
});

• id
  
  • An unique id for the interval.
  • This id can be used to stop the interval by calling clearinterval(id).
• delay
  
  • The number of seconds to wait between the actions calls.
  • When using 0 as delay, the actions will be called once every frame.
• actions
  
  • The actions to call every delay seconds.

setinterval(time, 1.0, 
    jsget(time, (new Date()).toLocaleTimeString(); );
    trace('time=',time);
  );

<events onkeydown="setinterval(get(keycode), 0.1, trace(keycode); );"
        onkeyup="clearinterval(get(keycode));"
        />

• variable
  • The boolean variable that should be toggled.

toggle(fullscreen);

toggle(layer[button1].visible);

• variable
  • The variable that should be switched / changed.
• value1, value2, ... (optionally)
  • The switch-through values for this variable.

switch(fullscreen);

switch(layer[button1].visible);

switch(layer[button1].alpha, 1.0, 0.5);

switch(layer[child].parent, button1, button2, button3);

switch(destpos, -100, 0, +100); tween(y,get(destpos));

• Break / stop the execution of action calls from the current flow and the also the action calls from one nesting level up (e.g. when called inside an if() call then also the flow outside that if will be stopped).
• When used inside a for() or loop() loop, the break() call will also stop that loop.

• Directly exit / stop the current actions 'call'.
• A 'call' is either a call to an <action> or the calling of a variable that contains action code or the calling of action code from events.

• caller
  • The element that should be used as caller.
  • Can be either a String with the name/path of the element or directly the element Object itself.
  • Can be only a <plugin> / <layer> or <hotspot> element - or null.
  • The value null can be used to remove the current caller and to use the global scope.
• actions
  • Any krpano action code.
  • The code will be executed in the 'context' of the caller - that means 'direct' access to its properties.

callwith(layer[test], onclick);

callwith(layer[test], trace('test pos=',x,'/',y); );

callwith(layer[test], tween(alpha, 0.0); );

• scope
  • The scope for the actions code.
  • Available scopes:
    • global
    • local
    • localonly
    • parent
    • private:NAME
    Details about the scopes here: actions scope.
• actions
  • Any krpano action code.

scope(localonly, for(set(i,0), i LT 10, inc(i), trace(i)); );

scope(private:my_xml_plugin, trace(internal_var); );

• variable
  
  • The variable name.
  • The variable will be created when it doesn't exists.
• value
  
  • The new value for this variable.
  • When the variable already exists, then the value will be converted to the type of that variable.

• element
  
  • A layer or hotspot element.

<action ... scope="local">
  set(localvar, 123);
  addhotspot(auto,hs);
  ...
  linkeventscope(hs);
  set(hs.onclick, trace('localvar=',get(localvar)); );
</action>

• variable
  • The name or path of a krpano variable that should get linked.
• object and varname
  • Any object and the name or the variable/property that should get linked.
• sourcevariable
  • The name or path of a krpano variable that should be the source.
  • When this variable changes, the current variable will also change.
• var1|var2:expression
  • Link to one or more variables and use an expression to calculate the value.
  • When linking to multiple variables, they must be separated by | or , characters.
  • The expression need to be defined after a : character.
• events:expression
  • Link to one or more events and use an expression to calculate the value.
  • The synax for the events is event.EVENTNAME, where EVENTNAME can be any of the krpano events.
  • When linking to multiple events, they must be separated by | or , characters.
  • The expression need to be defined after a : character.

link(layer[radar].rotate, view.hlookat);

link(layer[info].text, view.hlookat|view.vlookat:'Lookat:'+roundval(view.hlookat,2)+'/'+roundval(view.vlookat,2));

• This can be necessary/useful in some cases, because the link will get only updated automatically when the values of the linked variables will change.
• E.g. this can be used when the value of the variable had been manually changed and should be set back to the value generated by the linking.

• variable
  • The name or path of a krpano variable that is linked and should get updated.
• object and varname
  • Any object and the name or the variable/property that is linked and should get updated.

• Could be used multiple times on one variable, but when calling removeonchange(), then all onchange callbacks will be removed.
• When onchange() is getting called from a layer or hotspot event - or by using callwith(), then that layer/hotspot object will be the variable scope for direct access.
  Otherwise the Object where the variable is defined, will be the variable scope and allow direct access to the variable without using the 'full-path'.
• By writing attribute.onchange="..." it would be possible to define onchange() callbacks already in the xml when defining attributes!

• variable
  • The name or path of a krpano variable.
• object and varname
  • Any object and the name or the variable/property.
• callback
  • The actions or a Javascript function that will be called when the variable changes.

onchange(xml.scene, trace('new scene loaded:',xml.scene); );

• elementname or object
  • Either the name/path of a krpano element or directly the element Object itself.
  • E.g. layer[test] or myelement[name].
• styles
  • The name of a <style> element.
  • Several style names can be to combined by a | character.

• elementname or object
  • Either the name/path of a krpano element or directly the element Object itself.
  • E.g. layer[test] or myelement[name].
• styles
  • The name of a <style> element.
  • Several style names can be to combined by a | character.

assignstyle(layer[test], 'teststyle');

assignstyle(layer[test], 'style1|style2');

• destobject
  • The destination object - the object where the attributes will be copied to. Existing attributes will be overwritten.
• srcobject
  • The source object - all attributes from that object will be copied to the destination object.

copyattributes(get(layer[test]), get(style[style1]));

• eventname
  • The name of the event.
  • Can be also any custom name, when event listeners for that name are used.
• instantly (optionally)
  
  • A Boolean setting (true or false, false by default).
  • When set to true, the events will be called and executed instantly, when not set or set to false, the events will be called after the current actions calls.

<events name="events1" myevent="trace(events1...);" />
<events name="events2" myevent="trace(events2...);" />
...
events.dispatch(myevent);

• with 2 parameters:
  
  • add(dst,val1)  ⇒  dst = dst + val1 (like +=)
  • sub(dst,val1)  ⇒  dst = dst - val1 (like -=)
  • mul(dst,val1)  ⇒  dst = dst * val1 (like *=)
  • div(dst,val1)  ⇒  dst = dst / val1 (like /=)
  • mod(dst,val1)  ⇒  dst = dst % val1 (modulate)
  • pow(dst,val1)  ⇒  dst = dst ^ val1
• with 3 parameters:
  
  • add(dst,val1,val2)  ⇒  dst = val1 + val2
  • sub(dst,val1,val2)  ⇒  dst = val1 - val2
  • mul(dst,val1,val2)  ⇒  dst = val1 * val2
  • div(dst,val1,val2)  ⇒  dst = val1 / val2
  • mod(dst,val1,val2)  ⇒  dst = val1 % val2 (modulate)
  • pow(dst,val1,val2)  ⇒  dst = val1 ^ val2

• variable
  • The variable where the result of the calculation will be stored.
  • When the variable doesn't exists, it will be created.
• valueA / valueB (optionally)
  
  • The values or variables for the calculation.

set(val, 1);
add(val, 1);
trace('val should be 2: val=',val);

mul(doublewidth, width, 2.0);

mul(scale, 0.5);

div(result, vala, valb);

add(dst,rotate,360); tween(rotate,get(dst),5);

add(xpos, mouse.x, mouse_x_offset);

sub(destx, stagewidth,  destwidth);

div(aspect,16,9);

mod(cur_hlookat,cur_hlookat,360);

pow(sqrt,val,0.5);

• variable
  • The variable to increase or decrease.
• byvalue (optionally)
  • Increase or decrease the variable by this value.
  • When not set, the variable will be increased or decreased by 1.
• max / min (optionally)
  • Defines maximum and minimum values.
  • When one limit will be reached then the value will be set back to the other limit value. This can be used to let the varibale either wrap around a defined range or to clip at at specific limit (with min=max).

inc(i);

inc(frame,1,get(lastframe),0);

inc(ypos,30);

inc(view.hlookat, 2, 90, 90);

• variable
  • The variable to clamp / to limit.
• min
  • The minimum value - when value of the variable is below that value, it will be set to this min value.
• max
  • The maximum value - when value of the variable is above that value, it will be set to this max value.

clamp(percent, 0, 100);

screentolayer(bar, mouse.stagex,mouse.stagey, lx,ly);
div(fill, lx, layer[bar].pixelwidth);
mul(fill, 100);
clamp(fill, 0, 100);
txtadd(layer[barfill].width, get(fill), '%');

• Math.PI
  • Mathematically constant with the value of PI (3.141592)
• Math.abs(var) or Math.abs(result,v)
  
  • Make an absolute value.
• Math.acos(var) or Math.acos(result,v)
  
  • Calculates the arc cosine (in radians).
• Math.asin(var) or Math.asin(result,v)
  
  • Calculates the arc sine (in radians).
• Math.atan(var) or Math.atan(result,v)
  
  • Calculates the arc tangent (in radians).
• Math.atan2(result,a,b)
  
  • Calculates the arc tangent (in radians) of the two variables a and b.
  • It is similar to calculating the arc tangent of a / b, except that the signs of both arguments are used to determine the quadrant of the result.
• Math.ceil(var) or Math.ceil(result,v)
  
  • Calculates the next highest integer value by rounding up.
• Math.cos(var) or Math.cos(result,v)
  
  • Calculates the cosine (parameter in radians).
• Math.exp(var) or Math.exp(result,v)
  
  • Calculates e (=base of the natural system of logarithms, ~2.718282) raised to the power of var/v.
• Math.floor(var) or Math.floor(result,v)
  
  • Calculates the next lowest integer value by rounding down.
• Math.log(var) or Math.log(result,v)
  
  • Calculates the natural logarithm.
• Math.max(var,var2) or Math.max(result,...vars)
  
  • Get the largest value of all given variables or values.
• Math.min(var,var2) or Math.min(result,...vars)
  
  • Get the lowest value of all given variables or values.
• Math.pow(var,var2) or Math.pow(result,v1,v2)
  
  • Calculates var/v1 raised to the power of var2/v2.
• Math.round(var) or Math.round(result,v)
  
  • Calculates the rounded integer value.
• Math.sin(var) or Math.sin(result,v)
  
  • Calculates the sine (parameter in radians).
• Math.sqrt(var) or Math.sqrt(result,v)
  
  • Calculates the square root.
• Math.tan(var) or Math.tan(result,v)
  
  • Calculates the tangent (parameter in radians).

• destinationvariable (optionally)
  • The variable where the result will be stored.
  • Only when called with 3 parameters!
• variable
  • The variable to be rounded.
  • When called with 1 or 2 parameters, the result will be stored also in that variable.
• decimalplaces (optionally)
  • The number of decimal places - 0 when not set.
  • Negative values work like positive ones, except that trailing zeros are automatically removed (except for a least one zero after the comma dot).

roundval(val);

roundval(val, 2);

roundval(val, 123.0, 6);   // ⇒ "123.000000"

roundval(val, 123.0, -6);  // ⇒ "123.0"

roundval(hlookat_print, view.hlookat, 2);

• destinationvariable (optionally)
  • The variable where the result will be stored.
  • Only when called with 4 parameters!
• variable
  • The variable to be converted to a hexadecimal string.
  • When called with less than 4 parameters, the result will be stored also in that variable.
• prefix (optionally)
  • A prefix (like '0x' or '#') for the string.
• length (optionally)
  • A fixed length for the result.

tohex(color,'#',6);

set(color, ...an_external_integer_input...);
tohex(color,'#',6);
txtadd(layer[text1].css,'color:',get(color),';');

• destinationvariable (optionally)
  • The variable where the case conversion result will be stored.
  • Only when called with 2 parameters!
• variable / sourcevariable
  • The variable to be converted to a lower or upper case.

• destination
  • The destination variable where the connected text will be stored.
  • The variable will be created when it doesn't exists.
• txt1, txt2, txt3, ... (optionally)
  • The texts that will be connected together.
  • When using only one txt parameter then this text will be added to the content of current destination variable.
  • Note - when the content of a variable should be used - then the get() action must be used to resolve the variable!

txtadd(picfilename,'%CURRENTXML%/pic_',get(pic),'.jpg');

txtadd(crop,'0|',get(ypos),'|333|285');

txtadd(pname, 'thumbbar_image_', get(i));

txtadd(layer[text].html,'[p]',get(data[txt1].content),'[/p]');

txtadd(msg,get(view.fovtype),'=',get(fov),'°');

• dstvar
  • The destination variable where the extracted text will be stored.
  • The variable will be created when it doesn't exists.
• srcvar
  • The variable or text with the source text.
• startpos
  • The starting position from where the text should be extracted.
• len
  • The length of the text to extract.

• index
  • A variable that will store the index of first occurrence of 'searchtxt'.
  • Or -1 if 'searchtxt' never occurs.
  • The variable will be created when it doesn't exists.
• txt
  • The text in which it should be searched.
• searchtxt
  • The text to searched for.
• startindex (optionally)
  • The starting startindex / position where to start searching for the text (0 by default).

• var / srcvar / dstvar
  • The variable where to search for (var, srcvar) and where the result will be stored (var, dstvar).
  • The variable will be created when it doesn't exists.
• searchtxt
  • The text that should be searched for.
• replacetext
  • The text that will replace the 'searchtxt' occurrences.

• string
  • The string to split, can be either a text or a variable.
• separator
  • The separator character or string.
• resultingarray (when calling the txtsplit() action with 3 arguments)
  • Name of a krpano Array variable that will contain the split parts as 'value' properties.
• var1, var2, ... (when calling the txtsplit() action with 4 or more arguments)
  • The results of the spliting will be directly assigned to the given variables.
  • When using null as variable, that value will ignored/skipped (could be used to extract only some specific values).

txtsplit('1|2|3', '|', a, b, c);
trace('a=',get(a), ' b=',get(b), ' c=',get(c));

a=1 b=2 c=3

txtsplit('x|y|z', '|', arr);
for(set(i,0), i LT arr.count, inc(i),
  trace('arr[',get(i),'].value=',arr[get(i)].value);
);

arr[0].value=x
arr[1].value=y
arr[2].value=z

• var
  • The variable where the result will be stored.
  • The variable will be created when it doesn't exists.
• separator
  • The separator character or string that will be insert between the elements.
• array (when calling the txtjoin() action with 3 arguments)
  • Name of an array variable.
  • Can be either a value array or a krpano Array with 'value' properties (the output from txtsplit).
• var1, var2, ... (when calling the txtjoin() action with 4 or more arguments)
  • The variables or values to join.

txtsplit(image.prealign, '|', rx, ry, rz);
add(ry,90);
txtjoin(image.prealign, '|', rx, ry, rz);

txtsplit('1|2|3', '|', arr);
for(set(i,0), i LT arr.count, inc(i), mul(arr[get(i)].value,2); );
txtjoin(test, '|', arr);
trace(test);

2|4|6

• var
  • The variable where to store the character.
  • The variable will be created when it doesn't exists.
• charcode
  • The Unicode character code as number.

• var
  • Without text parameter - the variable which will be escaped/unescaped.
  • With text parameter - the variable where the escaped/unescaped text will be stored.
• text (optionally)
  • The text that that will be escaped/unescaped.

• variable
  • The variable that should be changed.
  • Use the | character to specify several variables.
  • When the variable name contains the word 'color', then process the variable value as 32bit ARGB color value.
• value
  • The destination value for this variable.
  • When tweening percent values - add a '%' character to the value.
  • Use the | character to specify several values for several variables.
  • Note - to tween to the value of another variable or to the result of an expression, the get() or or calc() actions can be used.
  • Note (Object API only) - when using expressions, the special keyword this is available to access the Object itself.
• objectpath (Object API)
  • The name/path to the Object (e.g. "hotspot[spot1]" or "view").
  • If getting called from a layer or hotspot event and that layer/hotspot should be changed, then the objectpath could be skipped or the name caller be used to address it.
• object (Javascript API)
  • The Object whose properties are to be changed/tweened.
• destobject (Javascript API)
  • An Object with properties and their destination values.
  • This Object should have one or more properties that the original Object also have. The properties from the original Object will then be tweened to the given values.
• time (optionally)
  • The time in seconds for the change from the current value to the destination value (0.5 seconds by default).
  • Instead of using a fixed time for the change it is possible to define the maximum moving distance for the value and a time for that distance (not supported when tweening multiple variables). This allows to use a short time for a short distance and long time for a long distance.
    This can be done by using the distance function (non JS API only):
    
    • distance(maxdistance,maxtime)
      
      • maxdistance - the maximum distance between the start and the destination value
      • maxtime - the time in seconds for this maximum distance
• tweentype (optionally) / type (Object API)
  • The tweening / interpolation type (easeOutQuad by default).
  • See here for all available tween types: tweentypes.
  • Can also be an Object with individual tweentypes per property (Javascript API).
• ondone (optionally)
  • The action commands that should be executed when the tween is done and the destination value has been reached.
  • Instead of normal actions, it is also possible to use the special keyword WAIT here. In this case the user interface and the execution of the following actions will be blocked until the destination value has been reached. The oninterrupt action can be used to make this action interruptable by the user.
• onupdate (optionally)
  • These action will be called every time (=every frame!) when the value will be updated / changed!

tween(scale,2);

tween(rotate,90);

tween(width,50%);

onover="tween(alpha,0.7,distance(0.3,0.2));"
onout="tween(alpha,1.0,distance(0.3,0.2));"

set(alpha,0);
set(visible,true);
tween(alpha, 1.0 ,0.3);

tween(layer[logo].width, get(destwidth));

set(layer[image].enabled,false);
tween(layer[image].alpha,0.0,0.5,default,removeplugin(image));

set(view.stereographic,true);
tween(view.vlookat, 90.0, 2.0);				
tween(view.fisheye, 1.0, 2.0);
tween(view.fov, 150.0, 2.0);

tween(image.prealign, '0|90|0');

tween(view, tx=0, ty=0, tz=0, time=1.0, type=smooth);

tween(view, ath=(hotspot[test].ath), atv=(hotspot[test].atv));

tween(hotspot[test], ath=(this.ath+360), type=linear);

tween(layer[test], width=(this.width LT 100 ? 100 : 50));

krpano.tween(krpano.view, {tx:0, ty:0, tz:0}, 1.0, "linear");

var layer = krpano.addlayer();
...
krpano.tween(layer, {y:0, height:"50%"});

var obj = {a:0.0, b:"50%", color:0xFF0000};
krpano.tween(obj, {a:1.0, c:"100%", color:0x0000FF});

var obj = {x:0.0};
krpano.tween(obj, {x:1.0}, 10.0, "default", null, function()
{
  // callback for each step/change
  console.log(obj.x);
});

krpano.tween(video,
    {width:0, height:0}, 
    0.5,
    {width:"linear", height:"easeoutexpo"}
);

• variable
  • The name of the variable which is currently tweening and should be stopped.
• ... variable, variable, ... (optionally)
  • Addtional variables that should stop tweening.

• object
  • The Object whose tweening properties should be stopped.
• vars
  • A list of variable/property-names.
  • Can by either a Javascript Array with Strings,
  • or a String with names separated by ',' or '|',
  • or an Object with properties (with any values),
  • or the String * to stop all tween animations related to this Object.

ondown="tween(layer[text].y, 10, distance(400,0.7), linear);"
onup="stoptween(layer[text].y);"

• The default tween type is easeoutquad.
• All easeinout* types have one optional arguments to control the crossing between the in and out functions (0.0 to 1.0, 0.5 by default).
• These tween types also have optional arguments:
  • step(steps)
  • power(exponent,crosspoint)

• A movement in 3D space with optional motion-blurring.
• Need to be called before a loadpano/loadscene/load... call.
• Works for normal 'non-3D' panos and for Depthmapped / 3D-Model panos.
• The 3D transition will start automatically once the new pano is loaded and ready.
• When set and during the 3D transition is running, the have3dtransition variable will be true.

• ref and dx, dy, dz or h, v, d
  • The reference for the given 3D coordinates:
  • ref="image" (default)
    • For panos without Depthmapping or a 3D-Model the dx, dy, dz values are defining the 3D moving direction. The length of the 3D direction vector defines the zooming distance and should be typically between 500 and 1000.
    • For panos with Depthmapping or a 3D-Model the dx, dy, dz values are a relative offset to the image 3D position of the next pano.
  • ref="world"
    • The dx, dy, dz values are defining an absolute 3D world position.
    • Only for Depthmapped / 3D-Model panos.
  • ref="sphere"
    • The h, v, d values are defining a spherical position as direction and a distance (1000.0 by default) for zooming.
    • Only for panos without Depthmapping or a 3D-Model.
• mblur (optionally)
  • Strengh of the motion blur effect: 0.0 to 0.9.
  • The default is 0.5.
• hlookatoffset (optionally)
  • An optional offset for the horizontal looking direction (view.hlookat).
  • Can be used when the panos are not aligned together (different Norths).
  • The default is 0.0.
• delay (optionally)
  • An optional delay in seconds before starting with the 3D-transition.
  • By default or when set to 0.0, the 3D-transition starts together with the pano-blending.
• time (optionally)
  • An optional duration time in seconds for the 3D-transition.
  • By default or when set to 0.0, the time will be automatically the same that will be set in the BLEND(blendtime) parameter.
• tweentype (optionally)
  • The tweening / interpolation type for the 3D-transition movement.
  • The default is easeOutQuad.

<hotspot ... onclick="scene3dtransition('scene2');" />

<action name="scene3dtransition" scope="local" args="newscene">
    set3dtransition("sphere", caller.ath,0);
    loadscene(get(newscene), null, MERGE, BLEND(0.5) );
</action>

• loadpano - load a xml file.
• loadscene - load a <scene>.
• loadpanoscene - load a <scene> from another xml file.
• loadpanoimage - load the currently defined <image> element.
  Need to be used together with image.reset().
• loadxml - load a xml string.

• xmlpath (for loadpano)
  • The path/url of the new pano xml file to be loaded (use null for none).
  • When a relative path will be used then the file will be loaded from the basedir folder, which is %FIRSTXML% by default. That means that the paths in all loadpano calls are relative to the first loaded xml file.
• xmlstring (for loadxml)
  • The content of a xml file as string / text to be loaded (should be escaped).
• scenename (for loadscene)
  • The name of the <scene> element that should to be loaded.
• vars (optionally)
  • Custom variables to set (use null for none).
  • These variables will be set after parsing / resolving the xml but before starting to load the pano images. This way these variables can be used either to overwrite settings from the xml or to set addtional ones.
  • Variables can be defined as var1=val1 pairs separated by &amp;.
• flags (optionally)
  • Addtional flags for loading (use null for none).
  • Several flags can be combined by a | character.
  • Available flags:
    • MERGE (the recommended flag)
      
      • Merges all settings from the current and the next pano.
      • If there are layers, plugins or hotspots in the new panorama with the same name as the kept ones, the new elements will not be loaded.
      • This is the recommended setting for virtual tours.
    • PRELOAD
      • Preload the full resolution of the next pano for the current viewing range before blending to it.
      • Without that flag the blending will start as soon ANY content (e.g. the preview-pano, low-res tiles, ...) has fully filled the view.
      • Without PRELOAD flag the switching from one pano to the next pano can be much faster, so this flag should be only used in certain cases.
    • KEEPIMAGE
      • Keep the current pano-image.
      • Ignores the <image> element from the next pano.
    • KEEPVIEW
      • Keep the current view settings.
      • Except the viewing range limitations as they are more related to the pano image.
    • KEEPMOVING
      • Keep the current view and allow moving during the blending.
    • KEEPLIMITS
      • Keep the current view limitations.
      • Without that flag, the current viewing limits will be reset when loading a new pano.
    • KEEPLOOKAT
      • Keep the current looking direction (hlookat, vlookat, camroll).
    • KEEP3D
      • Keep the current 3D position (tx, ty, tz).
    • KEEPSCENES
      • Keep the current scenes (loadpano only).
    • KEEPPLUGINS
      • Keep the current loaded layers / plugins.
    • KEEPHOTSPOTS
      • Keep the current loaded hotspots.
    • NOPREVIEW
      • Skip / ignore the <preview> element of the new pano.
    • REMOVESCENES
      • Remove all current scenes.
    • ONLYSCENES
      • Load only the <scene> elements from the xml, all other xml elements will be skipped.
    • IGNOREKEEP
      • Ignore the keep="true" setting and remove also these elements.
    • IMAGEONLY
      • Load only the pano-image (and the preview).
      • Can not be used with the loadpanoscene() action.
    • IMAGEANDVIEW
      • Load only the pano-image (and the preview) and the view settings.
      • Can not be used with the loadpanoscene() action.
    • NOAUTORUN
      • Do not automatically run <action> elements with autorun="onstart".
      • Note - <action> elements with autorun="preinit" will be always called!
    • RESET
      • Resets the krpano viewer before loading the new pano.
      • Removes all current layers, hotspots, actions, events and tween-animations/timers, even when defined with keep=true.
      • Set everything back to default except: custom created variables and the current area, network, memory and security settings.
• blend (optionally)
  • Blend / Crossfade to next pano image / Transition Animation
  • Available blending modes:
    

    NOBLEND

    No blending, just switch directly to the next panorama (the default).
    
    

    BLEND(time, tweentype)

    Blend / Crossfade from current panorama to next one.
    This is also the fallback mode when the selected mode is not supported!
    
    Parameters:

    • time - The blending time in seconds (default=2.0).
    • tweentype - The blending curve / motion shape, type of the blending animation (default=easeInCubic) - see tweentypes.
    
    

    (WebGL only)COLORBLEND(time, color, tweentype)

    Blend to a color and then from that color to the next panorama.
    
    Parameters:

    • time - The blending time in seconds (default=2.0).
    • color - The in-between color in hex format (default=0x000000 = black).
    • tweentype - The blending curve / motion shape, type of the blending animation (default=easeOutSine) - see tweentypes.
    
    

    (WebGL only)LIGHTBLEND(time, color, colorscale, tweentype)

    Add or subtract a color and then cross-fade to the next panorama.
    
    Parameters:

    • time - The blending time in seconds (default=2.0).
    • color - The color to add in hex format (default=0xFFFFFF = white).
    • colorscale - The scaling factor of the color, use negative values for subtracting (default=2.0).
    • tweentype - The blending curve / motion shape, type of the blending animation (default=easeInCubic) - see tweentypes.
    
    

    (WebGL only)SLIDEBLEND(time, angle, smooth, tweentype)

    A slide animation between the current and the next panorama.
    
    Parameters:

    • time - The blending time in seconds (default=2.0).
    • angle - The angle / direction of the slide in degrees (default=0.0).
    • smooth - The smoothing / blurring of the transition line (0.0 to 1.0, default=0.2).
    • tweentype - The blending curve / motion shape, type of the blending animation (default=linear) - see tweentypes.
    
    

    (WebGL only)OPENBLEND(time, shape, smooth, zoom, tweentype)

    An opening animation between the current and the next panorama.
    
    Parameters:

    • time - The blending time in seconds (default=2.0).
    • shape - A factor that defines the opening shape (-1.0 to +1.0) - 0.0=circle opening, -1.0=vertical opening, +1.0=horizontal opening (default=0.0).
    • smooth - The smoothing / blurring of the transition line (0.0 to 1.0, default=0.2).
    • zoom - Additionally zoom-out the old panorama (0.0 to 1.0, default=0.0).
    • tweentype - The blending curve / motion shape, type of the blending animation (default=linear) - see tweentypes.
    
    

    (WebGL only)ZOOMBLEND(time, zoom, tweentype)
    ZOOMBLEND(time, zoom, x, y, tweentype)

    Zoom into the current view and cross-fade to the next panorama.
    
    Parameters:

    • time - The blending time in seconds (default=2.0).
    • zoom - The zoom factor (default=2.0).
    • x, y - The zoom center (0.0 to 1.0, default=0.5).
    • tweentype - The blending curve / motion shape, type of the blending animation (default=easeInOutSine) - see tweentypes.
    
    DEMO: Pano Blending Demo
    
    Note - When the selected blending mode will be not supported, e.g. when using a transparent background or when using a 'WebGL only' mode and only CSS3D is available, then automatically the BLEND() mode will be used instead.
    
• loaddone (optionally)
  • Actions code or a Javascript function to call when the loading is done.
• loaderror (optionally)
  • Actions code or a Javascript function to call when the loading failed.
  • When not set or set to null, the error will be either handled by the onxmlerror event or show a fatal-error message.

• blend (optionally)
  • Optional loadpano blending settings.
  • The default is NOBLEND.
• flags (optionally)
  • Additional loadpano flags.
  • Flags that could be used here: PRELOAD, KEEPMOVING and NOPREVIEW.

• options (optionally)
  • When options is set to copy then all basic settings from the current <image> element are copied to the new one.

• url
  • The url of the xml file to load and include.
• string
  • The xml code to include as string.
• loaddone (optionally)
  • Actions code or a Javascript function to call when the loading is done.
• loaderror (optionally)
  • Actions code or a Javascript function to call when the loading failed.
  • When not set or set to null, the error will be either handled by the onxmlerror event or show a fatal-error message.
• autorunactions (optionally)
  • Automatically run <action> elements with autorun="onstart".
  • The default is true, use false to disable the automatic action running.
  • Note - <action> elements with autorun="preinit" will be always called!

• url
  • The url of the js file to load and execute.
  • Different to Javascript files loaded directly by the browser (using <script> in the HTML code), these js files can be encrypted using the krpano tools.
  • Optionally it is also possible to load several js files at once. For this the urls need to be separated by a pipe | character. The file loading will be done in parallel but the resulting Javascript code execution will be done when all files are loaded and in the same order as the files were requested. Example:
    

    loadjs('file1.js|file2.js|file3.js');

    When called directly from Javascript it is also possible to pass the files as Array:

    krpano.actions.loadjs(['file1.js','file2.js','file3.js']);

• loaddone (optionally)
  • Actions code or a Javascript function to call when the loading is done.
• loaderror (optionally)
  • Actions code or a Javascript function to call when the loading failed.
  • When not set or set to null, the error will be either handled by the onxmlerror event or show a fatal-error message.

• url
  • The url to open.
• target (optionally)
  • The target where the url should be opened.
  • Possible settings:
    • _blank - open the url in a new window (the default)
    • _self - open the url in the current frame in the current window
    • _parent - open the url in the parent of the current frame
    • _top - open the url in the top-level frame in the current window

openurl('https://krpano.com',_self);

openurl('help.html');

• h / v (lookat)
  • The horizontal and vertical looking direction (view.hlookat / view.vlookat) in spherical coordinates in degrees (-180 to +180 and -90 to +90).
• x / y / z (lookat3d)
  • The 3D-position to look at from the current 3D-position.
• fov (optionally)
  • The field of view (view.fov) in degrees (0 - 179).
• distortion (optionally)
  • The fisheye distortion setting (view.distortion).
• architectural (optionally)
  • The architectural projection setting (view.architectural).
• pannini (optionally)
  • The pannini projection setting (view.pannini).

lookat(0,0);

lookat(0,0,90);

loadpano(pano.xml);
lookat(45.1, -20.2, 110.0);

• h / v (lookto, moveto)
  • The horizontal and vertical looking direction (view.hlookat / view.vlookat) in spherical coordinates in degrees (-180 to +180, wraparound possible and -90 to +90).
• x / y / z (lookto3d)
  • The 3D-position to look to from the current 3D-position.
• hotspotname (for looktohotspot, optionally)
  • The name of the hotspot.
  • This will be use the hotspot position (ath/atv) as destination position.
  • When no name will be defined and looktohotspot() will be called from a hotspot element then that hotspot itself will be used.
• fov (optionally)
  • The destination fov (0 to 179).
  • The looktohotspot action will use automatically the size of the hotspot as destination fov when the fov was not set. The other actions keep the current fov when not set.
    
• motiontype (optionally)
  • The type of the motion.
  • Possible settings:
    • linear(speed) - a linear motion
      • speed = moving speed in degrees/second
        
    • smooth(accel,break,maxspeed) - accelerated smooth movement (=default)
      • accel = acceleration in degrees/second² (default=720)
      • break = negative acceleration in degrees/second² (default=-720)
      • maxspeed = maximum moving speed in degrees/second (default=720)
    • tween(tweentype,time) - tween animation curve
      • tweentype = one of the tween types
      • time = time in seconds for the movement
• shortestway (optionally)
  • The use the shortest possible way from the current to the destination position.
  • Possible settings: true or false (default=true).
• nonblocking (optionally, lookto only)
  • When set to true, then the lookto action will not wait for completing the movement before continue executing the the following actions. The user-interface will also be not blocked.
  • When the lookto movement is done then the ondone action will be called (when defined).
  • To stop/interrupt a lookto animation, the stoplookto() action can be anytime called.
• ondone (optionally, lookto only, only when nonblocking is true)
  • This action will be called when the nonblocking lookto movement is done.

moveto(100.0,5,linear(10));

zoomto(130,smooth());

lookto(33,-22,30,smooth(100,50,20));

looktohotspot(hotspot1);

looktohotspot(hotspot2, 40);

looktohotspot(hotspot3, 25, smooth(100,50,20));

looktohotspot(get(name));

• desthlookat
  • The intended destination hlookat value.
  • When desthlookat is the name of a variable, then automatically the value of that variable will be used.
  • The current view.hlookat variable will be adjusted (without changing the current view) to be next to this value.

adjusthlookat(140);
tween(view.hlookat, 140);

• source_ath
  • The source/start ath value.
  • source_ath needs to be the name of a variable.
• target_ath
  • The intended target/destination ath value.
  • When desthlookat is the name of a variable, then automatically the value of that variable will be used.

adjust360(hotspot[test].ath, view.hlookat);
tween(hotspot[test].ath, get(view.hlookat), 1.0);

• result
  • The name of the variable where the distance value will be stored.
  • The variable will be created when it doesn't exists.
  • When calling this function directly by Javascript, the result parameter can be null, the result will be returned as Javascript return value in this case.
• toH
  • Horizontal looking-to position (-180 to +180, wraparound possible).
  • Can be a variable name or a value.
• toV
  • Vertical looking-to position (-90 to +90).
  • Can be a variable name or a value.
• fromH (optionally)
  • Horizontal looking-from position (-180 to +180, wraparound possible).
  • Can be a variable name or a value.
  • When not defined, the current horizontal looking direction (view.hlookat) will be used by default.
• fromV (optionally)
  • Vertical looking-from position (-90 to +90).
  • Can be a variable name or a value.
  • When not defined, the current vertical looking direction (view.vlookat) will be used by default.

• parameter
  
  • any number - this the time the action will wait in seconds
  • LOAD - wait until loading is finished
  • BLEND - wait until loading and blending are finished

oninterrupt(break);
lookto(150,30,70);
wait(3);
lookto(242,0,150);
lookto(280,-10,50);
wait(3);

loadpano(pano2.xml,null,MERGE,BLEND(2));
lookat(100,50,5);
wait(BLEND);
lookto(100,50,150);

• actions
  
  • The action commands to call on a user interrupt.
  • Addtionally there is a special command possible here:
    break - this will just break the current actions.

oninterrupt(break);
lookto(150,30,70);
wait(3);
lookto(242,0,150);
lookto(280,-10,50);
wait(3);

oninterrupt( trace(user interrupt); );
lookto(0,0,90);			
lookto(90,0,90);
lookto(180,0,90);
lookto(270,0,90);
lookto(0,0,90);

• x / y - Screen coordinates in pixels from the left top edge.
• h / v - Spherical coordinates in degrees.
• stereoside (optionally)
  For stereo rendering - define to which screen side the coordinates should be mapped. Possible settings: l for the left side or r for right side or not-set/undefined for normal non-stereo screen coordinates.

• p - An object with x, y properties.

• When the given spherical coordinates can't be converted to screen coordinates, e.g. when 'behind' the screen, then the resulting values will be NaN (Not-a-Number). The Javascript call will return null in this case.

screentosphere(mouse.x, mouse.y, toh, tov);

• layer - The name of the <layer> element or the <layer> element itself.
• screenx / screenx - Screen/stage coordinates in pixels from the left top edge.
• layerx / layery - Layer coordinates from the left top layer edge.

• p - An object with x, y properties.

• The screen /stage coordinates are based on the krpano coordinate system (from left-top 0 / 0 to right-bottom stagewidth / stageheight).
• The layer coordinates will be scaled when scalechildren is enabled.
• Rotated layers are not supported!

screentolayer(bar, mouse.stagex,mouse.stagey, lx,ly);
div(fill, lx, layer[bar].pixelwidth);
mul(fill, 100);
clamp(fill, 0, 100);
txtadd(layer[barfill].width, get(fill), '%');

• h / v - Spherical coordinates in degrees.
• depth - Distance from spherical center (1000.0 by default).
• x / y / z - 3D space coordinates.

• spheretospace: p - An object with x, y, z properties.
• spacetosphere: p - An object with h, v, depth properties.

spheretospace(ath,atv,depth, tx,ty,tz);
set(ath,0);
set(atv,0);
set(depth,0);

spacetosphere(tx,ty,tz, ath,atv,depth);
set(tx,0);
set(ty,0);
set(tz,0);

• fov
  • A variable with the fov value that should be changed.
  • The result will be stored in the same variable.
• srcfovtype
  • The current fovtype.
  • Can be: HFOV, VFOV, DFOV or MFOV.
• dstfovtype
  • The new fovtype.
  • Can be: HFOV, VFOV, DFOV or MFOV.
• width (optionally)
  • The width of the fov area/frame in pixels.
  • By default the current screen/area size will be used.
• height (optionally)
  • The height of the fov area/frame in pixels.
  • By default the current screen/area size will be used.

set(view.fovtype, HFOV);
set(view.fov, 90);
...
set(view.fovtype, VFOV);
remapfovtype(view.fov, HFOV, VFOV);

• sx / sy (screenraycast)
  • Screen coordinates in pixels from the left top edge.
• x / y / z (raycast)
  • World-space 3D origin coordinates of the ray.
  • For using the current viewing position use view.tx, view.ty, view.tz.
• dx / dy / dz (raycast)
  • 3D direction vector of the ray.
  • For using the current viewing direction use view.dir.x, view.dir.y, view.dir.z.
• hit
  • An object with several properties about the result.
  • When there is no depth/3d-information at the requested point, it will be null.
  • Properties:
    • d - distance/depth from the screen to the point.
    • x,y,z - the worldspace x,y,z 3D coordinates of the hit-point (in cm).
    • nx,ny,nz - the normal vector of the hit-surface.
    • rx,ry,rz - rotation angles (in degrees) that match the hit-surface (in "zxy" rotation-order - note: that's not the default one for hotspots).
    • hs - a hotspot object (only when a hotspot with hittest=true will be hit).
  • Note - the performance and accuracy of the results depends on the the depthmap.hittestmode settings.
  • Javascript usage notes: when called by Javascript the hit object will be returned directly, no parameter for a krpano variable need to be passed.

raycast(view.tx, view.ty, view.tz, view.dir.x, view.dir.y, view.dir.z, hit);
if(hit,
  trace('distance to wall:', hit.d, 'cm');
);

screenraycast(mouse.x, mouse.y, hit);
if(hit,
  copy(hs.tx, hit.x);
  copy(hs.ty, hit.y);
  copy(hs.tz, hit.z);
  copy(hs.rx, hit.rx);
  copy(hs.ry, hit.ry);
  copy(hs.rz, hit.rz);
);

• Request a redraw.
• Can be used when changing settings that don't cause a redraw by its own.

• name
  • Name of the new layer/plugin or hotspot element.
  • When no name is given or auto is used as name, then an automatic-generated name will be used.
  • When there is already an element with the given name, no new element will be created, instead the current one will be returned.
• varname (optionally)
  
  • Create a variable with the given name linked to the new added element.
• renderer (optionally)
  
  • Set the hotspot renderer setting directly on creation.
  • This can avoid the temporary unnecessary and creation of a HTML element (for CSS3D-hotspots) when actually a WebGL-hotspot is desired.

• The new added element.

• Layers and plugins are the same, just different names.

addlayer(button);
set(layer[button].url,button.jpg);
set(layer[button].align,bottom);
set(layer[button].x,10);
set(layer[button].y,20);
set(layer[button].onhover,showtext('hovering the new button'));
set(layer[button].onclick, removelayer(button) );

addhotspot(newspot);
set(hotspot[newspot].url,spot.png);
set(hotspot[newspot].ath,150);
set(hotspot[newspot].atv,30);
set(hotspot[newspot].scale,0.7);
set(hotspot[newspot].zoom,true);
set(hotspot[newspot].onclick, removehotspot(newspot) );

addhotspot(polyspot);
set(hotspot[polyspot].fillalpha, 0.25);
set(hotspot[polyspot].borderalpha, 0.50);
set(hotspot[polyspot].onclick, removehotspot(polyspot) );
set(hotspot[polyspot].point[0].ath,-10);
set(hotspot[polyspot].point[0].atv,-10);
set(hotspot[polyspot].point[1].ath,-10);
set(hotspot[polyspot].point[1].atv,+10);
set(hotspot[polyspot].point[2].ath,+10);
set(hotspot[polyspot].point[2].atv,+10);
set(hotspot[polyspot].point[3].ath,+10);
set(hotspot[polyspot].point[3].atv,-10);

addlayer('background_layer', bg);
bg.loadstyle('design1');
set(bg.bgcolor, 0x777777);

• name
  • Name of the layer/plugin or hotspot element that should be removed.
• removechildren (optionally)
  
  • When set to true, all children elements will be removed too.

layer[name].remove()
hotspot[name].remove()

• krpano
  • The krpano Interface object (allows additionally also direct Javascript access to all whole krpano structure and all functions there).
• caller - the object of the <layer>, <plugin> or <hotspot> element that has called that action.

jscall('document.getElementById("test").style.display="none";');

jscall(calc('console.log("krpano version: ' + version + '")'));

jscall('history.back()');

• krpano
  • The krpano Interface object (allows additionally also direct Javascript access to all whole krpano structure and all functions there).
• caller - the object of the <layer>, <plugin> or <hotspot> element that has called that action.

• variable
  • The name of krpano variable where the returned value will be stored.
  • The variable will be created when it doesn't exist.
• Javascript code
  • The Javascript code to call.
• noerror (optionally)
  
  • When set to true, no error will be rerported on errors and undefined be returned.

jsget(ret, 'location.href');
trace('location=', get(ret));

jsget(passwort, 'prompt("Enter Password")');
if(password == 'hidden', ...);

jsget(date, 'new Date().toISOString().slice(0,10);');
trace('date=', get(date));

• krpano
  • The krpano Interface object (allows additionally also direct Javascript access to all whole krpano structure and all functions there).
• caller - the object of the <layer>, <plugin> or <hotspot> element that has called that action.

onclick="js:alert(caller.path);"

onclick="js:krpano.actions.lookto(0,0);"

• styles
  • A string with CSS styles/classes.

• state (optionally)
  
  • true - Show the log window (default).
  • false - Hide the log window.
  • toggle - Show or hide the log window depending on the current state.
• position (optionally)
  
  • top - Show the log at the top of the viewer window.
  • bottom - Show the log at the bottom of the viewer window (default).

• debug() will trace DEBUG: messages.
  These messages will be only shown when the debugmode setting is enabled.
• trace() will trace INFO: messages.
• warning() will trace WARNING: messages.
• error() will trace ERROR: messages and additionally also open the log (only when showerrors is enabled).

• ...
  • Any text or variable.
  • When passing a variable, then that variable will be automatically resolved to its value.
• Special parameter values:

  • [HTML] ...

    When the text starts with [HTML] then the following text can be HTML-code, but where the < and > characters need to be replaced with [ and ].

  • [OW] ...

    The line will be 'overwriteable' - that means the next trace will overwrite / replace that line.

  • [CLEARLOG]

    Clears the log.

  • [MAXLINES=NN]

    Defines the maximum lines to log, the default is 200.

trace('view.maxpixelzoom=', view.maxpixelzoom);

<events onkeydown="trace('keycode=',keycode);" />

onresize="trace('size=',stagewidth,'x',stageheight);"

onclick="trace('mouse clicked at ', mouse.x, ' / ', mouse.y);"

trace('xyz=',xyz,' get(xyz)=',get(xyz));

• errormessage
  • The error message to show.

• This could be used to temporary hide errors or warnings for certain special cases.
• Only 'direct' errors can be suppressed, but not 'delayed' errors like loading errors.

• actions
  • Any krpano action code.