|
VisKProg (previously called "Visual 'K'") is a programming language
for KDE, which is designed for programming newbies.
This tutorial was updated for version 0.1.6 by
Christoph Pinkel, and
Rainer Jochem.
Now, enjoy this tutorial, and become a great programmer :-)
Warning
VisKProg is unstable alpha software, i.e. only few of the planned
functionality is already implemented, and you may be confronted
with a lot of errors.
Furthermore there's the usual "NO WARRANTY"-statement in the GPL 2,
covering VisKProg.
Preparation
Well, before you can start to write your own KDE program with
VisKProg, you've to install some programs: First of all VisKProg,
i.e. the packages VKBase and VKIDE. If you were able to compile
and install VKIDE, nearly everything you need is already installed.
If you run into trouble ./configure'ing VK-IDE, check the error output
of ./configure, to see, what you need. Furthermore, you must
have the GNU automake and autoconf tools installed (They should come with
your distribution, with a package named "automake" or "autoconf" or
something like that ).
Then, you can start to create our project using the
vkNewProject tool. It just needs the destination directory
(i.e. your home directory) and a name for the project.
As all KDE projects start with a 'K', your project also
should. Furthermore, the name mustn't contain other
characters than alphabetic ones, especially no white-space. Then start
your work as a programmer :-).
In order to make your work with VisKProg as easy as possible, this version 0.1.6 comes
with a new help to create your own project:
Open kfm and change into the directory vkNewProject has installed your project.
If you open the source-directory, a welcome-page will automatically appear
(but only, if you have switched the html-view of kfm on - else you
have to open the index.html-file by yourself) and help you creating your project.
To see the rest of the source-directory you have to switch the html-view of kfm off.
At this point, we should define, what I mean with a VisKProg
project: it's a program written in VisKProg, with all developer files
(especially the source code) and with a subdirectory for the
corresponding KDE project, while a KDE project is a c++-written
program, and in our case, it's autogenerated from your VisKProg sources.
Anyway, we need the c++/KDE project, because other people need it to
install your program on their computers.
Step 1: "Hello world!"
Now prepare for the worsest program, the world has ever seen: "Hello world" :-)
Nearly every programming language tutorial starts with a "Hello world!"
program, and as a civilized freeware project's tutorial, this
manual does also.
Our "Hallo world" should show a small window, that looks like the
following, and the only action it should do, is closing the window,
when the user clicked the OK button.
Get ready!
Well, when you have followed the instructions in chapter
"Preparations", you have now a directory called "khelloworld" in
your home directory, that contains a template of a (nearly empty)
VisKProg project. Open the KFM and switch in directory
"~/khelloworld/source/VK/win". This is the directory, that contains
the source code of the default main window (called "win") and the
sources of all "actions", that belong to this window.
"Source" is a short name for "source code" and it means a file
that contains your programs "commands". Open also a terminal
emulation (konsole or kvt) and switch to the same directory.
Now, open the window file "win.vktf" with the VisKProg GUI builder
("kwinedit"). You'll see an editor view, like this one:
Drawing a window
KWinedit is not a real WYSIWYG window editor, i.e. the running
program will look a little different from the one you see in the
editor, so don't worry about the "unnormal" look & feel.
For our hello world, we've got to add the text "Hello world",
an OK button and we want to change the text in the titlebar
to "Hello!".
Every element in a window, like buttons, or text fields (called labels)
is called a widget, as well as windows themselves are also
widgets.
To add a widget to the window, just select the widgets "tool" from
the "Tool" menu, and then draw the widget in your window, like
drawing a shape in a painting program.
First, select "Label" to draw a text label in the middle of the window.
Then, select "Button", and draw your "OK" button.
If you did so, you may want to change the text of the label
from the default "New text label" to "Hello world", and the text
on the button from "New button" to "OK".
To do so, you have to know, that the appearance of all widgets
is defined by it's properties. Right click on the widget
of your choice, and select "Edit properties" from the context menu.
If you clicked (for instance) on your button, KWinedit may open
a property dialog like the following:
On the left side, you see the property names, on the right side
the property values.
The property that controls the text is called "Caption", so
click on the little "."-button next to the value of "Caption", to change the text
to "OK". Then you should also change the "Name" property to
something like "ok". The name property controls the widget name. A
name is used internally in VisKProg, and it's of high importance, whenever
you want to add an "action" belonging to this widget (like leaving the
program, if the user clicks on the button). So you should select
a short name, that describes the widget, like "ok", "button",
or "okButton".When you've finished, modify the properties of your
label, especially the "Caption" property (set it to "Hello world!").
After all, you want to change the caption of the window (the
text in the title bar). So click on the window's background with
the right mouse button, select "Edit properties" and change the
caption to "Hello!".
Translating, compiling, running, ...
To see, whether it works, you must translate, compile
and run the program. Translating means, creating a
c++-KDE project from the VisKProg project. Compiling
means, to make an executable program from the
KDE project.
Sounds difficult? The only thing you must do is clicking
on "run" (you find this script in the source-directory of your project e.g.
~/khelloworld/source) and wait a time.
"run" does all these jobs for you. If you want to see more detail
information, you can also start "make" in the ./source directory of
your project. In fact, it does the same jobs. If you don't want
to run the program, and your only interest is, whether you can
translate your project properly (i.e. you didn't make any
mistakes), it's quicker just to run "make" in the directory of your
*.vktf window-file.
Adding program code
There's still one thing, we haven't implemented yet: Leaving
the program, when the user clicks the "OK" button.
In a way, you can say, that we start now to write the
program.
VisKProg offers Events and Functions to allow
the programmer to write code. While functions must be called explicitly
by the programmer from anywhere else in the program, events start
automatically when the event they describe happens
(In our case: "The user has clicked on the OK button").
Each function and event is stored in an own file with
the suffix "*.vk" in the directory of the window, to which they
belong. As our event belongs to the button "ok", which belongs to
the window "win", we have to store it in the actual directory ("win").
The eventname and the filename are the same; they describe the
event in the follwing form: widgetname '_' eventname
If you've called your button "ok", the complete filename is
"ok_click.vk".
But to create and to open the file in the VK source code editor (ksrcedit),
you just have to right-click on your button, and select
"Edit events->click".
Then, write the following in your file:
Event ok_click()
{
}
At the moment, just take this code "as is" you will understand it later,
and if ksrcedit warns you about "Syntax errors" or something like that,
check whether something may be wrong with your code, but don't worry:
in the actual version, ksrcedit sometimes has it's very own ideas of
what's proper VisKProg code.
If you want to get more detailed and better warnings, you must
load the window specific configuration file "win.vkc" in the
source editor, using the "Edit->Reload *.vkc file" menu entry.
If there is no win.vkc file yet, create it by typing "make" at
your terminal in the ./source directory of your project.
Now, use the ./run command again, to try out your program!
Step 2: "Hello world" version 2.0
Now, we want our "Hello world" program to be more "active":
We'll add an "About" button, next to the "OK" button, and the
program should ask whether to quit, when you clicked on "OK".
The "about" dialog
Open win.vktf in KWinEdit again, and move the "OK" button,
so that there is enough place for a second button next to it.
When you've finished, add another button, and change its name
to "about" and its caption to "About".
You know, that you need an event file, if you want that new
button to do something, and as the button is called "about", and
we want to edit the "click" event, the event name is about_click.
So open the file using the "Edit event->click" entry of the buttons
context menu, then add the following code:
Event about_click()
{
}
You see, that this small event has much common with our first
ok_click() event. That's because each function and event has
an exactly defined strucure. So check what these parts mean:
- Event: This indicates, that the following is an event,
not a function.
- about_click: This is the event name. It has the
form widget-name_event-name, and as our widget
is the button with the name "about" and the event
is the "click" event, the event name is "about_click".
- (): The empty parenthesis indicates, that
the event doesn't take any arguments.
Arguments are like command line arguments (e.g. "ls"
with the "-l" option: "ls -l"): They make extra information
avaible to the event or function. If a function
or event takes arguments, then they're listed in the
parenthesis, otherwise (in our case) the parenthesis is empty.
- The whole first line ("Event about_click()") is called the event
declaration.
- {
}: This is the main code block of the event.
a code block is a number of commands enclosed in
'{' '}', in this event zero commands.
If you want the event to do something, you've got to add commands.
There are several kinds of commands, the one you already know is
the (pre-defined) function call. Remember: A function is like an event, but
the programmer must call it by command, or more exactly by a function call.
And as there are a lot of "standard" jobs, needed by a large number
of programs, VisKProg comes with a number of so called pre-defined functions,
i.e. you haven't to write the function yourself but it's already avaible and
you can just call it.
In the first event ("ok_click") you've already used such a function
call: Exit();
Exit is a pre-defined function, "()" indicates, that you doesn't give
any arguments to the function (i.e. it doesn't take any arguments), and
the semicolon terminates the command. It regulary stands at the end of
every command, to make clear, where the command ends.
As a click on the "About" button should open a window with an
about message, we may now write a new window. But since this takes
a lot of time, we use a trick: There is one simple pre-defined
function in VisKProg, which is designed to show small dialogs with
just a message text and some simple buttons (like "OK" or "Yes" and
"No"). This function is called "MsgBox", and it takes three arguments:
The message text, an ID that indicates which combination of buttons to
use, and the text in the title bar of the message window. The arguments
are listed inside the parenthesis, separated by ','.
The syntax of MsgBox is the following:
MsgBox ( message_text, button_ID,
titlebar_caption );
I used the message text "Hello world 2.0\n\n(c) Christoph Pinkel",
the button ID '0' ( 0 ==> just show an OK button ) and the titlebar
caption "About". So my function call is
MsgBox( "Hello world 2.0\n\n(c) Christoph Pinkel", 0, "About" );
The event now looks like the following:
Event about_click()
{
MsgBox( "Hello world 2.0\n\n(c) Christoph Pinkel", 0, "About" );
}
Please note: The "\n" sequences in my string are called
escape sequences, and the escape sequence "\n" is the
symbol for a newline. (NOTE: these escape sequences can't be used at the moment,
because unfortunalety ksrcedit will hang up if you try to type an '\'...)
Now, modify and save your about_click.vk file, and try to
./run the project.
Still, we haven't implemented the "Really quit?" dialog in the
"ok_click" event. Open the file ok_click.vk and change the commands in its
code block to:
a = MsgBox( "Really quit ?", 2, "Hello world" );
If a == 1 Then Exit();
This was a lot of new stuff: first, we fetched a return
value from the MsgBox function in the variable "a".
Then, we compared the value of "a" with the value "1", and told the
computer only to quit, if they are equal.
-
Returning values is a special feature of functions. As well as they
may take arguments, they may return so-called "return values" to offer
the one who called the function special information. In the case
of MsgBox, the function returns the number of the button, pressed
by the user; and in a Yes-No-MsgBox which we have builded with the
butten-ID '2' as the second argument, the "Yes" button is the first one
(i.e. MsgBox returns "1" if "Yes" has been pressed). In our MsgBox
call above (in the about_click event) we just didn't care about the
return value, as there were no choice for the user (and it's unineresting
to check whether the user has pressed the "OK" button or the "OK"
button :-) ), and so MsgBox "returned" its return value to nowhere.
-
A variable in VisKProg is a "place" in the memory, where you can temporary
"save" data. You can use any name composed of alphanumeric characters
and underscores ('_'), that starts with an alphabetic character as
a variable name. Correct variable names are names like
"a", "b", "c", "i", "ii","X", "Y", "myVar1", "return_value". Names,
that start with an underscore or a digit like "_v" or "1st_var" mustn't
be used.
There's no need to declare variabled explicitly, but
variables that aren't declared lost their value, when the event or
function, where they're used in, exits. I.e. if an event
starts two times, both times these variables are "empty" when
they appear for the first time in the event/function. Also, you
can't check the value of a variable of another event: if you use for instance
the variable "a" in two events, these are two different
variables, with different values.
-
You can change the value of a variable whenever you want, using a
set-to-operation. Set-to-operations are another kind of
commands and they have the form variable_name = new_value ;
A correct set-to-operation would be "x=1.1;" , "pi = 3.141592;" ,
" my_String = "Hello!"; " or "i = 0;". Our "a = MsgBox ..." command
is a mixed command. It's a set-to-operation,
but the new value is the return value of a function (MsgBox), so
in a way it's also a function call.
-
The "If ..."-command is yet another type of commands: It's a base
command, i.e. a command with a syntax on it's own, which differs a
little from every other syntax. There are only very few base commands,
but they are used very often. The syntax of "If" is:
If condition Then command_to_do;
The command_to_do only gets executed, if the condition is true.
Please note, that you must use "==" to compare two values,
not just "=". There is a difference between '=' and "==":
'=' is used to set a variables value, "==" compares
two values without changing them.
Allright, change your ok_click.vk file to the following, then
try to ./run it.
Event ok_click()
{
a = MsgBox( "Really quit ?", 2, "Hello world" );
If a == 1 Then
}
Step 3: A small calculator
Working with properties
You see, writing VisKProg code is not really difficult, but it's
necessary to let your program be "active". A very important part
in the code of a GUI based program is always the following (very
simple) one: changing widget properties at runtime.
When the user invoked an event, you often want to make the program
react by showing differences in the window. For instant, you
may have a window with a label and an OK button, and you want
to change the lables caption from "Please click OK" to "Thank you.",
as soon as the user clicked "OK".
KSimpleCalc
As our first "complex" (but still easy-to-write) application,
we now write a little calculator. You see, we now have to manage
different properties: We must "read" the users input and
"write" the result to an "edit field". Then, we need a lot
of buttons, for the different operations and also a lot of
events. My calculator looks like this:
First create your new project (e.g. "KSmallCalc"). Then
open the main window, as described in the paragraphs above, and
add your widgets: The text edit field (for both users input and
the result) is of widget type "LineEdit". I called it "edit", my
exit button "btExit", the "CLS"-button "btCls", the "="-button "bt0",
the "+"-button "bt1", the "-"-button "bt2", the "*"-button "bt3"
and the "/"-button "bt4". Anyway, you can call them like you want,
but in the description below, they are called this way. You already
can edit the click event of the exit button and write an "exit event" -
with or without YesNo-msgbox, like you want :-)
With the operations (+-*/), it's more difficult. To see the
problem, remember what the calculator must do:
- It takes a number
- An operation button is clicked
- It takes another number
- It shows the result, after the "="-button was pressed
So you see, the mathamatical operation can not be done before three
information are given: Two numbers and the kind of the operation.
So you must "save" which operation button was pressed, to know later
which operation to do. Furthermore, the first number must be saved,
as it will be "overwritten", when the user has entered the second
number in the line edit. To save these values, we need variables -
but not just regular (local) variables, as you know that their values
will be lost, when the event they belong to, terminates. And
we need their values later in another event (event bt0_click).
So we have to use "regional" variables. You can access to a regional
variable from every event (or function) of one window
or subwindow: the window, they are declared for. To
declare a regional variable, select "Edit->Regional variables"
from the menu of KWinEdit. Then add two variables, for the
first number and for the kind of operation. I called them
"num1" and "opType". As init values I took "0" and "*".
We can use these variables as we use any other variables, but they
keep their values, while we work in the "area" of our
main window. Now, let's write the code for the click events of
the "+", "-", "*" and "/" buttons. They should save the actual caption
of edit (i.e. the first number) in num1 and their own "id" (i.e.
"+", "-", "*" or "/") in opType. Finally, they should "reset"
the caption of edit to an empty string (""), so the user
can start to enter the second number, promptly. In order to
get the value of a property in a variable or to change it,
you have to use a third type of commands: property access.
The syntax of property access is easy and "e-mail like". That means,
that you must specify the property you want to "read" or change
in the form PROPERTY@WIDGET. PROPERTY is
the property you request (e.g. Caption), while WIDGET must be
the exact, non-ambigous name of the widget. Non-ambigous means, that
you have to specify the widget in it's whole hirarchy, where
different stages in the hirarchy are separated by points.
So if your actual window is called "win", the non-ambigous name
of "edit" is "win.edit", and the name of your btCls is "win.btCls".
But as this takes too long if you enter it every time
(imagine the name of a button "SubButton12" in the subwindow
"wdSub1" in the window "mainWindow": "mainWindow.wdSub1.SubButton12"),
you can just write "." for your actual window ("win"), and also ".edit"
for "edit" in the actual window.
So, the "read-num1" line is the following:
num1 = Caption@.edit;
And the line to set edit's caption back to "" is:
Caption@.edit = "";
So, my bt1_click event looks like this:
Well, the code of the other operation buttons (-*/) is
nearly the same, excepted the opType = ... line: you
have to use the buttons "id" there each time, i.e. "-"
for bt2, etc.
The last "difficult" event is the one of the "="-button. Here,
the program should add, substract, multiplicate or divide
the two numbers (i.e. the one in variable "num1", and the actual
caption of "edit"). Then, it should change edit's caption to
the result. The event is more then 20 lines long (wow!!!) and there are
four "different" code blocks in it: one "if"-block for each
operation:
Event bt1_click()
{
If opType == "+" Then
{
Caption@.edit = num1 + Caption@.edit;
}
If opType == "-" Then
{
Caption@.edit = num1 - Caption@.edit;
}
If opType == "*" Then
{
Caption@.edit = num1 * Caption@.edit;
}
If opType == "/" Then
{
Caption@.edit = num1 / Caption@.edit;
}
}
Well, the Caption@.edit = ... lines are operations with
property access, and they just handle the properties as
you can do it with any variable. So "Caption@.edit = num1 + Caption@.edit;"
would have the same effect as "a = num1 + a;" (read: "Set the new value of 'a' to
the value of 'num1' plus the actual value of 'a'!") would have, with the
simple difference that our second "variable" is not a real variable
but the actual value of the caption property of edit, and we want
to set our result not to an invisible variable, but again to the caption
of edit.
Finally, you still have to write the event of the "CLS" button.
Make it clearing the caption of edit with "Caption@.edit = "";"
and set the values of num1 and opType back to "0" and to "+";
Installing
When your calculator works, you probably want to install it on your
system and in your kpanel. Maybe, you've already heard of
the makefile hacking and these things, you have to do to make
your project ready to be installed. Fortunately, the VisKProg tools
do most of this work for you. Anyway, they need information
from you in order to generate the kpanel link and description files.
The information they need, are stored in the ./source directory
of your project in file "project.conf". Please open this configuration
file in a text editor (e.g. kedit) and change at least the
following entries in the "Project" section:
- name: the projects name (name = "KSimpleCalc";)
- author: your name
- email: your e-mail address
Then save the file, switch to the ./source directory in your
terminal emulation and run "make prepare". Eventually, you may want
to edit the "icon.xpm" and "mini-icon.xpm" files in the same direcory
before. Then, you can install your program, like you do it with
every KDE program: cd .. in the top level directory, and
run "./configure", "make" and "make install" (as root).
Step 4: Minimal df frontend
Frontends
In the UNIX world, most programs are text based. But since
some time, new users are joining the Linux community who don't work
with shells at all. So it's an important job, to write graphical
front-ends to the very powerful text based programs for these
users. VisKProg provides a widget called "ProcCtrl" to control
child processed, for instant a text based tool.
ProcCtrl widget
The ProcCtrl widget looks like a label, and it protocols
the text output of your child process in it's caption,
but as the user usually isn't interested in this kind
of information, it is invisible (Visible="FALSE") by default.
In some cases (or for debugging), you may want to turn it
visible, anyway. Then, the ProcCtrl widget has four other
important properties:
- Command: This is the name of the program, you want to run (e.g. "df")
- Arguments: The command line arguments for the programs (here: none)
- Running: Is the child process active ? If not, you may
start it by changing the value to "TRUE" at runtime.
If the value is already "TRUE" in the editor mode,
the process will directly be started, after your
programs has started.
- ReturnVal: Programs return a numeric value, when the exit.
0 stands for "finished OK", a value greater than 0
means, that the program started, but it wasn't able
to fullfill your wishes (e.g. file not found, ...),
negative values (-32,-33,-34) have special meanings.
See widget documentation for details. This property
is read only, you can check it at runtime, but you
mustn't change it's value.
You can use this widget in different ways. As an invisible
"start tool" for another X11 (or KDE) application, as a "ghost"
who controls background commands (cp, rm, mv, ...) or as a
"terminal" label, that shows you the information, a child process
prints to it's stdout (standard output, regulary
the text screen [console, terminal] ).
KMiniDF
I know, there are already several KDE frontends to the
df ("Disk free") tool, but this one is the most minimalistic one ;).
The df program shows the status of the mounted partitions. So
It's not complex, to "manage" it's output, we just have to make
the ProcCtrl widget visible, so it shows the whole output of df
(and that is what we want). So our program "KMiniDF" should
have a small window with a ProcCtrl widget and two buttons,
an "Update" button (to run df again, and so to update the information)
and one to quit. Change the Visible property of your ProcCtrl
to true, the Command property to "df", Arguments to "" (no arguments)
and Running to "TRUE", as we want df to be run directly at start time.
Then edit the exit event of your ProcCtrl. This event is called
when df quits, and we should check, whether everything was OK.
I called my ProcCtrl widget "dfCtrl", so the function looks like this:
Event dfCtrl_Exit()
{
If ReturnVal@.dfCtrl != 0 Then
//!= 0 means "Not == 0"
{
MsgBox( "Error running 'df'.", 4, "Error" );
}
}
The update button should start df again (Running@.dfCtrl = "TRUE";),
but as the output of the child process usually is added
to the end of the "label" caption and we just want to see the
output of the latest df call, we should clean the caption first:
Caption@.dfCtrl = "";
I think, thats all for this capter: you know yourself, what to
write in the Quit button's click event :-)
Step 5: Kcount
For and while loops
Now we want to write a small (not very useful) program, in order to amuse the user after his
looong and boring work... :-)
Once started,there should appear a "Start"-button. If the user really clicks on it, a countdown
will get started which ist to confirm by msgboxes. After having clicked on "OK" for several weeks,
and finally "0" has been reached, the user should get a reward with the appearance of a nice
picture in the main window
So, the following problems are to solve:
The countdown
The picture, which should be turned visible at a certain time
First, the countdown:
Now, we want to make the program count from a constant value down to 0.
To do so, we have two possibilities: we can use for loops or we can use
while loops. The syntax is:
For [Value / Variable] to [Value / Variable] do
While ( [Variable] [< > == !=] [Variable / Value] ) do
First we have to make our program to count from 0 up to an maximum value. Just have a look at the
program with a for loop and with a while loop:
Event StartButton_click()
{
max=5;
for i=0 to max do
{
count=max-i;
if count !=0 then
{
msgbox(count,0,"Countdown...");
}
if count ==0 then
{
msgbox("IGNITION!",0,"Countdown...");
}
}
}
|
Event StartButton1_click()
{
count=6;
while (count != 0) do
{
count=count-1;
msgbox(count,0,"Countdown...");
if count ==0 then
{
msgbox("IGNITION!",0,"Countdown...");
}
}
}
|
The for loop is running until 5 (max) has been reached. During each loop 'count' gets less
because i is getting more with each loop
The while loop acts quite similar: it is running as long as count is unequal 0.
The if blocks in both programs have the function to call different message-boxes by different values.
Now, try to run the program.
Pixmap-label
What we still have to do, is adding the picture. To do so, you have to copy your picture
(as *.xpm !!!) in the directory /source/pics of your project.
To show a picture in a window, a special label is needed: a Pixmap-label.
Draw such a label in your window and open the "Properties"-menu.
At the caption "Picture" you can choose the picture you have put into ./pics .
H I N T: It's also possible to copy more than one picture into the ./pics-directory and to
change - during your program is running - the picture which is to show.
To do so, you have only to use the command Picture@.pixlabel="my_picture2.xpm";
Because we don't want to see the picture directly at the startup of our program, we also have
to change the caption of Visible to "False" .
Now, we have to adapt the program code: in the if block 'if count==0 then ...'
you have to add the following line Visible@.pixlabel="TRUE";
I think there's no explanation needed... :-)
This are the important parts of this small program. Everything else (Exit, About and so on)
is left to you.
H I N T: If you try to run your program meanwhile, don't worry, if your picture isn't visible.
It is first visible after having installed your program!
Under construction: should explain: - user defined functions
Step 6: A small image viewer
Under construction: should explain: - file access -
Step 7: Your programs
You should be prepared to write your own programs now. Please do it!
But I think, you will find out that you still don't know enough to
write the programs, you really want to write. So, first of
all remember, that VisKProg is still alpha software, so
maybe the functions you need aren't implemented, yet. But
it's also possible, that they are avaible. So use
the VisKProg
function documentation to look for functions
you still don't know or read the
widget documentation to learn
more about widgets, you don't (really) know, yet.
But still, and even if VisKProg will have reached a 1.0 version,
it won't provide everything, you could do with
C/C++ (with the Qt and KDE libraries). So after a time,
you may want to learn C++-KDE programming. If you want to,
have a look at developer.kde.org
( there you always find KDE programmer tutorials [for people
who already know C(++)] ) and at
www.kdevelop.org (a great C++/KDE developing environement).
Maybe (when VisKProg has reached a more advanced level), someone could
write a tutorial for people who come from VisKProg ? Please
e-mail suggestions to
de_cp@linuxstart.com.
If you wrote a VisKProg program, please let me
know. I'm interested in everything, and if you want to,
we may publish your program VisKProg's sites. If you need
help (the tutorial is still under construction, I know) or
(even better) if you want to help me, please contact me
at
de_cp@linuxstart.com. As there still aren't so much people who use
VisKProg, I also may try to implement special functions, that aren't
implemented yet, if you need them. Ask me!
Now, may the source be with you!
Kind regards,
Chris
Back to the top
© 2000 by Christoph Pinkel and
Rainer Jochem
|