GBX and Tools in Woodman Docker

Thanks to the development of neural networks, automating work has become much easier now.

CorelDRAW has long allowed you to write macros for almost any routine task. Of course, you can write your own macro completely from scratch. But this is not always easy, especially if you are not a programmer and do not want to dig into all the internal details.

And this is exactly where the docker makes life much easier.

A lot has already been done and thought through in it:

• there is a ready-made structure;
• there are clear ways to connect your own macros;
• there are ready-made examples;
• there is a more convenient approach to working with CorelDRAW objects.

So you do not need to start from a blank page and immediately dive into the complex programming part.

At first glance, all this may seem unfamiliar, but in practice you can give the neural network a reference file and a couple of examples directly from the docker, and it will already understand what format the code should be created in. This means that even without deep programming knowledge, you can build your own tool faster and start getting rid of routine work.

There are two main ways in the docker

There are two main ways to do this in the docker: a simple one and a more advanced one.

1. GBX — simple level

The first and simplest level is GBX.

GBX is a universal modular generator where each generator is represented by a separate JS file. Such a file is automatically read by the docker and added to the list.

The main advantage of GBX is that you do not need to think about how everything works at the lowest level.

Using simple rules, you describe the interface:

• required fields;
• checkboxes;
• buttons;
• parameters.

After that, you use an already simplified way of creating CorelDRAW objects and interacting with them.

All the required information is described in detail in the file:

gbx_readme.txt

2. TOOLS — more advanced level

The next, more advanced level is creating your own tool through TOOLS.

Here you need to create your own HTML and JS files with a name like:

cat_<your module name>

In HTML, you write a full interface, and in JS, you place your scripts.

After that, you simply place these files into the folder:

tools

And the docker will automatically pick them up. The new tool will appear in the list, as if it had always belonged there.

Very convenient. And what is especially nice, without the feeling that for one simple action you now have to pay separately with time, nerves, and reading three forums in a row.

I also recommend drawing a nice button and placing it into the folder:

img

Because a macro without an icon will, of course, still work. But your own button immediately turns it from just a line in a list into a proper tool that looks like it belongs.

It is a small thing, but it is exactly these small things that make the interface stop feeling temporary and start feeling like a well-thought-out working environment.

A real implementation example

There is already a good example of how this can look in practice from one of the subscribers.

He made several generators, some of which are already included in the docker out of the box, as well as a separate powerful tool for creating CNC programs, that is, G-code, for a router and plasma cutter.

This is exactly the case when the idea did not stay somewhere at the level of:

“Well, theoretically, this is possible.”

The person took the ready-made docker base, added his own task, turned it into a proper tool, and now it is no longer just a macro in a separate file, but a full-fledged part of the working system.

You can see his work here: boosty.to/groslazerdesign

The main point

You do not have to be a programmer or write everything from scratch.

The docker already takes care of most of the complex preparation work, and all you need to do is explain more clearly to the neural network what exactly you want to automate, and get a working result faster.

And perhaps that is the most important part.

You do not struggle with complex methods or assemble everything piece by piece from nothing. You create your macro almost like a constructor, and then it immediately becomes part of a convenient docker, alongside other useful tools.

This way, automation stops being something distant and complicated. It becomes an ordinary working assistant that gradually takes over routine tasks and leaves you more time for the actual work.