Check it out here:

http://www.rbdevzone.com/ultraupdater/

On Mac OS X, these buttons are in this order: Cancel, OK

On Windows and Linux, these buttons are: OK, Cancel

I’ve put together a quick control that handles this for you automatically. However, it is a ContainerControl so you’ll need REALbasic Professional or REAL Studio to use it.

Download it here (documentation and the BSD license) are embedded as Notes in the control itself.

OKCancelControl.rbp.zip

First, REALbasic does not have CallByName. However, it does have Introspection (aka reflection) which can be used to achieve this.

The official function definition in VB is:

CallByName(object As Object, procname As String, calltype As Integer, [args() As Variant])

This is a bit limited as it cannot handle return values. I’d also prefer a more object-oriented syntax. So our REALbasic definitions are:

Object.CallByName(name As String, nameType As CallType, ParamArray args As Variant)
Object.CallByName(name As String, nameType As CallType, ParamArray args As Variant) As Variant

In order for this to be usable on any object, we’ll implement these as extension methods. First we need to create a module to contain our methods. Create a module called CallByNameExtension. This self-contained module will eventually have everything we need to use CallByName in our projects.

Next, we need to create the CallType enumeration. This is used to specify the type of the we want to call. Our options are Method, PropertyGet and PropertySet. On our module, create a CallType enumeration with those three values (Method, PropertyGet, PropertySet).

Now create our two method signatures for CallByName:

Sub CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant)
End Sub

Function CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant) As Variant
End Function

Since both of these methods will actually use very similar code, we will create a private worker method to actually do the call. Create a new private method:

Private Function CallByNameWorker(obj As Object, name As String, nameType As CallType, args() As Variant) As Variant
End Function

Note that we’ve changed the ParamArray to just a simple array. This is because we cannot resend the parameters as a ParamArray.

Let’s add the simple code to the public methods:

Sub CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant)
 
   Call CallByNameWorker(obj, name, nameType, args)
 
End Sub

Function CallByName(Extends obj As Object, name As String, nameType As CallType, ParamArray args As Variant) As Variant
 
  Return CallByNameWorker(obj, name, nameType, args)
 
End Function

As you can see, this code simply calls the worker, saving the return value if appropriate. Since ParamArrays are converted to real arrays, we can just pass that along to the worker as well.

In the worker method we’ll use Introspection to actually call the method or to get/set the value of the property. Here is the code:

Private Function CallByNameWorker(obj As Object, name As String, nameType As CallType, args() As Variant) As Variant
  If obj <> Nil Then
 
    Dim info As Introspection.TypeInfo
    info = Introspection.GetType(obj)
 
    Select Case nameType
    Case CallType.Method
      // Get the names of all the methods on the object
      Dim methods() As Introspection.MethodInfo
      methods = info.GetMethods
 
      // Search for the specified method
      For Each m As Introspection.MethodInfo In methods
        If m.Name = name Then
          // We found it, so call it
          Dim rv As Variant
          rv = m.Invoke(obj, args)
 
          Return rv
        End If
      Next
 
    Case CallType.PropertyGet
      // Get the names of all the properties on the object
      Dim props() as Introspection.PropertyInfo
      props = info.GetProperties
 
      // Search for the specified property
      For Each p As Introspection.PropertyInfo In props
        If p.Name = name Then
          // We found it, so return its value
          Dim value As Variant
          value = p.Value(obj)
 
          Return value
        End If
      Next
 
    Case CallType.PropertySet
      // Get the names of all the properties on the object
      Dim props() as Introspection.PropertyInfo
      props = info.GetProperties
 
      // Search for the specified property
      For Each p As Introspection.PropertyInfo In props
        If p.Name = name Then
          // We found it so set its value to the first argument
          p.Value(obj) = args(0)
        End If
      Next
    End Select
 
  End If
 
Exception e As RuntimeException
  Dim eInfo As Introspection.TypeInfo
  eInfo = Introspection.GetType(e)
 
  Dim eMessage As String
  eMessage = "A " + eInfo.FullName + " occurred."
  If e.Message <> "" Then
    eMessage = eMessage + EndOfLine + "Message: " + e.Message
  End If
 
  MsgBox(eMessage)
End Function

This code has one significant limitation when it comes to calling methods: it cannot handle overloaded methods. If you have multiple methods with the same name, but with different parameters, then this code will not always call the method you expect. In order to fix this we would have to compare the types of each of the supplied arguments with the types of the arguments for each matching method and then call the one where everything matches. This is all possible using Introspection, but I’ll leave it as an exercise for the reader.

Download the project with all the code: CallByName.rbp.zip

Did you know that your computer can read minds? This week we’ll witness its extraordinary mind-reading powers by creating a simple REALbasic project. See if you can figure out how it works before looking at the code!

Downloads

Because the code for this demo is drop-dead simple, there isn’t really any reason to cover the process of putting an interface together. Check one of the previous tutorials if you are a complete REALbasic newbie. The fact is, this project doesn’t have any tricky code at all. The trick lies in the mathematical content of the application, not the code itself.

Download the Guessing Game project.

Originally published by ResExcellence Reprinted with permission

One of the most frequently asked questions among REALbasic lists is “How do I rotate an image?” This project will show you how to quickly and easily rotate an image in realtime. The REALbasic Group2D class simplifies matters significantly for us. By dragging a few items to your interface and adding a bit of code, you’ll be spinning in no time.

Build the Interface

Launch REALbasic and add a Canvas, a PushButton, and a Slider control to the Window1 interface. Set the maximum value of the slider to 6283. Since one complete rotation around a circle is approximately 6.283 radians, we’ll use the larger value of 6283 to insure fine resolution upon rotation. Next, click on the slider to select it and uncheck its Enabled property in the Properties window. Then, add an image file to your project. I snagged a photo of Michael Coyle, ResEx’ own top dog. His image accompanies the source code download at the end of this tutorial. The final interface looks like this:

Add the Code

Double-click PushButton1 and add the following code to its Action event.

  Dim px as PixmapShape
  Dim p as Picture
 
  px=New PixmapShape(coyle)
  p=New Picture(coyle.width,coyle.height,32)
  d=New Group2D
  d.append(px)
  Canvas1.Backdrop=p
  Canvas1.backdrop.Objects=d
  canvas1.Refresh 
  slider1.enabled = True

Next, add this code to the Paint event of Canvas1.

  g.clearRect 0,0,me.width,me.height
  g.drawobject d,47,60

With the Window1 code editor opened, create a new property of that window, by choosing Edit-New Property. Name the property like this:

d as Group2D

Conclusion

Choose Debug-Run to see your work. By drawing an image using a Group2D object, you can a number of important image operations. The speed isn’t as fast as an RGBSurface, but for many tasks its perfectly suitable.

Download the ImageSpinner project.

Originally published by ResExcellence Reprinted with permission

regcode.googlecode.com

By using Google Code, RegCode is now in a nice Subversion repository, which anyone case download (if you’re interested in contributing, let me know and I’ll add you to the project so you can commit changes). There’s also a wiki, which I’m using for documentation and a place to track issues.

Check it out!

First, let’s understand what Eval does. Essentially, it takes as input a string that contains an expression to evaluate. Usage is like this: result = Eval(expression). For our purposes, we can return the result as a Variant.

In REALbasic, we’ll want a subclass of RBScript, so create a new class, which we’ll call Evaluator, and set its super to RBScript. To this class, add a private property: mResult As Variant. We’ll use this value to return the result of the evaluation.

Now add a new public method called Eval with this code:

Function Eval(expression As String) Returns Variant
  Dim source As String
 
  source = "Dim expr As Variant = " + expression + EndOfLine + _
  "Print(expr)"
 
  Self.Source = source
 
  Self.Run
 
  Return mResult
End Function

This code creates a simple line of REALbasic code that will parse the expression and runs this code using RBScript. The result it output using the Print command which will call the Print event in the Evaluator class. Speaking of which, add this code to the Print event:

mResult = msg

This will assign the value that was output with Print to the property we created so that we can return it.

That’s it. Our Eval function is now ready to use. To test it, create a Window with two EditFields (ExpressionField and ResultField) and a PushButton and add this code to the button’s Action event:

  Dim result As Variant
 
  Dim myEval As New Evaluator
  result = myEval.Eval(ExpressionField.Text)
 
  ResultField.Text = result.StringValue

Download Evaluator project

Mac OS X is full of private APIs available only to Apple to use in their own software and the operating system. Clever developers, much more knowledgeable than I, have been able to reverse engineer some of these APIs and do some neat things with them. I was fiddling with the CGSPrivate functions that were made popuplar by a program called Desktop Manager which makes virtual desktops, and made a REALbasic module of (almost) all of the functions in that header as well as some others.

One of the neat things in this header are functions to transition the entire screen, like fast user switching does. I haven’t yet done anything useful with these methods, but I did write a tiny sample application that demonstrates these effects.

Full Screen Effects

The code below is pretty simple, and with a fair amount of work using more of the functions, you could do some wickedly cool stuff, like… a virtual desktop manager program made in REALbasic.

Dim cid as Integer = _CGSDefaultConnection()Dim transNo As IntegerdimDim transSpec As CGSTransitionSpectransSpec.Type = CGSTransitionType(PopupMenu1.ListIndex + 1)
 
transSpec.Option = CGSTransitionOption(PopupMenu2.ListIndex)
 
transSpec.WindowID = 0 // Fullscreen
 
transSpec.BackColorPtr = 0
 
Dim err As Integer
 
err = CGSNewTransition(cid, transSpec, transNo)
 
err = CGSSetWorkspace(cid, 0)
 
err = CGSInvokeTransition(cid, transNo, 0.5)
 
CGSPrivate.Delay(0.5)
 
err = CGSReleaseTransition(cid, transNo)

Finished

Download CGSPrivate Project

Originally published by ResExcellence
Reprinted with permission

AllowDecimals As Boolean: Set to True (or check in the IDE) to allow decimal numbers to be entered.  Otherwise only integers can be entered.

This is a simple control, but I’ve found it useful from time-to-time.

Download NumberField Control

Download Convert MS BASIC Format REAL Numbers to IEEE Format