Differences from VB

Non-Language-Specific Differences

• VB embeds the class code for each form object into the same file as the form definition. Gambas keeps them separate, in a .form and a .class file.

• File extensions:

• Gambas projects are defined as a directory with a .project file in it, and all of the files in that directory. VB can have multiple project files in each directory and can pull the same source file from a different directory into different projects, which has its benefits and disadvantages.

• Screen measurements in VB are done in "twips", units of 1/1440 of an inch; in Gambas they're done in actual pixels.

• Form controls in Gambas programs are private by default. You can change this by going into the Project Properties dialog and checking the Make Form Controls Public checkbox.

• The Gambas divide / operator returns an integer if its operands are all integers. For example, PRINT 9 / 2 returns 4 and not 4.5 . To use floating point division, you must convert one of the operands to the Float datatype, e.g. you must use PRINT 9.0 / 2 or PRINT CFloat(9) / 2 . In VB, division using / is always a floating-point operation, with an implicit conversion to doubles prior to the division and if necessary, an implicit conversion back to integer afterward; VB has a separate integer division operator.

• Str$(), Val(), CStr()... conversion functions behave differently. For example, Str$() and Val() use the localization settings in Gambas, whereas they don't in Visual Basic. Read the documentation carefully for more details. Note that Gambas behaviour is more logical :-).

VB Has It, Gambas Doesn't

• You can't edit code in Break mode in Gambas; you need to end program execution first.

• Function and procedure parameters are passed by value. They cannot be passed by reference as in Visual Basic. Note that VB passes parameters by reference if you do not use its ByVal keyword, so be careful when you try to port a VB project.

• There is no such thing as a project-wide global variable in Gambas. As a workaround, consider making a class called Global and declaring your global variables as static public variables in that class, and then referring to them as Global.variablename in your project. It's still poor programming practice but at least they'll be identified as global variables whenever you use them ;)

• Unless you include "Option Explicit" in a VB module, you don't need to declare variables prior to using them. Gambas behaves as if "Option Explicit" were always turned on, which makes for much better code at the expense of a bit more work.

• There's no direct Gambas equivalent to the "Index" property of VB form controls. You can easily create arrays of controls, but you have to do it in code. There's currently (0.62) no way to do it graphically. Thus, when you copy a control and paste it back on the form it came from, rather than prompting you to create a control array it automatically renames the copied control to an appropriate name.

• You can't currently create transparent labels in Gambas; the background is always opaque.

• The MouseMove event only occurs when a mouse button is depressed in Gambas, meaning you can't use it for the traditional mouse-over effects yet (other than the standard Tooltip associated with each control). The exception is the DrawingArea control, which has a Tracking property that allows getting mouse move events even if no mouse button is pressed.

• In VB you could put two strings together with the symbol + . Because the + sign is only used for mathematical addition in Gambas, you should use & instead, when you want to add one string to another.

• If you use the print command the colon : does not work to seperat your code. You must take a new line instead.

• The print command in VB 3.0 did not make a Linefeed. If you used it to print out some text with printer.print, then text got lost. The Print Command in Gambas puts everything in one line. There is nothing lost.

• In Vb you can use the mid command to cut out a substring and put in some other. In Gambas the command is named mid$. You can not assign a new substring to it. For example in VB mystring = "The dog jumps": Mid(mystring, 5, 3) = "fox" . results in mystring = "The fox jumps". That does not work in Gambas. You can use the Replace$() function to work around this behavior some of the time: mystring = Replace$(mystring, mid(mystring, 5, 3), "fox") would work for the above example, but if mystring were abcdeabcdeabcde the result would be foxdefoxdefoxde. Of course, mystring = Replace$(mystring, "dog", "fox") would be easier!

Gambas Has It, VB Doesn't

• Unlike VB, you're not required to compile in GUI support if you want to write a Gambas command-line application. Just unselect the "gb.qt" component in Project Properties and make sure you define a Sub Main.

• Gambas has the concept of control groups, which allow you to handle events from any number of different controls with one handler subroutine. This reduces redundant code and can be used to do many of the things VB's control indexes can do, and some things that VB can't.

• Whereas VB makes it impossible to run a program synchronously and receive its output without learning how to do API calls (Shell merely launches the program in the background) Gambas allows you to do so using SHELL and EXEC, control the processes you start using the Process object, and even read from and write to them, allowing you to easily add functionality with helper applications. This makes it incredibly easy to write Gambas front-ends for almost any command-line procedure.

• As of Gambas 0.60, you can do all of the above with Unix devices and special files as well, such as serial or parallel ports. Use the /proc filesystem to write a RAID monitor, for example, or use named pipes to get multiple channels of information from a back-end program in any other language.

• To make an odd-shaped window you just set the ME.Mask property of the current window to a picture that has transparent areas. VB requires API calls and a bit more work..

• You can create controls and menu dynamically, just by instantiating them with the NEW instruction.

• You can embed a Gambas form into another one: when you instantiate the first, specify the second as the parent.

• And of course, Gambas is Free Software whose development environment is written in itself, allowing you to customize it to a large degree using just your BASIC skillset.

Same Functionality, Different Terminology

• End Sub/End Function: see END.

• Exit Sub/Exit Function: see RETURN. Also, rather than setting a variable with the same name as the function and then exiting the function, you can simply include the desired return value as a parameter to RETURN.

• End (end program): see QUIT.

• On Error: see TRY, CATCH and FINALLY.

• Msgbox: see Message. Normally you'd want Message.Info.

• VB's default InputBox function (pop up a dialog prompting for a value which is returned to the calling program) is implemented as a Gambas library function (0.61 and later). You need to add USE "Util" at the top of your module or class before calling InputBox.

• DoEvents: see WAIT. WAIT also replaces the frequently used Windows API "sleep" function.

• Inserting Double Quotes in Strings: Rather than two consecutive double quotes as in VB, use the backslash as an escape character as in C or Perl (\").

• VScrollBar, HScrollBar: Gambas' ScrollBar replaces both of these. It automatically figures out whether you want a vertical or horizontal scrollbar based on the control's dimensions: make it wide, and you get a horizontal scrollbar; make it tall, and get a vertical one.

• Open and Save dialogs: You can use either the Qt or enhanced KDE dialogs in place of the Windows common dialog. Some of the properties are named differently and filters are specified like this: "Filter 1 (*.foo);;Filter 2 (*.bar)" instead of "Filter 1 (*.foo)|Filter 2 (*.bar)".

• Validating text entry: In VB, certain events have a "Cancel" parameter you can set to prevent the event from being handled normally after your handler is done, so that for instance you can allow only letters or numbers to be typed, perform field validation, or force entry to be all upper or lower case. In Gambas, this is done by using the STOP EVENT instruction.

• Keyboard and Mouse event handlers does not take parameters. They use instead static public members of the Mouse and Key classes. For example:
  • Mouse.X and Mouse.Y for the mouse coordinates.
  • Mouse.Left to know if the left button is pressed.
  • Key.Code to get the code of a key.
  • Key.Shift to know if the SHIFT key is pressed.
  • ...and so on.

Cross-Reference

Following is a list of pages that include VB-migration notes: