case
FORMULA

The case statement allows multiple decisions to be chained together (also see the elseif statement).

Parameters

This statement has one parameter:

formula – is a formula that decides whether or not to execute the following statements. The result of this formula must be a Boolean (true/false) value.

Description

The case statement is designed to be used in groups. Each group begins with a case statement and ends with an endcase statement, there may be multiple case statements in between. There may also be a single defaultcase statement after the last case statement and before the endcase statement. The general arrangement should look something like this:

``````case (is formula 1 true?)
perform option 1
case (is formula 2 true?)
perform option 2
case (is formula 3 true?)
perform option 3
endcase
``````

When Panorama is running a procedure and encounters a group of case statements, it starts from the top of the group and checks whether or not the first formula is true. If not, it skips to the next case statement, continuing until it finds a true formula (if any). When it finds a true formula, it executes the statements after the case statement, continuing up until the next case statement, or until a defaultcase or endcase statement. It then jumps past the endcase statement and continues executing statements from there.

If none of the case formulas is true, Panorama will jump past the endcase statement and continues executing statements from there. Or, if there is a defaultcase statement, Panorama will jump to that.

If more than one case formula is true, only the first one encountered will be executed. In fact, once Panorama finds a true formula, it skips all of the other case statements in the group.

This example assigns a dollar amount to the field Rate based on the chosen shipper.

``````case Shipby = "UPS Ground"
Rate = 5.00
case Shipby = "UPS Blue"
Rate = 7.50
case Shipby = "UPS Red"
Rate = 10.00
case Shipby = "Fed-ex standard"
Rate = 12.00
case Shipby = "Fed-ex overnight"
Rate = 18.00
case Shipby = "Fed-ex overnight Saturday"
Rate = 25.00
defaultcase
Rate = 4.50
endcase
``````

The next example illustrates the possibility of multiple true formulas. If Sales is 650, all three of these formulas will be true. However, the award will be Gold since this is the first true formula. Since the first case is true, the following cases (Silver and Bronze) are all skipped.

``````case Sales > 500
award = "Gold"
case Sales > 250
award = "Silver"
case Sales > 100
award = "Bronze"
endcase
``````

It’s important to get the order right. In the following example, it would be impossible to get Gold or Silver awards.

``````case Sales > 100
award = "Bronze"
case Sales > 250
award = "Silver"
case Sales > 500
award = "Gold"
endcase
``````

#### Case vs. If/ElseIf

An alternative to a group of case statements is to use the if, elseif, else and endif statements. Here’s the first example above rewritten to use these statements.

``````if Shipby = "UPS Ground"
Rate = 5.00
elseif Shipby = "UPS Blue"
Rate = 7.50
elseif Shipby = "UPS Red"
Rate = 10.00
elseif Shipby = "Fed-ex standard"
Rate = 12.00
elseif Shipby = "Fed-ex overnight"
Rate = 18.00
elseif Shipby = "Fed-ex overnight Saturday"
Rate = 25.00
else
Rate = 4.50
endif
``````

An advantage to using if/elseif/endif is that these statements can be nested – case statements cannot be nested. Here this example has been rewritten to group each shipping company into a group.

``````if Shipby beginswith "UPS"
if Shipby endswith "Red"
Rate = 10.00
elseif Shipby = "UPS Blue"
Rate = 7.50
else
Rate = 5.00
endif
elseif Shipby beginswith "Fed-ex"
if Shipby endswith "Saturday"
Rate = 25.00
elseif Shipby endswith "overnight"
Rate = 18.00
else
Rate = 12.00
endif
else
Rate = 4.50
endif
``````

In this particular example it’s probably better not to nest the options, but in some cases this can be much clearer.

• call -- allows a procedure to call a separate procedure within the current database as a subroutine.
• call( -- allows a procedure to be called as a subroutine within a formula and return a result.
• calledby( -- returns true if this function is in code called by the specified database, the specified procedure, or both.
• callerslocalvariablevalue( -- allows a subroutine to access a local variable in the procedure that called it.
• callingdatabase( -- returns the name of the database that called this procedure as a subroutine, if any.
• callingprocedure( -- returns the name of the procedure that called this procedure as a subroutine, if any.
• callwithin -- allows a procedure to call a mini-procedure within a separate procedure within the current database as a subroutine.
• callwithin( -- allows a "mini-procedure" to be called as a subroutine within a formula and return a result.
• callwithindatabase( -- returns true if the current procedure was called by another procedure in the same database, false if it was called by a procedure in another database.
• catch -- works with try and endcatch to trap errors in a sequence of statements.
• Custom Database Initialization -- using an .Initialize procedure to automatically run custom code when a database opens.
• debug -- stops the current program, allowing you to examine variables or single step.
• defaultcase -- works together with the case statement to specify statements that will be executed if none of the *case* statements are true.
• disableabort -- prevents loops from being stopped early by pressing SHIFT-COMMAND-ESCAPE or by exceeding the maximum allowed loop time.
• else -- works together with the if statement to specify statements that will be executed for both the *true* and *false* cases.
• elseif -- allows multiple if decisions to be chained together.
• enableabort -- allows the SHIFT-COMMAND-ESCAPE key sequence to stop an endless loop.
• endcase -- marks the end of statements controlled by a previoius case statement.
• endcatch -- works with try and catch to trap errors in a sequence of statements.
• endif -- marks the end of statements controlled by a previoius if statement.
• endloop -- is used at the end of a loop.
• Error Handling -- Techniques for trapping runtime errors instead of letting them abort the program.
• Error Wizard -- Advanced dialog for displaying program errors.
• execute -- allows a procedure to call a sequence of statements within the current procedure as a "mini-subroutine".
• execute( -- allows a formula to execute a sequence of statements and return a result.
• executeasap -- executes the specified code at the first possible opportunity, non-atomically.
• executecatcherrors -- is the same as the execute statement, except for the fact that if an error occurs while running, it can be trapped by an if error statement immediately following the executecatcherrors statement.
• executelocal -- is the same as the execute statement, but it shares local variables with the procedure that called it.
• farcall -- allows a procedure to call a separate procedure within a different database as a subroutine.
• farcallwithin -- allows a procedure to call a mini-procedure within a separate procedure in a different database as a subroutine.
• for -- is used at the beginning of a loop that loops a fixed number of times.
• goto -- allows a procedure to arbitrarily jump from one spot to another within the procedure.
• if -- decides what code to execute next.
• info("callerslocalvariables") -- returns a list of local variables defined in the procedure that called the current procedure.
• info("error") -- returns the most recent error message.
• info("labels") -- lists the labels in the current procedure.
• info("procedurestack") -- returns the contents of Panorama's procedure call stack.
• loop -- is used at the beginning of a loop.
• looparray -- is used at the beginning of a loop that loops over the elements of an array.
• loopdataarray -- is used at the beginning of a loop that loops over the elements of a data array.
• loopindex -- allows a procedure to determine how many times a loop has been repeated.
• loopwhile -- is used at the beginning of a loop.
• noimplicitassignment -- does nothing, and is only retained for compatibility with earlier versions.
• nop -- does nothing (**n**o **op**eration).
• onerror -- can be used to catch all errors that are not trapped by if error or try statements.
• onfailedresume -- is used to setup a semi-graceful recovery if a resume statement fails because there was no pause statement.
• parameter( -- is used to transfer data between a main procedure and a subroutine.
• pause -- temporarily pauses a procedure.
• Preventing Endless Loops -- setting up a timeout limit to prevent endless loops.
• quit -- quits Panorama.
• repeatloopif -- decides whether to continue with a loop or to start over again from the top.
• resume -- resumes a procedure that has been temporarily halted with the pause statement.
• return -- ends a subroutine.
• returnerror -- passes an error back to the current subroutines calling procedure.
• setcallerslocal -- allows a subroutine to modify a local variable in the procedure that called it.
• seterror -- changes the error message returned by info("error").
• setparameter -- is used to transfer data from a subroutine back to the main procedure that called it.
• setwaitinglocal -- assigns a value to a local variable in the parent procedure of an asynchronous task, allowing the asynchronouse code to pass a value back to the code that spawned it.
• shortcall -- allows a procedure to call a sequence of statements within the current procedure as a "mini-subroutine".
• stop -- stops all running procedures immediately.
• stoploopif -- decides whether to continue with a loop or to exit the loop immediately.
• throwerror -- causes an immediate error.
• try -- works with catch and endcatch to trap errors in a sequence of statements.
• until -- is used at the end of a loop, and can control how many times the loop is executed.
• usecallerslocalvariables -- temporarily swaps out a subroutine's current local variables with the local variables of the procedure that called this subroutine. The statement can be used only in a subroutine, not in a calling procedure.
• usefunctioncallerslocalvariables -- temporarily swaps out a procedures current local variables with the local variables of the procedure that called this the call(, callwithin( or execute( function.
• usemylocalvariables -- reverses the action of the UseCallersLocalVariables statement, switching back to the current procedure's normal local variables.
• waitfortask -- temporarily pauses a procedure until the specified task is complete.
• while -- is used at the end of a loop, and can control how many times the loop is executed.

History

 Version Status Notes 10.0 Updated Carried over from Panorama 6.0, but no longer limited to 75 case statements per group.