Check it out here:

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

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

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