Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:37
📄 CREDITS CREDITS ======= eZ Components team ------------------ - Sergey Alexeev - Sebastian Bergmann - Jan Borsodi - Raymond Bosman - Frederik Holljen - Kore Nordmann - Derick Rethans - Vadym Savchuk - Tobias Schlitt - Alexandru Stanoi	229 B	2024-07-17 10:18
📄 LICENSE eZ Components Licence ===================== New BSD Licence --------------- Copyright (c) 2005-2008, eZ Systems A.S. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of eZ Systems A.S. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	1.53 KB	2024-07-17 10:18
📄 example_input.php <?php /** * Example for the usage of ezcConsoleParameter class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className */ function __autoload( $className ) { ezcBase::autoload( $className ); } $optionHandler = new ezcConsoleInput(); // Register simple parameter -h/--help $optionHandler->registerOption( new ezcConsoleOption( 'h', 'help' ) ); // Register complex parameter -f/--file $file = new ezcConsoleOption( 'f', 'file', ezcConsoleInput::TYPE_STRING, null, false, 'Process a file.', 'Processes a single file.' ); $optionHandler->registerOption( $file ); // Manipulate parameter -f/--file after registration $file->multiple = true; // Register another complex parameter that depends on -f and excludes -h $dir = new ezcConsoleOption( 'd', 'dir', ezcConsoleInput::TYPE_STRING, null, true, 'Process a directory.', 'Processes a complete directory.', array( new ezcConsoleOptionRule( $optionHandler->getOption( 'f' ) ) ), array( new ezcConsoleOptionRule( $optionHandler->getOption( 'h' ) ) ) ); $optionHandler->registerOption( $dir ); // Register an alias for this parameter $optionHandler->registerAlias( 'e', 'extended-dir', $dir ); // Process registered parameters and handle errors try { $optionHandler->process( array( 'example_input.php', '-h' ) ); } catch ( ezcConsoleOptionException $e ) { echo $e->getMessage(); exit( 1 ); } // Process a single parameter $file = $optionHandler->getOption( 'f' ); if ( $file->value === false ) { echo "Parameter -{$file->short}/--{$file->long} was not submitted.\n"; } elseif ( $file->value === true ) { echo "Parameter -{$file->short}/--{$file->long} was submitted without value.\n"; } else { echo "Parameter -{$file->short}/--{$file->long} was submitted with value <".var_export($file->value, true).">.\n"; } // Process all parameters at once: foreach ( $optionHandler->getOptionValues() as $paramShort => $val ) { switch ( true ) { case $val === false: echo "Parameter $paramShort was not submitted.\n"; break; case $val === true: echo "Parameter $paramShort was submitted without a value.\n"; break; case is_array( $val ): echo "Parameter $paramShort was submitted multiple times with value: <".implode(', ', $val).">.\n"; break; default: echo "Parameter $paramShort was submitted with value: <$val>.\n"; break; } } ?>	2.64 KB	2024-07-17 10:18
📄 example_menu_dialog_full.php <?php require_once "Base/src/base.php"; function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); $opts = new ezcConsoleMenuDialogOptions(); $opts->text = "Please choose a possibility:\n"; $opts->validator = new ezcConsoleMenuDialogDefaultValidator( array( "A" => "Selection A", "B" => "Selection B", "C" => "Selection C", "D" => "Selection D", "Z" => "Selection Z", ), "Z" ); $dialog = new ezcConsoleMenuDialog( $out, $opts ); $res = ezcConsoleDialogViewer::displayDialog( $dialog ); echo "User seletced $res\n"; ?>	624 B	2024-07-17 10:18
📄 example_output.php <?php /** * Example for the usage of ezcConsoleOutput class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className */ function __autoload( $className ) { ezcBase::autoload( $className ); } // Create the output handler $out = new ezcConsoleOutput(); // Set the verbosity to level 10 $out->options->verbosityLevel = 10; // Enable auto wrapping of lines after 40 characters $out->options->autobreak = 40; // Set the color of the default output format to green $out->formats->default->color = 'green'; // Set the color of the output format named 'success' to white $out->formats->success->color = 'white'; // Set the style of the output format named 'success' to bold $out->formats->success->style = array( 'bold' ); // Set the color of the output format named 'failure' to red $out->formats->failure->color = 'red'; // Set the style of the output format named 'failure' to bold $out->formats->failure->style = array( 'bold' ); // Set the background color of the output format named 'failure' to blue $out->formats->failure->bgcolor = 'blue'; // Output text with default format $out->outputText( 'This is default text ' ); // Output text with format 'success' $out->outputText( 'including success message', 'success' ); // Some more output with default output. $out->outputText( "and a manual linebreak.\n" ); // Manipulate the later output $out->formats->success->color = 'green'; $out->formats->default->color = 'blue'; // This is visible, since we set verboseLevel to 10, and printed in default format (now blue) $out->outputText( "Some verbose output.\n", null, 10 ); // This is not visible, since we set verboseLevel to 10 $out->outputText( "Some more verbose output.\n", null, 20 ); // This is visible, since we set verboseLevel to 10, and printed in format 'failure' $out->outputText( "And some not so verbose, failure output.\n", 'failure', 5 ); ?>	2.06 KB	2024-07-17 10:18
📄 example_progressbar.php <?php /** * Example for the usage of ezcConsoleProgressbar class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className / function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); $out->formats->red->color = "red"; // Create progress bar itself $progress = new ezcConsoleProgressbar( $out, 100, array( 'step' => 5 ) ); $progress->options->emptyChar = '-'; $progress->options->progressChar = $out->formatText('>', "red"); $progress->options->formatString = "Uploading file </tmp/foobar.tar.bz2>: %act%/%max% kb [%bar%]"; // Perform actions $i = 0; while( $i++ < 20 ) { // Do whatever you want to indicate progress for usleep( mt_rand( 20000, 2000000 ) ); // Advance the progressbar by one step ( uploading 5k per run ) $progress->advance(); } // Finish progress bar and jump to next line. $progress->finish(); $out->outputText( "Successfully uploaded </tmp/foobar.tar.bz2>.\n", 'success' ); / OUTPUT: (sequential, will be printed into 1 line and updated in reallife) Uploading file </tmp/foobar.tar.bz2>: 5/100 kb [++#----------------------------------------------] Uploading file </tmp/foobar.tar.bz2>: 10/100 kb [+++++#-------------------------------------------] Uploading file </tmp/foobar.tar.bz2>: 15/100 kb [++++++++#----------------------------------------] Uploading file </tmp/foobar.tar.bz2>: 20/100 kb [+++++++++++#-------------------------------------] Uploading file </tmp/foobar.tar.bz2>: 25/100 kb [++++++++++++++#----------------------------------] Uploading file </tmp/foobar.tar.bz2>: 30/100 kb [+++++++++++++++++#-------------------------------] Uploading file </tmp/foobar.tar.bz2>: 35/100 kb [++++++++++++++++++++#----------------------------] Uploading file </tmp/foobar.tar.bz2>: 40/100 kb [+++++++++++++++++++++++#-------------------------] Uploading file </tmp/foobar.tar.bz2>: 45/100 kb [++++++++++++++++++++++++++#----------------------] Uploading file </tmp/foobar.tar.bz2>: 50/100 kb [+++++++++++++++++++++++++++++#-------------------] Uploading file </tmp/foobar.tar.bz2>: 55/100 kb [++++++++++++++++++++++++++++++++#----------------] Uploading file </tmp/foobar.tar.bz2>: 60/100 kb [+++++++++++++++++++++++++++++++++++#-------------] Uploading file </tmp/foobar.tar.bz2>: 65/100 kb [++++++++++++++++++++++++++++++++++++++#----------] Uploading file </tmp/foobar.tar.bz2>: 70/100 kb [+++++++++++++++++++++++++++++++++++++++++#-------] Uploading file </tmp/foobar.tar.bz2>: 75/100 kb [++++++++++++++++++++++++++++++++++++++++++++#----] Uploading file </tmp/foobar.tar.bz2>: 80/100 kb [+++++++++++++++++++++++++++++++++++++++++++++++#-] Uploading file </tmp/foobar.tar.bz2>: 85/100 kb [++++++++++++++++++++++++++++++++++++++++++++++++#] Uploading file </tmp/foobar.tar.bz2>: 90/100 kb [++++++++++++++++++++++++++++++++++++++++++++++++#] Uploading file </tmp/foobar.tar.bz2>: 95/100 kb [++++++++++++++++++++++++++++++++++++++++++++++++#] Uploading file </tmp/foobar.tar.bz2>: 100/100 kb [++++++++++++++++++++++++++++++++++++++++++++++++#] Uploading file </tmp/foobar.tar.bz2>: 100/100 kb [++++++++++++++++++++++++++++++++++++++++++++++++#]Successfully uploaded </tmp/foobar.tar.bz2>. */ ?>	3.36 KB	2024-07-17 10:18
📄 example_progressmonitor.php <?php /** * Example for the usage of ezcConsoleProgressMonitor class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className / function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); // Create a progress monitor $status = new ezcConsoleProgressMonitor( $out, 7 ); // Perform actions $i = 0; while( $i++ < 7 ) { // Do whatever you want to indicate progress for usleep( mt_rand( 20000, 2000000 ) ); // Advance the statusbar by one step $status->addEntry( 'ACTION', "Performed action #{$i}." ); } $out->outputLine(); / OUTPUT: 14.3% ACTION Performed action #1. 28.6% ACTION Performed action #2. 42.9% ACTION Performed action #3. 57.1% ACTION Performed action #4. 71.4% ACTION Performed action #5. 85.7% ACTION Performed action #6. 100.0% ACTION Performed action #7. */ ?>	1.07 KB	2024-07-17 10:18
📄 example_question_dialog_collection_full.php <?php require_once "Base/src/base.php"; function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); $opts = new ezcConsoleQuestionDialogOptions(); $opts->text = "Do you want to proceed?"; $opts->showResults = true; $opts->validator = new ezcConsoleQuestionDialogCollectionValidator( array( "y", "n" ), "n", ezcConsoleQuestionDialogCollectionValidator::CONVERT_LOWER ); $dialog = new ezcConsoleQuestionDialog( $out, $opts ); echo "The user decided to " . ( ezcConsoleDialogViewer::displayDialog( $dialog ) === "n" ? "not " : "" ) . "proceed.\n"; ?>	613 B	2024-07-17 10:18
📄 example_question_dialog_factory_yesno.php <?php require_once "Base/src/base.php"; function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); $dialog = ezcConsoleQuestionDialog::YesNoQuestion( $out, "Is the answer to everything 42?", "y" ); if ( ( $res = ezcConsoleDialogViewer::displayDialog( $dialog ) ) === "y" ) { echo "You are so right! Don't forget your towel! :)\n"; } else { echo "You should better read some Douglas Adams!\n"; } ?>	461 B	2024-07-17 10:18
📄 example_question_dialog_type_full.php <?php require_once "Base/src/base.php"; function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); $opts = new ezcConsoleQuestionDialogOptions(); $opts->text = "How old are you?"; $opts->showResults = true; $opts->validator = new ezcConsoleQuestionDialogTypeValidator( ezcConsoleQuestionDialogTypeValidator::TYPE_INT ); $dialog = new ezcConsoleQuestionDialog( $out, $opts ); if ( ( $res = ezcConsoleDialogViewer::displayDialog( $dialog ) ) < 8 ) { echo "Sorry, I can not believe that you are $res years old!\n"; } else { echo "Hey, you're still young! :)\n"; } ?>	630 B	2024-07-17 10:18
📄 example_statusbar.php <?php /** * Example for the usage of ezcConsoleStatusbar class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className / function __autoload( $className ) { ezcBase::autoload( $className ); } $out = new ezcConsoleOutput(); // Create status bar itself $status = new ezcConsoleStatusbar( $out ); // Perform actions $i = 0; while( $i++ < 20 ) { // Do whatever you want to indicate progress for usleep( mt_rand( 20000, 2000000 ) ); // Indicate success or failure $status->add( (bool)mt_rand( 0, 1 ) ); } $out->outputLine(); // Print statistics $out->outputLine( $status->getSuccessCount() . ' operations succeeded, ' . $status->getFailureCount() . ' failed.' ); / OUTPUT: +-++++-++++-++-+--+- 13 operations succeeded, 7 failed. */ ?>	987 B	2024-07-17 10:18
📄 example_table.php <?php /** * Example for the usage of ezcConsoleTable class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className / function __autoload( $className ) { ezcBase::autoload( $className ); } // Initialize the console output handler $out = new ezcConsoleOutput(); // Define a new format "headline" $out->formats->headline->color = 'red'; $out->formats->headline->style = array( 'bold' ); // Define a new format "sum" $out->formats->sum->color = 'blue'; $out->formats->sum->style = array( 'negative' ); // Create a new table $table = new ezcConsoleTable( $out, 60 ); // Create first row and in it the first cell $table[0][0]->content = 'Headline 1'; // Create 3 more cells in row 0 for ( $i = 2; $i < 5; $i++ ) { $table[0][]->content = "Headline $i"; } $data = array( 1, 2, 3, 4 ); // Create some more data in the table... foreach ( $data as $value ) { // Create a new row each time and set it's contents to the actual value $table[][0]->content = "$value"; } // Set another border format for our headline row $table[0]->borderFormat = 'headline'; // Set the content format for all cells of the 3rd row to "sum" $table[2]->format = 'sum'; $table->outputTable(); echo "\n"; / RESULT (without color): +------------+------------+------------+------------+ // \| Headline 1 \| Headline 2 \| Headline 3 \| Headline 4 \| // Red bordered line +------------+------------+------------+------------+ // \| 1 \| \| \| \| +------------+------------+------------+------------+ \| 2 \| \| \| \| // Content printed in white on blue +------------+------------+------------+------------+ \| 3 \| \| \| \| +------------+------------+------------+------------+ \| 4 \| \| \| \| +------------+------------+------------+------------+ */ ?>	2.09 KB	2024-07-17 10:18
📄 example_table_2.php <?php /** * Example for the usage of ezcConsoleTable class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License / require_once 'Base/src/base.php'; /* * Autoload ezc classes * * @param string $className */ function __autoload( $className ) { ezcBase::autoload( $className ); } // Initialize the console output handler $out = new ezcConsoleOutput(); // Define format schemes for even and odd rows $out->formats->evenRow->color = 'red'; $out->formats->evenRow->style = array( 'bold' ); $out->formats->oddRow->color = 'blue'; $out->formats->oddRow->style = array( 'bold' ); // Define format schemes for even and odd cells $out->formats->evenCell->color = 'red'; $out->formats->evenCell->style = array( 'negative' ); $out->formats->oddCell->color = 'blue'; $out->formats->oddCell->style = array( 'negative' ); // Create a new table with a width of 60 chars $table = new ezcConsoleTable( $out, 60 ); // Set global cell content align $table->options->defaultAlign = ezcConsoleTable::ALIGN_CENTER; for ( $i = 0; $i < 5; $i ++ ) { for ( $j = 0; $j < 5; $j++ ) { // Fill each table cell with ## $table[$i][$j]->content = '##'; if ( $i === $j ) { // On diagonal line set explicit cell format for even/odd $table[$i][$j]->format = $j % 2 == 0 ? 'evenCell' : 'oddCell'; } } // Set global format for even/odd rows $table[$i]->format = $i % 2 == 0 ? 'evenRow' : 'oddRow'; // Set border format for even/odd rows $table[$i]->borderFormat = $i % 2 == 0 ? 'evenRow' : 'oddRow'; } $table->outputTable(); echo "\n"; ?>	1.71 KB	2024-07-17 10:18
📁 img	-	2025-05-25 12:37
📄 tutorial.txt eZ Components - ConsoleTools ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ .. contents:: Table of Contents Introduction ============ The ConsoleTools component provides several useful tools to build applications that run on a computer console (sometimes also called shell or command line). For example, eZ Publish includes several shell scripts that perform tasks like clearing caches. .. note:: From version 1.5.2 on, all necessary string operations in ConsoleTools are performed using `ext/iconv`__. This makes the component binary safe and allows you to use arbitrary unicode characters in your texts. Please make sure to convert your text to UTF-8 before submitting it to a method in ConsoleTools, if you use a different, non ASCII-compatible encoding. .. __: http://php.net/iconv Class overview ============== The ConsoleTools component offers several (mostly independent) classes to perform different tasks. The main classes are: ezcConsoleOutput ezcConsoleOutput is responsible for printing text to the console. It allows you to print text in different colors with different background colors. It can also apply other styling information to the text, making it bold or underlined for example. It can automatically wrap text after a certain number of characters are printed (keeping words intact) and handle output of different verbosity levels. ATTENTION: Windows does not support the styling of text. ezcConsoleInput Using this little tool, you can handle the options and arguments provided to your shell application. It is capable of handling and validating three types of option datatypes (string, int and none) and can handle optional and mandatory options as well as rules to define relations between them. Rules can include dependencies and exclusions between options. ezcConsoleProgressbar Most often you will use a console application in favor of a web application when it comes to processing time-consuming tasks. To indicate the current progress of a task, a kind of "status indicator" will be used, which is most commonly a progress bar. ezcConsoleProgressbar gives you an easy-to-use interface to display this. It will keep track of re-drawing the bar as needed, showing current and maximum values, as well as percentage completion. It is fully configurable regarding its visual appearance. ezcConsoleStatusbar ezcConsoleStatusbar is the "little brother" of ezcConsoleProgressbar. It also allows you to display the progress of a time-consuming action, but does not use a fixed bar-like appearance. Instead, it indicates successful and failed operations by displaying specific characters and keeps a count of successes and failures. This allows you to indicate the progress of a process where you don't initially know the number of actions to be performed. ezcConsoleProgressMonitor Sometimes you need to display the progress of several actions and don't want to use a progress bar to do so. In this case you need the status indicator. It allows you to display a status entry for each action and generates the percentage completion of the current step. ezcConsoleTable This class lets you easily create tables to be displayed on the console. It has a very convenient interface to create a table and manage the data it contains. It is highly configurable regarding the table's appearance (for example, different color and style information for content and borders on a per-cell basis, character selection for borders, variable width of the table and so on). ezcConsoleTable will also take care of measuring the best width for table columns (to make your content fit best), automatically wrapping content and aligning the content in the cells as indicated. ezcConsoleDialog This interface provides a common API for user interaction elements. A console dialog can request information from a user and react on this information interactively. For you as a user of ezcConsoleDialog, a dialog is displayed to the user and returns a result value to you, which was provided by the user of your application in some way. Currently 2 implementations of ezcConsoleDialog exist: ezcConsoleQuestionDialog is a dialog for asking a simply question and retrieving the answer from the user of an application. Instances of the ezcConsoleMenuDialog class display a menu to the user and retrieves his choice of a menu item. Usage ===== Printing text to the console ---------------------------- As mentioned, the class ezcConsoleOutput is used to print text to the console. Let's look at a basic example: .. include:: tutorial_example_01_output_basic.php :literal: The ezcConsoleOutput object is simply instantiated. You can optionally submit options and predefined formatting options to its constructor, but this can also be done later. In line 7, you can see how format is defined. Formats are created on the fly, as soon as you access them (for reading or writing) through the $output->formats attribute. There, we create a format called "info" and assign the color value "blue" to it. This will make all text printed with this format blue. In line 9, you can see how the format is applied to some text at printing time. The second example shows some more advanced code: .. include:: tutorial_example_02_output_advanced.php :literal: In this example, two more formats are defined: "error" and "fatal". These formats have an additional style attribute set, which makes them both appear bold. The "fatal" format will also underline the text and give it a black background color. The difference between ezcConsoleOutput->outputText() and ezcConsoleOutput->outputLine() is that the latter automatically adds a newline value to your text. The newline sequence used here is adjusted based on the operating system. The use of ezcConsoleOutput->outputLine() is recommended over the direct output of, for example, "\n". If you leave the second parameter of ezcConsoleOutput::outputText() and ezcConsoleOutput::outputLine() out, the "default" format is used. The default is set to your console's default setting, but you can also change this as for any other format you define. A third variant to format text is ezcConsoleOutput->formatText(), which returns the formatted string instead of printing it. This example shows some of the options ezcConsoleOutput supports: .. include:: tutorial_example_03_output_options.php :literal: autobreak Will wrap lines automatically after the set amount of characters, keeping word boundaries intact. verbosityLevel Allows you to specify a third parameter to ezcConsoleOutput->outputLine() and ezcConsoleOutput->outputText() to indicate a verbosity level for when the text should be printed. By setting the "verbosityLevel" option for ezcConsoleOutput, you define which texts will and will not be printed. In our example, the call on line 23 would not print out text with the "verbosityLevel" option set to 3, but the call on line 25 would. The last example shows how to change the target of a format, which allows you to print text e.g. to STDERR. .. include:: tutorial_example_output_targets.php :literal: The error message 'Unable to connect to database' will be printed in bold, with a red foreground color to STDOUT. The default target is ezcConsoleOutput::TARGET_OUTPUT, which prints to STDOUT and has standar output buffering in place. If you want to switch out the standard output bufferung, use ezcConsoleOutput::TARGET_STDOUT. Although this feature was originally not designed for that purpose, you can also use any other arbitrary PHP stream definition as a target. For example 'file:///var/log/my.log' to get the messages redirected to a log file instead of displaying them. Mastering options and arguments ------------------------------- Below is a simple example for ezcConsoleInput: .. include:: tutorial_example_04_input_basic.php :literal: After instantiating a new ezcConsoleInput object to handle the options, an option is registered on lines 7-12. This option will be available as "-h" and "--help". The ezcConsoleInput->process() call makes ezcConsoleInput respond to the options submitted by the user. If any error occurs with the submitted user data, the method will throw an exception of type ezcConsoleOptionException. By default, all options are registered with the value type ezcConsoleInput::TYPE_NONE, which indicates that they don't expect a value from the user. If a value is submitted anyway, ezcConsoleInput->process() will throw a ezcConsoleOptionTypeViolationException. On line 23, a check is performed to see whether an option was submitted. If an option was not submitted, its $value property will contain bool false. Depending on the $type set, it can contain different value types if it was submitted. If you use the (not shown here) ezcConsoleOption->$multiple property, the value will be an array containing the specified value types. The next example is more advanced: .. include:: tutorial_example_05_input_advanced.php :literal: Two options are registered here: "-i" / "--input" and "-o" / "--output". For the first one, additional properties for the ezcConsoleOption object are submitted through the constructor. For the second ezcConsoleOption object, you see how to provide additional properties after construction. We change the type of both options to expect a string value from the user (lines 13 and 20). In lines 25 and 28 we make both parameters depend on each other. If one of them is submitted without the other, ezcConsoleInput->process() will throw an ezcConsoleOptionDependencyViolationException. Aside from dependency rules, you can also define exclusion rules using ezcConsoleOption->addExclusion(). On line 43, the method ezcConsoleInput->getSynopsis() is used to retrieve a synopsis string for the program. The synopsis for our example would look like this: :: $ ./tutorial_example_05_input_advanced.php [-h] [-i <string> [-o <string>] ] [[--] <args>] The synopsis will indicate the option value types, whether they are optional, the inter-option dependencies and default values (if set). On line 46, the property ezcConsoleOption->$shorthelp is accessed, where you can store some short help information. It has a reasonable default value set. On line 49, the submission of the "-o" option is checked. Because this has a dependency on the "-i" option, a check for that is not necessary. Line 52 shows how you can access the arguments submitted to the program. ezcConsoleInput->getArguments() always returns an array (which is empty if no arguments are submitted). A more advanced way of handling arguments is explained further below. Here is an example of how the defined program would be called: :: $ ./tutorial_example_05_input_advanced.php -i /var/www -o /tmp foo bar The program would respond by printing the following: :: Input: /var/www, Output: /tmp Arguments: foo, bar As you can see, this example does not define, which arguments are expected and therefore, the program simply accepts any number of arguments and provides them through the ezcConsoleInput->getArguments() method. The following example shows, how specific arguments can be defined: .. include:: tutorial_example_12_input_arguments.php :literal: As seen before, a help option is registered. In addition, 3 arguments are registered: The first one with the name "source" is a standard argument. It is mandatory for the user to submit a value here. The second argument, "destination" is optional and a default value is assigned, which will be used, if the user does not provide a value for it. The third one ("iterations") is not of type string, but an integer. Because the second argument is optional, this third one is automatically optional, too. Since no default value is assigned, it will be null, if the user does not submit it. If a value is provided, it must be an integer. Argument definitions are processed as usual inside the ezcConsoleInput->process() method, but will throw an ezcConsoleArgumentException if something goes wrong. If desired, exceptions about options and arguments can be caught together using ezcConsoleException or be handled on their own. The value of an argument can be fetched from its definition, using its value property. As can be seen at the very end of the example, for reading purpose, arguments can be accessed by their name. This does not work for writing purpose, since a specific order must be given there. If the --help option is set, mandatory arguments don't need to be submitted and are silently ignored. The help text generated by ezcConsoleInput for this example looks like this: :: Usage: $ tutorial_example_12_input_arguments.php [-h] [--] <string:source> [<string:destination>] [<int:iterations>] A simple text program -h / --help No help available. Arguments: <string:source> The source directory. <string:destination> No help available. <int:iterations> Number of iterations. For further information, please refer to the API documentation of ezcConsoleInput. Progress indication ------------------- This example defines a simple progress bar: .. include:: tutorial_example_06_progressbar_basic.php :literal: The created progressbar will count to a maximum value of 15, submitted to ezcConsoleProgressbar->__construct() in line 7. ezcConsoleProgressbar utilizes ezcConsoleOutput to print the generated progress bar. The call to ezcConsoleProgressbar->advance() pushes the progress bar one step further on each call and redraws it (line 11). Calling ezcConsoleProgressbar->finish() will set the progress bar to 100% immediately. The progress bar generated by the example will look like this: .. image:: img/consoletools_tutorial_example_06.png The next example performs more customization on the progress bar appearance: .. include:: tutorial_example_07_progressbar_advanced.php :literal: The defined options array demonstrates only a small subset of options. For detailed information, see the API documentation on ezcConsoleProgressbarOptions. The "emptyChar" value defines the character to prefill the bar, the "barChar" option defines the character to fill the bar with when calling ezcConsoleProgressbar->advance(). Using the "formatString" option, you define the appearance of the whole bar. Here the substitution of several placeholders (like "%fraction%" and "%bar%") is permitted. "formatString" must contain the "%bar%" placeholder, while all other values are optional. Any other printable character is permitted. Formatting options are allowed in the "formatString" option, but not in any other option. "redrawFrequency" defines how often the progressbar will be redrawn. In the example this will be every 50th call to ezcConsoleProgressbar->advance(). The resulting progress bar looks like this: .. image:: img/consoletools_tutorial_example_07.png With ezcConsoleStatusbar, you can indicate the progress of a time-consuming action in a simpler way. Here is an example: .. include:: tutorial_example_08_statusbar.php :literal: This variant of indicating progress only displays success or failure indicators for an action and allows you to run any number of actions, without specifying in advance how many you will perform. The "successChar" and "failureChar" options indicate which string to print on a successful or failed action. Lines 11 and 12 format these strings. Indicating a status is done using ezcConsoleStatusbar->add(), which expects true for a succeeded action and false for a failed one (line 20). You can access the number of successes and failures through ezcConsoleStatusbar->getSuccessCount() and ezcConsoleStatusbar->getFailureCount(). To make ezcConsoleStatusbar wrap a line after a certain amount of statuses, you can use ezcConsoleOutput->$autobreak. Here the result of the example: .. image:: img/consoletools_tutorial_example_08.png Finally, ezcConsoleProgressMonitor can indicate progress, but does not use a bar-like interface. It simply prints status information about each action you perform and shows the current progress as a percentage value in relation to the number of actions you plan to perform overall. .. include:: tutorial_example_11_progressmonitor.php :literal: Line 7 creates a new status indicator, which will iterate over 7 actions. Inside the while loop, we simulate some actions. The call to $status->addEntry() adds a status entry and causes the indicator to print the entry. Every entry consists of a tag (first parameter) and a message. The result of the example is as follows: :: 14.3% ACTION Performed action #1. 28.6% ACTION Performed action #2. 42.9% ACTION Performed action #3. 57.1% ACTION Performed action #4. 71.4% ACTION Performed action #5. 85.7% ACTION Performed action #6. 100.0% ACTION Performed action #7. More information on these classes can be found in the API documentation of ezcConsoleProgressbar, ezcConsoleStatusbar and ezcConsoleProgressMonitor. Large data served in a table ---------------------------- This is the result of a table generated by ezcConsoleTable: .. image:: img/consoletools_tutorial_example_09.png Here is its corresponding source code: .. include:: tutorial_example_09_table_basic.php :literal: ezcConsoleTable (like ezcConsoleStatusbar and ezcConsoleProgressbar) uses the ezcConsoleOutput class to print to the console. To create a table, you just need to submit the maximum width of the table to its constructor: ezcConsoleTable->__construct(). Options for table formatting are inherited from the table itself to the table rows and from there to the table cells. On each inheritance level, options can be overridden individually. The "defaultBorderFormat" option sets the global format value for all borders (line 24). This is overridden in line 26 for the first row of the table. Table rows are accessed like an array in PHP (this is achieved by implementing the ArrayAccess_ interface from SPL_). ezcConsoleTable implements the Iterator interface (SPL_, too) to allow iteration over table rows using foreach. Each table row is represented by an object of type ezcConsoleTableRow, which also implements the ArrayAccess_ and Iterator interfaces to access cells contained in the rows in the same way. Each of the named classes allows the access of its properties as usual, in addition to access to its contained objects through the array interface. ezcConsoleTableRow and ezcConsoleTableCell have a $format setting to define the format of the contained text. All cells (as described above) will inherit the setting of their parent ezcConsoleTableRow, as long as this has not been explicitly overridden. The same applies to ezcConsoleTableRow->$align and ezcConsoleTableCell->$align. Possible align values are: - ezcConsoleTable::ALIGN_DEFAULT (inherit from parent) - ezcConsoleTable::ALIGN_LEFT - ezcConsoleTable::ALIGN_RIGHT - ezcConsoleTable::ALIGN_CENTER The content of a cell is stored in the ezcConsoleTableCell->$content property (line 34). The usage of formatted text in a cell is possible, but not recommended. If you want to define the format of cell content, use the ezcConsoleTableCell->$format property. .. _SPL: http://php.net/spl .. _ArrayAccess: http://www.php.net/~helly/php/ext/spl/interfaceArrayAccess.html Below is a more advanced (but in a way useless) example to show the handling of tables: .. include:: tutorial_example_10_table_advanced.php :literal: The "corner", "lineHorizontal" and "lineVertical" options define which characters to use for the borders of the table. These options must be exactly one character long and cannot contain formatting information. To style the borders, use the ezcConsoleTable->$defaultBorderFormat and ezcConsoleTableRow->$borderFormat properties. The random format and alignment options selected above create the following table: .. image:: img/consoletools_tutorial_example_10.png More information on the handling of tables on the shell can be found in the API documentation of ezcConsoleTable, ezcConsoleTableRow and ezcConsoleTableCell. Interacting with the user ------------------------- Implementations of the interface ezcConsoleDialog are generic building blocks, which allow to interact with the user of a shell application using STDIN. A dialog is initialized, displayed and will return a value provided by the user. What exactly happens inside a specific dialog may vary. Commonly, the dialog validates and possibly manipulates the provided value before returning it. The most basic dialog is the ezcConsoleQuestionDialog, which prints out some text and retrieves a single value back. .. include:: tutorial_example_13_dialog_question.php :literal: Every dialog expects an instance of ezcConsoleOutput which is used to display it. The question dialog here will display the text "Do you want to proceed?" and expects an answer from the user. The $showResults option indicates, that the possible values the user may provide will be indicated, as well as the default value, if one is set. The mechanism for validating the answer is defined by an instance of ezcConsoleQuestionDialogValidator. In the example, a collection validator is used, which defines a collection of valid values. Beside that, it performs a case conversion on the user provided result before validating it, if desired. Displaying a dialog can either be done directly, by calling ezcConsoleDialog->display(), or the more convenient way, shown in the example. The ezcConsoleDialogViewer::displayDialog() method displays the dialog in a loop, until the user provided a valid value, so that the program can rely on this. In the example, the user is asked after every performed action, if he still wants to proceed. If the answer is "n" or "N", the program stops. An example run of this application could look like this: :: Some action performed... Do you want to proceed? (y/n) [y] y Some action performed... Do you want to proceed? (y/n) [y] Some action performed... Do you want to proceed? (y/n) [y] n Goodbye! A very similar yes/no question can be created through convenience method very easily: .. include:: tutorial_example_14_dialog_yesnoquestion.php :literal: The created yes/no question dialog contains a custom question and defaults to "y", if nothing is selected. In contrast to the last example, the dialog created here also accepts "yes" and "no" as answers. Both phrases can be used in any typing, e.g. like "yEs" or "NO". This is made possibly by the ezcConsoleQuestionDialogMappingValidator, which extends ezcConsoleQuestionDialogCollectionValidator. The mapping validator allows to define an arbitrary mapping between the user typed answers and expected ones. Therefore the dialog still only returns either "y" or "n". The second dialog type, provided with ConsoleTools, is the ezcConsoleMenuDialog. Similar to the ezcConsoleQuestionDialog, it displays a list of menu items to the user and requires him to choose one of these. An example for this class looks like this: .. include:: tutorial_example_15_dialog_menu.php :literal: Again the dialog is instantiated and some options are tweaked to get the desired behaviour. The validator in this case receives an array of possible menu items, while the key represents the identifier and the value contains the text to be displayed for the item. The second argument is the default value, chosen if the user simply presses <return>. An example run of this program could look like this: :: Please choose a possibility: 1) Perform some more actions 2) Perform another action 0) Quit Select: [0] 1 Performing some more actions... Please choose a possibility: 1) Perform some more actions 2) Perform another action 0) Quit Select: [0] 2 Performing some other actions! Please choose a possibility: 1) Perform some more actions 2) Perform another action 0) Quit Select: [0] The character used to divide the identifier and text, as well as the text indicating that a selection must be done, can be tweaked, too. Further information about dialogs can be found in the API documentation of ezcConsoleDialog, ezcConsoleQuestionDialog and ezcConsoleMenuDialog. .. Local Variables: mode: rst fill-column: 79 End: vim: et syn=rst tw=79	23.92 KB	2024-07-17 10:18
📄 tutorial_autoload.php <?php $dir = dirname( __FILE__ ); $dirParts = explode( DIRECTORY_SEPARATOR, $dir ); switch ( $dirParts[count( $dirParts ) - 3] ) { case 'doc': require_once 'ezc/Base/base.php'; break; // pear case 'trunk': require_once "$dir/../../Base/src/base.php"; break; // svn default: require_once "$dir/../../Base/src/base.php"; break; // bundle } /** * Autoload ezc classes * * @param string $className */ function __autoload( $className ) { ezcBase::autoload( $className ); } ?>	495 B	2024-07-17 10:18
📄 tutorial_example_01_output_basic.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->info->color = 'blue'; $output->outputText( 'Test text in color blue', 'info' ); ?>	184 B	2024-07-17 10:18
📄 tutorial_example_02_output_advanced.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->info->color = 'blue'; $output->formats->error->color = 'red'; $output->formats->error->style = array( 'bold' ); $output->formats->fatal->color = 'red'; $output->formats->fatal->style = array( 'bold', 'underlined' ); $output->formats->fatal->bgcolor = 'black'; $output->outputText( 'This is some standard text ' ); $output->outputText( 'including some error', 'error' ); $output->outputText( ' wrapped in standard text.' ); $output->outputText( "\n" ); $output->outputLine( 'This is a fatal error message.', 'fatal' ); $output->outputText( 'Test' ); ?>	657 B	2024-07-17 10:18
📄 tutorial_example_03_output_options.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->info->color = 'blue'; $output->formats->info->style = array( 'bold' ); $output->setOptions( array( 'autobreak' => 78, 'verbosityLevel' => 3 ) ); $output->outputLine( 'This is a very very long info text. It has so much information in '. 'it, that it will definitly not fit into 1 line. Therefore, '. 'ezcConsoleOutput will automatically wrap the line for us.', 'info' ); $output->outputLine(); $output->outputLine( 'This verbose information will currently not be displayed.', 'info', 10 ); $output->outputLine( 'But this verbose information will be displayed.', 'info', 2 ); ?>	755 B	2024-07-17 10:18
📄 tutorial_example_04_input_basic.php <?php require_once 'tutorial_autoload.php'; $input = new ezcConsoleInput(); $helpOption = $input->registerOption( new ezcConsoleOption( 'h', 'help' ) ); try { $input->process(); } catch ( ezcConsoleOptionException $e ) { die( $e->getMessage() ); } if ( $helpOption->value !== false ) { echo "Help requested."; } else { echo "No help requested."; } ?>	399 B	2024-07-17 10:18
📄 tutorial_example_05_input_advanced.php <?php require_once 'tutorial_autoload.php'; $input = new ezcConsoleInput(); $helpOption = $input->registerOption( new ezcConsoleOption( 'h', 'help' ) ); $inputOption = $input->registerOption( new ezcConsoleOption( 'i', 'input', ezcConsoleInput::TYPE_STRING ) ); $outputOption = $input->registerOption( new ezcConsoleOption( 'o', 'output' ) ); $outputOption->type = ezcConsoleInput::TYPE_STRING; $inputOption->addDependency( new ezcConsoleOptionRule( $outputOption ) ); $outputOption->addDependency( new ezcConsoleOptionRule( $inputOption ) ); try { $input->process(); } catch ( ezcConsoleOptionException $e ) { die( $e->getMessage() ); } if ( $helpOption->value === true ) { echo $input->getSynopsis() . "\n"; foreach ( $input->getOptions() as $option ) { echo "-{$option->short}/{$option->long}: {$option->shorthelp}\n"; } } elseif ( $outputOption->value !== false ) { echo "Input: {$inputOption->value}, Output: {$outputOption->value}\n"; echo "Arguments: " . implode( ", ", $input->getArguments() ) . "\n"; } ?>	1.11 KB	2024-07-17 10:18
📄 tutorial_example_06_progressbar_basic.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $bar = new ezcConsoleProgressbar( $output, 15 ); for ( $i = 0; $i < 15; $i++ ) { $bar->advance(); usleep( mt_rand( 2000, 200000 ) ); } $bar->finish(); $output->outputLine(); ?>	271 B	2024-07-17 10:18
📄 tutorial_example_07_progressbar_advanced.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->bar->color = 'blue'; $output->formats->bar->style = array( 'bold' ); $options = array( 'emptyChar' => ' ', 'barChar' => '-', 'formatString' => '%fraction%% <' . $output->formatText( '%bar%', 'bar' ) . '> Uploaded %act% / %max% kb', 'redrawFrequency' => 50, ); $bar = new ezcConsoleProgressbar( $output, 1024, $options ); for ( $i = 0; $i < 1024; $i++ ) { $bar->advance(); usleep( mt_rand( 200, 2000 ) ); } $bar->finish(); $output->outputLine(); ?>	596 B	2024-07-17 10:18
📄 tutorial_example_08_statusbar.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->success->color = 'green'; $output->formats->failure->color = 'red'; $options = array( 'successChar' => $output->formatText( '+', 'success' ), 'failureChar' => $output->formatText( '-', 'failure' ), ); $status = new ezcConsoleStatusbar( $output, $options ); for ( $i = 0; $i < 120; $i++ ) { $nextStatus = ( bool )mt_rand( 0,1 ); $status->add( $nextStatus ); usleep( mt_rand( 200, 2000 ) ); } $output->outputLine(); $output->outputLine( 'Successes: ' . $status->getSuccessCount() . ', Failures: ' . $status->getFailureCount() ); ?>	656 B	2024-07-17 10:18
📄 tutorial_example_09_table_basic.php <?php require_once 'tutorial_autoload.php'; $data = array( array( 'Name', 'Nationality', 'Birthday' ), array( 'Derick Rethans', 'Dutch', '1978-12-22' ), array( 'Frederik Holljen', 'Canadian / Norwegian', '1978-11-15' ), array( 'Jan Borsodi', 'Norwegian', '1977-10-13' ), array( 'Raymond Bosman', 'Dutch', '1979-07-24' ), array( 'Tobias Schlitt', 'German', '1980-05-19' ), ); $output = new ezcConsoleOutput(); $output->formats->headBorder->color = 'blue'; $output->formats->normalBorder->color = 'gray'; $output->formats->headContent->color = 'blue'; $output->formats->headContent->style = array( 'bold' ); $table = new ezcConsoleTable( $output, 78 ); $table->options->defaultBorderFormat = 'normalBorder'; $table[0]->borderFormat = 'headBorder'; $table[0]->format = 'headContent'; $table[0]->align = ezcConsoleTable::ALIGN_CENTER; foreach ( $data as $row => $cells ) { foreach ( $cells as $cell ) { $table[$row][]->content = $cell; } } $output->outputLine( 'eZ components team:' ); $table->outputTable(); $output->outputLine(); ?>	1.06 KB	2024-07-17 10:18
📄 tutorial_example_10_table_advanced.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->blue->color = 'blue'; $output->formats->blue->style = array( 'bold' ); $output->formats->red->color = 'red'; $output->formats->red->style = array( 'bold' ); $output->formats->green->color = 'green'; $output->formats->green->style = array( 'bold' ); $colors = array( 'red', 'blue', 'green' ); $aligns = array( ezcConsoleTable::ALIGN_LEFT, ezcConsoleTable::ALIGN_CENTER, ezcConsoleTable::ALIGN_RIGHT ); $table = new ezcConsoleTable( $output, 78 ); $table->options->corner = ' '; $table->options->lineHorizontal = ' '; $table->options->lineVertical = ' '; $table->options->widthType = ezcConsoleTable::WIDTH_FIXED; for ( $i = 0; $i < 10; $i++ ) { for ( $j = 0; $j < 10; $j++ ) { $table[$i][$j]->content = '*'; $table[$i][$j]->format = $colors[array_rand( $colors )]; $table[$i][$j]->align = $aligns[array_rand( $aligns )]; } } $table->outputTable(); $output->outputLine(); ?>	1 KB	2024-07-17 10:18
📄 tutorial_example_11_progressmonitor.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $status = new ezcConsoleProgressMonitor( $output, 7 ); $i = 0; while( $i++ < 7 ) { usleep( mt_rand( 20000, 2000000 ) ); $status->addEntry( 'ACTION', "Performed action #{$i}." ); } $output->outputLine(); ?>	299 B	2024-07-17 10:18
📄 tutorial_example_12_input_arguments.php <?php require_once 'tutorial_autoload.php'; $input = new ezcConsoleInput(); $helpOption = $input->registerOption( new ezcConsoleOption( 'h', 'help' ) ); $helpOption->isHelpOption = true; $input->argumentDefinition = new ezcConsoleArguments(); $input->argumentDefinition[0] = new ezcConsoleArgument( "source" ); $input->argumentDefinition[0]->shorthelp = "The source directory."; $input->argumentDefinition[1] = new ezcConsoleArgument( "destination" ); $input->argumentDefinition[1]->mandatory = false; $input->argumentDefinition[1]->default = './'; $input->argumentDefinition[2] = new ezcConsoleArgument( "iterations" ); $input->argumentDefinition[2]->type = ezcConsoleInput::TYPE_INT; $input->argumentDefinition[2]->shorthelp = "Number of iterations."; $input->argumentDefinition[2]->longhelp = "The number of iterations to perform."; try { $input->process(); } catch ( ezcConsoleException $e ) { die( $e->getMessage() ); } if ( $helpOption->value === true ) { echo $input->getHelpText( "A simple text program" ); } else { echo "Source: {$input->argumentDefinition["source"]->value}\n"; echo "Destination: {$input->argumentDefinition["destination"]->value}\n"; echo "Iterations: " . ( $input->argumentDefinition["iterations"]->value === null ? "not set" : $input->argumentDefinition["iterations"]->value ); } ?>	1.41 KB	2024-07-17 10:18
📄 tutorial_example_13_dialog_question.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $question = new ezcConsoleQuestionDialog( $output ); $question->options->text = "Do you want to proceed?"; $question->options->showResults = true; $question->options->validator = new ezcConsoleQuestionDialogCollectionValidator( array( "y", "n" ), "y", ezcConsoleQuestionDialogCollectionValidator::CONVERT_LOWER ); do { echo "\nSome action performed...\n\n"; } while ( ezcConsoleDialogViewer::displayDialog( $question ) !== "n" ); echo "Goodbye!\n"; ?>	552 B	2024-07-17 10:18
📄 tutorial_example_14_dialog_yesnoquestion.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $question = ezcConsoleQuestionDialog::YesNoQuestion( $output, "Do you want to proceed?", "y" ); do { echo "\nSome action performed...\n\n"; } while ( ezcConsoleDialogViewer::displayDialog( $question ) !== "n" ); echo "Goodbye!\n"; ?>	334 B	2024-07-17 10:18
📄 tutorial_example_15_dialog_menu.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $menu = new ezcConsoleMenuDialog( $output ); $menu->options = new ezcConsoleMenuDialogOptions(); $menu->options->text = "Please choose a possibility:\n"; $menu->options->validator = new ezcConsoleMenuDialogDefaultValidator( array( "1" => "Perform some more actions", "2" => "Perform another action", "0" => "Quit", ), "0" ); while ( ( $choice = ezcConsoleDialogViewer::displayDialog( $menu ) ) != 0 ) { switch ( $choice ) { case 1: echo "Performing some more actions...\n"; break; case 2: echo "Performing some other actions!\n"; break; } } ?>	739 B	2024-07-17 10:18
📄 tutorial_example_output_targets.php <?php require_once 'tutorial_autoload.php'; $output = new ezcConsoleOutput(); $output->formats->error->color = 'red'; $output->formats->error->style = array( 'bold' ); $output->formats->error->target = ezcConsoleOutput::TARGET_STDERR; $output->outputLine( 'Unable to connect to database', 'error' ); ?>	308 B	2024-07-17 10:18

Edit File:

Terminal