• TYPO3 Core APIs
    latest (9-dev)
  • Sitemap
  • Introduction
    • Overview
    • Code examples
      • Feedback
    • Credits
    • Dedication
  • Extension Architecture
    • Introduction
      • Extensions and the Core
    • Files and locations
      • Files
      • Reserved file names
      • Reserved folders
    • System, Global and Local extensions
      • Local extensions
      • Global extensions
      • System extensions
      • Loading precedence
    • Choosing an extension key
      • About GPL and extensions
      • Security
      • Registering an extension key
    • Naming conventions
      • Note on "old" extensions:
      • Extending "extensions classes"
    • Installing extensions
    • Declaration file
      • Deprecated configuration
    • Configuration files
      • Best practice for ext_tables.php and ext_localconf.php
    • Configuration options
    • Extending the $TCA array
      • Storing the changes
        • Storing in extensions
          • Storing in the Overrides folder
          • Storing in ext_tables.php files
        • Changing the TCA "on the fly"
      • Customization examples
        • Example 1: extending the fe_users table
        • Example 2: extending the tt_content table
      • Verifying the $TCA
    • The Extension Manager (EM)
    • Creating a new extension
      • Kickstarting the extension
    • Creating a new distribution
      • Concept of distributions
      • Kickstarting the distribution
        • Configuring the distribution display in the EM
        • Fileadmin files
        • Database data
        • Distribution configuration
        • Delivering custom dependencies
      • Test your distribution
      • More information
    • Adding documentation
      • Sphinx project
      • README.rst
    • Other resources
  • TYPO3 explained
    • Directory structure
    • PHP Namespaces
      • Core example
      • Usage in extensions
      • Namespaces in Extbase
      • Namespaces for test classes
      • Creating instances
      • References
    • Autoloading
      • Autoloading classes since TYPO3 7.x
      • Loading classes without composer mode
      • Loading classes with composer mode
      • Best practices
    • Bootstrapping
      • Application Context
        • Custom Contexts
        • Usage Example
    • Variables and Constants
      • Constants
        • Table 1: Traditional List
        • Table 2: Base Constants
          • This version, branch and copyright
          • TYPO3 external links
          • String constants
          • Security related constant
          • Operating system identifier
          • Service error constants
      • Global variables
        • Exploring global variables
    • Backend User Object
      • Checking user access
        • Checking access to current backend module
        • Checking access to any backend module
        • Access to tables and fields?
        • Is "admin"?
        • Read access to a page?
        • Is a page inside a DB mount?
        • Selecting readable pages from database?
        • Saving module data
        • Getting module data
        • Getting TSconfig
        • Getting the username
        • Get User Configuration value
    • TYPO3 Core Engine (TCE)
      • Introduction
        • Database
        • Files
      • Database: DataHandler basics (formerly known as TCEmain)
        • Commands Array
          • Command keywords and values
          • Examples of commands:
        • Data Array
          • Examples of Data submission
        • Clear cache
          • Hook for cache post-processing
        • Flags in DataHandler
      • Using DataHandler in scripts
        • DataHandler examples
          • Submitting data
          • Executing commands
          • Clearing cache
          • Complex data submission
          • Both data and commands executed with alternative user object
      • The "tce_db.php" API
      • File functions basics
        • Files Array
          • Command keywords and values
      • The "tce_file.php" API
    • FormEngine
      • Introduction
      • Main rendering workflow
      • Data compiling
        • Data groups and providers
        • Extending data groups with own providers
        • Adding data to data array
      • Rendering
        • Class inheritance
        • NodeFactory
        • Result array
        • Node expansion
        • Add fieldControl example
    • Database Access
      • Introduction
        • Understanding Doctrine-Dbal and Doctrine-Orm
        • Low-level and high-level database calls
        • Credits
      • Configuration
      • Basic CRUD
        • INSERT a row
        • SELECT a single row
        • SELECT multiple rows with some WHERE magic
        • UPDATE multiple rows
        • DELETE a row
      • Class overview
      • ConnectionPool
        • Pooling
      • QueryBuilder
        • select() and addSelect()
        • count()
        • delete()
        • update() and set()
        • insert() and values()
        • from()
        • where(), andWhere() and orWhere()
        • join(), innerJoin(), rightJoin() and leftJoin()
        • orderBy() and addOrderBy()
        • groupBy() and addGroupBy()
        • setMaxResults() and setFirstResult()
        • getSQL()
        • getParameters()
        • execute()
        • expr()
        • createNamedParameter()
        • quoteIdentifier() and quoteIdentifiers()
        • escapeLikeWildcards()
        • getRestrictions(), setRestrictions(), resetRestrictions()
      • Connection
        • insert()
        • bulkInsert()
        • update()
        • delete()
        • truncate()
        • count()
        • select()
        • lastInsertId()
        • createQueryBuilder()
      • ExpressionBuilder
        • Junctions
        • Comparisons
        • Aggregate functions
        • Various Expressions
          • TRIM
          • LENGTH
      • RestrictionBuilder
        • Rationale
        • Main construct
        • Restrictions
        • QueryRestrictionContainer
        • Examples
      • Statement
        • fetch()
        • fetchAll()
        • fetchColumn()
        • rowCount()
        • Re-use prepared Statement()
      • QueryHelper
        • parseOrderBy()
        • parseGroupBy()
        • parseTableList()
        • parseJoin()
        • stripLogicalOperatorPrefix()
        • getDateTimeFormats()
      • Migrating from TYPO3_DB
        • Compare raw queries
        • enableFields() and deleteClause()
        • From ->exec_UDATEquery() to ->update()
        • Result set iteration
        • sql_insert_id()
        • fullQuoteStr()
        • ext_tables.sql
        • extbase QueryBuilder
      • Various tips and tricks
    • Internationalization
      • Introduction to XLIFF
        • Basics
        • File locations and naming
      • Translating XLIFF files
        • The TYPO3 translation server
        • Translating locally
        • Custom translations
        • Custom languages
        • Custom translation servers
    • Programming with workspaces in mind
      • Frontend challenges in general
        • Summary
      • Frontend implementation guidelines
      • Frontend scenarios impossible to preview
      • Backend challenges
        • Workspace-related API for backend modules
      • Backend module access
      • Detecting current workspace
      • Using DataHandler with workspaces
      • Moving in workspaces
    • Digital assets management (FAL)
      • Introduction
      • Basic Concepts
        • Storages and drivers
        • Files and metadata
        • File references
      • Architecture
        • Overview
        • Folders
          • Processed files
          • Migrated files
        • Database structure
          • sys_file
          • sys_file_metadata
          • sys_file_reference
          • sys_file_processedfile
          • sys_file_collection
          • sys_file_storage
          • sys_filemounts
        • Components
          • Files and Folders
          • File References
          • Storage
          • Drivers
          • The File Index
          • Collections
          • Services
        • Signals and slots
          • \TYPO3\CMS\Core\Resource\ResourceStorage
          • \TYPO3\CMS\Core\Resource\ResourceFactory
          • \TYPO3\CMS\Core\Resource\Index\FileIndexRepository
          • \TYPO3\CMS\Core\Resource\Index\MetaDataRepository
          • \TYPO3\CMS\Core\Resource\Service\FileProcessingService
      • Administration
        • Permissions
          • System permissions
          • File mounts
          • User permissions
            • User permissions per storage
            • User permissions details
          • Default upload folder
          • Frontend permissions
        • File Storages
        • Maintenance
          • Scheduler tasks
          • Processed files
      • Using FAL
        • Using FAL in the frontend
          • TypoScript
          • Fluid
            • The ImageViewHelper
            • Get File Properties
            • FLUIDTEMPLATE
        • TCA definition
        • The ResourceFactory class
          • Getting the default Storage
          • Getting any Storage
        • Working with Files, Folders and File References
          • Getting a file
          • Copying a file
          • Adding a file
          • Creating a file reference
            • In the backend context
            • In the frontend context
          • Getting referenced files
          • Listing files in a folder
        • Working with collections
    • Caching framework
      • Quick start for Integrators
        • Change specific cache options
        • Garbage collection task
      • Configuration
        • Cache configurations
        • How to disable specific caches
      • Caching framework architecture
        • Basic knowhow
          • About the identifier
          • About tags
        • Caches in the TYPO3 Core
        • Garbage collection task
        • Cache API
      • Cache frontends
        • Frontend API
        • Available frontends
          • String Frontend
          • Variable Frontend
          • PHP Frontend
      • Cache backends
        • Backend API
        • Common options
        • Database Backend
          • InnoDB issues
          • Options
        • Memcached Backend
          • Warning and design constraints
          • Options
        • Redis Backend
          • Options
        • APC Backend
        • Xcache Backend
        • Wincache backend
        • File Backend
          • Options
        • Simple File Backend
        • PDO Backend
          • Options
        • Transient Memory Backend
        • Null Backend
      • Developer information
        • Cache registration and usage
        • Cache access logic
    • Using the system log
      • Making logging simple
    • Logging with TYPO3
      • Quickstart
      • Logger
        • Instantiation
        • Log() method
        • Shorthand methods
      • Configuration of the Logging system
        • Writer configuration
        • Processor configuration
      • The LogRecord model
      • Log Writers
        • Built-in Log Writers
          • DatabaseWriter
          • FileWriter
          • PhpErrorLogWriter
          • SyslogWriter
        • Custom Log Writers
      • Log Processors
        • Built-in Log Processors
          • IntrospectionProcessor
          • MemoryUsageProcessor
          • MemoryPeakUsageProcessor
          • WebProcessor
        • Custom Log Processors
    • Error and Exception Handling
      • Configuration
      • Error Handler
      • Production Exception Handler
      • Debug Exception Handler
      • Examples
        • Debugging and development setup
        • Production setup
        • Performance setup
      • How to extend the error and exception handling
    • Using the system registry
      • The registry table (sys_registry)
      • The registry API
        • Examples
    • Mail API
      • Configuration
        • mail
        • smtp
        • sendmail
        • mbox
        • <classname>
      • How to create and send mails
      • How to add attachments
      • How to add inline media
      • How to set and use a default sender
      • SwiftMailer documentation
    • Services
      • Introduction
        • Two reasons to use services
          • 1. Freedom of implementation
          • 2. Extend functionality with extensions
      • Using services
        • Service precedence
        • Simple use
        • Use with subtypes
        • Calling a chain of services
      • Configuration
        • Registration changes
        • Service configuration
        • Service type configuration
      • Developer's Guide
        • Introducing a new service type
        • Implementing a service
          • Service registration
          • PHP class
        • Service API
          • Service implementation
          • Getter methods for service information
          • Error handling
          • General service functions
          • I/O tools
          • I/O Input and I/O output
        • Service-related API
          • \TYPO3\CMS\Core\Utility\ExtensionManagementUtility
          • \TYPO3\CMS\Core\Utility\GeneralUtility
    • Authentication
      • Why use services?
      • The authentication process
      • The login data
      • The "auth" services API
      • The service chain
      • Developing an authentication service
      • Advanced options
    • Form protection tool
      • Usage in the backend
      • Usage in the Install Tool
    • Flash messages
      • Flash messages API
        • Flash messages severities
      • Flash messages renderer
      • Flash messages in Extbase
      • JavaScript-based flash messages (Notifications API)
    • System categories
      • Using categories
        • Managing categories
        • Making a table categorizable
        • Using categories in flexforms
      • System categories API
      • Category collections
      • Usage with TypoScript
    • System collections
      • Record collections
      • File collections
      • Collections API
      • Example
    • Enumerations
      • How To Use Enumerations
        • Create an Enumeration
        • Use an Enumeration
        • Exceptions
        • Implement custom logic
    • HTTP request library / Guzzle / PSR-7
      • Basic usage
    • Icon API
      • Registration
        • IconProvider
      • Use icons in your code
        • The PHP way
        • The Fluid ViewHelper
    • Hooks and Signals
      • The concept of "hooks" and "signals"
        • Hooks and Signals vs. XCLASS extensions
        • Proposing hooks or signals
        • Using hooks
        • Using Signals
        • Finding Signals
      • Hook configuration
        • $GLOBALS['TYPO3_CONF_VARS']['EXTCONF']
        • $GLOBALS['TYPO3_CONF_VARS']['SC_OPTIONS']
        • $GLOBALS['TYPO3_CONF_VARS']['TBE_MODULES_EXT']
      • Creating hooks
        • Using TYPO3CMSCoreUtilityGeneralUtility::makeInstance()
        • Using with TYPO3CMSCoreUtilityGeneralUtility::callUserFunction()
    • Extending classes (XCLASSes)
      • Introduction
      • How does it work?
      • Limitations
      • Declaration
      • Coding practices
    • Feature Toggles
      • Naming of Feature Toggles
      • Using the API as extension author
      • Core Feature Toggles
        • Example: Enable Feature Toggle
    • JavaScript in TYPO3
      • In-depth presentation
        • Client-Side programming
        • Server-side programming
        • Different Content Formats
          • Plain Text
          • XML
          • JSON
      • Developing with AJAX in the TYPO3 Backend
      • RequireJS in the TYPO3 Backend
        • Credits
          • Use RequireJS in your own extension
          • Dependency Handling
          • Loading your own or other RequireJS modules
          • Shim library to use it as own RequireJS modules
    • Soft References
      • Default soft reference parsers
        • substitute
        • notify
        • images
        • typolink
        • typolink_tag
        • ext_fileref
        • email
        • url
      • User-defined soft reference parsers
    • Session Storage Framework
      • Database storage backend
      • Using Redis to store sessions
      • Writing your own session storage
      • References
    • Rich Text Editors (RTE)
      • Rich Text Editors in the TYPO3 backend
        • Introduction
        • Plugging a RTE
        • API for Rich Text Editors
      • Transformations
        • Introduction
          • Hybrid modes
            • In Database
            • In RTE
          • Configuration
          • Where transformations are performed
        • Process illustration
          • Step 1: The RTE Applications
          • Step 2: The RTE-specific Transformation
          • Step 3: The Main Transformation
          • Step 4: The Database
          • Step 5: Rendering the website
          • Step 6: The Website
          • Content Examples
        • Transformation overview
          • Transformation filters
          • Meta transformations
        • Page TSconfig
          • Examples
          • RTE configuration
            • disabled
            • proc
            • RTE-specific
          • Processing configuration
            • overruleMode
            • allowTagsOutside
            • allowTags
            • denyTags
            • blockElementList
            • HTMLparser_rte, HTMLparser_db
            • dontRemoveUnknownTags_db
            • allowedClasses
            • keepPDIVattribs
            • dontFetchExtPictures
            • plainImageMode
            • exitHTMLparser, entryHTMLparser
            • User transformations
        • Custom transformations API
          • Custom transformation key
          • Registering the transformation key in the system
          • Code listing
      • Historical perspective on RTE transformations
        • Properties and transformations
        • RTE transformations in Content Elements
          • Conclusion
    • TypoScript Syntax Study
      • Introduction
        • About this chapter
        • What is TypoScript?
          • PHP arrays
          • TypoScript syntax, object paths, objects and properties
          • Note about perceived semantics
          • Note about the internal structure when parsed into a PHP array
        • Credits
      • Syntax
        • Introduction
          • Example
        • Contexts
        • TypoScript syntax
          • Example:
          • object path
          • operator
          • value
          • Comments
            • Example:
          • Comment blocks
            • Rules:
            • Example:
          • Value assignment: The "=" operator
            • Rules:
          • Value modifications: The ":=" operator
            • Rules:
            • Example:
          • Code blocks: The { } signs
            • Rules:
            • Example:
          • Multi-line values: The ( ) signs
            • Rules:
            • Example:
          • Object copying: The "<" sign
            • Example:
          • References: the "=<" sign
            • Example
          • Object unsetting: The ">" Sign
            • Example:
          • Conditions: Lines starting with "["
            • Rules:
            • Example:
        • Conditions
          • Where conditions can be used
          • The syntax of conditions
          • Combining conditions
          • The special [ELSE], [END] and [GLOBAL] conditions
          • Where to insert conditions in TypoScript?
          • The [GLOBAL] condition
          • Summary
        • Includes
          • Alternative, traditional Syntax
          • Conditions
          • Best practices
      • TypoScript Templates
        • Usage
        • Entering and structuring TypoScript templates
          • Inclusions
          • Template Analyzer
        • Constants
          • What are constants?
            • Example
        • Using constants
          • Example
        • Declaring constants for the Constant Editor
          • Default values:
          • Comments:
          • Keys:
            • cat=
              • Predefined categories
              • Custom categories
              • Subcategories
              • Predefined subcategories
              • Custom subcategories
              • Constants ordering
            • type=
            • label=
        • Debugging
      • TSconfig
        • Entering Page TSconfig
        • Entering User TSconfig
      • Sorting out details
        • Parsing, storing and executing TypoScript
          • Parsing TypoScript
          • Storing parsed TypoScript
          • Executing TypoScript
        • Myths, FAQ and acknowledgements
          • Myth: "TypoScript is a scripting language"
          • Myth: "TypoScript has the same syntax as JavaScript"
          • Myth: "TypoScript is a proprietary standard"
          • Myth: "TypoScript is very complex"
          • Why not XML instead?
      • The TypoScript parser API
        • Introduction
        • Parsing custom TypoScript
          • Root level
          • ->COLORS
          • ->ADMINFO
            • A case story
        • Implementing custom conditions
      • Next steps
    • Page types
      • Create new Page Type
    • User Settings Configuration
      • ['columns'] section
      • ['showitem'] section
      • Extending the User Settings
      • Checking the configuration
    • Extension scanner
      • Introduction
      • Goals and non goals
      • Limits
      • Extension authors
      • Project developers
      • Core developers
        • Connection to Changelog RST files
        • Extension scanner PHP configuration
    • Various examples
      • Debugging
      • Rendering page trees
      • Accessing the clipboard
        • Putting elements into the clipboard
      • Context-Sensitive Menus
        • Context menu rendering flow
          • Markup
          • ContextMenuController
            • Item providers registration
            • Gathering items
          • Menu rendering in JavaScript
        • API usage in the Core
        • Adding context menu to elements in your backend module
        • Disabling context menu items from TSConfig
        • Tutorial: How to add a custom context menu item
          • Step 1: Item provider registration
          • Step 2: Implementation of the item provider class
          • Step 3: JavaScript actions
      • Parsing HTML
        • Extracting blocks from an HTML document
        • Extracting single tags
        • Cleaning HTML content
        • Advanced processing
      • Links to edit records
        • Editing a record
        • Editing only a few fields from a record
        • Creating a form for new elements
      • Support for custom tables in the Page module
      • Adding elements to the Content Element Wizard
      • Using custom permission options
        • Registration
        • Evaluation
        • Keys for options
  • Coding Guidelines
    • Introduction
      • Following PSR standards
      • The CGL as a means of quality assurance
    • PHP file formatting
      • General requirements for PHP files
        • File names
        • PHP tags
        • Line breaks
        • Line length
        • Whitespace and indentation
        • Character set
      • File structure
        • Namespace
        • Copyright notice
        • Included files
        • Class information block
        • PHP class
        • Optional module execution code
      • PHP syntax formatting
        • Identifiers
        • Comments
        • Debug output
        • Curly braces
        • Conditions
        • Switch
        • Loops
        • Strings
        • Booleans
        • NULL
        • Arrays
        • PHP features
        • Global variables
        • Functions
      • Using phpDoc
        • Class information block
        • Function information block
          • Short and long description
    • PHP architecture
      • Modeling Cross Cutting Concerns
        • Static methods, static classes, utility classes
          • Characteristica
          • Rationale
          • Good examples
          • Bad examples
          • Red Flags
        • Traits
          • Characteristica
          • Rationale
          • Good examples
          • Bad examples
          • Further reading
        • Services
          • Characteristica
          • Rationale
          • Good examples
          • Bad examples
          • Further reading
      • Working with exceptions
        • Introduction
        • Exception types
          • Typical cases for exceptions that are designed to be caught
          • Typical cases for exceptions that should not be caught
        • Typical exception arguments
        • Exception inheritance
        • Extending exceptions
        • Good examples
        • Bad examples
        • Further readings
      • General links
    • Coding: Best practices
      • Accessing the database
      • Singletons
      • Static methods
        • Example
      • Localization
        • Defining localized strings
      • Unit tests
        • Unit test files
        • Using unit tests
        • Adding unit tests
        • Conventions for unit tests
      • Handling deprecation
      • Namespaces and class names of user files
  • Data Formats
    • <T3DataStructure>
      • Elements
        • Elements nesting other elements ("Array" elements):
        • Elements containing values ("Value" elements):
        • Example
      • Sheet references
        • Example
      • Parsing a Data Structure
    • <T3locallang>
      • Elements
        • Elements nesting other elements ("Array" elements):
        • Elements containing values ("Value" elements):
        • <T3locallangExt>
          • Example: locallang-XML file for a backend module
          • Example: locallang-XML file (CSH) with reference to external include file
  • Next Steps
  • Targets For Cross-Referencing
 
TYPO3 Core APIs
  • Docs »
  • TYPO3 explained »
  • Various examples »
  • Links to edit records
  • Edit me on GitHub

Links to edit records¶

It is often needed to create links to edit records in the TYPO3 backend. The same syntax is also used for creating new records. TYPO3 provides an API for creating such links, namely \TYPO3\CMS\Backend\Utility\BackendUtility::editOnClick(). This script will create an onclick-JavaScript event linking to the alt_doc.php script in the PATH_typo3 directory.

This is not always needed, especially in backend modules using the dispatcher method (which should be all backend modules, since the dispatched was introduced in TYPO3 4.1). A simple link to alt_doc.php (with the proper parameters) works just as well.

Furthermore when using Fluid templates, you cannot call PHP code directly but have to wrap it in a view helper. The "examples" extensions demonstrates with the "edit link" view helper (\Documentation\Examples\ViewHelpers\Be\EditLinkViewHelper):

public function render($parameters, $returnUrl = '') {
   $uri = 'alt_doc.php?' . $parameters;
   if (!empty($returnUrl)) {
      $uri .= '&returnUrl=' . rawurlencode($returnUrl);
   }

   $this->tag->addAttribute('href', $uri);
   $this->tag->setContent($this->renderChildren());
   $this->tag->forceClosingTag(TRUE);
   return $this->tag->render();
}

This can then be used in the Fluid template. Below are a few examples, also demonstrating what kind of parameters must be passed to achieve various results:

<p>
   <Ex:be.editLink parameters="edit[pages][1]=edit" returnUrl="mod.php?M=tools_ExamplesExamples&tx_examples_tools_examplesexamples[action]=links" title="{f:translate(key: 'function_links_edit_page_1')}">
      <Ex:be.icon icon="actions-document-open" title="{f:translate(key: 'function_links_edit_page_1')}" />
      <f:translate key="function_links_edit_page_1" />
   </Ex:be.editLink>
</p>
<p>
   <Ex:be.editLink parameters="edit[pages][1]=edit&columnsOnly=title,hidden" returnUrl="mod.php?M=tools_ExamplesExamples&tx_examples_tools_examplesexamples[action]=links" title="{f:translate(key: 'function_links_edit_page_1_restricted')}">
      <Ex:be.icon icon="actions-document-open" title="{f:translate(key: 'function_links_edit_page_1_restricted')}" />
      <f:translate key="function_links_edit_page_1_restricted" />
   </Ex:be.editLink>
</p>
<p>
   <Ex:be.editLink parameters="&edit[tx_examples_haiku][1]=new&defVals[tx_examples_haiku][title]=New%20haiku" returnUrl="mod.php?M=tools_ExamplesExamples&tx_examples_tools_examplesexamples[action]=links" title="{f:translate(key: 'function_links_new_haiku')}">
      <Ex:be.icon icon="actions-document-new" title="{f:translate(key: 'function_links_new_haiku')}" />
      <f:translate key="function_links_new_haiku" />
   </Ex:be.editLink>
</p>

The links appear as one can expect:

Edit links in the examples BE module

The three different links in the "examples" BE module

Editing a record¶

The first example (edit[pages][1]=edit) opens the page with uid 1 for editing.

The general syntax is thus "&edit[tablename][uid]=edit". You can specify as many tables and uids you like and you will get them all in one single form! The "uid" variable can even be a comma list of uids (short way of editing more records from the same table at once).

The examples above leads to the normal edit form for a page:

The standard form for editing a page

Page 1 ready for editing with the standard form

Editing only a few fields from a record¶

The second example does the same, but restricts the display to only the "title" and "hidden" fields (edit[pages][1]=edit&columnsOnly=title,hidden).

The fields can be listed in the "columnsOnly" parameter, as a comma-separated list. The example above results in the following:

The restricted form for editing a page

Page 1 ready for editing with a form showing only selected fields

Creating a form for new elements¶

The third example uses somewhat more complex parameters:

&edit[tx_examples_haiku][1]=new&defVals[tx_examples_haiku][title]=New%20haiku

The link triggers the creation a new record for the table "tx_examples_haiku" on page 1. It also sets a default value for the "title" field ("New haiku"). Note the following things:

  • the first parameter is still called "edit" even if this is about creating a new record. The creation of a record is indicated by the value "new".
  • the value in the second pair of square brackets ([1]) indicates the page where the new record will be stored.
  • you need to URL-encode the values yourself, if needed (e.g. New%20haiku).

This results in the following form, standard but with a pre-filled title field.

Creating a new haiku

Form for creating a new haiku with pre-filled title

Next Previous

View page source

© Copyright since 2000 by the TYPO3 Documentation Team

Last rendered on Apr 14, 2018 22:40

Built with Sphinx and t3SphinxThemeRtd. Report theme issues here.

Legal Info

Versions
Project
Contact
Issues
Repository
Downloads
Related Links v: latest (9-dev)