Previous Index Next

VisKProg 0.1.7

Introduction

Preparation

Step 1: "Hello world!"

  • Get ready!
  • Drawing a window
  • Translating, compiling, running, ...
  • Adding program code
  • Step 2: "Hello world" version 2.0

    Step 3: A small calculator

  • Working with properties
  • KSimpleCalc
  • Installing
  • Step 4: Minimal df frontend

  • Frontends
  • ProcCtrl widget
  • KMiniDF
  • Step 5: Kcount

  • For and while loops
  • Picture labels
  • Step 6: A small image viewer

    Step 7: Your programs

    Introduction

    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()
    {

      Exit();
    }

    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
        Exit();
    }

    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