OSErr QTWired_AddWraparoundMatrixOnIdle (QTAtomContainer theContainer)
{
MatrixRecord myMinMatrix, myMaxMatrix, myDeltaMatrix;
long myFlags = kActionFlagActionIsDelta | kActionFlagParameterWrapsAround;
QTAtom myActionAtom;
OSErr myErr = noErr;
myMinMatrix.matrix[0][0] = myMinMatrix.matrix[0][1] = myMinMatrix.matrix[0][2] = EndianS32_NtoB(0xffffffff);
myMinMatrix.matrix[1][0] = myMinMatrix.matrix[1][1] = myMinMatrix.matrix[1][2] = EndianS32_NtoB(0xffffffff);
myMinMatrix.matrix[2][0] = myMinMatrix.matrix[2][1] = myMinMatrix.matrix[2][2] = EndianS32_NtoB(0xffffffff);
myMaxMatrix.matrix[0][0] = myMaxMatrix.matrix[0][1] = myMaxMatrix.matrix[0][2] = EndianS32_NtoB(0x7fffffff);
myMaxMatrix.matrix[1][0] = myMaxMatrix.matrix[1][1] = myMaxMatrix.matrix[1][2] = EndianS32_NtoB(0x7fffffff);
myMaxMatrix.matrix[2][0] = myMaxMatrix.matrix[2][1] = myMaxMatrix.matrix[2][2] = EndianS32_NtoB(0x7fffffff);
myMinMatrix.matrix[2][1] = EndianS32_NtoB(Long2Fix((1 * kSpriteTrackHeight / 4) - (kPenguinHeight / 2)));
myMaxMatrix.matrix[2][1] = EndianS32_NtoB(Long2Fix((3 * kSpriteTrackHeight / 4) - (kPenguinHeight / 2)));
SetIdentityMatrix(&myDeltaMatrix);
myDeltaMatrix.matrix[2][1] = Long2Fix(1);
// change location
myErr = WiredUtils_AddSpriteSetMatrixAction(theContainer, kParentAtomIsContainer, kQTEventIdle, 0, NULL, 0, 0, NULL, &myDeltaMatrix, &myActionAtom);
if (myErr != noErr)
goto bail;
myErr = WiredUtils_AddActionParameterOptions(theContainer, myActionAtom, 1, myFlags, sizeof(myMinMatrix), &myMinMatrix, sizeof(myMaxMatrix), &myMaxMatrix);
bail:
return(myErr);
}
void ofxQtAudioRecorder::prepareAudioRecording(int sampleRate, int numChannels_){
OSErr err = noErr;
// create audio description and set format ID along with format flags, mBitsPerChannel and mBytesPerPacket
AudioStreamBasicDescription asbd;
numChannels = numChannels_;
asbd.mSampleRate = sampleRate;
asbd.mFormatID = kAudioFormatLinearPCM;
asbd.mFormatFlags = kAudioFormatFlagsNativeFloatPacked;
// if multi-channel, the data format must be interleaved (non-interleaved is not allowed),
// and you should set up the asbd accordingly
asbd.mChannelsPerFrame = numChannels; // 2 (Stereo)
// mBitsPerChannel = number of bits of sample data for each channel in a frame of data
asbd.mBitsPerChannel = sizeof (Float32) * 8; // was 8 // 32-bit floating point PCM
// mBytesPerFrame = number of bytes in a single sample frame of data
// (bytes per channel) * (channels per frame) = 4 * 2 = 8
asbd.mBytesPerFrame = (asbd.mBitsPerChannel>>3) * asbd.mChannelsPerFrame; // // number of *bytes* per channel * channels per frame
asbd.mFramesPerPacket = 1; // For PCM, frames per packet is always 1
// mBytesPerPacket = (bytes per frame) * (frames per packet) = 8 * 1 = 8
asbd.mBytesPerPacket = asbd.mBytesPerFrame * asbd.mFramesPerPacket;
//printf("bits per channel %i\n", asbd.mBitsPerChannel);
//printf("bytes per frame %i - %i %i\n", asbd.mBytesPerFrame, (asbd.mBitsPerChannel>>3), asbd.mChannelsPerFrame);
//printf("bytes per packet %i\n", asbd.mBytesPerPacket);
err = QTSoundDescriptionCreate(&asbd,
NULL, 0,
NULL, 0,
kQTSoundDescriptionKind_Movie_Version2,
&soundDesc);
checkErr(0x0200);
audioTrack = NewMovieTrack(movie, Long2Fix(0), Long2Fix(0), kFullVolume);
err = GetMoviesError();
checkErr(0x0201);
audioMedia = NewTrackMedia(audioTrack, SoundMediaType, sampleRate, NULL, 0);
err = GetMoviesError();
checkErr(0x0202);
return;
}
//------------------------------------------------------------------------
// DrawString
//
//------------------------------------------------------------------------
nsresult
nsATSUIToolkit::DrawString(
const PRUnichar *aCharPt,
PRUint32 aLen,
PRInt32 x, PRInt32 y,
short &oWidth,
short aSize, short aFontNum,
PRBool aBold, PRBool aItalic, nscolor aColor)
{
oWidth = 0;
if (!nsATSUIUtils::IsAvailable())
return NS_ERROR_NOT_INITIALIZED;
StPortSetter setter(mPort);
ATSUTextLayout aTxtLayout;
StartDraw(aCharPt, aLen, aSize, aFontNum, aBold, aItalic, aColor, aTxtLayout);
if (nsnull == aTxtLayout)
return NS_ERROR_FAILURE;
OSStatus err = noErr;
ATSUTextMeasurement iAfter;
err = ::ATSUGetUnjustifiedBounds(aTxtLayout, 0, aLen, NULL, &iAfter, NULL,
NULL);
if (noErr != err) {
NS_WARNING("MeasureText failed");
return NS_ERROR_FAILURE;
}
err = ::ATSUDrawText(aTxtLayout, 0, aLen, Long2Fix(x), Long2Fix(y));
if (noErr != err) {
NS_WARNING("ATSUDrawText failed");
return NS_ERROR_FAILURE;
}
oWidth = FixRound(iAfter);
// aTxtLayout is cached and does not need to be disposed
return NS_OK;
}
OSErr DoPlayMovie(Boolean useOverlay)
{
Rect movieBounds;
OSErr err;
BailErr((err = GetAMovieFile(&mMovie)));
GetMovieBox(mMovie, &movieBounds);
mMovieController = NewMovieController(mMovie, &movieBounds, mcTopLeftMovie | mcNotVisible);
NormalizeMovieRect(mMovie);
GetMovieBox(mMovie, &movieBounds);
BailErr((err = InitializeMungData(movieBounds,
FrontWindow(),
useOverlay, /* overlay */
true, /* clamp */
false /* draw with QT Effect */
)));
// This is key, as we need to draw all frames in our
// offscreen gworld first. Once there, our custom
// decompressor component can perform overlay drawing
// or color clamping
SetMovieGWorld(mMovie, GetMungDataOffscreen(), nil);
// Our DrawCompleteProc calls BlitOneMungData which
SetupMovieDrawCompleteProc();
// ---------
SetMovieActive(mMovie, true);
#ifndef __APPLE_CC__
// Due to a bug in Jaguar, some QT functions are missing from
// /System/Library/CFMSupport/CarbonLib, so we must manually
// grab the function pointers from the QuickTime.framework
// for CFM Carbon applications. MachO Carbon applications do not
// have the problem.
GetMissingQTFunctionPointers();
#endif
InstallMovieIdlingEventLoopTimer(&mMovieTimerState);
// start the movie playing
MCDoAction(mMovieController, mcActionPrerollAndPlay, (void*)Long2Fix(1));
bail:
return err;
}
void PsychSetATSUStyleAttributesFromPsychWindowRecord(ATSUStyle atsuStyle, PsychWindowRecordType *winRec)
{
PsychFontStructType *psychFontRecord;
int psychColorSize;
//for ATSU attributes
ATSUFontID atsuFontID;
Fixed atsuFontSize;
ATSURGBAlphaColor atsuFontColor;
ATSStyleRenderingOptions atsuRenderOptions;
GLdouble colorVector[4];
OSStatus callError;
ATSUAttributeTag aaTags[] = {kATSUFontTag, kATSUSizeTag, kATSURGBAlphaColorTag, kATSUStyleRenderingOptionsTag };
ByteCount aaSizes[] = {sizeof(ATSUFontID), sizeof(Fixed), sizeof(ATSURGBAlphaColor), sizeof(ATSStyleRenderingOptions) };
ATSUAttributeValuePtr aaValue[] = {&atsuFontID, &atsuFontSize, &atsuFontColor, &atsuRenderOptions};
//set the font index
PsychGetFontRecordFromFontNumber(winRec->textAttributes.textFontNumber, &psychFontRecord);
if(psychFontRecord==NULL)
PsychErrorExitMsg(PsychError_internal, "Failed to lookup the font from the font number");
atsuFontID=psychFontRecord->fontFMRef;
//set the font size
atsuFontSize=Long2Fix((long)(winRec->textAttributes.textSize));
//set the color
PsychCoerceColorMode(&(winRec->textAttributes.textColor));
PsychConvertColorToDoubleVector(&(winRec->textAttributes.textColor), winRec, colorVector);
atsuFontColor.red=(float)colorVector[0];
atsuFontColor.green=(float)colorVector[1];
atsuFontColor.blue=(float)colorVector[2];
atsuFontColor.alpha=(float)colorVector[3];
// Set anti-aliasing mode (on/off): Default is to leave it up to the system to decide when
// to anti-alias and when not. But this flag allows to always force anti-aliasin on or off:
atsuRenderOptions = kATSStyleNoOptions;
if(PsychPrefStateGet_TextAntiAliasing()==0) atsuRenderOptions = kATSStyleNoAntiAliasing;
if(PsychPrefStateGet_TextAntiAliasing()> 0) atsuRenderOptions = kATSStyleApplyAntiAliasing;
//assign attributes to the style object
callError=ATSUSetAttributes(atsuStyle, 4, aaTags, aaSizes, aaValue);
}
void DoKillMovie()
{
if (mMovieController && mMovie)
{
OSErr err = noErr;
/* stop movie */
MCDoAction(mMovieController, mcActionPlay, (void*)Long2Fix(0));
#ifdef __APPLE_CC__
err = QTUninstallNextTaskNeededSoonerCallback(mTaskNeededSoonerCallback,mMovieTimerState.theEventTimer);
#else
err = mQTUninstallNextTaskPtr(mTaskNeededSoonerCallback,mMovieTimerState.theEventTimer);
#endif
RemoveEventLoopTimer(mMovieTimerState.theEventTimer);
/* remove draw complete proc. */
SetMovieDrawingCompleteProc(mMovie,
movieDrawingCallWhenChanged,
nil,
NULL);
DisposeMovieDrawingCompleteUPP(mMyDrawCompleteProc);
DisposeMungData();
DisposeMovieController(mMovieController);
DisposeMovie(mMovie);
DisposeEventLoopTimerUPP(mEventLoopTimer);
#ifdef __APPLE_CC__
DisposeQTNextTaskNeededSoonerCallbackUPP(mTaskNeededSoonerCallback);
#else
mDisposeQTNextTaskPtr(mTaskNeededSoonerCallback);
#endif
mMovieController = nil;
mMovie = nil;
}
}
pascal void DMModeInfoProc ( void* pData,
DMListIndexType nIndex,
DMDisplayModeListEntryPtr pInfo)
{
DMModeInfoRec* pInfoData = (DMModeInfoRec*) pData;
Fixed refresh = Long2Fix(pInfoData->pMode->refresh);
for(unsigned long i = 0; i < pInfo->displayModeDepthBlockInfo->depthBlockCount; ++i)
{
#define pDBI pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthVPBlock
if (pInfoData->pMode->w == (int&) pInfo->displayModeResolutionInfo->csHorizontalPixels &&
pInfoData->pMode->h == (int&) pInfo->displayModeResolutionInfo->csVerticalLines &&
pInfoData->pMode->bpp == (int) pDBI->vpPixelSize &&
refresh == pInfo->displayModeResolutionInfo->csRefreshRate)
{
memcpy(&pInfoData->sMode, pInfo->displayModeDepthBlockInfo->depthVPBlock[i].depthSwitchInfo,
sizeof(VDSwitchInfoRec));
pInfoData->sMode.csMode = pDBI->vpPixelSize;
pInfoData->bMatched = true;
break;
}
#undef pDBI
}
}
OSErr QTWired_AddPenguinTwoConditionalActions (QTAtomContainer theContainer, QTAtom theEventAtom)
{
QTAtom myNewActionAtom, myNewParamAtom, myConditionalAtom;
QTAtom myExpressionAtom, myOperatorAtom, myActionListAtom;
short myParamIndex, myConditionIndex, myOperandIndex;
float myConstantValue;
QTAtomID myVariableID;
ModifierTrackGraphicsModeRecord myBlendMode, myCopyMode;
OSErr myErr = noErr;
myBlendMode.graphicsMode = blend;
myBlendMode.opColor.red = myBlendMode.opColor.green = myBlendMode.opColor.blue = 0x8fff; // grey
myCopyMode.graphicsMode = ditherCopy;
myCopyMode.opColor.red = myCopyMode.opColor.green = myCopyMode.opColor.blue = 0xffff; // white
WiredUtils_AddActionAtom(theContainer, theEventAtom, kActionCase, &myNewActionAtom);
myParamIndex = 1;
WiredUtils_AddActionParameterAtom(theContainer, myNewActionAtom, myParamIndex, 0, NULL, &myNewParamAtom);
// first condition
myConditionIndex = 1;
WiredUtils_AddConditionalAtom(theContainer, myNewParamAtom, myConditionIndex, &myConditionalAtom);
WiredUtils_AddExpressionContainerAtomType(theContainer, myConditionalAtom, &myExpressionAtom);
WiredUtils_AddOperatorAtom(theContainer, myExpressionAtom, kOperatorEqualTo, &myOperatorAtom);
myOperandIndex = 1;
myConstantValue = kButtonStateOne;
WiredUtils_AddOperandAtom(theContainer, myOperatorAtom, kOperandConstant, myOperandIndex, NULL, myConstantValue);
myOperandIndex = 2;
myVariableID = kPenguinStateVariableID;
WiredUtils_AddVariableOperandAtom(theContainer, myOperatorAtom, myOperandIndex, 0, NULL, 0, myVariableID);
WiredUtils_AddActionListAtom(theContainer, myConditionalAtom, &myActionListAtom);
WiredUtils_AddMovieSetRateAction(theContainer, myActionListAtom, 0, Long2Fix(1));
WiredUtils_AddSpriteSetGraphicsModeAction(theContainer, myActionListAtom, 0, 0, NULL, 0, 0, NULL, &myBlendMode, NULL);
WiredUtils_AddSpriteSetGraphicsModeAction(theContainer, myActionListAtom, 0, 0, NULL, 0, kTargetSpriteID, (void *)kPenguinOneSpriteID, &myCopyMode, NULL);
WiredUtils_AddSpriteTrackSetVariableAction(theContainer, myActionListAtom, 0, kPenguinStateVariableID, kButtonStateTwo, 0, NULL, 0);
// second condition
myConditionIndex = 2;
WiredUtils_AddConditionalAtom(theContainer, myNewParamAtom, myConditionIndex, &myConditionalAtom);
WiredUtils_AddExpressionContainerAtomType(theContainer, myConditionalAtom, &myExpressionAtom);
WiredUtils_AddOperatorAtom(theContainer, myExpressionAtom, kOperatorEqualTo, &myOperatorAtom);
myOperandIndex = 1;
myConstantValue = kButtonStateTwo;
WiredUtils_AddOperandAtom(theContainer, myOperatorAtom, kOperandConstant, myOperandIndex, NULL, myConstantValue);
myOperandIndex = 2;
myVariableID = kPenguinStateVariableID;
WiredUtils_AddVariableOperandAtom(theContainer, myOperatorAtom, myOperandIndex, 0, NULL, 0, myVariableID);
WiredUtils_AddActionListAtom(theContainer, myConditionalAtom, &myActionListAtom);
WiredUtils_AddMovieSetRateAction(theContainer, myActionListAtom, 0, Long2Fix(0));
WiredUtils_AddSpriteSetGraphicsModeAction(theContainer, myActionListAtom, 0, 0, NULL, 0, 0, NULL, &myCopyMode, NULL);
WiredUtils_AddSpriteSetGraphicsModeAction(theContainer, myActionListAtom, 0, 0, NULL, 0, kTargetSpriteID, (void *)kPenguinOneSpriteID, &myBlendMode, NULL);
WiredUtils_AddSpriteTrackSetVariableAction(theContainer, myActionListAtom, 0, kPenguinStateVariableID, kButtonStateOne, 0, NULL, 0);
return(myErr);
}
// This example is almost identical to the helloworld example, except that
// in this case, there are two styles instead of just one. ATSUSetRunStyle
// is used to apply a style to different parts of the text.
//
void DrawMultipleStylesContents(WindowRef window)
{
CFStringRef string;
UniChar *text;
UniCharCount length;
UniCharArrayOffset currentStart, currentEnd;
ATSUStyle style1, style2;
ATSUTextLayout layout;
ATSUFontID font;
Fixed pointSize;
ATSUAttributeTag tags[2];
ByteCount sizes[2];
ATSUAttributeValuePtr values[2];
Fixed lineWidth, ascent, descent;
CGContextRef cgContext;
float x, y, cgY, windowHeight;
ItemCount numSoftBreaks;
UniCharArrayOffset *theSoftBreaks;
int i;
GrafPtr port, savedPort;
Rect portBounds;
// Set up the graphics port
port = GetWindowPort(window);
GetPort(&savedPort);
SetPort(port);
GetPortBounds(port, &portBounds);
EraseRect(&portBounds);
// Create a style object. This is one of two objects necessary to draw using ATSUI.
// (The layout is the other.)
verify_noerr( ATSUCreateStyle(&style1) );
// Look up the font we are going to use, and set it in the style object, using
// the aforementioned "triple" (tag, size, value) semantics. This is how almost
// all settings in ATSUI are applied.
verify_noerr( ATSUFindFontFromName(kMultipleStylesFontName, strlen(kMultipleStylesFontName), kFontFullName, kFontNoPlatform, kFontNoScript, kFontNoLanguage, &font) );
tags[0] = kATSUFontTag;
sizes[0] = sizeof(ATSUFontID);
values[0] = &font;
verify_noerr( ATSUSetAttributes(style1, 1, tags, sizes, values) );
// Set the point size, also using a triple. You can actually set multiple triples at once,
// since the tag, size, and value parameters are arrays. Other examples do this, such as
// the vertical text example.
//
pointSize = Long2Fix(kMultipleStylesFontSize);
tags[0] = kATSUSizeTag;
sizes[0] = sizeof(Fixed);
values[0] = &pointSize;
verify_noerr( ATSUSetAttributes(style1, 1, tags, sizes, values) );
// Now we create the second of two objects necessary to draw text using ATSUI, the layout.
// You can specify a pointer to the text buffer at layout creation time, or later using
// the routine ATSUSetTextPointerLocation(). Below, we do it after layout creation time.
verify_noerr( ATSUCreateTextLayout(&layout) );
// Before assigning text to the layout, we must first convert the string we plan to draw
// from a CFStringRef into an array of UniChar.
string = CFStringCreateWithCString(NULL, "In this example, various parts of the text have different styles applied. The same style is used more than once.", kCFStringEncodingASCII);
// Extract the raw Unicode from the CFString, then dispose of the CFString
length = CFStringGetLength(string);
text = (UniChar *)malloc(length * sizeof(UniChar));
CFStringGetCharacters(string, CFRangeMake(0, length), text);
CFRelease(string);
// Attach the resulting UTF-16 Unicode text to the layout
verify_noerr( ATSUSetTextPointerLocation(layout, text, kATSUFromTextBeginning, kATSUToTextEnd, length) );
// Now we tie the two necessary objects, the layout and the style, together
verify_noerr( ATSUSetRunStyle(layout, style1, kATSUFromTextBeginning, kATSUToTextEnd) );
// Now, for this example we create a second style, and assign it to various runs within
// the text. For our example, the run offsets are hard-coded for simplicity's sake. In
// a real application, style runs are often assigned from external sources, such as user
// selection.
verify_noerr( ATSUCreateAndCopyStyle(style1, &style2) );
// Change the font for the second style
verify_noerr( ATSUFindFontFromName(kMultipleStylesFontName2, strlen(kMultipleStylesFontName2), kFontFullName, kFontNoPlatform, kFontNoScript, kFontNoLanguage, &font) );
tags[0] = kATSUFontTag;
sizes[0] = sizeof(ATSUFontID);
values[0] = &font;
verify_noerr( ATSUSetAttributes(style2, 1, tags, sizes, values) );
// Apply the new style to the text in various places
verify_noerr( ATSUSetRunStyle(layout, style2, 8, 7) ); // The word "example"
verify_noerr( ATSUSetRunStyle(layout, style2, 65, 7) ); // The word "applied"
verify_noerr( ATSUSetRunStyle(layout, style2, 83, 5) ); // The word "style"
verify_noerr( ATSUSetRunStyle(layout, style2, 107, 4) ); // The word "once"
// In this example, we are breaking text into lines.
// Therefore, we need to know the width of the line.
lineWidth = X2Fix(portBounds.right - portBounds.left - 2.0*kMultipleStylesMargin);
tags[0] = kATSULineWidthTag;
sizes[0] = sizeof(Fixed);
values[0] = &lineWidth;
verify_noerr( ATSUSetLayoutControls(layout, 1, tags, sizes, values) );
// Prepare the CGContext for drawing
QDBeginCGContext(port, &cgContext);
tags[0] = kATSUCGContextTag;
sizes[0] = sizeof(CGContextRef);
values[0] = &cgContext;
verify_noerr( ATSUSetLayoutControls(layout, 1, tags, sizes, values) );
// Prepare the coordinates for drawing. In our example, "x" and "y" are the coordinates
// in QD space. "cgY" contains the y coordinate in CG space.
//
windowHeight = portBounds.bottom - portBounds.top;
x = kMultipleStylesMargin; // leave a small left margin
y = kMultipleStylesMargin; // leave a small top margin
cgY = windowHeight - y; // Subtract the y coordinate from the height of the
// window to get the coordinate in CG-aware space.
// Break the text into lines
verify_noerr( ATSUBatchBreakLines(layout, kATSUFromTextBeginning, length, lineWidth, &numSoftBreaks) );
verify_noerr( ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, 0, NULL, &numSoftBreaks) );
theSoftBreaks = (UniCharArrayOffset *) malloc(numSoftBreaks * sizeof(UniCharArrayOffset));
verify_noerr( ATSUGetSoftLineBreaks(layout, kATSUFromTextBeginning, kATSUToTextEnd, numSoftBreaks, theSoftBreaks, &numSoftBreaks) );
// Loop over all the lines and draw them
currentStart = 0;
for (i=0; i <= numSoftBreaks; i++) {
currentEnd = ((numSoftBreaks > 0 ) && (numSoftBreaks > i)) ? theSoftBreaks[i] : length;
// This is the height of a line, the ascent and descent. Getting the values this way is the preferred method.
ATSUGetLineControl(layout, currentStart, kATSULineAscentTag, sizeof(ATSUTextMeasurement), &ascent, NULL);
ATSUGetLineControl(layout, currentStart, kATSULineDescentTag, sizeof(ATSUTextMeasurement), &descent, NULL);
// Make room for the area above the baseline
y += Fix2X(ascent);
cgY = windowHeight - y;
// Draw the text
verify_noerr( ATSUDrawText(layout, currentStart, currentEnd - currentStart, X2Fix(x), X2Fix(cgY)) );
// Make room for the area beloww the baseline
y += Fix2X(descent);
// Prepare for next line
currentStart = currentEnd;
}
// This is a one-shot window, so we are now ready to dispose of all our objects.
// Normally, we would want to keep everything around in case we needed to redraw or change
// the text at some point.
// Tear down the CGContext
CGContextFlush(cgContext);
QDEndCGContext(port, &cgContext);
// Deallocate string storage
free(text);
// Layout and styles also need to be disposed
verify_noerr( ATSUDisposeStyle(style1) );
verify_noerr( ATSUDisposeStyle(style2) );
verify_noerr( ATSUDisposeTextLayout(layout) );
// Restore the graphics port
SetPort(savedPort);
}
OSErr QTTarg_AddTextToggleButtonTrack (Movie theMovie)
{
Track myTrack = NULL;
Media myMedia = NULL;
MatrixRecord myMatrix;
RGBColor myKeyColor;
Fixed myWidth, myHeight;
TimeValue myDuration = 0L;
TimeValue myTimeScale = 0L;
OSErr myErr = noErr;
//////////
//
// get some information about the target movie
//
//////////
if (theMovie == NULL) {
myErr = paramErr;
goto bail;
}
myWidth = Long2Fix(2 * kButtonWidth);
myHeight = Long2Fix(2 * kButtonHeight);
myDuration = GetMovieDuration(theMovie);
myTimeScale = GetMovieTimeScale(theMovie);
//////////
//
// create a new sprite track in the target movie
//
//////////
myTrack = NewMovieTrack(theMovie, myWidth, myHeight, kNoVolume);
myMedia = NewTrackMedia(myTrack, SpriteMediaType, myTimeScale, NULL, 0);
// set the track matrix to compensate for any existing movie matrix
GetMovieMatrix(theMovie, &myMatrix);
if (InverseMatrix(&myMatrix, &myMatrix))
SetTrackMatrix(myTrack, &myMatrix);
myErr = BeginMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
//////////
//
// add sprite images and sprites to the sprite track; add actions to the sprites
//
//////////
QTTarg_AddTextButtonSamplesToMedia(myMedia, 2 * kButtonWidth, 2 * kButtonHeight, myDuration);
//////////
//
// insert media into track
//
//////////
myErr = EndMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
// add the media to the track
InsertMediaIntoTrack(myTrack, 0, 0, GetMediaDuration(myMedia), fixed1);
//////////
//
// set the sprite track properties
//
//////////
QTTarg_SetTrackProperties(myMedia, kNoQTIdleEvents); // no idle events
myKeyColor.red = myKeyColor.green = myKeyColor.blue = 0xffff; // white
MediaSetGraphicsMode(GetMediaHandler(myMedia), transparent, &myKeyColor);
// make sure that the sprite track is in the frontmost layer
SetTrackLayer(myTrack, kMaxLayerNumber);
SetTrackLayer(myTrack, QTTarg_GetLowestLayerInMovie(theMovie) - 1);
bail:
return(myErr);
}
OSErr QTTarg_MakeDualVRControllerMovie (void)
{
Movie myMovie = NULL;
Track myTrack = NULL;
Media myMedia = NULL;
RGBColor myKeyColor;
Fixed myWidth, myHeight;
FSSpec myFile;
Boolean myIsSelected = false;
Boolean myIsReplacing = false;
StringPtr myPrompt = QTUtils_ConvertCToPascalString(kSpriteSavePrompt);
StringPtr myFileName = QTUtils_ConvertCToPascalString(kSpriteSaveMovieFileName);
long myFlags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;
short myResRefNum = 0;
short myResID = movieInDataForkResID;
OSType myType = FOUR_CHAR_CODE('none');
OSErr myErr = noErr;
//////////
//
// create a new movie file
//
//////////
// prompt the user for the destination file name
QTFrame_PutFile(myPrompt, myFileName, &myFile, &myIsSelected, &myIsReplacing);
myErr = myIsSelected ? noErr : userCanceledErr;
if (!myIsSelected)
goto bail;
// create a movie file for the destination movie
myErr = CreateMovieFile(&myFile, FOUR_CHAR_CODE('TVOD'), smSystemScript, myFlags, &myResRefNum, &myMovie);
if (myErr != noErr)
goto bail;
// select the "no-interface" movie controller
myType = EndianU32_NtoB(myType);
SetUserDataItem(GetMovieUserData(myMovie), &myType, sizeof(myType), kUserDataMovieControllerType, 1);
//////////
//
// get some information about the target movie
//
//////////
myWidth = Long2Fix(kVRControlMovieWidth);
myHeight = Long2Fix(kVRControlMovieHeight);
//////////
//
// create a new sprite track in the target movie
//
//////////
myTrack = NewMovieTrack(myMovie, myWidth, myHeight, kNoVolume);
myMedia = NewTrackMedia(myTrack, SpriteMediaType, kVRControlMovieDuration, NULL, 0);
myErr = BeginMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
//////////
//
// add sprite images and sprites to the sprite track; add actions to the sprites
//
//////////
QTTarg_AddVRControllerButtonSamplesToMedia(myMedia, kVRControlMovieWidth, kVRControlMovieHeight, kVRControlMovieDuration);
//////////
//
// insert media into track
//
//////////
myErr = EndMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
// add the media to the track
InsertMediaIntoTrack(myTrack, 0, 0, GetMediaDuration(myMedia), fixed1);
//////////
//
// set the sprite track properties
//
//////////
QTTarg_SetTrackProperties(myMedia, 0); // idle as fast as possible
myKeyColor.red = myKeyColor.green = myKeyColor.blue = 0xffff; // white
MediaSetGraphicsMode(GetMediaHandler(myMedia), transparent, &myKeyColor);
//////////
//
// add the movie resource to the movie file
//
//////////
myErr = AddMovieResource(myMovie, myResRefNum, &myResID, myFile.name);
bail:
if (myResRefNum != 0)
CloseMovieFile(myResRefNum);
if (myMovie != NULL)
DisposeMovie(myMovie);
free(myPrompt);
free(myFileName);
return(myErr);
}
OSErr QTTarg_AddIconMovieSamplesToMedia (Media theMedia)
{
QTAtomContainer mySample = NULL;
QTAtomContainer mySpriteData = NULL;
QTAtom myActionAtom = 0;
QTAtom myTargetAtom = 0;
RGBColor myKeyColor;
Point myLocation;
short isVisible, myIndex;
Fixed myDegrees;
FixedPoint myPoint;
OSErr myErr = noErr;
//////////
//
// create a key frame sample containing the sprite images
//
//////////
// create a new, empty key frame sample
myErr = QTNewAtomContainer(&mySample);
if (myErr != noErr)
goto bail;
myKeyColor.red = myKeyColor.green = myKeyColor.blue = 0xffff; // white
myPoint.x = Long2Fix(kIconDimension / 2);
myPoint.y = Long2Fix(kIconDimension / 2);
// add images to the key frame sample
SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kOldQTIconID, &myKeyColor, kOldQTIconSpriteAtomID, &myPoint, NULL);
SpriteUtils_AddPICTImageToKeyFrameSample(mySample, kNewQTIconID, &myKeyColor, kNewQTIconSpriteAtomID, &myPoint, NULL);
//////////
//
// add the initial sprite properties and actions to the key frame sample
//
//////////
// the old QT icon sprite
myErr = QTNewAtomContainer(&mySpriteData);
if (myErr != noErr)
goto bail;
myLocation.h = kIconDimension + (kIconDimension / 2);
myLocation.v = ((kIconSpriteTrackHeight - kIconDimension) / 2) + (kIconDimension / 2);
isVisible = true;
myIndex = kOldQTIconImageIndex;
SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, NULL, &myIndex, NULL, NULL, NULL);
WiredUtils_AddQTEventAndActionAtoms(mySpriteData, kParentAtomIsContainer, kQTEventMouseClickEndTriggerButton, kActionSpriteRotate, &myActionAtom);
myDegrees = EndianS32_NtoB(FixRatio(90, 1));
WiredUtils_AddActionParameterAtom(mySpriteData, myActionAtom, kFirstParam, sizeof(myDegrees), &myDegrees, NULL);
WiredUtils_AddSpriteIDActionTargetAtom(mySpriteData, myActionAtom, 2, NULL);
SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kOldQTIconSpriteAtomID);
QTDisposeAtomContainer(mySpriteData);
// the new QT icon sprite
myErr = QTNewAtomContainer(&mySpriteData);
if (myErr != noErr)
goto bail;
myLocation.h = kIconSpriteTrackWidth - (kIconDimension + (kIconDimension / 2));
myLocation.v = ((kIconSpriteTrackHeight - kIconDimension) / 2) + (kIconDimension / 2);
isVisible = true;
myIndex = kNewQTIconImageIndex;
SpriteUtils_SetSpriteData(mySpriteData, &myLocation, &isVisible, NULL, &myIndex, NULL, NULL, NULL);
WiredUtils_AddQTEventAndActionAtoms(mySpriteData, kParentAtomIsContainer, kQTEventMouseClickEndTriggerButton, kActionSpriteRotate, &myActionAtom);
myDegrees = EndianS32_NtoB(FixRatio(90, 1));
WiredUtils_AddActionParameterAtom(mySpriteData, myActionAtom, kFirstParam, sizeof(myDegrees), &myDegrees, NULL);
WiredUtils_AddSpriteIDActionTargetAtom(mySpriteData, myActionAtom, 1, NULL);
SpriteUtils_AddSpriteToSample(mySample, mySpriteData, kNewQTIconSpriteAtomID);
SpriteUtils_AddSpriteSampleToMedia(theMedia, mySample, kSpriteMediaFrameDurationIcon, true, NULL);
bail:
if (mySample != NULL)
QTDisposeAtomContainer(mySample);
if (mySpriteData != NULL)
QTDisposeAtomContainer(mySpriteData);
return(myErr);
}
OSErr QTTarg_CreateTwinSpritesMovie (void)
{
Movie myMovie = NULL;
Track myTrack = NULL;
Media myMedia = NULL;
FSSpec myFile;
Boolean myIsSelected = false;
Boolean myIsReplacing = false;
Fixed myHeight = 0;
Fixed myWidth = 0;
StringPtr myPrompt = QTUtils_ConvertCToPascalString(kSpriteSavePrompt);
StringPtr myFileName = QTUtils_ConvertCToPascalString(kSpriteSaveMovieFileName);
long myFlags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;
OSType myType = FOUR_CHAR_CODE('none');
short myResRefNum = 0;
short myResID = movieInDataForkResID;
OSErr myErr = noErr;
//////////
//
// create a new movie file
//
//////////
// prompt the user for the destination file name
QTFrame_PutFile(myPrompt, myFileName, &myFile, &myIsSelected, &myIsReplacing);
myErr = myIsSelected ? noErr : userCanceledErr;
if (!myIsSelected)
goto bail;
// create a movie file for the destination movie
myErr = CreateMovieFile(&myFile, FOUR_CHAR_CODE('TVOD'), smSystemScript, myFlags, &myResRefNum, &myMovie);
if (myErr != noErr)
goto bail;
// select the "no-interface" movie controller
myType = EndianU32_NtoB(myType);
SetUserDataItem(GetMovieUserData(myMovie), &myType, sizeof(myType), kUserDataMovieControllerType, 1);
//////////
//
// create the sprite track and media
//
//////////
myWidth = Long2Fix(kIconSpriteTrackWidth);
myHeight = Long2Fix(kIconSpriteTrackHeight);
myTrack = NewMovieTrack(myMovie, myWidth, myHeight, kNoVolume);
myMedia = NewTrackMedia(myTrack, SpriteMediaType, kSpriteMediaTimeScale, NULL, 0);
myErr = BeginMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
//////////
//
// add the appropriate samples to the sprite media
//
//////////
myErr = QTTarg_AddIconMovieSamplesToMedia(myMedia);
if (myErr != noErr)
goto bail;
myErr = EndMediaEdits(myMedia);
if (myErr != noErr)
goto bail;
// add the media to the track
InsertMediaIntoTrack(myTrack, 0, 0, GetMediaDuration(myMedia), fixed1);
//////////
//
// set the sprite track properties
//
//////////
QTTarg_SetTrackProperties(myMedia, 1);
//////////
//
// add the movie resource to the movie file
//
//////////
myErr = AddMovieResource(myMovie, myResRefNum, &myResID, myFile.name);
bail:
if (myResRefNum != 0)
CloseMovieFile(myResRefNum);
if (myMovie != NULL)
DisposeMovie(myMovie);
free(myPrompt);
free(myFileName);
return(myErr);
}
TextWriter::TextWriter(int in_x, int in_y, Renderer &in_renderer, bool in_centered, int in_size, std::wstring fontname) :
x(in_x), y(in_y), size(in_size), original_x(0), last_line_height(0), centered(in_centered), renderer(in_renderer)
{
x += renderer.m_xoffset;
original_x = x;
y += renderer.m_yoffset;
#ifdef WIN32
Context c = renderer.m_context;
point_size = MulDiv(size, GetDeviceCaps(c, LOGPIXELSY), 72);
HFONT font = 0;
if (font_size_lookup[in_size] == 0)
{
// Set up the LOGFONT structure
LOGFONT logical_font;
logical_font.lfHeight = get_point_size();
logical_font.lfWidth = 0;
logical_font.lfEscapement = 0;
logical_font.lfOrientation = 0;
logical_font.lfWeight = FW_NORMAL;
logical_font.lfItalic = false;
logical_font.lfUnderline = false;
logical_font.lfStrikeOut = false;
logical_font.lfCharSet = ANSI_CHARSET;
logical_font.lfOutPrecision = OUT_DEFAULT_PRECIS;
logical_font.lfClipPrecision = CLIP_DEFAULT_PRECIS;
logical_font.lfQuality = PROOF_QUALITY;
logical_font.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
lstrcpy(logical_font.lfFaceName, fontname.c_str());
font = CreateFontIndirect(&logical_font);
HFONT previous_font = (HFONT)SelectObject(c, font);
wglUseFontBitmaps(c, 0, 128, next_call_list_start);
font_size_lookup[in_size] = next_call_list_start;
font_handle_lookup[in_size] = font;
next_call_list_start += 130;
SelectObject(c, previous_font);
}
#else
// TODO: is this sufficient?
point_size = size;
if (font_size_lookup[size] == 0)
{
int list_start = glGenLists(128);
// MACNOTE: Force Trebuchet MS. It's what we mostly use anyway, but
// I want to be sure they have it.
const CFStringRef font_name = CFSTR("Trebuchet MS");
ATSFontFamilyRef font = ATSFontFamilyFindFromName(font_name, kATSOptionFlagsDefault);
if (!font) throw PianoGameError(WSTRING(L"Couldn't get ATSFontFamilyRef for font '" << WideFromMacString(font_name) << L"'."));
AGLContext context = aglGetCurrentContext();
if (!context) throw PianoGameError(L"Couldn't retrieve OpenGL context while creating font.");
GLboolean ret = aglUseFont(context, font, normal, size, 0, 128, list_start);
if (ret == GL_FALSE) throw PianoGameError(WSTRING(L"aglUseFont() call failed with error code: " << aglGetError()));
font_size_lookup[size] = list_start;
// Create the ATSU style object that we'll use for calculating text extents and store it for later.
ATSUStyle style;
OSStatus status = ATSUCreateStyle(&style);
if (status != noErr) throw PianoGameError(WSTRING(L"Couldn't create ATSU style. Error code: " << static_cast<int>(status)));
Fixed fixed_size = Long2Fix(size);
ATSUAttributeTag tags[] = { kATSUSizeTag };
ByteCount sizes[] = { sizeof(Fixed) };
ATSUAttributeValuePtr values[] = { &fixed_size };
status = ATSUSetAttributes(style, sizeof(sizes) / sizeof(ByteCount), tags, sizes, values);
if (status != noErr) throw PianoGameError(WSTRING(L"Couldn't set ATSU style attributes. Error code: " << static_cast<int>(status)));
atsu_style_lookup[size] = style;
}
#endif
}
nsresult nsMessengerOSXIntegration::OnAlertFinished(const PRUnichar * aAlertCookie)
{
nsresult rv = NS_OK;
nsCOMPtr<nsIPrefBranch> prefBranch (do_GetService(NS_PREFSERVICE_CONTRACTID, &rv));
NS_ENSURE_SUCCESS(rv, rv);
PRBool bounceDockIcon = PR_FALSE;
prefBranch->GetBoolPref("mail.biff.animate_dock_icon", &bounceDockIcon);
// This will call GetAttention(), which will bounce the dock icon.
if (!mSuppressBiffIcon)
{
nsCOMPtr<nsIWindowMediator> mediator (do_GetService(NS_WINDOWMEDIATOR_CONTRACTID));
if (bounceDockIcon && mediator)
{
nsCOMPtr<nsIDOMWindowInternal> domWindow;
mediator->GetMostRecentWindow(NS_LITERAL_STRING("mail:3pane").get(), getter_AddRefs(domWindow));
if (domWindow)
{
nsCOMPtr<nsIDOMChromeWindow> chromeWindow(do_QueryInterface(domWindow));
chromeWindow->GetAttention();
}
}
// This will change the dock icon.
// If we want to overlay the number of new messages on top of
// the icon ...
// use OverlayApplicationDockTileImage
// -- you'll have to pass it a CGImage, and somehow we have to
// create the CGImage with the numbers. tricky
PRInt32 totalNewMessages = CountNewMessages();
CGContextRef context = ::BeginCGContextForApplicationDockTile();
// Draw a circle.
::CGContextBeginPath(context);
::CGContextAddArc(context, 95.0, 95.0, 25.0, 0.0, 2 * M_PI, true);
::CGContextClosePath(context);
// use #2fc600 for the color.
::CGContextSetRGBFillColor(context, 0.184, 0.776, 0.0, 1);
//::CGContextSetRGBFillColor(context, 1.0, 1.0, 1.0, 0.7);
::CGContextFillPath(context);
// Draw the number.
nsAutoString total;
total.AppendInt(totalNewMessages);
// Use a system font (kThemeUtilityWindowTitleFont)
ScriptCode sysScript = ::GetScriptManagerVariable(smSysScript);
Str255 fontName;
SInt16 fontSize;
Style fontStyle;
::GetThemeFont(kThemeSmallEmphasizedSystemFont, sysScript, fontName,
&fontSize, &fontStyle);
FMFontFamily family = ::FMGetFontFamilyFromName(fontName);
FMFont fmFont;
OSStatus err = ::FMGetFontFromFontFamilyInstance(family, fontStyle, &fmFont,
nsnull);
if (err != noErr)
{
NS_WARNING("FMGetFontFromFontFamilyInstance failed");
::EndCGContextForApplicationDockTile(context);
return NS_ERROR_FAILURE;
}
ATSUStyle style;
err = ::ATSUCreateStyle(&style);
if (err != noErr)
{
NS_WARNING("ATSUCreateStyle failed");
::EndCGContextForApplicationDockTile(context);
return NS_ERROR_FAILURE;
}
Fixed size = Long2Fix(24);
RGBColor white = { 0xFFFF, 0xFFFF, 0xFFFF };
ATSUAttributeTag tags[3] = { kATSUFontTag, kATSUSizeTag, kATSUColorTag };
ByteCount valueSizes[3] = { sizeof(ATSUFontID), sizeof(Fixed),
sizeof(RGBColor) };
ATSUAttributeValuePtr values[3] = { &fmFont, &size, &white };
err = ::ATSUSetAttributes(style, 3, tags, valueSizes, values);
if (err != noErr) {
NS_WARNING("ATSUSetAttributes failed");
::ATSUDisposeStyle(style);
::EndCGContextForApplicationDockTile(context);
return NS_ERROR_FAILURE;
}
UniCharCount runLengths = kATSUToTextEnd;
ATSUTextLayout textLayout;
err = ::ATSUCreateTextLayoutWithTextPtr(total.get(),
kATSUFromTextBeginning,
kATSUToTextEnd, total.Length(), 1,
&runLengths, &style, &textLayout);
if (err != noErr)
{
NS_WARNING("ATSUCreateTextLayoutWithTextPtr failed");
::ATSUDisposeStyle(style);
::EndCGContextForApplicationDockTile(context);
return NS_ERROR_FAILURE;
}
ATSUAttributeTag layoutTags[1] = { kATSUCGContextTag };
ByteCount layoutValueSizes[1] = { sizeof(CGContextRef) };
ATSUAttributeValuePtr layoutValues[1] = { &context };
err = ::ATSUSetLayoutControls(textLayout, 1, layoutTags, layoutValueSizes,
layoutValues);
if (err != noErr)
{
NS_WARNING("ATSUSetLayoutControls failed");
::ATSUDisposeStyle(style);
::EndCGContextForApplicationDockTile(context);
return NS_ERROR_FAILURE;
}
Rect boundingBox;
err = ::ATSUMeasureTextImage(textLayout, kATSUFromTextBeginning,
kATSUToTextEnd, Long2Fix(0), Long2Fix(0),
&boundingBox);
if (err != noErr)
{
NS_WARNING("ATSUMeasureTextImage failed");
::ATSUDisposeStyle(style);
::EndCGContextForApplicationDockTile(context);
return NS_ERROR_FAILURE;
}
// Center text inside circle
err = ::ATSUDrawText(textLayout, kATSUFromTextBeginning, kATSUToTextEnd,
Long2Fix(90 - (boundingBox.right - boundingBox.left) / 2),
Long2Fix(95 - (boundingBox.bottom - boundingBox.top) / 2));
::ATSUDisposeStyle(style);
::ATSUDisposeTextLayout(textLayout);
::CGContextFlush(context);
::EndCGContextForApplicationDockTile(context);
mBiffIconVisible = PR_TRUE;
}
mSuppressBiffIcon = PR_FALSE;
mAlertInProgress = PR_FALSE;
return NS_OK;
}
OSErr makeMovieFromVideoFramesFile(char *inDestMovieFile)
{
Handle dataRef = NULL;
OSType dataRefType;
ImageDescriptionHandle videoDescH = NULL;
OSErr err;
#if TARGET_OS_WIN32
err = InitializeQTML(0);
if ((err = GetMoviesError()) != noErr) goto bail;
#endif
err = EnterMovies();
if ((err = GetMoviesError()) != noErr) goto bail;
// create a data reference from the full path to the video frames file
makeDataRefFromFullPath(inDestMovieFile, &dataRef, &dataRefType);
if (dataRef == NULL) goto bail;
Movie m = NewMovie(0);
if ((err = GetMoviesError()) != noErr) goto bail;
// create the video track for the movie
Track videoT = NewMovieTrack( m, Long2Fix(kFrameWidth), Long2Fix(kFrameHeight), kNoVolume);
if ((err = GetMoviesError()) != noErr) goto bail;
// create the video track media
Media videoM = NewTrackMedia( videoT, VideoMediaType, kMediaTimeScale, dataRef, dataRefType);
if ((err = GetMoviesError()) != noErr) goto bail;
videoDescH = (ImageDescriptionHandle)NewHandleClear(sizeof(ImageDescription));
if (videoDescH == NULL) goto bail;
// create the ImageDescription that will describe our video track media samples
videoDescH[0]->idSize = sizeof(ImageDescription);
videoDescH[0]->cType = kCodecType; // the codec type for your data
videoDescH[0]->temporalQuality = codecNormalQuality;
videoDescH[0]->spatialQuality = codecNormalQuality;
videoDescH[0]->width = kFrameWidth;
videoDescH[0]->height = kFrameHeight;
videoDescH[0]->hRes = 72L << 16;
videoDescH[0]->vRes = 72L << 16;
videoDescH[0]->depth = 32;
videoDescH[0]->clutID = -1;
SampleReference64Record videoRef;
videoRef.dataOffset.hi = 0; videoRef.dataOffset.lo = 0;
videoRef.dataSize = (kFrameWidth*kFrameHeight*4) * kNumberOfSamples;
videoRef.durationPerSample = kDurationPerSample;
videoRef.numberOfSamples = kNumberOfSamples;
videoRef.sampleFlags = 0;
// now add all of our media samples to the movie data file.
err = AddMediaSampleReferences64(videoM, (SampleDescriptionHandle)videoDescH,
1, &videoRef, 0);
if (err != noErr) goto bail;
TimeValue mediaDuration = kNumberOfSamples * kDurationPerSample;
// inserts a reference to our media samples into the track.
err = InsertMediaIntoTrack(videoT, 0, 0, mediaDuration,
fixed1); // media's rate (1.0 = media's natural playback rate).
if (err != noErr) goto bail;
DataHandler outDataHandler;
// opens a data handler for our movie storage (the video frames file)
err = OpenMovieStorage (dataRef, dataRefType, kDataHCanWrite, &outDataHandler );
if (err != noErr) goto bail;
// add a movie to our movie storage container
err = AddMovieToStorage (m, outDataHandler );
if (err != noErr) goto bail;
err = CloseMovieStorage (outDataHandler);
outDataHandler = NULL;
bail:
if (videoDescH)
{
DisposeHandle((Handle)videoDescH);
}
return err;
}
static
OSStatus RunRoundTripFlatteningSample(
WindowRef windowRef )
{
OSStatus err;
CGrafPtr windowPort;
CGContextRef cgContext;
Rect windowRect;
PixMapHandle pixMap;
ATSUTextMeasurement xPosition;
ATSUTextMeasurement yPosition;
// initialize the global styles
err = InitializeGlobalStyles();
require_noerr( err, RunATSUIFlatteningTest_err );
// get the port for the window
windowPort = GetWindowPort( windowRef );
// get the port's pixMap. This will be used to find the viewable window area
pixMap = GetPortPixMap( windowPort );
// get the bounds for the port
GetPortBounds( windowPort, &windowRect );
// Offset the rect to obtain the window's viewable area
OffsetRect( &windowRect, -(**pixMap).bounds.left, -(**pixMap).bounds.top );
// calculate the x and y positions
xPosition = Long2Fix( windowRect.left + kGlobalXOffsetValue );
yPosition = Long2Fix( windowRect.bottom - kGlobalYSpaceBetweenTests );
// start the cgContext for the port
err = QDBeginCGContext( windowPort, &cgContext );
require_noerr( err, RunATSUIFlatteningTest_err );
// add a label to the test
err = AddTextLabel( "Reference Style\0", cgContext, xPosition,
&yPosition );
require_noerr( err, RunATSUIFlatteningTest_err );
// create the layout for the default run information
err = DrawLayoutForStyleAndRunInfo( gGlobalStyleArray, kGlobalStyleArraySize,
gGlobalStyleRunInfoArray, kGlobalStyleRunInfoArraySize, gTestString,
gTestStringLen, cgContext, xPosition, &yPosition );
require_noerr( err, RunATSUIFlatteningTest_err );
// add some space to separate the tests
yPosition -= Long2Fix( kGlobalYSpaceBetweenTests );
// add a label to the test
err = AddTextLabel( "Flattened And Unflattened Sample\0", cgContext,
xPosition, &yPosition );
require_noerr( err, RunATSUIFlatteningTest_err );
// run the default options for this test
err = RoundTripFlatten( cgContext, xPosition, &yPosition, gGlobalStyleArray,
kGlobalStyleArraySize, gGlobalStyleRunInfoArray, kGlobalStyleRunInfoArraySize,
gTestString, gTestStringLen );
require_noerr( err, RunATSUIFlatteningTest_err );
// kill the cgContext for the port
err = QDEndCGContext( windowPort, &cgContext );
require_noerr( err, RunATSUIFlatteningTest_err );
RunATSUIFlatteningTest_err:
return err;
}
