Status report September 30

Compiled a new version of wrappers for OpenCascade 6.3 and uploaded it on SVN on \wrappers\builds\debug\.
Ported the previous version of C++/CLI Naro to OpenCascade 6.3.
Started porting the new version of Naro made with SCSF to the new wrappers. The visualization works properly but the importer crashes, there are some small changes needed at the wrappers.

Tomorrow will work at recompiling the wrappers with the small changes, and finish porting the previous C# Naro application and the current SCSF Naro application. This task should take about half a day. After that will continue with the tasks scheduled last week.

Status report September 29

Worked at generating the wrappers for OpenCascade 6.3.
Tried to generate wrappers also for the new visualization package named NIS but there is a lot of handmade code to be made there so for the moment left the package out of wrapping.

Prepared the code generator, generated the wrapper files and started compiling the generated codes. I think that by tomorrow, if no special problems will arise, the wrappers will be compiled successfully and uploaded on SVN.

Status report September 27

Analyzed the new OpenCascade version 6.3 against the previous version. The changes are not that big as expected.

The result of the analysis:
- at file level, classes signature: from the 14587 there are 454 different files, 501 new files added and removed 64. The code changes are not very big: some char* changed to const car*, some virtual keywords removed, many new data types and handlers added. From the functionality point of view the changes are not so big: some layer management added, some code patches, small changes at the visualization code,
- the documentation is almost unchanged, added small texts about the new functionality: something like added a page of text describing projections,
- the sample code applications are unchanged.

Tomorrow will work at updating the wrappers to support the new OpenCascade version. Task estimated to take 2 days. The update is important because the application is at the point where OCAF will be inserted and the new version of OC claims that there are many improvements added to OCAF.

After finishing this task will continue with the tasks scheduled last week.

Status report September 26

Worked at porting the Sketcher functionality to the new project.

Made a Rectangle 2D class and made also a test OpenCascade solution where created a 2D and a 3D view. On this application will test what happens when OpenCascade 2d/3d views are assigned to the same Form and also will test the 2D drawing functionality. When the code will be ok will add the files into the SCSF NaroCad project.

Studied also the OpenCascade documentation about 2D drawing and analyzed the sample applications to see if the solution implemented previously is ok.

Tomorrow will continue working at porting the Sketcher. The tasks that remained to be made: decide if the current 2D drawing code is properly implemented, implement a rectangle driver that allows storing the rectangle shape into OCAF, port the 2D drawing code to the application, make transitions between the 3D and 2d views.

Work status September 25

Finished implementing the modeling commands by adding a rectangle drawing at window zooming and at selection.
Finished the Load from file functionality.
Implemented the Selection mechanism for selecting vertices, edges, faces and solids.

Started working at porting the Sketcher functionality (2D drawing) together with adding OCAF functionality in the application. All the newly created shapes will be added in the OCAF tree and the operations will support Undo/Redo.

Hope to finish this task in about 2 days. Some of the subtasks of this task are: implement a Rectangle2D class derived from AIS2D_InteractiveObject to be drawn on the screen, implement a rectangle driver that allows storing the rectangle shape into OCAF, port the 2D drawing code to the application, make transitions between the 3D and 2d views.
In parallel with this task will also work at making a roadmap and a release estimation.
The tasks made and under development are posted on Sourceforge. More tasks will be added there.

Work status September 24 (2)

Added at the application a new module that imports BREP files. The module automatically adds itself to the File->Import menu.
The files are loaded properly. Will work again at this functionality when the OCAF will be added, at that time the loaded module will have to be added at the root Label to support Undo/Redo.
The source files are still loaded under \branches\newcode\ folder.

Tomorrow will work at finalize the unfinished tasks and also at adding new tasks to be done on the release version 0.0.1.

Progress report September 24 (1)

Finished implementing the object manipulation commands: fit all, dynamic zooming, dynamic panning, global panning, front, top, left, back, right, bottom, axo, dynamic rotation, reset, hidden on, hidden off.
Made a part of zoom window command. Remained to implement drawing a helper rectangle that shows the selected area.


Started on Sourceforge a Release 0.0.1 task. Started adding there small tasks to be finished to have this release version and an estimation and progress for them. These days will finish adding all the tasks and make a final estimation for the 0.0.1 Release version.

Progress report September 23

Today implemented the commands that manipulate the model (top, left, right, etc).
Added also the code that splits the working view in 1 to 4 windows, the commands are automatically added to the menu by the loaded module.

Next tasks to be done:
- enable the tree view from the left, estimated to take 1-2 hours,
- add commands and finish existing commands that involve mouse move events and GDI drawing, estimated to take 3-4 hours,
- port the code that loads from file as a module, task estimated to take 2-4 hours,
- make a situation with the tasks to be done and post a project roadmap on Sourceforge and maybe also on the web page, task estimated to take 2-3 hours.

I hope in two days to have everything ported from the previous C# application and start porting the previous code from the C++/CLI original project (the 2D drawing).

Progress report September 22

Continued the work at porting Naro to SCSF.

Today implemented a service that allows modules that load to add their own toolbar with their own commands. At the Modeling module loading added code to create its own toolbar dynamically and it worked.
Implemented also the window redrawing event and the OpenCascade content appeared.

The latest code version is on SVN \branches\newcode\.

Next tasks to be done:
- execute/port the commands generated by the loaded toolbar (zoom, rotate, pan, etc), task estimated to take a few hours,
- enable the tree view from the left, estimated to take 1-2 hours.
Hope to finish some of these tasks today.

When these are finished will continue with adding the load from file module.

Work progress September 21

Added OpenCascade code to the application. It starts properly but the redrawing is not made yet properly.

Will continue working at the Command infrastructure of the application and implement the redrawing, rotate, zoom, etc commands. Task estimated to take half a day up to a day.

Work progress September 20

Finished porting the modeling view to the SCSF application. Will continue with working at adding OpenCascade code.

Work progress September 19

Worked at porting the 3D modeling view on the new SCSF application. Not finished yet.
Started preparing the Command infrastructure of the application.

Tomorrow will work at finishing these two tasks.

Work progress September 18

Added a new module to the SCSF application, module that handles Drawing Parts. The module registers itself in the File->New->Part menu, loads the application layout and fills there the specific controls for this operation.
Started working at implementing this module.

Next tasks to be done at implementing the Part module:
- port the 3D modeling view on the right side of the Drawing Part module view, on the left will be loaded a tree view control,
- port the model manipulation functionality (rotate, zoom, etc).

Work progress September 17

Succeeded to build an application with SCSF having a MDI workspace. The Layout is in a separate module and it contains a tabbed Icon workspace for the tree list and a Deck workspace for the drawing area.

The next step is to port the 3D drawing code on the Deck workspace, task estimated to take 1-2 days. This will be made a separate module.

Work progress September 11

Made the layout of the application.

The architecture will be like the following:
- the main application contains a Shell and a menu,
- the View Layout module that contains on the Left an IconTabbedWorkspace (containing the tree view) and on Right a DeckWorkspace with the UserControl that can split in 4 views. Different user operations like Drawing a Part, Making an Assembly, Make a Drawing will use a view with this Layout on which they load their custom tabs,
- each set of functionality (like model manipulation or selections) will be packed into a module that registers at loading a toolbar with the functionality that it provides and the menu entries; the main application has access to the UIExtension sites and can show/hide any of the registered toolbars,
- each use case, like Drawing a Part, will start by launching an child ControlledWorkItem that has access to the Application Model (the OCAF tree), at the application context and active view,
- the View will generate loosely coupled events that will be listened by the running child WorkItem or internally by the tree view.

Studied the Tree views that similar applications have. Actually in the tree view they represent the model through the sketches and the features applied to them. Looked how the features are attached to sketches and what happens if a sketch or a feature is deleted.

Will continue with implementing this concept and porting existing code on it.

Work progress September 10

Porting Naro to SCSF is very exciting. Spent the day at implementing the application infrastructure and also tried different layouts for the views.

Tomorrow will continue working at the layout and at module splitting.

Started porting Naro to SCSF

Started making the application Shell and thinking at different possibilities for refactoring the application structure.

Tomorrow will start coding by splitting the code into modules that load at application startup.

Work progress September 8

Spent the day evaluating the Spring.Net vs SCSF functionality, read blogs/articles on the features they provide and comparisons on them, looked at the reference manuals. It seems that the NaroCad needs are covered by these frameworks each with its advantages and disadvantages. Probably will choose Spring.Net because it has a license that fits better the project's purpose.

The functionality that I plan to achieve in the next two weeks is to have a modular application that allows drawing a 2D shape and raising it on 3D having the possibility to Undo the operations. As an extra feature the drawn object should be visible in a tree view. The modules will be plugged in the application at startup.

The next tasks that I am planning to do are the following:
- include one of these frameworks into the application: modify the application to be split on modules loaded at startup, implement loading a STEP file as the first module/plugin of the application, task that should take 2-3 days using Spring.Net or less with SCSF,
- in parallel make a document describing the application architecture that will be updated weekly and make a page with the application roadmap, task that takes 1-2 days,
- start adding new functionality to the application: review the undo/redo mechanism and implement it properly in the application, port the 2D drawing from the C++/CLI version (task that should take 2-4 days), add an object tree view (task that should take 2-4 days), add a 3D functionality like Extrude to be applied on a 2D shape.

Work progress September 5

Looked today at Mono.AddIn framework.

Currently I am pretty puzzled not having an idea what decision to take on which framework to use or how to combine them to obtain the functionality needed.

Will study more on Internet about use cases with these frameworks and hope to have a clear image/point about what path to follow until the end of the weekend.

The possibilities that I see now (not having a deep understanding of the frameworks) are:
- SCSF that offers much of the functionality needed but limits the usage on Windows, the advantage is also that I have some knowledge about it,
- Spring.Net with Spring.Net RichClient that might have the functionality needed, at a first view it seems to cover the application needs, don't know yet how well it supports Windows-based applications,
- a combination like Windsor container for Dependency Injection and something like Mono.AddIn for extending it or StructureMap to implementh both DI and plugins. At the first look these doesn't seem to deliver the functionality delivered by SCSF.

On the other hand I would like to hurry implementing OpenCascade functionality that probably will create the biggest problems in application development.

Hope to have a more clear idea at the end of the weekend.

Work progress September 4

Looked at Spring.Net and Spring.Net RichClient application frameworks.
Read blogs to see user experiences with some of the application frameworks.

Work progress September 3

Started evaluating the Windsor Container, Spring.Net and StructureMap. Looking also for possibilities to integrate with these concepts from SCSF that might be changed later in the case of porting to Linux.

Looked at Windsor Container sample codes and made a quick review on StructureMap. The Plugin and Pluggable attributes/concepts from the later look interesting.

Will continue with looking at StructureMap and at Spring.Net.

Work progress September 2 (2)

In the previous post the sentences might be confusing not explaining that Windsor is mainly an inversion of control container offering only a part of the functionality a software factory offers.
Not found yet a software factory offering similar functionality as SCSF.

Work progress September 2

Worked at making with SCSF an use case where using Root and Child Controlled WorkItems with Model View Presenters, Events and Commands to understand how these concepts work together. Got a general understanding of these. The code provided with SCSF is great, improves a lot the productivity but has a problem: the EULA from the site restricts its usage only to Windows (the EULA from the source codes doesn't specify this restriction).

Because of the license restrictions from SCSF started searching for alternative software factories that might provide similar functionality. The main functionality needs are: enable modular architecture, dependency injection, oriented towards testability and plugability. The Windsor Container probably will be chosen. Also parts from Caliburn might be useful. They don't offer that much functionality like the one provided by SCSF but they are of great help.

The tasks that will be made:
- spend two days evaluating/learning Windsor and Caliburn also think how much it would take to implement an EventBroker like and Command mechanism, search for other alternatves,
- decide for a solution and make an estimate/roadmap.