The data structure

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

CORE

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.

DATA

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

GUI

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 :

/viewer
/graph
/parameters

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

Advertisements

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 !

ButtleOFX

Last meeting before the winter break

Since the last meeting, we decided many things about our project.

During the last weeks, we created the arborescence : we split the core from the graphical user interface (gui).
We now have a main application that gather all the modules . The viewer and the nodes are connected : when we click on a node, the picture associated is seen in the viewer. The Param Editor should be connected soon.

We discuss about five main subjects during the last meeting :

  • The data structure : we have to organize our code in differents layers :
    – The ButtleApp in python : it’s here that we define all our classes.
    – The Buttle Wrapper in python and PySide : it enables to wrap the nodes and to communicate with the interface.
    – The QManager : it enables to handle the elements created dynamically in QML
    – The QItem
  • In order to connect the different layers, we decided to make a system of update : the ButtleWrapper observe the QItem. When an item changes in the interface, it notifies the ButtleWrapper which upadtes itself.
  • Resizable application : currently, if you resize the main window, some contents are hidden. So the aim is now to make everything resizable in order to have a usable application.
  • Undo/Redo : we created the base of the undo-redo but we now need to create all the commands to undo and redo all our functions.
  • Connections : in the graph, the nodes are now functionnal. We have to make the connections between them.

The aim is to connect Buttle to Tuttle when we come back in January. We have a lot to do but we are motivated ! Moreover, Fabien sent us some mails today with technics that simplify our code ! (For example, the QManager is not used anymore for the nodes).