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.

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.

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.

• In Gambas, you can create and display as many copies of a form as you wish.

• 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. The good news is, in Gambas, nearly all events have this feature built in. The bad news is, most people don't know it because the IDE doesn't tell them. When you edit a control's event handlers in the Gambas IDE, the handler is automatically created as a Sub. If you change it to a Function returning Boolean, e.g. FUNCTION myTextBox_KeyPress(...) as Boolean you can Return True at any time during the function and it will cancel the normal event processing for that particular firing of the event.

Cross-Reference

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