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

Download the code to try it out. To use it, simply include the ResizableSheet class in your project and set your sheet’s Super to it. And of course, be sure to enable the resizable property on the sheet.

It worked pretty well for me in REALbasic 2008 Release 1.

Download Resizable Sheet 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

In this tutorial we’re going to write a CapacityString class which will vastly improve string performance in certain situations. Now, I admit this tutorial isn’t exactly going to be eye catching, but I think for some of you it will be quite an eye opener.

The Problem

Let’s say that you’re going to be importing some data from a file, processing it, and outputting the results to a string. Since this process can take quite a while you’re going to want to display a progress dialog with a progress bar that increments realistically based on the current position in the file. Normally you’d have something that looks like this:

bin = File.OpenAsBinaryFile
length = bin.Length 
 
For i = 1 To length Step 2048
   s = s + ProcessData( bin.Read(2048) )
   // show progress
Next

There’s nothing extraordinary about this code at all, but what if I told you that it could be sped up by over 50 times? It’s quite possible, and easy.

Note that every time through the loop we assign a value to the string “s”, and during that assignment REALbasic reallocates a block of memory to store the contents of that string. The problem is that allocating memory is actually pretty slow, so doing it over and over and over again is very inefficient. The solution is to simply allocate enough memory up front so that it never has to be reallocated. Sounds easy, and it is, but REALbasic strings can’t do this so what we need to do is do it ourselves using a MemoryBlock.

The CapacityString Class

Create a new class called CapacityString and add three properties to it: mCapacity as Integer, mLength as Integer, and mData as MemoryBlock. mData is the chunk of memory that we’re going to be using to store the string, mCapacity will cache the size of the MemoryBlock (although it will always contain the value returned by mData.Size, the fewer function calls we make the faster the code will be), and because the string inside the MemoryBlock will almost never be the size of the MemoryBlock itself, we use mLength to store the size of the string.

Sub Constructor(capacity as Integer)
   mCapacity = capacity
   mData = New MemoryBlock(mCapacity)
End Sub 
 
Function Operator_Convert() As String
   Return mData.StringValue(0, mLength)
End Function

The constructor initializes the mData MemoryBlock to have the capacity we want, and Operator_Convert is a handy method to return the string that is stored in the CapacityString.

The SetString method below sets the string in the CapacityString. The first thing that each of these methods below does is first check to see if the string will actually fit inside of the MemoryBlock. If it doesn’t, it resizes (within the method, function calls would add overhead ;^) and then assigns the string.

Sub SetString(s as String)
   Dim slen As Integer = LenB(s)
   If mCapacity < slen Then
      mCapacity = slen
      mData.Size = mCapacity
   End If 
 
   mData.StringValue(0, slen) = s
   mLength = slen
End Sub 
 
Sub AppendString(s As String)
   Dim slen As Integer = LenB(s) 
 
   If mCapacity < mLength + slen Then
      mCapacity = mLength + slen
      mData.Size = mCapacity
   End If 
 
   mData.StringValue(mLength, slen) = s
   mLength = mLength + slen
End Sub

AppendString is similar to SetString but just adds the string onto the end. This is equivalent to “s = s + …”. The InsertString method below doesn’t have a direct equivalent to REALbasic’s String type because you have to use Mid or Left and Right with Strings to be able to insert text in the middle. So this not only speeds things up, but gives us extra functionality. That’s nice. :^)

Sub InsertString(location As Integer, s As String)
   Dim slen As Integer = LenB(s)
   If mCapacity < mLength + slen Then
      mCapacity = mLength + slen
      mData.Size = mCapacity
   End If 
 
   // 0 based
   location = location - 1
   mData.StringValue(location + slen, mLength - location) = mData.StringValue(location, mLength - location)
   mData.StringValue(location, slen) = s
   mLength = mLength + slen
End Sub

For a simple test of the class, you can use this code:

Sub Action()
   dim s as String
   dim cs as CapacityString
   dim bin as BinaryStream
   dim i, length as Integer
   dim time as Double
   dim file as FolderItem   file = GetOpenFolderItem("") 
 
   if file = nil then return 
 
   ///////////////////////
   // Using a String
   ///////////////////////
   time = Microseconds
   bin = File.OpenAsBinaryFile
   length = bin.Length 
 
   for i = 1 to length step 2048
      s = s + bin.Read(2048)
   next 
 
   time = (Microseconds - time) / 1000000
   MsgBox "String: " + Format(time, "###.##") + " seconds"
   bin.Close 
 
   ///////////////////////
   // Using a CapacityString
   ///////////////////////
   time = Microseconds
   bin = File.OpenAsBinaryFile
   length = bin.Length
   cs = New CapacityString(length) 
 
   for i = 1 to length step 2048
      cs.AppendString bin.Read(2048)
   next 
 
   time = (Microseconds - time) / 1000000
   MsgBox "CapacityString: " + Format(time, "###.##") + " seconds"
   bin.Close
End Sub

Finished

This isn’t a completely “finished” class as it doesn’t take every string posibility into account, but it’s a solid foundation for anyone wanting to take the idea even further.

Download CapacityString REALbasic project

Originally published by ResExcellence
Reprinted with permission

After much hard work and perspiration (not really)…….. it’s done.

As I originally thought, this code will take forever to explain and I don’t think many of you will want to read it anyway. It works and that’s all you need to know, right? If you have any questions about how this works, just shoot me an email and I’ll be happy to answer it. Also, if you have any changes that make it not-as-ugly on Windows… I may look at those too.

Download Splitter Control REALbasic project

Originally published by ResExcellence
Reprinted with permission

Many years ago, Erick Tejkowski posted a tutorial on alternating row colors to get the same style as an iTunes type listbox. The solution is simple, but yet many people still ask how to do it. We’ll step through the process on how to do this with REALbasic 2007.

Create the Class

Code reusability is a good thing. We’ll subclass the standard REALbasic listbox. Add a new class to your project and name it “ARListBox”. In the properties list set its super to “ListBox” so it can inherit all of the listbox events and properties.

Edit the ARListbox code and add a property called “bAlternateRows as Boolean” and set it’s scope to Public. Find the CellBackgroundPaint event and add this code:

Function CellBackgroundPaint(g As Graphics, row As Integer, column As Integer) As Boolean
If bAlternateRows And row Mod 2 = 0 Then
   g.ForeColor = RGB(237, 243, 254)
   g.FillRect(0, 0, g.Width, g.Height)
End If
End Function

The function is pretty straightforward but we’ll go through it line by line. The event is called by by REALbasic when it needs to draw the ListBox (as in a refresh event), you don’t have to do anything to get this to work. RB passes in the graphics object as well as the row and column of the cell in question.

If bAlternateRows is set to TRUE we take the row variable and use the MOD function to determine if the row is even or not. The MOD function is the same as saying, take the row, divide it by 2 and give me the remainder. If the remainder is zero, then do the painting.

When we want to make the row the alternate color we set the foreground of the graphics object to our alternate color. In this case, we’re using a hard coded color and you could easily substitute your own. Then we call the FillRect method of the graphics object and fill the entire graphics object starting at top, left (i.e. 0, 0) and filling the entire width and height of the graphics object.

An Aside on the Event Handling

Technically, we should return a True from this function if we’ve handled the DrawCellBackgroundPaint event so RB doesn’t try to do it twice. But since we haven’t created a new DrawCellBackgroundPaint event this isn’t an issue and RB doesn’t really care. If you ever want to override this functionality in the future, you would define a new event named exactly the same as the DrawCellBackgroundPaint (you could name it anything, but it helps using the same function name) with the same parameters and return value. To allow your instantiated class to override the behavior you then add this:

Function CellBackgroundPaint(g As Graphics, row As Integer, column As Integer) As Boolean
//Call our event and see if the user has handled it
If CellBackgroundPaint(g, row, column) Then Return True 
 
//If we haven’t handled it, this is the default behavior
If bAlternateRows And row Mod 2 = 0 Then
   g.ForeColor = RGB(237, 243, 254)
   g.FillRect(0, 0, g.Width, g.Height)
End If 
 
Return True
End Function

Edit Property List Behavior

Now that we’ve defined our class go back to the project tab and right click on the ARListBox class. Select Property List Behavior from the options. Once the dialog opens, scroll down the properties list and check the bAlternateRows checkbox and then click the OK button.

Once we’ve checked this option, our bAlternateRows variable may be set through the IDE instead of having to set it via code. This is simply a shortcut and could easily have been done via code in the open event or done using Computed Properties. One could argue that Computed Properties may be the best way to do this if you decide to change the color or toggle the bAlternateRows value at runtime. In our simple example this isn’t an issue.

Add the Control To a Window

Now go to Window1 that was created for you when you created a new project. Choose “Project Controls” from the tools pallet and drag a new instance of ARListbox on to your window. Resize and change properties as necessary. In the Properties List you’ll see the bAlternatveRows property under the ‘behavior’ heading. Make sure it’s checked.

Go into the code editor and find the Open event of ARListbox1 (the default name of our new ARListbox object. In the open event use this code:

Sub Open()
Dim i As Integer
For i = 1 To 15
   Me.AddRow "Row " + Str(i)
   Me.Cell(i - 1, 1) = "Cell (" + str(i) + ", 1)"
   Me.Cell(i - 1, 2) = "Cell (" + str(i) + ", 2)"
Next
End Sub

This code simply gives us some sample data for our listbox to use. You can play around with the number of rows and the text in the cells, but the important point is that each even row in the listbox is colored!

Conclusion

With this sample project we’ve created a very simple and elegant variation of the standard listbox. It demonstrates how to subclass a control and some of the basics of events. Enjoy!

The MessageDialog class is an important user interface element that if not done correctly, sticks out like a sore thumb on Mac OS X. Users expect a consistent message interface between applications, so it is critical that developers adopt and embrace the MessageDialog class as a part of becoming a good Mac OS X citizen.

It’s a Sheet!

This tutorial isn’t exactly the most indepth of them all. In the code below, you simply have a chunk which sets up a MessageDialog in the CancelClose event of a Window and displays it using ShowModalWithin.

Function CancelClose(appQuitting As Boolean) As Boolean
Dim dlog As MessageDialog
 
// Create Dialog
dlog = New MessageDialog
dlog.Message = "Do you want to save the changes you made in the document """ + self.Title + """?"
dlog.Explanation = "Your changes will be lost if you don't save them."
dlog.ActionButton.Caption = "&Save..."
dlog.CancelButton.Caption = "Cancel"
dlog.AlternateActionButton.Caption = "&Don't Save"
dlog.ActionButton.Visible = True
dlog.CancelButton.Visible = True
dlog.AlternateActionButton.Visible = True
 
// Show Dialog
Select Case dlog.ShowModalWithin(self).Caption
Case "&Save..."
MsgBox "Pretend this is a save dialog..."
Return False
Case "&Don't Save"
Return False
Case "Cancel"
Return True
End Select
End Function

Finished

What’s really nice about this class is that any cross-platform issues are already taken care of for you. If the ShowModalWithin method is used to create a sheet window in Mac OS X, the same code compiled for Windows and Linux has the dialos appear as a standalone window. In addition, the placement of the Save, Don’t Save, and Cancel buttons is different in Mac OS X than it is in Windows and Linux, but the MessageDialog class takes care of button placement as well.

Download MessageDialogSheet REALbasic project

Originally published by ResExcellence
Reprinted with permission

Continuing the article about drawing a simple rectangle with a Quartz shadow, in this article we take a look at axial gradients. The code for this is actually a major pain to explain (I admit I don’t know everything there is to know about it as well), so, sorry, but I’m going to pull a “just look at the code if you want” here.

What I’ve done is add on an extension to the Graphics class which takes a bunch of parameters.

Sub DrawAxialGradient(Extends g as Graphics,
c as Canvas,
vertical as Boolean,
color1 as Color,
color2 as Color,
Left as Integer,
Top as Integer,
Width as Integer,
Height as Integer)

The canvas parameter is actually optional, but you won’t be able to see why in the example project. Right now, because of the way Canvases are implemented it’s a pain in the butt to deal with because the context you’re drawing into is actually the window’s. That is, a Canvas isn’t a “real” control, it’s just an abstract way to look at a certain rectangle in the window. That’s a problem because if you’re trying to draw into a canvas, you need to know about the window the canvas is in so you can translate the coordinates and clip appropriately. If you’re not drawing in canvas, you pass in nil and it should just do the right thing.

The vertical boolean parameter specifies if the axial shading is vertical or horizontal (there’s no start point and end point definition in this implementation, it’s a bit hardcoded). Color1 and Color2 are the two (not, not three or more in this implementation), and the next four parameters are the bounds of the gradient.

It’s relatively limiting (better than what RB has!), but that’s mostly because to do everything you can in Quartz, you really have to do it all yourself, or I’d really have to spend more time to abstract it out and provide a few different methods and ways of doing things. Have look around the code and you should see why it’d actually be a little tricky.

Download Quartz Gradients REALbasic project

Originally published by ResExcellence
Reprinted with permission

Should you accidentally enter the wrong password while logging onto an OS X machine, you’ll notice that the login window wiggles back and forth a few times. In fact, it looks like the login window is shaking its head “NO!” at you. This week we’ll look at how to implement this functionality with REALbasic. It turns out that it’s very simple to accomplish, so let’s get started.

Build the Interface

Launch REALbasic and open the default Window1. To this window, add a PushButton and a Timer. Set the Mode property of the Timer to 0 (zero). You can arrange the window however you wish.
Add the Code
Open the Code Editor for Window1 and add two properties to the window:

• OrigX As Integer
• Wiggle As Integer

Next, enter this code in the Action event of PushButton1:

Wiggle = 0
OrigX = Self.Left
Timer1.Period = 30
Timer1.Mode = 2

Finally, add this code to the Action event of Timer1:

If Wiggle > 5 Then
   Me.Mode = 0
   Self.Left = OrigX
Else
   If (Wiggle Mod 2) = 0 Then
      Self.Left = OrigX - 20
   Else
      Self.Left = OrigX + 20
   End If
   Wiggle = Wiggle + 1
End If

By clicking the PushButton, you reset some variables that keep track of the position of the window as well as the number of wiggles. Then, the timer starts firing. As the timer fires, it increases the wiggle counter and alternates the position of the window between its two positions. Once the counter exceeds 5, the timer stops. Simple, eh?

Conclusion

That’s all there is to it.

Download Wiggle Window REALbasic project

Originally published by ResExcellence
Reprinted with permission