void LCD_resize(Lcd *x)
{
Rect r;
short hor,ver;
#ifdef debug
post("LCD_Resize");
#endif
r = x->lcd_box.b_rect;
hor = x->cols = FixRound(FixRatio(((r.right-r.left-(2*BORDER_WIDTH))),x->f_width));
ver = x->rows = FixRound(FixRatio(((r.bottom-r.top-(2*BORDER_HEIGHT))),x->f_height));
#ifdef FORCEDResize
x->lcd_box.b_rect.right = r.left + (2*BORDER_WIDTH) + hor*x->f_width;
x->lcd_box.b_rect.bottom = r.top + (2*BORDER_HEIGHT) + ver*x->f_height;
#endif
if (x->lcd_region)
DisposeRgn(x->lcd_region);
x->lcd_oldRect = r = x->lcd_box.b_rect;
InsetRect(&r,1,1);
x->lcd_region = NewRgn();
RectRgn(x->lcd_region,&r); /* DDZ simpler way to make a rectangular region */
}
int Blend (int i1, int i2)
{
Fixed smallFix, bigFix, tempFix;
smallFix = ONE * i1;
bigFix = ONE * i2;
tempFix = FixMul (fract, bigFix) +FixMul (ONE-fract, smallFix);
return (FixRound (tempFix));
}
//------------------------------------------------------------------------
// GetWidth
//
//------------------------------------------------------------------------
nsresult
nsATSUIToolkit::GetTextDimensions(
const PRUnichar *aCharPt,
PRUint32 aLen,
nsTextDimensions& oDim,
short aSize, short aFontNum,
PRBool aBold, PRBool aItalic, nscolor aColor)
{
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 after;
ATSUTextMeasurement ascent;
ATSUTextMeasurement descent;
err = ::ATSUGetUnjustifiedBounds(aTxtLayout, 0, aLen, NULL, &after, &ascent,
&descent);
if (noErr != err)
{
NS_WARNING("ATSUGetUnjustifiedBounds failed");
return NS_ERROR_FAILURE;
}
oDim.width = FixRound(after);
oDim.ascent = FixRound(ascent);
oDim.descent = FixRound(descent);
// aTxtLayout is cached and does not need to be disposed
return NS_OK;
}
//------------------------------------------------------------------------
// GetBoundingMetrics
//
//------------------------------------------------------------------------
nsresult
nsATSUIToolkit::GetBoundingMetrics(
const PRUnichar *aCharPt,
PRUint32 aLen,
nsBoundingMetrics &oBoundingMetrics,
short aSize, short aFontNum,
PRBool aBold, PRBool aItalic,
nscolor aColor)
{
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;
Rect rect;
ATSUTextMeasurement width;
if((err = ATSUMeasureTextImage(aTxtLayout,
kATSUFromTextBeginning, kATSUToTextEnd, 0, 0, &rect)) != noErr)
{
NS_WARNING("ATSUMeasureTextImage failed");
return NS_ERROR_FAILURE;
}
// return the values in points, the caller will convert them into twips
oBoundingMetrics.leftBearing = rect.left;
oBoundingMetrics.rightBearing = rect.right;
oBoundingMetrics.ascent = -rect.top;
oBoundingMetrics.descent = rect.bottom;
err = ::ATSUGetUnjustifiedBounds(aTxtLayout, kATSUFromTextBeginning,
kATSUToTextEnd, NULL, &width, NULL, NULL);
if (err != noErr)
{
oBoundingMetrics.width = oBoundingMetrics.rightBearing;
}
else
oBoundingMetrics.width = FixRound(width);
return NS_OK;
}
//------------------------------------------------------------------------
// 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;
}
void QTSound_CreateMySoundTrack (Movie theMovie)
{
Track theTrack;
Media theMedia;
Handle sndHandle = nil;
SoundDescriptionHandle sndDesc = nil;
long sndDataOffset;
long sndDataSize;
long numSamples;
OSErr err = noErr;
#if TARGET_OS_WIN32
char path[MAX_PATH+1];
short resID;
FSSpec fsspec;
fsspec.vRefNum = 0;
fsspec.parID = 0;
GetModuleFileName( NULL, path, MAX_PATH+1);
NativePathNameToFSSpec((char *)&path, &fsspec, 0);
/* open our application resource file so we
can access the Macintosh 'snd ' resource */
resID = FSpOpenResFile(&fsspec, fsRdPerm);
CheckError (ResError(), "FSpOpenResFile error" );
#endif
sndHandle = GetResource ('snd ', kOurSoundResourceID);
CheckError (ResError(), "GetResource error" );
if (sndHandle == nil)
{
return;
}
sndDesc = (SoundDescriptionHandle) NewHandle(4);
CheckError (MemError(), "NewHandle error" );
QTSound_CreateSoundDescription (sndHandle,
sndDesc,
&sndDataOffset,
&numSamples,
&sndDataSize );
theTrack = NewMovieTrack (theMovie, 0, 0, kFullVolume);
CheckError (GetMoviesError(), "NewMovieTrack error" );
theMedia = NewTrackMedia (theTrack, SoundMediaType,
FixRound ((**sndDesc).sampleRate),
nil, 0);
CheckError (GetMoviesError(), "NewTrackMedia error" );
err = BeginMediaEdits (theMedia);
CheckError( err, "BeginMediaEdits error" );
err = AddMediaSample(theMedia,
sndHandle,
sndDataOffset,/* offset in data */
sndDataSize,
kSoundSampleDuration,/* duration of each sound sample */
(SampleDescriptionHandle) sndDesc,
numSamples,
kSyncSample,/* self-contained samples */
nil);
CheckError( err, "AddMediaSample error" );
err = EndMediaEdits (theMedia);
CheckError( err, "EndMediaEdits error" );
err = InsertMediaIntoTrack (theTrack,
kTrackStart,/* track start time */
kMediaStart,/* media start time */
GetMediaDuration (theMedia),
fixed1);
CheckError( err, "InsertMediaIntoTrack error" );
if (sndDesc != nil)
{
DisposeHandle( (Handle)sndDesc);
}
}
//------------------------------------------------------------------------
ATSUTextLayout nsATSUIToolkit::GetTextLayout(short aFontNum, short aSize, PRBool aBold, PRBool aItalic, nscolor aColor)
{
ATSUTextLayout txLayout = nsnull;
OSStatus err;
if (nsATSUIUtils::gTxLayoutCache->Get(aFontNum, aSize, aBold, aItalic, aColor, &txLayout))
return txLayout;
UniChar dmy[1];
err = ::ATSUCreateTextLayoutWithTextPtr (dmy, 0,0,0,0,NULL, NULL, &txLayout);
if(noErr != err) {
NS_WARNING("ATSUCreateTextLayoutWithTextPtr failed");
// goto errorDone;
return nsnull;
}
ATSUStyle theStyle;
err = ::ATSUCreateStyle(&theStyle);
if(noErr != err) {
NS_WARNING("ATSUCreateStyle failed");
// goto errorDoneDestroyTextLayout;
err = ::ATSUDisposeTextLayout(txLayout);
return nsnull;
}
ATSUAttributeTag theTag[ATTR_CNT];
ByteCount theValueSize[ATTR_CNT];
ATSUAttributeValuePtr theValue[ATTR_CNT];
//--- Font ID & Face -----
ATSUFontID atsuFontID;
// The use of ATSUFONDtoFontID is not recommended, see
// http://developer.apple.com/documentation/Carbon/Reference/ATSUI_Reference/atsu_reference_Reference/chapter_1.2_section_19.html
FMFontStyle fbStyle;
if (::FMGetFontFromFontFamilyInstance(aFontNum, 0, &atsuFontID, &fbStyle) == kFMInvalidFontErr) {
NS_WARNING("FMGetFontFromFontFamilyInstance failed");
// goto errorDoneDestroyStyle;
err = ::ATSUDisposeStyle(theStyle);
err = ::ATSUDisposeTextLayout(txLayout);
return nsnull;
}
theTag[0] = kATSUFontTag;
theValueSize[0] = (ByteCount) sizeof(ATSUFontID);
theValue[0] = (ATSUAttributeValuePtr) &atsuFontID;
//--- Font ID & Face -----
//--- Size -----
float dev2app;
short fontsize = aSize;
dev2app = mContext->DevUnitsToAppUnits();
// Fixed size = FloatToFixed( roundf(float(fontsize) / dev2app));
Fixed size = FloatToFixed( (float) rint(float(fontsize) / dev2app));
if( FixRound ( size ) < 9 && !nsFontUtils::DisplayVerySmallFonts())
size = X2Fix(9);
theTag[1] = kATSUSizeTag;
theValueSize[1] = (ByteCount) sizeof(Fixed);
theValue[1] = (ATSUAttributeValuePtr) &size;
//--- Size -----
//--- Color -----
RGBColor color;
#define COLOR8TOCOLOR16(color8) ((color8 << 8) | color8)
color.red = COLOR8TOCOLOR16(NS_GET_R(aColor));
color.green = COLOR8TOCOLOR16(NS_GET_G(aColor));
color.blue = COLOR8TOCOLOR16(NS_GET_B(aColor));
theTag[2] = kATSUColorTag;
theValueSize[2] = (ByteCount) sizeof(RGBColor);
theValue[2] = (ATSUAttributeValuePtr) &color;
//--- Color -----
//--- Bold -----
Boolean isBold = aBold ? true : false;
theTag[3] = kATSUQDBoldfaceTag;
theValueSize[3] = (ByteCount) sizeof(Boolean);
theValue[3] = (ATSUAttributeValuePtr) &isBold;
//--- Bold -----
//--- Italic -----
Boolean isItalic = aItalic ? true : false;
theTag[4] = kATSUQDItalicTag;
theValueSize[4] = (ByteCount) sizeof(Boolean);
theValue[4] = (ATSUAttributeValuePtr) &isItalic;
//--- Italic -----
err = ::ATSUSetAttributes(theStyle, ATTR_CNT, theTag, theValueSize, theValue);
if(noErr != err) {
NS_WARNING("ATSUSetAttributes failed");
// goto errorDoneDestroyStyle;
err = ::ATSUDisposeStyle(theStyle);
err = ::ATSUDisposeTextLayout(txLayout);
return nsnull;
}
err = ::ATSUSetRunStyle(txLayout, theStyle, kATSUFromTextBeginning, kATSUToTextEnd);
if(noErr != err) {
NS_WARNING("ATSUSetRunStyle failed");
// goto errorDoneDestroyStyle;
err = ::ATSUDisposeStyle(theStyle);
err = ::ATSUDisposeTextLayout(txLayout);
return nsnull;
}
err = ::ATSUSetTransientFontMatching(txLayout, true);
if(noErr != err) {
NS_WARNING( "ATSUSetTransientFontMatching failed");
// goto errorDoneDestroyStyle;
err = ::ATSUDisposeStyle(theStyle);
err = ::ATSUDisposeTextLayout(txLayout);
return nsnull;
}
nsATSUIUtils::gTxLayoutCache->Set(aFontNum, aSize, aBold, aItalic, aColor, txLayout);
return txLayout;
}
void QTEffects_RespondToDialogSelection (OSErr theErr)
{
Boolean myDialogWasCancelled = false;
short myResID = movieInDataForkResID;
UInt16 myMovieIter;
short mySrcMovieRefNum = 0;
Movie myPrevSrcMovie = NULL;
Track myPrevSrcTrack = NULL;
Movie myNextSrcMovie = NULL;
Track myNextSrcTrack = NULL;
short myDestMovieRefNum = 0;
FSSpec myFile;
Boolean myIsSelected = false;
Boolean myIsReplacing = false;
StringPtr myPrompt = QTUtils_ConvertCToPascalString(kEffectsSaveMoviePrompt);
StringPtr myFileName = QTUtils_ConvertCToPascalString(kEffectsSaveMovieFileName);
Movie myDestMovie = NULL;
Fixed myDestMovieWidth, myDestMovieHeight;
ImageDescriptionHandle myDesc = NULL;
Track videoTrackFX, videoTrackA, videoTrackB;
Media videoMediaFX, videoMediaA, videoMediaB;
TimeValue myCurrentDuration = 0;
TimeValue myReturnedDuration;
Boolean isFirstTransition = true;
TimeValue myMediaTransitionDuration;
TimeValue myMediaFXStartTime, myMediaFXDuration;
OSType myEffectCode;
long myFlags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;
long myLong;
OSErr myErr = noErr;
// standard parameter box has been dismissed, so remember that fact
gEffectsDialog = 0L;
myDialogWasCancelled = (theErr == userCanceledErr);
// we're finished with the effect list and movie posters
QTDisposeAtomContainer(gEffectList);
if (gPosterA != NULL)
KillPicture(gPosterA);
if (gPosterB != NULL)
KillPicture(gPosterB);
// when the sign says stop, then stop
if (myDialogWasCancelled)
goto bail;
// add atoms naming the sources to gEffectSample
myLong = EndianU32_NtoB(kSourceOneName);
QTInsertChild(gEffectSample, kParentAtomIsContainer, kEffectSourceName, 1, 0, sizeof(myLong), &myLong, NULL);
myLong = EndianU32_NtoB(kSourceTwoName);
QTInsertChild(gEffectSample, kParentAtomIsContainer, kEffectSourceName, 2, 0, sizeof(myLong), &myLong, NULL);
// extract the 'what' atom to find out what kind of effect it is
{
QTAtom myEffectAtom;
QTAtomID myEffectAtomID;
long myEffectCodeSize;
Ptr myEffectCodePtr;
myEffectAtom = QTFindChildByIndex(gEffectSample, kParentAtomIsContainer, kParameterWhatName, kParameterWhatID, &myEffectAtomID);
myErr = QTLockContainer(gEffectSample);
BailError(myErr);
myErr = QTGetAtomDataPtr(gEffectSample, myEffectAtom, &myEffectCodeSize, &myEffectCodePtr);
BailError(myErr);
if (myEffectCodeSize != sizeof(OSType)) {
myErr = paramErr;
goto bail;
}
myEffectCode = *(OSType *)myEffectCodePtr; // "tsk"
myEffectCode = EndianU32_BtoN(myEffectCode); // because the data is read from an atom container
myErr = QTUnlockContainer(gEffectSample);
BailError(myErr);
}
// ask the user for the name of the new movie file
QTFrame_PutFile(myPrompt, myFileName, &myFile, &myIsSelected, &myIsReplacing);
if (!myIsSelected)
goto bail; // deal with user cancelling
// create a movie file for the destination movie
myErr = CreateMovieFile(&myFile, FOUR_CHAR_CODE('TVOD'), 0, myFlags, &myDestMovieRefNum, &myDestMovie);
BailError(myErr);
// open the first file as a movie; call the first movie myPrevSrcMovie
myErr = OpenMovieFile(&gSpecList[0], &mySrcMovieRefNum, fsRdPerm);
BailError(myErr);
myErr = NewMovieFromFile(&myPrevSrcMovie, mySrcMovieRefNum, NULL, NULL, 0, NULL);
BailError(myErr);
myErr = CloseMovieFile(mySrcMovieRefNum);
BailError(myErr);
// if the movie is shorter than kMinimumDuration, scale it to that length
SetMovieTimeScale(myPrevSrcMovie, kTimeScale);
myErr = QTEffects_GetFirstVideoTrackInMovie(myPrevSrcMovie, &myPrevSrcTrack);
BailNil(myPrevSrcTrack);
if (GetTrackDuration(myPrevSrcTrack) < kMinimumDuration) {
myErr = ScaleTrackSegment(myPrevSrcTrack, 0, GetTrackDuration(myPrevSrcTrack), kMinimumDuration);
BailError(myErr);
}
// find out how big the first movie is; we'll use it as the size of all our tracks
GetTrackDimensions(myPrevSrcTrack, &myDestMovieWidth, &myDestMovieHeight);
#if USES_MAKE_IMAGE_DESC_FOR_EFFECT
// create a new sample description for the effect,
// which is just an image description specifying the effect and its dimensions
myErr = MakeImageDescriptionForEffect(myEffectCode, &myDesc);
if (myErr != noErr)
BailError(myErr);
#else
// create a new sample description for the effect,
// which is just an image description specifying the effect and its dimensions
myDesc = (ImageDescriptionHandle)NewHandleClear(sizeof(ImageDescription));
BailNil(myDesc);
(**myDesc).idSize = sizeof(ImageDescription);
(**myDesc).cType = myEffectCode;
(**myDesc).hRes = 72L << 16;
(**myDesc).vRes = 72L << 16;
(**myDesc).dataSize = 0L;
(**myDesc).frameCount = 1;
(**myDesc).depth = 0;
(**myDesc).clutID = -1;
#endif
// fill in the fields of the sample description
(**myDesc).vendor = kAppleManufacturer;
(**myDesc).temporalQuality = codecNormalQuality;
(**myDesc).spatialQuality = codecNormalQuality;
(**myDesc).width = FixRound(myDestMovieWidth);
(**myDesc).height = FixRound(myDestMovieHeight);
// add three video tracks to the destination movie:
// - videoTrackFX is where the effects and stills live; it's user-visible.
// - videoTrackA is where the "source A"s for effects live; it's hidden by the input map
// - videoTrackB is where the "source B"s for effects live; it's hidden by the input map
videoTrackFX = NewMovieTrack(myDestMovie, myDestMovieWidth, myDestMovieHeight, 0);
BailNil(videoTrackFX);
videoMediaFX = NewTrackMedia(videoTrackFX, VideoMediaType, kTimeScale, NULL, 0);
BailNil(videoMediaFX);
myErr = BeginMediaEdits(videoMediaFX);
BailError(myErr);
videoTrackA = NewMovieTrack(myDestMovie, myDestMovieWidth, myDestMovieHeight, 0);
BailNil(videoTrackA);
videoMediaA = NewTrackMedia(videoTrackA, VideoMediaType, kTimeScale, NULL, 0);
BailNil(videoMediaA);
videoTrackB = NewMovieTrack(myDestMovie, myDestMovieWidth, myDestMovieHeight, 0);
BailNil(videoTrackB);
videoMediaB = NewTrackMedia(videoTrackB, VideoMediaType, kTimeScale, NULL, 0);
BailNil(videoMediaB);
// create the input map
{
long myRefIndex1, myRefIndex2;
QTAtomContainer myInputMap;
QTAtom myInputAtom;
OSType myInputType;
QTNewAtomContainer(&myInputMap);
// first input
if (videoTrackA) {
AddTrackReference(videoTrackFX, videoTrackA, kTrackModifierReference, &myRefIndex1);
QTInsertChild(myInputMap, kParentAtomIsContainer, kTrackModifierInput, myRefIndex1, 0, 0, NULL, &myInputAtom);
myInputType = EndianU32_NtoB(kTrackModifierTypeImage);
QTInsertChild(myInputMap, myInputAtom, kTrackModifierType, 1, 0, sizeof(myInputType), &myInputType, NULL);
myLong = EndianU32_NtoB(kSourceOneName);
QTInsertChild(myInputMap, myInputAtom, kEffectDataSourceType, 1, 0, sizeof(myLong), &myLong, NULL);
}
// second input
if (videoTrackB) {
AddTrackReference(videoTrackFX, videoTrackB, kTrackModifierReference, &myRefIndex2);
QTInsertChild(myInputMap, kParentAtomIsContainer, kTrackModifierInput, myRefIndex2, 0, 0, NULL, &myInputAtom);
myInputType = EndianU32_NtoB(kTrackModifierTypeImage);
QTInsertChild(myInputMap, myInputAtom, kTrackModifierType, 1, 0, sizeof(myInputType), &myInputType, NULL);
myLong = EndianU32_NtoB(kSourceTwoName);
QTInsertChild(myInputMap, myInputAtom, kEffectDataSourceType, 1, 0, sizeof(myLong), &myLong, NULL);
}
// set that map
SetMediaInputMap(GetTrackMedia(videoTrackFX), myInputMap);
QTDisposeAtomContainer(myInputMap);
}
myCurrentDuration = 0;
#if MAKE_STILL_SECTIONS
// copy the first sample of the first video track of the first movie to videoTrackFX, with duration kStillDuration.
myErr = CopyPortionOfTrackToTrack(myPrevSrcTrack, eStartPortion + eMiddlePortion, videoTrackFX, myCurrentDuration, &myReturnedDuration);
BailError(myErr);
myCurrentDuration += myReturnedDuration;
#endif
// now process any remaining files
myMovieIter = 1;
while (myMovieIter < gSpecCount) {
// open the next file as a movie; call it nextSourceMovie
myErr = OpenMovieFile(&gSpecList[myMovieIter], &mySrcMovieRefNum, fsRdPerm);
BailError(myErr);
myErr = NewMovieFromFile(&myNextSrcMovie, mySrcMovieRefNum, NULL, NULL, 0, NULL);
BailError(myErr);
// we're done with the movie file, so close it
myErr = CloseMovieFile(mySrcMovieRefNum);
BailError(myErr);
// if the movie is shorter than kMinimumDuration, scale it to that length
SetMovieTimeScale(myNextSrcMovie, kTimeScale);
myErr = QTEffects_GetFirstVideoTrackInMovie(myNextSrcMovie, &myNextSrcTrack);
BailNil(myNextSrcTrack);
if (GetTrackDuration(myNextSrcTrack) < kMinimumDuration) {
myErr = ScaleTrackSegment(myNextSrcTrack, 0, GetTrackDuration(myNextSrcTrack), kMinimumDuration);
BailError(myErr);
}
// create a transition effect from the previous source movie's first video sample to the next source movie's first video sample
// (the effect should have duration kEffectDuration);
// this involves adding one sample to each of the three video tracks:
// sample from previous source movie -> videoTrackA
myErr = QTEffects_CopyPortionOfTrackToTrack(myPrevSrcTrack, eFinishPortion, videoTrackA, myCurrentDuration, &myReturnedDuration);
BailError(myErr);
// sample from next source movie -> videoTrackB
myErr = QTEffects_CopyPortionOfTrackToTrack(myNextSrcTrack, eStartPortion, videoTrackB, myCurrentDuration, &myReturnedDuration);
BailError(myErr);
// effect sample -> videoTrackFX
if (isFirstTransition) {
myMediaTransitionDuration = myReturnedDuration;
myMediaFXStartTime = GetMediaDuration(videoMediaFX);
myErr = AddMediaSample(videoMediaFX, gEffectSample, 0, GetHandleSize(gEffectSample), myMediaTransitionDuration, (SampleDescriptionHandle)myDesc, 1, 0, NULL);
BailError(myErr);
myMediaFXDuration = GetMediaDuration(videoMediaFX) - myMediaFXStartTime;
isFirstTransition = false;
}
myErr = InsertMediaIntoTrack(videoTrackFX, myCurrentDuration, myMediaFXStartTime, myMediaFXDuration, FixRatio(myReturnedDuration, myMediaTransitionDuration));
BailError(myErr);
myCurrentDuration += myReturnedDuration;
#if MAKE_STILL_SECTIONS
// copy the first video sample of myNextSrcMovie to videoTrackFX, with duration kStillDuration.
myErr = QTEffects_CopyPortionOfTrackToTrack(myNextSrcTrack, eMiddlePortion + (myMovieIter + 1 == theSpecCount) ? eFinishPortion : 0, videoTrackFX, myCurrentDuration, &myReturnedDuration);
BailError(myErr);
myCurrentDuration += myReturnedDuration;
#endif // MAKE_STILL_SECTIONS
// dispose of previous source movie.
DisposeMovie(myPrevSrcMovie);
myPrevSrcMovie = myNextSrcMovie;
myPrevSrcTrack = myNextSrcTrack;
myNextSrcMovie = NULL;
myNextSrcTrack = NULL;
myMovieIter++;
} // while
myErr = EndMediaEdits(videoMediaFX);
BailError(myErr);
myErr = AddMovieResource(myDestMovie, myDestMovieRefNum, &myResID, "\pMovie 1");
BailError(myErr);
CloseMovieFile(myDestMovieRefNum);
if (myPrevSrcMovie != NULL)
DisposeMovie(myPrevSrcMovie);
DisposeMovie(myDestMovie);
bail:
free(myPrompt);
free(myFileName);
QTDisposeAtomContainer(gEffectSample);
DisposeHandle((Handle)myDesc);
return;
}
void Text::calculate_position_and_advance_cursor(TextWriter &tw, int *out_x, int *out_y) const
{
#ifdef WIN32
const long options = DT_LEFT | DT_NOPREFIX;
Context c = tw.renderer.m_context;
int previous_map_mode = SetMapMode(c, MM_TEXT);
HFONT font = font_handle_lookup[tw.size];
// Create the font we want to use, and swap it out with
// whatever is currently in there, along with our color
HFONT previous_font = (HFONT)SelectObject(c, font);
// Call DrawText to find out how large our text is
RECT drawing_rect = { tw.x, tw.y, 0, 0 };
tw.last_line_height = DrawText(c, m_text.c_str(), int(m_text.length()), &drawing_rect, options | DT_CALCRECT);
// Return the hdc settings to their previous setting
SelectObject(c, previous_font);
SetMapMode(c, previous_map_mode);
#else
// Convert passed-in text to Unicode
CFStringRef cftext = MacStringFromWide(m_text, true).get();
CFDataRef unitext = CFStringCreateExternalRepresentation(kCFAllocatorDefault, cftext, kCFStringEncodingUnicode, 0);
if (!unitext) throw PianoGameError(WSTRING(L"Couldn't convert string to unicode: '" << m_text << L"'"));
CFRelease(cftext);
// Create an ATSU layout
ATSUTextLayout layout;
const UniCharCount run_length = kATSUToTextEnd;
OSStatus status = ATSUCreateTextLayoutWithTextPtr((ConstUniCharArrayPtr)CFDataGetBytePtr(unitext), kATSUFromTextBeginning, kATSUToTextEnd, CFDataGetLength(unitext) / 2, 1, &run_length, &atsu_style_lookup[tw.size], &layout);
if (status != noErr) throw PianoGameError(WSTRING(L"Couldn't create ATSU text layout for string: '" << m_text << L"', Error code: " << static_cast<int>(status)));
// Measure the size of the resulting text
Rect drawing_rect = { 0, 0, 0, 0 };
ATSUTextMeasurement before = 0;
ATSUTextMeasurement after = 0;
ATSUTextMeasurement ascent = 0;
ATSUTextMeasurement descent = 0;
status = ATSUGetUnjustifiedBounds(layout, 0, kATSUToTextEnd, &before, &after, &ascent, &descent);
if (status != noErr) throw PianoGameError(WSTRING(L"Couldn't get unjustified bounds for text layout for string: '" << m_text << L"', Error code: " << static_cast<int>(status)));
// NOTE: the +1 here is completely arbitrary and seemed to place the text better.
// It may just be a difference between the Windows and Mac text placement systems.
drawing_rect.top += tw.y + 1;
drawing_rect.left += tw.x + FixRound(before);
drawing_rect.right += tw.x + FixRound(after);
// Not used.
drawing_rect.bottom = 0;
// Clean-up
ATSUDisposeTextLayout(layout);
CFRelease(unitext);
#endif
// Update the text-writer with post-draw coordinates
if (tw.centered) drawing_rect.left -= (drawing_rect.right - drawing_rect.left) / 2;
if (!tw.centered) tw.x += drawing_rect.right - drawing_rect.left;
// Tell the draw function where to put the text
*out_x = drawing_rect.left;
*out_y = drawing_rect.top;
}
QFixed QFontEngineMac::leading() const
{
ATSUTextMeasurement metric;
ATSUGetAttribute(style, kATSULeadingTag, sizeof(metric), &metric, 0);
return FixRound(metric);
}
