->
   
 
Stack name: Name
base/stack

Stack contains C cards.
Stack contains B backgrounds.

Size of stack: 67 K

Card size: ↔512342
Card Name: name
Card number: 1
Card ID: 1





Name: name
Background ID: 1
Background shared by N cards.

Contains N background fields.
Contains N background buttons.




Button Name: Name
CardBkgnd button number: 1
CardBkgnd part number: 1
CardBkgnd button ID: 1
Transparent
Opaque
Rectangle
Round Rect
Shadow
Checkbox
Radio Button
Standard
Default
Oval
Popup

None
1
2
3
4
5

Preview





 
Field name: name
CardBkgnd field number: 1
CardBkgnd part number: 1
CardBkgnd field ID: 1
Transparent
Opaque
Rectangle
Shadow
Scrolling










Preview
Username
Password

Create new stack...
Open “A Stack”
Open “A Stack”
Open “A Stack”
Undo
Redo
Log In / Register...
Log Out...
Import Stack...
Export Stack
Show Message Box
Reveal Javascript
Full Screen Mode
Reload Page
  🍪  
{ }
<statement>
answer <expression>alert(<expression>);
ask <expression> with <expression>_.it=(prompt(<expression>,<expression>)||'');
ask <expression>_.it=(confirm(<expression>)?'OK':'Cancel');
go [to] first [card|cd] wildcard.stackOf(this.me).card = wildcard.stackOf(this.me).firstCard;
| go [to] {prev|previous} [card|cd] wildcard.stackOf(this.me).card = wildcard.stackOf(this.me).prevCard;
| go [to] next [card|cd] wildcard.stackOf(this.me).card = wildcard.stackOf(this.me).nextCard;
| go [to] {card|cd} id <value> wildcard.stackOf(this.me).card = wildcard.stackOf(this.me).qs('card-part[id=\"'+number(<value>)+'\"]');
| go [to] {card|cd} <value> wildcard.stackOf(this.me).card = (typeof <value>==='number') ? wildcard.stackOf(this.me).qsa('card-part')[number(<value>)-1] : wildcard.stackOf(this.me).qs('card-part[name="'+<value>+'"]');
| go [to] home top_stackList(stackcontainer.qs('modal-dialog[ID="1"]'));
get <expression>_.it = <expression>;
put <expression> into <part>
| set <part> to <expression>
<part>.contents = <expression>;
put <expression> after <part><part>.contents += <expression>;
put <expression> into <variable>
| set <variable> to <expression>
_.<variable> = <expression>;
set my <property> to <expression>this.me.<property> = <expression>;
set [the] <property> of <part> to <expression><part>.<property> = <expression>;
send <message> <expressionList> to <part>Script.Send(<part>,'<message>',<expressionList>);
enable <part><part>.enabled = true;
disable <part><part>.enabled = false;
hide <part><part>.visible = false;
show <part><part>.visible = true;
{ visual | play | flash | choose | type } [<extratext>]null;
<message> <expressionList>(this.<message>)(<expressionList>);
<command>
if <expression> then <scriptLine>if (<expression>) { <scriptLine> }
if <expression> thenif (<expression>) {
else} else {
end if}
repeat while <expression>while (<expression>) {
repeat until <expression>while (!(<expression>)) {
repeat with <variable> = <expression> to <expression>for (_.<variable>=<expression>; _.<variable> <= <expression>; _.<variable>++) {
repeat with <variable> = <expression> down to <expression>for (_.<variable>=<expression>; _.<variable> >= <expression>; _.<variable>--) {
repeat <expression>for (var _.n=1; _.n <= <expression>; _.n++) {
repeat [ forever ]while(1) {
next repeatcontinue;
exit repeatbreak;
end repeat}
return <expression>return <expression>;
returnreturn null;
<expression>
<expression> or <expression>boolean(<expression>) || boolean(<expression>)
<expression> and <expression>boolean(<expression>) && boolean(<expression>)
<expression> { is not | ≠ | <> } <expression><expression> != <expression>
| <expression> { is | equals | = } <expression><expression> == <expression>
<expression> { <= | ≤ | is less [than] or equal to } <expression>number(<expression>) <= number(<expression>)
| <expression> { < | is less than } <expression>number(<expression>) < number(<expression>)
| <expression> { >= | ≥ | is more [than] or equal to } <expression>number(<expression>) >= number(<expression>)
| <expression> { > | is more than } <expression>number(<expression>) > number(<expression>)
<expression> & <expression>[<expression>, <expression>].join('')
| <expression> && <expression>[<expression>, <expression>].join(' ')
<expression> { plus | + } <expression>number(<expression>) + number(<expression>)
| <expression> { minus | <hyphen> } <expression>number(<expression>) - number(<expression>)
<expression> { times | * } <expression>number(<expression>) * number(<expression>)
| <expression> { divided by | / } <expression>number(<expression>) / number(<expression>)
| <expression> div <expression>Math.floor( number(<expression>) / number(<expression>) )
| <expression> mod <expression>number(<expression>) % number(<expression>)
<exponent>
<value>
<value>
<number> | <string> | true | false
<message>(<expressionList>)this.<message>(<expressionList>)
[the] <property> of <part><part>.<property>
my <property>this.me.<property>
the result_.the_result
[the] <message> of <value>this.<message>(<value>)
the <identifier>wildcard.<identifier>
item <expression> {of|in} <value>String(<value>).split(_.comma)[<expression>-1]
word <expression> {of|in} <value>('* '+<value>).split(/[^\S\n]+/)[<expression>]
line <expression> {of|in} <value>String(<value>).split(_.return)[<expression>-1]
<hyphen><value>(0 - number(<value>))
not <value>!boolean(<value>)
<part><part>.contents
<variable>_.<variable>
(<expression>)(<expression>)
<part>
methis.me
this stackwildcard.stackOf(this.me)
this {card|cd}wildcard.stackOf(this.me).card
[the] next [card|cd] wildcard.stackOf(this.me).nextCard
[the] {prev|previous} [card|cd] wildcard.stackOf(this.me).prevCard
this {background|bkgnd|bg}wildcard.stackOf(this.me).background
{button|btn} <number> of <part><part>.qsa('button-part')[<number>-1]
{card|cd} {button|btn} <number>wildcard.stackOf(this.me).card.qsa('button-part')[<number>-1]
[background|bkgnd|bg] {button|btn} <number>wildcard.stackOf(this.me).background.qsa('button-part')[<number>-1]
{field|fld} <number> of <part><part>.qsa('field-part')[<number>-1]
{card|cd} {field|fld} <number>wildcard.stackOf(this.me).card.qsa('field-part')[<number>-1]
[background|bkgnd|bg] {field|fld} <number>wildcard.stackOf(this.me).background.qsa('field-part')[<number>-1]
other tokens:
<scriptLine> = { <command> | <statement> }
<expressionList> = [ <expression> [, <expression> ]* ]
<parameterList> = [ <parameter> [, <parameter> ]* ]
<message> | <variable> | <property> = <identifier>
<exponent> = <value>^<exponent>Math.pow(<value>, <exponent>)
<exponent> = <value>^<value>Math.pow(<value>, <value>)
<identifier> /[A-Z][A-Z\d]*/i
<number> /[\d]+([.][\d]+)?/
<string> /"[^"]*"/
handlers for script messages, in parts, cards, backgrounds, stacks, or WildCard
on <message> <parameterList>function <message>(<parameterList>) {
    [ <scriptLine> ]*
end <message> }
messages are sent to everything
<message> = mouseDown, mouseStillDown, mouseUp, openField, closeField, openCard, and anything else you write
The targets can catch them in script handlers. If not caught they get sent down the message path to their containing cards and backgrounds, and then the stack may catch them. Handlers can respond to both user-generated messages as well as ones you call yourself.
-- These handlers are available to any WildCard script. -- Handlers accept parameters and can return a value on square y return y times y end square -- You can use JavaScript in handlers function sqrt n return Math.sqrt(n); end sqrt function random n return Math.floor(Math.random()*n) + 1; end random function date return Date(); end date -- Send messages from Javascript with wildcard.do('beep') or just wildcard.Beep(); on do lineOfScript put "on run" & return & lineOfScript & return & "end run" into handler return new Script(null, _.handler).run(); end do function value scriptExpression put "on run" & return & "return" && scriptExpression & return & "end run" into handler return new Script(null, _.handler).run(); end value on put message put_into_messagebox(message, true); end put on beep count for (var i=1; (count||1)>=i; i++) setTimeout(perform_system_beep,350*(i-1)); end beep on help go home go to card "What was HyperCard?" end help
Thank you Bill Atkinson and others for inspiration. HyperCard was/is software under Apple's copyright and this is just a pretty good homage.

©2022 by Hypervariety Custom Software