As of today BaseGUI consists of the following functional components:
- The Base controller: This is the main class to create instances of
specific file types, there already exists a Txt instance derived from this class
that helps to deal with standard .txt ASCII files.
- The Widget controller: This is the main class to create graphical components on the system.
There exists already several GUI components implemened such a: checkboxes, comboboxes,
text entries.
The fundamental design of basegui has not changed practically anything from my
initial proposed model.
I have already built 4 different graphical interfaces using these two controllers, for the files:
/etc/conf.d/{clock,consolefont,metalog,keymap} , and i hope many more comings.
Both of the controllers have been designed simultaneously, though i started coding
on the Base controller first (as planned in my proposal) , and from there on,
building the Widget controller and the necessary utilities for them to work.
Just to give some percents about my progress:
- Base Controller : 70%
- Widget Controller : 60%
- GUIs:
- clock : 100%
- metalog : 100%
- keymap : 90%
- consolefont : 80%
I expect to design at least 4 more GUI's.
I still need to do some work on both of the main controller classes,
but they involve more about extending certain functionalities and checking
for possible errors than anything else, so the main function is already implemented
in both of them.
Now, to describe very briefly how BaseGUI works, but first at all,
we have to specify what BaseGUI really is.
BaseGUI is two things:
1- A graphical interface for easy access in a centralized way
of different GUI's in the system.
2- An API to design these graphical interfaces and easy heir integrations
into the system.
Users will only care of the number (1) aspect , they don't need to deal with
any programming feature.
Programmers will work with the number (2) aspect to design and integrate their
GUI's into the BaseGUI application.
These are the resumed and general steps of how BaseGUI works:
- Create and associate a Base controller object with a specific file of
a certain type in the system.
- Create a Widget controller object and associates it with a specific Base controller
object to get a graphical functional widget.
- Use the different Widget functions and utilities to work around the file
through a specific Widget controller.
- Pack these Widgets components into the main graphical window.
All these functionalities are already working on the program.
Now, this is just a brief and general explanation of how BaseGUI works, but it might
involve more steps depending on the needs of the user, like for example, deriving
instances from the main Base controller class to support more file types, etc.
One important feature of BaseGUI is that allows developers to integrate graphical
interfaces written on any language so far, but its API can only be used to build
pygtk (python+gtk) interfaces at the moment, so i like to say that the point
number (1) is a language independent feature and point number (2) a language dependent
feature of the application.
It would be possible to create bindings for the API on other languages, and i plan to do
it in the future, but for now my original project doesn't include such a goals, and
i have still to focus on continue extending the current pygtk API.
Ok, this has just been a brief status report about my work so far, it didn't intend
to be a complete documentation or tutorial about all the internals and
features of BaseGUI , but a few lines to show how far i go on my work and
how the application is already working fine in more than 50%.
I also expect to release a proper tutorial for this programm, both for the users
and for the developers, where i will document the two main aspects (1) and (2)
of the application.
Thanks,
|
