` view element. You can see the input and output in the snippet below.
> **Note**
>
> This is just an example. In fact, paragraph support is already provided by the [paragraph plugin](../../../api/paragraph.md) so you do not really need to write your own ` ` element conversion.
You just learned about the [`elementToElement()` **downcast** conversion helper method](helpers/downcast.md#element-to-element-conversion-helper)! More helpers are documented in the following chapters.
## Downcast pipelines
The CKEditor 5 engine uses two different views: the **data view** and the **editing view**.
The **data view** is used when generating the editor output. This process is controlled by the data pipeline.
The **editing view**, on the other hand, is what you see when you open the editor. This is controlled by the editing pipeline.
The simple code example presented before registers a converter for both of these pipelines at once. It means that a ` ` view element in both the **data view** and the **editing view** all the same.
Sometimes you may want to alter the converter logic for a specific pipeline. For example, in the editing view you may want to add some additional class to the view element. This kind of operation requires setting separate converters for both views, unlike the previous example where one, general downcast was set up.
```js
// dataDowncast for data pipeline
editor.conversion
.for( 'dataDowncast' )
.elementToElement( {
model: 'paragraph',
view: 'p'
} );
// editingDowncast for editing pipeline
editor.conversion
.for( 'editingDowncast' )
.elementToElement( {
model: 'paragraph',
view: {
name: 'p',
classes: 'paragraph-in-editing-view'
}
} );
```
## Converting text attributes
As you should already know from the [chapter about the model](../../architecture/editing-engine.md#model), an **attribute** may be applied to a model text node.
Such text node attributes may be converted into view elements.
To do so, you can register a converter by using the [`attributeToElement()` conversion helper](helpers/downcast.md#attribute-to-element-conversion-helper):
```js
editor.conversion
.for( 'downcast' )
.attributeToElement( {
model: 'bold',
view: 'strong'
} );
```
The above converter will handle the conversion of every `bold` model text node attribute to a `` view element, as shown in the snippet below.
> **Note**
>
> Again, this is just an example for the sake of simplicity. Bold support is actually provided by the [basic styles](../../../features/basic-styles.md) plugin so you do not have to write your own bold attribute to strong element conversion.
## Converting element to element
Similar to the previous example, you can convert a ` ...` view element with the use of the [`elementToElement()` conversion helper](helpers/downcast.md#element-to-element-conversion-helper). A code to achieve it would look like this:
```js
editor.conversion
.for( 'downcast' )
.elementToElement( {
model: 'heading',
view: 'h1'
} );
```
Which is equivalent to:
```js
editor.conversion
.for( 'downcast' )
.elementToElement( {
model: 'heading',
view: ( modelElement, { writer } ) => {
return writer.createContainerElement(
'h1'
);
}
} );
```
You have previously learned that the `view` property can be a simple string or an object. The example above shows it is also possible to define a custom callback function to return the created element instead. The effect for this kind of conversion can be observed in the snippet below:
The `
`, `
`, etc).
You can check this in action by using the example below. Use the dropdown to change heading level in the model and see how view elements are updated by the converter:
> **Note**
>
> This, again, is just an example. Heading support is actually provided by the [headings feature](../../../features/headings.md) so you do not have to write your own `
` element conversion.
## Converting element to structure
Sometimes you may want to convert a **single model element** into a more complex view structure consisting of a **single view element with children**.
You can use the [`elementToStructure()` conversion helper](helpers/downcast.md#element-to-structure-conversion-helper) for this purpose:
```js
editor.conversion
.for( 'downcast' ).elementToStructure( {
model: 'myElement',
view: ( modelElement, { writer } ) => {
return writer.createContainerElement( 'div', { class: 'wrapper' }, [
writer.createContainerElement( 'div', { class: 'inner-wrapper' }, [
writer.createSlot()
] )
] );
}
} );
```
The above converter will convert all `