Skip to main content

Create an editor

note

This section describes how to create a single editor for a 'simple' type app. For a more complex app with object hierarchy, see the instructions on how to create a tree-type app.

To create an editor, we first need to define an entity type by creating its controller in app.py.

The controller class

To create an entity-type's controller class, define a class that inherits from ViktorController in app.py. The name of the class is the name of the entity type. The label attribute is obligatory and defines the name of the entity type as shown in the interface:

from viktor import ViktorController


class ExampleType(ViktorController): # defines entity type 'ExampleType'
label = "Example Type" # label to be shown in the interface

Next, we will define the editor's parametrization.

Click to see all available controller members

New in v12.11.0

Create a views-only editor by omitting the parametrization attribute on the corresponding controller class.

Changed in v12.6.0

Controller attribute summary is no longer required to be defined.

Changed in v12.3.0

Entity type information (label, children, and show_children_as) were added to the controller class (and removed from the manifest).

The controller class has the following members:

  • label (obligatory): name of the entity type as shown in the interface.
  • parametrization: defines the editor's parametrization.
  • summary: to show a summary.
  • children: (tree-type app only) define this entity-type's children. Not providing the key is equal to having no children.
  • show_children_as: (tree-type app only) defines how to visualize the children ('Table' | 'Cards').
  • methods for views.
  • methods for action buttons.
  • method for processing of a file upload.
  • any other methods you'd like to create yourself.

Defining a parametrization

To create the editor's parametrization, define a class that inherits from ViktorParametrization in app.py and assign it to the controller class using the parametrization attribute.

The name of the parametrization class is arbitrary. Input fields and action buttons can be added to the editor by adding them as attributes on the parametrization class. For example:

from viktor import ViktorControllerfrom viktor.parametrization import ViktorParametrization, TextField, NumberFieldclass Parametrization(ViktorParametrization):    input_1 = TextField('This is a text field')       # add a field for textual input    input_2 = NumberField('This is a number field')   # add a field for numeric inputclass ExampleType(ViktorController):    label = "Example Type"    parametrization = Parametrization   # assign the parametrization class to the controller class

The above editor's parametrization will look as follows in the interface:

Example parametrization

Defining a view

Views can be added to the editor by defining a view method on the controller class and decorate it with one of the available view classes. The label argument is obligatory and defines the name of the view as shown in the interface, as well as the duration_guess argument, which tells the platform to render the view instantly or not.

The view method should return the view result that corresponds to the chosen view type (e.g. GeometryResult for a GeometryView). User input is passed to a view method by means of the params argument in the method's signature:

class ExampleType(ViktorController):   ...   @GeometryView("Geometry view", duration_guess=1)   # decorate the view method with one of the available view classes   def my_geometry_view(self, params, **kwargs):      # create a view method       geometries = ...                               # params can be used to create results based on the user input       return GeometryResult(geometries)              # return the view result that corresponds to the view class
Click to see all available view arguments

New in v12.7.0

An update_label can be added to a view to change the default text presented on the update button

New in v12.5.0

A description can be added to a view to provide more information to the user through a tooltip

Every view class has the following arguments:

  • label (obligatory): name of the view as shown in the interface.
  • duration_guess (obligatory): tells the platform whether the view should be rendered as a quick or slow visualization:
    • <= 3: Quick visualization, which updates with every change in the editor.
    • > 3: Slow visualization, which can be refreshed manually by means of an update button.
  • description (>= v12.5.0): provide more information to the user through a tooltip (supports Markdown).
  • update_label (>= v12.7.0): change the default text presented on the update button.

Example

The following example controller implements 2 numeric input fields, a download button, and 2 views (geometry and data):

from viktor import ViktorControllerfrom viktor.geometry import Point, Spherefrom viktor.parametrization import ViktorParametrization, NumberField, DownloadButtonfrom viktor.result import DownloadResultfrom viktor.views import GeometryView, GeometryResult, DataView, DataResult, DataGroup, DataItemclass Parametrization(ViktorParametrization):    x = NumberField('X')    y = NumberField('Y')    download = DownloadButton("Download file", method='download_file')class ModelController(ViktorController):    label = 'Model'    parametrization = Parametrization    @GeometryView('3D Geometry', duration_guess=1)    def get_3d_view(self, params, **kwargs):        geometry = Sphere(Point(0, 0, 0), radius=10)        return GeometryResult(geometry)    @DataView('Data', duration_guess=1)    def get_data_view(self, params, **kwargs):        addition = params.x + params.y        multiplication = params.x * params.y        main_data_group = DataGroup(            DataItem('Data item 1', addition),            DataItem('Data item 2', multiplication),        )        return DataResult(main_data_group)    def download_file(self, params, **kwargs):        return DownloadResult('file content', 'file name')