2nd week of full work for ButtleOFX!

Hello !
The 2nd week was very intense for us, and results are here!

The Interface :
* The 4 views are totally functionnal, and can pass in full screen.
* There are 3 modes to open ButtleOFX : the “default mode”, the “browser mode”, the “advanced mode”

The Graph :
* Hard work on connections :
* We can unhook connections from the nodes
* We can switch connections
* Deletion of connections is easier
* Copy and paste nodes with their connections
* Translation of several nodes with their connections

The Browser :
* The browser is linked with the viewer
* Drag and drop of images and create automatically corresponding reader nodes
* Improve text input for path
* Arrows previous and next are functionnal
* Possibility to rename and suppress items and create folders
* Management of shortcuts

The Advanced Mode :
* We can create node without seeing the graph, only with a new Param Editor, which lists all the created nodes.

Miscellaneous :
* Help on nodes
* Parameters hint : the nodes properties are now available by right click on a node, and the paramaters are still on a separated column.

Next week we have a presentation of the avancement for the university. At this time we will post report.

The Buttle Team #2

The new version is in progress !

Hello !
For one week now, we’ve been fully working on Buttle.
And results begin to come ! So what’s new for the moment?

* Importants bugs has been fixed
* We worked on little improvements of design (menu, parameters…)

The Interface:
* Buttle workspace is shared in 4 view (Browser, Viewer, Graph, Params) which can be changed or closed

The Graph:
* Zoom is working
* A miniature of the graph was added

The Browser:
* You can browse between directories
* Was imported on Buttle Software
* We improved the management of the path text (suggestions)

* You can list nodes in the parameters part (usefull if the graph view is closed)

And it’s not the end ! We still have full of improvement to make !
And don’t worry if you think we can make much news features : we decided to have more quality than quantity !
In fact, as ButtleOFX is a open source software, we want our code to be clear and perennial.

So RDV next week, to tell you where we’ll be !

The Buttle Team #2

Last meeting


The last meeting was about menu and image browser!
We have done a begining of a new menu, because the old one doesn’t work with the moving that we have done. We have to find our way with QML and Python languages but it’s in progress.
Moreover, an image browser is being built : it offers to choose an image more easily than before. We are thinking about adding a viewer inside the browser to browse sequences or simply see images in a bigger size.
In order to improve the actual graph system we are also discovering in details the Canvas element in QML.

We keep on working!

Fresh news


It’s been a while since our last article but that doesn’t mean we’re not still working hard on the project ! So, to sum up, we presented the first version of our application the 1st of Frebruary and although it was rather a success, there are still some details we need to work on.

During the past month, we have been improving the following features :

Graphical User Interface
We are now able to see the name of the nodes’ clips. It helps the user when he wants to connect the nodes.
We can drag a node’s clip and drop it on another node’s clip to connect the concerned nodes. It makes it easier for the user : clicking on the clips was more difficult given their small size.
To select the node that will be displayed in the viewer, we now have to drop a mosquito on it (instead of double clicking). The double click will now assign a node to the param editor, and the single click will select a node in the graph editor (that the user will be able to cut/copy/paste etc). No more right click !
We have been improving the color picker so the position of the cursor changes when the parameters are modified.
In the param editor, the values are set to default on right click, and they appear in bold when the user changes them.
We have also set an icon for the application, which is better than the default question mark.

The undo/redo is now functional for almost every type of parameter (except for the RGB/RGBA parameters).

We have made changes in the data structure. We now have a ButtleData and a ButtleManager. ButtleData used to do all the job. Now, ButtleManager catches events from the QML and delegates the actions to the appropriate manager : nodeManager, connectionManager, etc.
ButtleData holds the current selected nodes’ information. We are also working on the multi selection so we replaced members such as “currentSelectedNodeName” with lists containing several names.


We still have a lot of issues and bugs to fix. The most important are :

Allow the user to save a graph
Improve the multi selection
Manage the keyframes
Display a light in the connections when an image is being computed
Manage several views in the viewer

First appraisal of the project

Hi !

The first appraisal of the project, this morning, passed well !

Our application improved a lot since last week and is now functional. Here is a screenshot of the programm at the current time :


The graph is now completely connected to Tuttle. We can create reader nodes while drag&droping images from the computer in the graph or loading a reader plugin manually from the organized list of plugins. We can access and modify all parameters of the node, and see the modifications in the viewer.

We have implemented a toolbar which permits us to copy, cut, paste, duplicate or delete the nodes, and to undo or redo the main commands.

We have installed the plugin FFMpeg and our player is now compatible with videos, so we can apply some effects on the video in real time, while playing in the viewer.

As our application was functional, we decided to install external plugins to try and use them in ButtleOFX. We installed the Sapphire plugins from GenArts, a platform based on OpenFX standard, so we can use these plugins in ButtleOFX. Then, all OpenFX plugins can be used in Buttle !


Points to improve in the next weeks :

  • Write the undo/redo commands for each undoable action, especially on the parameters
  • Improve the user experience (possibility to select several nodes, improvement of the Drag & Drop for the viewer and the connections)
  • Improve the color picker, not completely functional yet
  • Fix the different current bugs

Our objectives for the second semester :

  • A time management with keyframes for each parameter
  • A way to save the graph in a file and to be able to reload it later
  • A miniature of the graph (a usefull tool when the graph become very big)
  • A communication work : several videos, a presence on the social networks
  • A possibility to share the application (a point to discuss with our tutor, because we need to install TuttleOFX to use ButtleOFX, and currently there is no simple installer for Tuttle…)

The slides of our presentation: here !

See you soon for new adventures !

The data structure

We decided to divide our structure in three directories : buttleofx/core, buttleofx/data and buttleofx/gui.


For the moment, we can find the undo/redo commands in this directory. For every undoable action in the application, we will have a class with the undo and redo commands. For example, when a node is dragged, it is possible to undo the action. For this we will have a CommandSetCoord class with fucntions such as UndoCommand and RedoCommand.


It will contain all the data needed to manage the application. We created a singleton ButtleData defined by a Graph and the corresponding GraphWrapper.


Concerning the graphical user interface, we have been working hard on the data structure but finally got to something relevant. We will have three main layers :

The core objects
This layer will store the hard data, for example the Nodes’ name, type, position, …
It will contain python objects such as a Node class and a Graph class.

The wrappers
They are necessary to bind the qml data with the python data. For example, to expose the Nodes’ data in the form of QProperties.
It will contain objects such as a NodeWrapper class and a GraphWrapper class.

The qml objects
These are the one that the user will be able to see in the application. They are created from a model defined by the wrappers.

We want to separate the data concerning our three elements, so we will have three directories :


Each one will include the corresponding core objects, wrappers and qml objects. This way, we can work on and execute the three elements separatly.

Where we are up to with the project

When clicking on the “+” tool of the graph, a menu drops down showing the different types of nodes. After selecting one of them, a node appears in the graph. It is then possible to delete it with the “-” tool, or with the delete keybord key.

The nodes are defined by an image which can be displayed in the viewer by simply clicking on the existing nodes.

A list of parameters appears on the right. For the moment, we can modify the values visible in the inputs. But there is no interaction with the other modules yet.

So this is where we are up to with the project, and we still have a lot to do !