Amalgam Plugin defines a blending of pictures, windows and custom widgets allowing the creation of a novel GUI for the Mac and the Windows platforms. For example, you can create a mac user interface on windows, or a windows interface on the mac.

The Drawable class is compatible with a variety of usages, including the generation of alpha-aware pictures on your desktop that are not confined to a particular window:

In the above example, a number of pictures have been stashed together, and some of these pictures act as widgets, i.e. are mouse aware.

Version notes for this release:

1. [new]: Creation of a Drawable using a QuickTime movie.
2. [new]: Drawable.MovieTask, can be used in a timer to advance the reading and rendering of a movie frame. More appropriately, you would want to use the TimeBase Plugin to setup the drawing of a movie frame into a Drawable.
3. [new]: Drawable.Playing, to be used if the Drawable is rendering movie frames.
4. [chg]: the "responsive as boolean" attribute of the drawable class has been renamed tp "greedy as boolean". It does not change the implementation but the renaming would better reflect this attribute: If greedy is set to true, the drawable instance will obtain messages in its "change event" allowing the developer to respond to the state change (activate/deactivate and mouse hover, mousedown and mouseup events). To make use of it, subclass the drawable and implement the Change event. Note also that if greedy is set to true, the drawable will not respond to the mousedrag event.
5. [new]: the change event of the drawable class now returns a boolean value, and if you would return true, and greedy is false, the drawable will not respond to a mousedrag. Note that this behavior is equivalent to returning true in the mousedown event when subclassing a Drawbar.
6. {new]: Drawable.bitIsSet, useful if the Change event is being implemented.

QTFT or QuickTime FileTransfer allows the transfer of remote files to local files, including the transfer of files into REALbasic's virtual volumes and out. The crux of this plugin is to transfer the files asynchroneously and as quickly as possible. This plugin is a rewrite of our older QTFileTransfer plugin.

Version notes for this release:

1. [new]: Complete rewrite of the old QuickTimeFileTransfer Plugin

Timing and scheduling tasks with Timebases and clocks. This plugin provides a class that enables you to set and get the timebase of a movie. Access to the TimeBase also allows scheduling of tasks triggered from the TimeBase, and you can accomplish this with the TimeBaseCallBack class. It is a requirement that a QuickTime MoviePlayer (can be invisible) is living on the window. TimeBase is a QuickTime concept that derives time from either a clock component or from another timebase. A timebase constitutes a set of attributes, a time value and a time scale, which are interdepedent. For example, if the scale is being changed, the time value changes accordingly.

Time scale is the number of units into which a second is subdivided. For most QuickTime movies, the time scale is set to 600, meaning that the smallest fraction of time measurement for the movie is 1/600th of a second.

Another attribute is the rate, the multiplier for the time scale. The rate controls how fast the movie plays. When the rate is 1.0, the movie plays at its normal speed, meaning that for each second of play the movie's time advances a number of units equal to the time scale. If the rate is between 0.0 and 1.0, the movie plays in slow motion, and fewer units are counted off per second of play. A negative rate implies that the movie is playing backward. A rate of 0 means that the movie is stopped.

TimeBaseCallBack defines a callback event that is triggered by the TimeBase/clock component. Callback events are scheduled at specific times, at rate changes, time jumps, and also can be scheduled when this callback instance is being destroyed. When callback events do not involve memory movement, events can be triggered at interupt time. TImeBaseClock is a search engine to look for a clockComponent that can be used to drive a timebase. The search can be limited by flags defined as constants to this class, or by using a subType.

Version notes for this release:

1. [fix]: Changed the way constructors are defined to make this plugin compatible with REALbasic 2008R3 or higher.

Version notes for this release:

[new] WordGuise.FreezeUpdate, inhibits the redrawing and notifications, and supercedes the feature.SuppressRecalText and feature.SuppressReDraw methods.

[new] WordGuise.ReadOnly, a design-time property and supercedes the feature.ReadOnly methods.

[new, windows only] WordGuiseTable class created to embed tables in the wordguide field.

[new, windows only] WordGuiseModule.TagTable to be used in WordGuiseStyledText.style for assignment of the table.

[fix, windows] DefaultTabWidth is functional.

[new] A handcursor will appear when the mouse is hovering over a link (MacOS) and when pressed (MacOS and Windows). The URL link event will fire when the mouse is pressed.

[fix, windows] readjustments of scrollbars and the text field.

[fix, windows] textMargin of the WordGuise control is properly offsetting the displayed text in the view field.

Screenshots on a mac and win box show a WordGuise widget displaying text that was loaded by RTF-formatted text displayed in the editfield below. The buttons "Load" and "Save" will parse rtf from the editfield to the WordGuise widget and write out rtf formatted text from the WordGuise widget to the editfield

VideoOut Plugin, based on QuickTime Video Output Components enables RB programmers to output DV and DVCPRO video streams via the FireWire port (also known as iLink or IEEE-1394) of your Macintosh and Windows computers. New in this version of the plugin is its compatibility with RB2005 for MacIntosh and Windows, and the addition of a novel method that will allow switching movies, without destruction and reastablishing ownership of the VOut. The SwitchMovie method requires the connection be established already and it will redetermine the software settings internally as much as possible.

REALbasic programmers who do not have a hardware device can still provide support in their applications by using VideoOut emulators (for development), i.e., extensions that come with the plugin. There are 2 sets of extensions for each of the 3 main platforms,

MacOS 9 classic and carbon: SoftVOutPPC and SoftCodecPPC
MacOS X Universal: SoftVOutXcode.component
WIN32: SoftVOut.qtx and SoftCodec.qtx

SoftVOut emulates a Video Out by using the lower right corner of the screen. Because it is the screen a transfer codec is in principle not required. A codec emulator is provided, which does not do much interesting other then providing a funny transfer of the image(s) when the pixel depth is other than 32. For your info, transfer codecs are primarily provided by the manufacturer of the hardware.

VideoOutComponent uses the component descriptions of the MacOS. If a valid component instance is created, you use this class to obtain the default settings from the VideoOutComponent, to present it to the user and let the user alter the settings. The client is able to design a settings dialog, or even avoid the presentation of such a dialog.

The characteristics can also include a list of decompressor components required for the mode that are provided specifically for the video output device. If a video output device cannot directly display any of the pixel formats supported by QuickTime, the vendor of the device must provide one or more special decompressors to convert supported pixel formats to a format the device can display. If a video output device can display one or more of the pixel formats supported by QuickTime, the Image Compression Manager can use standard decompressors that are included with QuickTime, and the list of special decompressor components can be empty.

Version notes for this release:

1. [fix]: Changed the way constructors are defined to make this plugin compatible with REALbasic 2008R3 or higher
   

On OSX AVC devices (i.e. camcorders, etc.) are represented in the IORegistry as instances of IOFireWireAVCUnit.This plugin is a Mach-O only plugin, is not dependent on third party bundles as it was in the past. AVC interfaces the play, record, wind and other vcr features and thus permits the manipulation of the vcr from your computer and keyboard.

Two sample projects are provided.

"Notify.rb" when compiled as "FireWireNotifier" monitors the connection when an AVC device is connected (hot plug), and can be used during development of another rb-project, like "AVC.rb", which uses the AVC class, but also the FWNotification class. FWNotification uses an IONotificationPort and the CurrentEventLoop.

1) The GrowIcon of the window needs to be set.
  ** this ensures the visibility of  HiGrowBox instances.
  ** you can then use the WindowAttributes plugin to disable 
  the GrowIcon of the window by disabling the ResizableAttribute.
2) For LiveResizing you require to call the "refresh" method.
  ** In the PositionChanged event you call either me.refresh 
  or "refresh" of another control.

Example:
Sub PositionChanged(dx as integer, dy as integer)
  scrollBar1.Left = scrollBar1.left + dx
  scrollbar1.height = scrollbar1.height + dy
 
  scrollbar2.top = scrollbar2.top+dy
  scrollbar2.width = scrollBar2.width+dx
  
  pushButton1.left = pushButton1.left+dx
  pushButton1.top = pushButton1.top+dy
  
  me.refresh
End Sub

This plugin extends the window class in RB4 and RB5, and subclasses the window class in versions of pre-RB4.

The major purpose of this plugin is to set the transparancy of the growbox view of the window. This feature is implementable for windows that don't require the windowComposite Attribute.

Another purpose is the instalation of a lifeResizeAttribute. This is already supported in REALbasic 5, but not in REALbasic 4.x. You can use this however too in REALbasic 5. If you set this attribute a Life resizing event will be called. There you should handle your controls to move according to your needs.

Make sure you also have NavDialog Plugin downloaded when you want to run the RB-project.

After you run the project and have generated all of the headers in the CFM2OSX folder, you should start the compilation of the precompiled header files, using the provided CW-project. In the CW-project 2 targets have been defined. Choose the target that compiles the headers.

Once compiled go back into the RB project and choose the stub-tabpanel. Hit the button and locate the CoreGraphics framework in the "CFM2OSX/FlattenedHeaders/Framework Headers/CoreGraphics.framework" folder, using NavServices. You can choose multiple files, and I recommend all of the CG\ files. These files are then listed in the listbox when you have accepted these files in NavServices (you have hit the "Choose" button). The program automatically generates the stubs and has been tested and adapted towards all the CoreGraphics Files. Most of the prototypes are translated into stubs.

When you are done go back to CW and run the testLibrary target. This will compile the stubs into one CoreGraphicsLibStub you subsequently can use in your projects to link against. All you then need to do is call the function "InitFrameworks(gBundlePtr)" as defined in "InitAllFrameWorks.h", which was generated by the RB-project.

If you need specific prototypes from other frameworks you can copy these prototypes into a file and use that file to generate the specific prototypes. For instance some CG-related prototypes are defined in QuickDraw.h. These are not defined in carbonlib, while many other prototypes are. It is thus pointless to generate stubs that are already defined in carbonlib.

Developers know how to weak link to the systemFramework of MacOSX, while the header files in the various frameworks provide the prototypes of the functions available. CodeWarrior does not provide precompiled headers for CFM-based targets, only MACHO-based targets on OSX.

This plugin has been put to life for a couple of reasons. The first reason was to provide tools you can use to meaningfully implement a new class that comes with NavDialog Plugin. This new class is called NavCustomization, which allows you to add a DITL resource to a NavDialog window. Navigation Services allows you to do this, and because Navigation belongs to the Human Interface Experience, it was almost imperative to implement ResourceEdit. In order to give the REALbasic programmer the necessary tools, a new plugin had to be created, which does several things.

1) Allows you to use existing REALbasic controls for prototyping DITL and DLOG resources.
2) Write resources out into a resourcefork.
3) Provide classes you use to bring life into these resources.
4) Make it compatible with the NavDialog Plugin.

A spinoff of this plugin is possibly the provision of tools you could exploit to copy ResEdit and bring it on the MacOSX market. It seems also be useful for Windows.

You need RB Plugin Plunger to inspect the methods, properties and events.

Features a NavCallback that allows the client to sneak the user's temporally choices when a NavDialog is open. It also provides ways to block the opening, saving or creation of a new folder.

Features MacOS X issues, like sheets and other cosmetic stuff. NavDialog plugin consists of 8 classes, NavReply, NavTypeList, NavDialogOptions, NavDialogOptionFlags, NavUserAction, NavDialog, NavCallback and NavCustomization.

A simple implementation of this plugin would be:

dim flags as NavDialogOptionFlags
dim navdlg as NavDialog
dim UserAction as NavUserAction

  navdlg = new NavDialog
  if navDlg <> nil then
    navdlg.userAction = new UserAction
    navdlg.Options = new NavDialogOptions
    flags = navdlg.Options.NavDialogOptionFlags
    if flags <> nil then
      flags.kNavDefaultNavDlogOptions=true
    end if
    navdlg.typeList = nil
  end if

Note: not every method is documented yet.

Another feature this plugin provides is the ability to make a movie of part of your desktop with the "ScreenGrabber" class. It uses the "SequenceGrabber" API of QuickTime, and for this "thng" resources are provided for three platforms (an 68K resource can be made available on request). In order to make the screenGrabber to work you need to put the "PictChannel PPC" extension into the extension folder (Classic MacOS) and restart your computer. For Windows you need to place the "sgchComponent.qtx" in the \Windows\System\ folder, and the "PictChannel.component" in the /Library/QuickTime/ folder to use it in MacOSX. If you have no access to the MacOSX QuickTime folder when running MacOSX (please provide me with info how to do this, because I am ignorant here), you can put the PictChannel.component extension in the /System/Library/QuickTime/ folder from MacOS classic. The project you need is "movieRendering" to appreciate the Grabber feature(s).

Note: not every method is documented yet, You need RB Plugin Plunger to inspect the methods, properties and events.

This Plugin attempts to provide access to the atoms and atom containers, create atoms, delete them, as well as covering a lot of the Wired Movie API. It is not an easy plugin when dealing with Atom Containers, because setting up a top-down tree is another programming language it self.

MovieWires Plugin is accompanied with a bunch of classes that provide read-only properties (constants) that would help in get you a bit used to the Wired Movie API. You can avoid usage of these read-only properties by supplying the appropriate integer or four-char-strings. For this two helper functions are available:

Int2Str and Str2Int.

Int2Str takes an integer and returns a string of 4 characters (OSType) and Str2Int does the reverse. The read-only classes are all subclasses of "MovieConstants", which does not have any properties, methods or events. MovieConstants is meant to keep the read-only classes inside a "virtual folder" (= MovieConstants) in RB's popupMenu of classes.

The plugin contains additional classes: a WiredMovie class, a Track class and a Media class, and provides additional functions to manipulate tracks with AtomContainers. It also comes with sample projects to show it's capabilities too.

The extended methods to the movie and movieplayer classes, originally found in MovieWorks plugin have been incorporated here. The wiredMovie class contains a lot of utility functions to manipulate movies when opened as a wired movie. Permanent changes are carried out by calling updateMovieResource. The MoviePlayer is extended to provide 4 additional events that are useful with wired movies.

To obtain info on the methods and functions, please download RB Plugin Plunger. Examples for MovieWires Plugin and MovieWorks Plugin you get here. Make sure you put the plugin MediaBlending, comes with the examples, in the plugins folder to be able to run some projects.

MovieGuts plugin comprises some classes that may be usefull.

ImageCompressor (Class)

The ImageCompressor uses the following types:

--StandardCompressionType, 
--StandardCompressionSubType 

QTFileTypes (Class)

This class is very handy. It loads all of the QuickTime extension components that are used to open files (usually 70 or more types are loaded). You can then retrieve each of the fileTypes and put them into a NavTypeList, which is a class property to the NavDialog class.

QTGraphicsImporter (Class)

This class is capable to retrieve/determine the number of images a single file contains. It does not need to be a movieFile, while it can determine whether it is a movie. Flash Images can be retrieved, and a DataHandle, represented as an integer can be presented as an argument to the wiredMovie class constructor. This class can be instantiated with either a folderItem or url as argument.

QTMovieExporter (Class)

This class allows for exporting a movieFile. A movieFile can be exported as an anyType file, as a hinted file, where you can issue a hinter settings dialog. You can save exporter settings, set exported movie dimensions by hand or from a file.

The constructor takes a movie and a folderItem to which the movie is exported, and returns the exported folderitem. It requires instantiation of the class with hintType 'hint'. You can provide a hinter movie settings dialog. If you do so, some flaws in the QuickTime API will show up: underlying windows are not updated; The same behavior occurs in QuickTime Player.

QTMovieImporter (Class)

This class is able to import almost everything based on the QTFileTypes. If you want to follow the progress of importing you should subclass this class and implement the events. The progress of importing is synchronous, it only returns when the importing process has completed.

SequenceCompressor (Class)

--StandardCompressionType, 
--StandardCompressionSubType 

Class Extensions:

FolderItem (Class Extension)

Methods:
ReadJPEG () as Picture
SaveAsJPEG (pic as picture)

Version 1.5: Tweaked the qtMovieImporter class. There are 3 type of constructors:

--The first type takes a qtComponent, thereby creating a qtImporterComponent. 

--The second type takes an URL. 

--The third type takes 2 folderItems and does not create a qtImporterComponent.  

-----

To obtain info on the methods and functions, please download RB Plugin Plunger. Examples for MovieWires Plugin and MovieWorks Plugin you get here.

About the plugin: The plugin is written around the URLAccess library. The major constituent is the URLentryItem with 3 property classes, including URLentryError for error reporting, URLentryFolderType to indicate where a folderItem should be downloaded to, and the URLentryOpenFlags to set up a particular behavior. All four classes will be automatically instantiated when you instantiate the URLentryItem with the new operator. By using this plugin you are using the URL Access Manager.

The URL Access Manager provides asynchronous and synchronous methods for downloading and uploading files or directories. Information about these methods is available here, but not all of them are implemented in the plugin. Only the Asynchronous URLOpen method is used, which gives more control to the RB-programmer.

In this plugin though URLOpen can be used in synchronous mode too, which means that if you call Download(url as string, byref folderItem as FolderItem, asynchronous as Boolean) in asynchronous mode, the folderItem is not available immediately; You can retrieve it from URLentryItem.Folderitem once you're being notified in ConnectionComplete or URLCompleted. In synchronous mode your application will wait until the URL action is completed, while you still can use the notification events of URLentryItem. The synchronous methods from the URL Access Manager does not provide this functionality, instead it 'll provide progress bar windows you probably want to write them your self.

To obtain info on the methods and functions, please download RB Plugin Plunger

HTMLrendering is a plugin, capable to render html files. This plugin "HTMLrendering" contains the renderer control. The FolderItemClass and MemoryBlockClass are extended with methods to allow opening of URLs in conjunction with the renderer.

Facilities have been provided for setting the default page displayed in a windows when no other file has been specified.

The renderer has events, properties and methods, that also allow you to get the url_address, url_title. One of the sample projects uses Dave Grogono's stationary multidoc project, which makes use of the url_title. The LookingForHTMLSource was designed to provide a callback into the HTMLrendering Library. It provides a fullURL string obtained after clicking a link on the page. This URL can be presented to another plugin "URLAccess" that will download the requested URL. That URL is saved as a folderItem of which the absolute path is funneled back into the HTML- library for rendering. The HTMLLookingForImage does something similar when the renderer requires a image. These 2 events are not being called when you would present a folderItem via the Navigation services.

To obtain info on the methods and functions, please download RB Plugin Plunger

In conjunction with the HTMLrenderer plugin, this plugin provide buttons for navigation of the history of visited links in the renderer. Navigation controls built in this control are grouped into two types. There are the built in navigation buttons (back, home, and forward) and there are custom buttons that you can add via a utility such as ResEdit. ResEdit templates have been included in the resource fork of this plugin for accessing the necessary resources. Be sure to make a backup of the plugin before doing any editing.

Buttons are described in a 'CICB' resources. These resources include the following information:

• A boundary rectangle for the icon. For this version of the plugin, for custom buttons this should always be the bounding rectangle { 0, 0, 32, 32 }
• A state value. This is used internally by the cIconButtons controland should be set to zero.
• Three 'cicn' id numbers for drawing the button in one of three states. These include disabled, enabled, and pressed. These id numbers are used to retrieve the 'cicn' resource used to draw the button in whatever state it happens to be in.
• Button link for custom buttons, this string should be a html link relative to the application's directory that refers to a html file to be displayed when the user clicks on the button.

To obtain info on the methods and functions, please download RB Plugin Plunger

We have provided the REALentry SDK with a library for each of the targets. Currently, REALentry has emerged to be even more important, example: a class (or control) that provides a SoundDescriptionHandle is used as an argument of a constructor of another class. Passing Handles as integer (as an alternative) may be ok, but it does not look like the real OOP way; passing it as an object like:

dim soundDescObject as SoundDescription
dim exporter as QTMovieExporter

//do something with soundDescObject
//

// constructor: QTMovieExporter(soundDescription as Object)
exporter = new QTMovieExporter(soundDescObject)

above would suggest (without REALentry SDK) to merge the 2 plugins together in a single resource.

Here follow the basic setups:

/////////////////////////////////////////////
//Here is a snippet to setup a class entry:
////////////////////////////////////////////
extern REALclassDefinition SoundDescriptionClass;
typedef struct SoundDescriptionData {
    ClassEntry             myClassEntry; // see below
    REALobject              self;
    SoundDescriptionHandle  mySoundDesc;
    OSStatus                myErr;
} SoundDescriptionData;

static SoundDescriptionHandle 
SoundDescription_ExportSoundDescriptionHandle(REALobject instance)
{
    ClassData(SoundDescriptionClass, instance, SoundDescriptionData, me);
    return me->mySoundDesc;
}

void* SoundDescription_Exports[1] =
{
    {SoundDescription_ExportSoundDescriptionHandle},
};

static void* SoundDescription_ExportResolver(long funcID)
{ 
    return SoundDescription_Exports[funcID];
}


static void SoundDescription_Constructor(REALobject instance) 
{
    ClassData(SoundDescriptionClass, instance, SoundDescriptionData, me);
    
    me->self = instance;

    me->myClassEntry.version = kCurrentREALControlVersion;      <-----
    me->myClassEntry.signature = 'SndD';                          <-----
    me->myClassEntry.Resolver = SoundDescription_ExportResolver; <-----

    me->mySoundDesc =
           (SoundDescriptionHandle)NewHandleClear(sizeof(SoundDescription));

    if (me->mySoundDesc == NULL) {
        me->myErr = memFullErr;
        return;
    }
}

/////////////////////////////////////////////////
//In another plugin the pointer is retrieved as:
////////////////////////////////////////////////
SoundDescriptionHandle 
ClassResolver_SoundDescription_GetSoundDescriptionHandle(REALobject soundDesc)
{
    fpClassResolver myResolver =
             (fpClassResolver)ClassEntryResolver(soundDesc, 'SndD');

    if (myResolver) {
        typedef SoundDescriptionHandle (*fp)(REALobject);
        fp _GetSoundDescriptionHandle = (fp)(myResolver(0));
        return _GetSoundDescriptionHandle(soundDesc);
    }
    return nil;
}


/////////////////////////////////////
//Here are the REALentry SDK snippets:
/////////////////////////////////////
typedef struct ClassEntry {
    long     version;            // current SDK version
    long     signature;          // identification iD of contol/class
    void*     Resolver;          // exported functions
} ClassEntry;


/*
    These are typedefs defined here, but any other types you can design
    for your own purposes.  They are not required here.  Please check out
    the documentation that comes with this sdk.
*/
typedef void* (*fpClassResolver)(long);
typedef void* (*fpControlResolver)(long);


/*
    The new functions for testing if entry exists and which entry you want.
    returns the resolver
*/
void *ClassEntryResolver(REALobject instance, long signature);
void *ControlEntryResolver(REALcontrolInstance instance, long signature);

long ClassEntrySignature(REALobject instance);
long ControlEntrySignature(REALobject instance);

Previously we said, and it still holds in many cases:

The REALbasic Plugin_API provides for numerous functions that allow the development of a class or control. In some cases, however, several classes/controls are developed that require "binding". This means one class needs to use data fields from another class. Those datafields mostly contain MacOS "toolbox" types we cannot easily provide in the RB environment that then are used in other methods. In general, it is difficult to provide for those cross talks, especially when you want to talk to a plugin from another author, and the source is not available. The proposal we ( Björn Eiriksson and I, Alfred van Hoek) are about to suggest has everything to do with having accessors to existing REALbasic classes/controls, and one example was given by REALsoftware. The plugin_API was recently updated to provide accessor functions to the MemoryBlock class, but each of these functions, or entries to a datafield of MemoryBlock, makes the REALbasic Runtime Engine bigger.

A reliable way was found to provide for class and control entry function pointers that points to an array of function pointers to actual class member functions. This allowed the StringList class (in development) to report to a rudimentary listbox control, based on the MacOS Toolbox ListHandle, without extended manipulation in the RB environment. This direct communication between a class and control is not as dependent on the manner plugins are loaded by REALbasic, and moreover, does not increase the size of the REALbasic Runtime Engine. Further info comes with the SDK.

MongoToDebugConsole, the tool you will need to debug your REALbasic Project. It is a cross-platform REALbasic Plugin that funnels information from your project back to the C/C++ environment, where it is further processed.

What is it?

A REALbasic Plugin that adds debugging facilities better than ever. You do not want to use Virtual1's Project CuisinArt debugging console? Use the MongoToDebugConsole plugin. You would like to use Virtual1's facilities, Project CuisinArt, but need a remote console? Use the MongoToDebugConsole plugin. You want to quickly debug your WIN32-compatible code? Use the MongoToDebugConsole plugin. You also need to setup your computer with Dcon-DEMO (comes with MongoToDCon)) to appreciate it. For a quick look inspect with RB Plugin Plunger.

Open source canvas-like plugin for REALbasic.