/*==LICENSE==* CyanWorlds.com Engine - MMOG client, server and tools Copyright (C) 2011 Cyan Worlds, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . Additional permissions under GNU GPL version 3 section 7 If you modify this Program, or any covered work, by linking or combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK (or a modified version of those libraries), containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the licensors of this Program grant you additional permission to convey the resulting work. Corresponding Source for a non-source form of such a combination shall include the source code for the parts of OpenSSL and IJG JPEG Library used as well as that of the covered work. You can contact Cyan Worlds, Inc. by email legal@cyan.com or by snail mail at: Cyan Worlds, Inc. 14617 N Newport Hwy Mead, WA 99021 *==LICENSE==*/ ////////////////////////////////////////////////////////////////////////////// // // // pfJournalBook Class // // A generic, high-level, abstract method of creating various Myst-like // // books within the game with very little effort, while ensuring that they // // all remain consistent in appearance and operability. // // // ////////////////////////////////////////////////////////////////////////////// #include "pfJournalBook.h" #include "hsUtils.h" #include "hsStlUtils.h" #include "hsResMgr.h" #include "pcSmallRect.h" #include "plgDispatch.h" #include "../pfGameGUIMgr/pfGUIDialogMod.h" #include "../pfGameGUIMgr/pfGUIControlMod.h" #include "../pfGameGUIMgr/pfGUICheckBoxCtrl.h" #include "../pfGameGUIMgr/pfGUIDialogHandlers.h" #include "../pfGameGUIMgr/pfGUIDynDisplayCtrl.h" #include "../pfGameGUIMgr/pfGUIClickMapCtrl.h" #include "../pfGameGUIMgr/pfGUIButtonMod.h" #include "../pfGameGUIMgr/pfGUIProgressCtrl.h" #include "../pfGameGUIMgr/pfGUIMultiLineEditCtrl.h" #include "../pfMessage/pfGUINotifyMsg.h" #include "../plGImage/plMipmap.h" #include "../plGImage/plDynamicTextMap.h" #include "../plPipeline/hsGDeviceRef.h" #include "../plMessage/plAnimCmdMsg.h" #include "../pnKeyedObject/plFixedKey.h" #include "../pnMessage/plRefMsg.h" #include "../pnMessage/plTimeMsg.h" #include "../plMessage/plLayRefMsg.h" #include "../plMessage/plMatRefMsg.h" #include "../plSurface/plLayerInterface.h" #include "../plSurface/plLayer.h" #include "../plSurface/hsGMaterial.h" #include "../plAgeLoader/plAgeLoader.h" #include "../pfSurface/plLayerBink.h" // So we can do image searches in our local age #include "../plNetClient/plNetClientMgr.h" #include "../plResMgr/plKeyFinder.h" // For notify sends #include "../pnMessage/plNotifyMsg.h" #include "../pnTimer/plTimerCallbackManager.h" #include "../plMessage/plTimerCallbackMsg.h" // For custom cursors #include "../plInputCore/plInputInterface.h" // For measuring text #include "../plGImage/plFont.h" // For SFX #include "hsTimer.h" ////////////////////////////////////////////////////////////////////////////// //// pfEsHTMLChunk Class ///////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// class pfEsHTMLChunk { public: std::wstring fText; // Paragraph text, or face name plKey fImageKey; // Key of image UInt8 fFontSize; UInt32 fFlags; UInt8 fType; UInt32 fEventID; pcSmallRect fLinkRect; // Used only for image chunks, and only when stored in the fVisibleLinks array hsColorRGBA fColor; UInt16 fAbsoluteX, fAbsoluteY; hsScalar fCurrOpacity; // For SFX images hsScalar fSFXTime; // For SFX images hsScalar fMinOpacity, fMaxOpacity; hsColorRGBA fCurrColor; hsColorRGBA fOffColor, fOnColor; bool fNoResizeImg; Int16 fLineSpacing; bool fTintDecal; bool fLoopMovie; bool fOnCover; // if true, the movie is on the cover UInt8 fMovieIndex; // the index of the movie in the source code, used for identification enum Flags { kFontBold = 0x00000001, kFontItalic = 0x00000002, kFontRegular= 0x00000004, // 'cause 0 means "style not defined" kFontMask = kFontBold | kFontItalic | kFontRegular, kFontColor = 0x00000008, kFontSpacing= 0x00000010, kCenter = 0x00000001, kLeft = 0x00000002, kRight = 0x00000003, kAlignMask = 0x00000003, kBlendAlpha = 0x00000004, kCanLink = 0x00000008, kFloating = 0x00000010, kGlowing = 0x00000020, kActAsCB = 0x00000040, // Cause the image to act in a checkbox-like fashion. // Min opacity turns into "off opacity" and max opacity // is "on opacity" kChecked = 0x00000080, // Only for kActAsCB, set if it's currently "checked" kTranslucent= 0x00000100 // is the image translucent? if so, use fCurrOpacity }; enum Types { kEmpty = 0, kParagraph, kImage, kPageBreak, kFontChange, kMargin, kCover, // Just a placeholder, never actually used after compile time kBook, // another placeholder kDecal, kMovie, kEditable // placeholder, ver 3.0 }; // Paragraph constructor pfEsHTMLChunk( const wchar_t *text ) { fType = kParagraph; if (text) fText = text; else fText = L""; fFlags = kLeft; fFontSize = 0; fImageKey = nil; fEventID = 0; fColor.Set( 0.f, 0.f, 0.f, 1.f ); fAbsoluteX = fAbsoluteY = 0; fCurrOpacity = 1.f; fMinOpacity = 0.f; fMaxOpacity = 1.f; fNoResizeImg = false; fLineSpacing = 0; fTintDecal = false; fLoopMovie = true; fOnCover = false; fMovieIndex = -1; } // Image constructor (used for decals and movies too) pfEsHTMLChunk( plKey imageKey, UInt32 alignFlags ) { fType = kImage; fText = L""; fFlags = alignFlags; fFontSize = 0; fImageKey = imageKey; fEventID = 0; fColor.Set( 0.f, 0.f, 0.f, 1.f ); fAbsoluteX = fAbsoluteY = 0; fCurrOpacity = 1.f; fMinOpacity = 0.f; fMaxOpacity = 1.f; fNoResizeImg = false; fLineSpacing = 0; fTintDecal = false; fLoopMovie = true; fOnCover = false; fMovieIndex = -1; } // Page break constructor pfEsHTMLChunk() { fType = kPageBreak; fText = L""; fImageKey = nil; fFontSize = 0; fFlags = 0; fEventID = 0; fColor.Set( 0.f, 0.f, 0.f, 1.f ); fAbsoluteX = fAbsoluteY = 0; fCurrOpacity = 1.f; fMinOpacity = 0.f; fMaxOpacity = 1.f; fNoResizeImg = false; fLineSpacing = 0; fTintDecal = false; fLoopMovie = true; fOnCover = false; fMovieIndex = -1; } // Font change constructor pfEsHTMLChunk( const wchar_t *face, UInt8 size, UInt32 fontFlags ) { fType = kFontChange; if (face) fText = face; else fText = L""; fFontSize = size; fFlags = fontFlags; fImageKey = nil; fEventID = 0; fColor.Set( 0.f, 0.f, 0.f, 1.f ); fAbsoluteX = fAbsoluteY = 0; fCurrOpacity = 1.f; fMinOpacity = 0.f; fMaxOpacity = 1.f; fNoResizeImg = false; fLineSpacing = 0; fTintDecal = false; fLoopMovie = true; fOnCover = false; fMovieIndex = -1; } ~pfEsHTMLChunk() {} }; ////////////////////////////////////////////////////////////////////////////// //// Our Template Dialog Handler ///////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// class pfJournalDlgProc : public pfGUIDialogProc { protected: pfBookData *fBook; public: enum TagIDs { kTagBookCover = 100, kTagLeftDTMap = 101, kTagRightDTMap = 102, kTagTurnFrontDTMap = 103, kTagTurnBackDTMap = 104, kTagTurnPageCtrl = 105, kTagLeftPageBtn = 106, kTagRightPageBtn = 107, kTagOutsideBookBtn = 108, kTagCoverLayer = 109, kTagLeftCornerBtn = 110, kTagRightCornerBtn = 111, kTagWidthCBDummy = 112, kTagHeightCBDummy = 113, kTagLeftEditCtrl = 120, kTagRightEditCtrl = 121, kTagTurnFrontEditCtrl = 122, kTagTurnBackEditCtrl = 123 }; pfJournalDlgProc( pfBookData *book ) : fBook( book ) { } virtual ~pfJournalDlgProc() { } virtual void DoSomething( pfGUIControlMod *ctrl ) { if ( fBook && fBook->fCurrBook ) { if( ctrl->GetTagID() == kTagBookCover ) { fBook->fCurrBook->Open(); } else if( ctrl->GetTagID() == kTagLeftPageBtn ) { // only turn pages if the book is actually open if( fBook->fCurrentlyOpen ) fBook->fCurrBook->IHandleLeftSideClick(); } else if( ctrl->GetTagID() == kTagRightPageBtn ) { // only turn pages if the book is actually open if( fBook->fCurrentlyOpen ) fBook->fCurrBook->IHandleRightSideClick(); } else if( ctrl->GetTagID() == kTagOutsideBookBtn ) { if( fBook->fCurrentlyOpen ) fBook->fCurrBook->CloseAndHide(); else fBook->fCurrBook->Hide(); } } } // Called on dialog init (i.e. first showing, before OnShow() is called), only ever called once virtual void OnInit( void ) { } // Called before the dialog is shown, always after OnInit() virtual void OnShow( void ) { } // Called before the dialog is hidden virtual void OnHide( void ) { } // Called on the dialog's destructor, before it's unregistered with the game GUI manager virtual void OnDestroy( void ) { } // Called when the dialog's focused control changes virtual void OnCtrlFocusChange( pfGUIControlMod *oldCtrl, pfGUIControlMod *newCtrl ) { } // Called when the key bound to a GUI event is pressed. Only called on the top modal dialog virtual void OnControlEvent( ControlEvt event ) { if( event == kExitMode ) { if( fBook->fCurrentlyOpen ) fBook->fCurrBook->CloseAndHide(); else fBook->fCurrBook->Hide(); } } virtual void HandleExtendedEvent( pfGUIControlMod *ctrl, UInt32 event ) { if (fBook) { if( ctrl == fBook->fLeftPageMap ) { if( event == pfGUIClickMapCtrl::kMouseHovered ) { if (fBook->fCurrBook) { // Update our custom cursor on the map Int32 idx = fBook->fCurrBook->IFindCurrVisibleLink( false, true ); if( idx != -1 ) fBook->fLeftPageMap->SetCustomCursor( plInputInterface::kCursorPoised/*Hand*/ ); else if(( fBook->fCurrBook->fCurrentPage > 1 )&&( fBook->fCurrBook->fAllowTurning )) fBook->fLeftPageMap->SetCustomCursor( plInputInterface::kCursorLeft ); else if ((fBook->fCurrBook->fAreEditing) && !(fBook->fLeftEditCtrl->ShowingBeginningOfBuffer())) // if we have more buffer to show fBook->fLeftPageMap->SetCustomCursor( plInputInterface::kCursorLeft ); else fBook->fLeftPageMap->SetCustomCursor( plInputInterface::kCursorUp ); } } } else if( ctrl == fBook->fRightPageMap ) { if( event == pfGUIClickMapCtrl::kMouseHovered ) { if (fBook->fCurrBook) { // Update our custom cursor on the map Int32 idx = fBook->fCurrBook->IFindCurrVisibleLink( true, true ); if( idx != -1 ) fBook->fRightPageMap->SetCustomCursor( plInputInterface::kCursorPoised/*Hand*/ ); else if((fBook->fCurrBook->fAreWeShowing) && ( fBook->fCurrBook->fCurrentPage + 2 <= fBook->fCurrBook->fLastPage )&&( fBook->fCurrBook->fAllowTurning )) fBook->fRightPageMap->SetCustomCursor( plInputInterface::kCursorRight ); else if((fBook->fCurrBook->fAreEditing) && !(fBook->fRightEditCtrl->ShowingEndOfBuffer())) // if we have more buffer to show fBook->fRightPageMap->SetCustomCursor( plInputInterface::kCursorRight ); else fBook->fRightPageMap->SetCustomCursor( plInputInterface::kCursorUp ); } } } } } }; //// Multiline edit handler class //////////////////////////////////////////// class pfBookMultiLineEditProc : public pfGUIMultiLineEditProc { private: pfBookData *bookData; public: pfBookMultiLineEditProc(pfBookData *owner) { bookData = owner; } virtual ~pfBookMultiLineEditProc() {} virtual void OnEndOfControlList(Int32 cursorPos) { bookData->HitEndOfControlList(cursorPos); } virtual void OnBeginningOfControlList(Int32 cursorPos) { bookData->HitBeginningOfControlList(cursorPos); } }; //// Book data class ///////////////////////////////////////////////////////// pfBookData::pfBookData(const char *guiName /* = nil */) { fCurrBook = nil; fDialog = nil; fCoverButton = fTurnPageButton = nil; fLeftPageMap = fRightPageMap = nil; fCoverLayer = nil; fCoverMaterial = nil; UInt16 i; for (i=0; i<4; i++) fPageMaterials[i] = nil; fLeftCorner = fRightCorner = nil; fWidthCtrl = fHeightCtrl = nil; fCurrSFXPages = kNoSides; fBaseSFXTime = 0.f; fResetSFXFlag = false; fSFXUpdateFlip = false; fCurrentlyTurning = false; fRightEditCtrl = fLeftEditCtrl = nil; fTurnFrontEditCtrl = fTurnBackEditCtrl = nil; fEditable = false; fAdjustCursorTo = -1; if (guiName) fGUIName = guiName; else fGUIName = "BkBook"; } pfBookData::~pfBookData() { RegisterForSFX( kNoSides ); } void pfBookData::LoadGUI() { // has the dialog been loaded yet? if (!pfGameGUIMgr::GetInstance()->IsDialogLoaded(fGUIName.c_str())) // no then load and set handler pfGameGUIMgr::GetInstance()->LoadDialog(fGUIName.c_str(), GetKey(), "GUI"); else // yes then just set the handler pfGameGUIMgr::GetInstance()->SetDialogToNotify(fGUIName.c_str(), GetKey()); } hsBool pfBookData::MsgReceive(plMessage *pMsg) { plGenRefMsg *ref = plGenRefMsg::ConvertNoRef(pMsg); if(ref != nil) { if(ref->fType == kRefDialog) { if(ref->GetContext() & (plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace)) { pfGUIDialogMod *temp = pfGUIDialogMod::ConvertNoRef(ref->GetRef()); if (temp != nil) // sanity check fDialog = temp; } /*else { fDialog = nil; fCoverButton = nil; }*/ return true; } else if(ref->fType == kRefDefaultCover) { if(ref->GetContext() & (plRefMsg::kOnCreate | plRefMsg::kOnRequest | plRefMsg::kOnReplace)) fDefaultCover = plMipmap::ConvertNoRef(ref->GetRef()); else fDefaultCover = nil; return true; } } plEventCallbackMsg *callback = plEventCallbackMsg::ConvertNoRef( pMsg ); if( callback != nil ) { // Our callback message to tell us the page is done flipping if( callback->fUser & 0x08 ) { // make sure that we still have a current book if (fCurrBook) { // Or actually maybe it's that we're done closing and should hide now, // produced from a CloseAndHide() if( callback->fEvent == kStop ) fCurrBook->Hide(); else fCurrBook->IFinishShow( ( callback->fUser & 0x01 ) ? true : false ); } } else if( fCurrentlyTurning ) { if( callback->fUser & 0x04 ) IFillUncoveringPage( (hsBool)( callback->fUser & 0x01 ) ? true : false ); else if( callback->fUser & 0x02 ) StartTriggeredFlip( (hsBool)( callback->fUser & 0x01 ) ? true : false ); else IFinishTriggeredFlip( (hsBool)( callback->fUser & 0x01 ) ? true : false ); } return true; } pfGUINotifyMsg *notify = pfGUINotifyMsg::ConvertNoRef(pMsg); if(notify != nil) { // The only time we should get this is when the dialog loads; after that, we hijack // the dialog proc with our own IInitTemplate(pfGUIDialogMod::ConvertNoRef(notify->GetSender()->ObjectIsLoaded())); return true; } plTimeMsg *time = plTimeMsg::ConvertNoRef( pMsg ); if( time != nil && fCurrSFXPages != kNoSides && !fCurrentlyTurning && fCurrentlyOpen ) { IHandleSFX( (hsScalar)time->DSeconds() ); return true; } plTimerCallbackMsg* timerMsg = plTimerCallbackMsg::ConvertNoRef(pMsg); if (timerMsg) { if (timerMsg->fID == 99) // the flip animation is about to end, hide the page to prevent flickering { // the right side was uncovered, so the left side needs to be hidden fLeftEditCtrl->SetVisible(false); } else if (timerMsg->fID == 98) { // the left side was uncovered, so the right side needs to be hidden fRightEditCtrl->SetVisible(false); } } return hsKeyedObject::MsgReceive(pMsg); } void pfBookData::IInitTemplate(pfGUIDialogMod *templateDlg) { hsAssert(templateDlg != nil, "Nil template in pfBookData::IInitTemplate()!"); // Init and ref our fDialog pointer hsgResMgr::ResMgr()->SendRef(templateDlg->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefDialog), plRefFlags::kPassiveRef); // Hijack the dialog proc with our own templateDlg->SetHandlerForAll(TRACKED_NEW pfJournalDlgProc(this)); // Find our animation keys // And other interesting pointers fCoverButton = pfGUICheckBoxCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagBookCover)); fTurnPageButton = pfGUICheckBoxCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagTurnPageCtrl)); fLeftPageMap = pfGUIClickMapCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagLeftPageBtn)); fRightPageMap = pfGUIClickMapCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagRightPageBtn)); fLeftCorner = pfGUIButtonMod::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagLeftCornerBtn)); fRightCorner = pfGUIButtonMod::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagRightCornerBtn)); fWidthCtrl = pfGUIProgressCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagWidthCBDummy)); fHeightCtrl = pfGUIProgressCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagHeightCBDummy)); fTurnPageButton->SetEnabled(false); fCoverButton->DontPlaySounds(); // dont let checkbox play sounds, journal will take care of that. fCoverLayer = pfGUIDynDisplayCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagCoverLayer))->GetLayer(0); fCoverMaterial = pfGUIDynDisplayCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagCoverLayer))->GetMaterial(0); fPageMaterials[kLeftPage] = pfGUIDynDisplayCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagLeftDTMap))->GetMaterial(0); fPageMaterials[kRightPage] = pfGUIDynDisplayCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagRightDTMap))->GetMaterial(0); fPageMaterials[kTurnFrontPage] = pfGUIDynDisplayCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagTurnFrontDTMap))->GetMaterial(0); fPageMaterials[kTurnBackPage] = pfGUIDynDisplayCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagTurnBackDTMap))->GetMaterial(0); // Grab and ref the default cover mipmap plLayer *lay = plLayer::ConvertNoRef(fCoverLayer); if((lay != nil)&&(lay->GetTexture() != nil)) hsgResMgr::ResMgr()->AddViaNotify(lay->GetTexture()->GetKey(), TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, kRefDefaultCover), plRefFlags::kPassiveRef); fLeftPageMap->SetFlag(pfGUIClickMapCtrl::kReportHovering); fRightPageMap->SetFlag(pfGUIClickMapCtrl::kReportHovering); fLeftEditCtrl = pfGUIMultiLineEditCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagLeftEditCtrl)); if (fLeftEditCtrl) { fLeftEditCtrl->SetEnabled(false); // disable the edit controls initially, we can turn them on later fLeftEditCtrl->SetVisible(false); } fRightEditCtrl = pfGUIMultiLineEditCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagRightEditCtrl)); if (fRightEditCtrl) { fRightEditCtrl->SetEnabled(false); fRightEditCtrl->SetVisible(false); } fTurnFrontEditCtrl = pfGUIMultiLineEditCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagTurnFrontEditCtrl)); if (fTurnFrontEditCtrl) { fTurnFrontEditCtrl->SetEnabled(false); fTurnFrontEditCtrl->SetVisible(false); } fTurnBackEditCtrl = pfGUIMultiLineEditCtrl::ConvertNoRef(templateDlg->GetControlFromTag(pfJournalDlgProc::kTagTurnBackEditCtrl)); if (fTurnBackEditCtrl) { fTurnBackEditCtrl->SetEnabled(false); fTurnBackEditCtrl->SetVisible(false); } // if all the edit controls are here, we are editable, so set up the initial link if (fLeftEditCtrl && fRightEditCtrl && fTurnFrontEditCtrl && fTurnBackEditCtrl) { fEditable = true; fLeftEditCtrl->SetNext(fRightEditCtrl); fLeftEditCtrl->SetEventProc(TRACKED_NEW pfBookMultiLineEditProc(this)); fTurnFrontEditCtrl->SetNext(fTurnBackEditCtrl); // these are always back to back } } //// IGetDTMap /////////////////////////////////////////////////////////////// // Just a quick helper plDynamicTextMap *pfBookData::GetDTMap(UInt32 which) { pfGUIDynDisplayCtrl *display = pfGUIDynDisplayCtrl::ConvertNoRef(fDialog->GetControlFromTag(which)); return display->GetMap(0); } //// GetEditCtrl ///////////////////////////////////////////////////////////// pfGUIMultiLineEditCtrl *pfBookData::GetEditCtrl(UInt32 which) { switch (which) { case pfJournalDlgProc::kTagLeftEditCtrl: return fLeftEditCtrl; case pfJournalDlgProc::kTagRightEditCtrl: return fRightEditCtrl; case pfJournalDlgProc::kTagTurnFrontEditCtrl: return fTurnFrontEditCtrl; case pfJournalDlgProc::kTagTurnBackEditCtrl: return fTurnBackEditCtrl; default: return nil; } } //// IRegisterForSFX ///////////////////////////////////////////////////////// // Registers (or unregisters) for time messages so we can process special FX // if we need to void pfBookData::RegisterForSFX(WhichSide whichPages) { if( whichPages == fCurrSFXPages) return; if(whichPages != kNoSides) { plgDispatch::Dispatch()->RegisterForExactType(plTimeMsg::Index(), GetKey()); } else plgDispatch::Dispatch()->UnRegisterForExactType(plTimeMsg::Index(), GetKey()); fCurrSFXPages = whichPages; } //// IHandleSFX ////////////////////////////////////////////////////////////// // Process SFX for this frame. Note: if ANYTHING is wrong (page starts not // calced, pointers bad, etc) just bail, since the SFX are just for visual // flair and not really needed. void pfBookData::IHandleSFX(hsScalar currTime, WhichSide whichSide /*= kNoSides*/) { if(fCurrBook == nil) return; if(whichSide == kNoSides) { if(fResetSFXFlag) { fBaseSFXTime=currTime; fResetSFXFlag=false; } fSFXUpdateFlip = !fSFXUpdateFlip; // Slightly recursive here to help us out a bit if(fSFXUpdateFlip&&(fCurrSFXPages & kLeftSide)) IHandleSFX(currTime, kLeftSide); else if(!fSFXUpdateFlip &&(fCurrSFXPages & kRightSide)) IHandleSFX(currTime, kRightSide); return; } // Update all SFX images for this page first hsScalar deltaT = currTime - fBaseSFXTime; UInt32 idx, inc = (whichSide == kLeftSide) ? 0 : 1; if(fCurrBook->fPageStarts.GetCount() <= fCurrBook->fCurrentPage + inc + 1) return; bool stillWant = false; for(idx = fCurrBook->fPageStarts[fCurrBook->fCurrentPage + inc]; idx < fCurrBook->fPageStarts[fCurrBook->fCurrentPage + inc + 1]; idx++) { pfEsHTMLChunk *chunk = fCurrBook->fHTMLSource[idx]; if(chunk->fFlags & pfEsHTMLChunk::kGlowing) { // Glow SFX: animate opacity based on time offset UInt8 isOdd = 0; hsScalar newDelta = deltaT; while(newDelta > chunk->fSFXTime) { isOdd = ~isOdd; newDelta -= chunk->fSFXTime; } // If we're not odd, then we're decreasing in opacity, else we're increasing if(isOdd) newDelta = chunk->fSFXTime - newDelta; chunk->fCurrOpacity = chunk->fMaxOpacity - ((chunk->fMaxOpacity - chunk->fMinOpacity)*(newDelta / chunk->fSFXTime)); stillWant = true; } else if(chunk->fFlags & pfEsHTMLChunk::kActAsCB) { // If our opacity doesn't match our checked state, slowly fade to it hsColorRGBA inc; inc.Set(0.1f, 0.1f, 0.1f, 0.1f); hsColorRGBA &want = (chunk->fFlags & pfEsHTMLChunk::kChecked) ? chunk->fOnColor : chunk->fOffColor; if(want != chunk->fCurrColor) { #define COMPARE_ME( wnt, curr ) \ if( wnt > curr + 0.1f ) \ { \ curr += 0.1f; stillWant = true; \ } \ else if( wnt < curr - 0.1f ) \ { \ curr -= 0.1f; stillWant = true; \ } \ else \ curr = wnt; COMPARE_ME( want.r, chunk->fCurrColor.r ) COMPARE_ME( want.g, chunk->fCurrColor.g ) COMPARE_ME( want.b, chunk->fCurrColor.b ) COMPARE_ME( want.a, chunk->fCurrColor.a ) } } } // All done updating that page. Now render it! fCurrBook->IRenderPage( fCurrBook->fCurrentPage + inc, ( whichSide == kLeftSide ) ? pfJournalDlgProc::kTagLeftDTMap : pfJournalDlgProc::kTagRightDTMap ); if( !stillWant ) { // Done with FX for this page, so unregister for FX on this page now RegisterForSFX((WhichSide)(fCurrSFXPages & ~whichSide)); } } //// IFillUncoveringPage ///////////////////////////////////////////////////// // Yet another step in the page flip, to make SURE we're already showing the // turning page before we fill in the page behind it void pfBookData::IFillUncoveringPage(hsBool rightSide) { // only show the turning page if the book is open if ( CurrentlyOpen() ) fTurnPageButton->SetVisible(true); // make sure there is a current book if (fCurrBook) { if (fCurrBook->fAreEditing) { int id; UpdatePageCorners(rightSide ? kRightSide : kLeftSide); if (rightSide) { fTurnBackEditCtrl->ForceUpdate(); // force everything that is changing to update fTurnBackEditCtrl->SetVisible(true); // and make sure everything is showing fTurnFrontEditCtrl->ForceUpdate(); fTurnFrontEditCtrl->SetVisible(true); fRightEditCtrl->ForceUpdate(); fRightEditCtrl->SetVisible(true); // The left edit ctrl doesn't update until the page flip animation is done id = 99; } else { fTurnFrontEditCtrl->ForceUpdate(); fTurnFrontEditCtrl->SetVisible(true); fTurnBackEditCtrl->ForceUpdate(); fTurnBackEditCtrl->SetVisible(true); fLeftEditCtrl->ForceUpdate(); fLeftEditCtrl->SetVisible(true); // The right edit ctrl doesn't update until the page flip animation is done id = 98; } // create a timer so we can hide the old left or right turn page right before the animation finishes to prevent flicker plTimerCallbackMsg* pTimerMsg = TRACKED_NEW plTimerCallbackMsg(GetKey(),id); plgTimerCallbackMgr::NewTimer( .5, pTimerMsg ); // .5 found by trial and error return; // the gui controls render everything for us, so ignoring this request } if(rightSide) fCurrBook->IRenderPage(fCurrBook->fCurrentPage + 1, pfJournalDlgProc::kTagRightDTMap); else fCurrBook->IRenderPage(fCurrBook->fCurrentPage, pfJournalDlgProc::kTagLeftDTMap); } // Update the page corner we're flipping away from UpdatePageCorners(rightSide ? kRightSide : kLeftSide); } //// ITriggerPageFlip //////////////////////////////////////////////////////// // Triggers the start of the page-flipping animation, as well as sets up the callback for when it's finished void pfBookData::ITriggerPageFlip(hsBool flipBackwards, hsBool immediate) { // Hack here: since we don't have an official interface to select these directly // in MAX, we just use a GUI check box to grab them for us, even though we never // actually use the functionality of the checkbox itself const hsTArray &keys = fTurnPageButton->GetAnimationKeys(); const char *animName = fTurnPageButton->GetAnimationName(); plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg(); if (immediate) { msg->SetCmd(plAnimCmdMsg::kGoToEnd); } else { msg->SetCmd(plAnimCmdMsg::kContinue); msg->SetCmd(plAnimCmdMsg::kSetForewards); } msg->SetAnimName(flipBackwards ? "backward" : "forward"); msg->AddReceivers(keys); // Here's the whole reason why we're not just checking the checkbox: so we can attach a callback // so we know when the animation completes. Pretty sad, huh? Poor checkbox. plEventCallbackMsg *eventMsg = TRACKED_NEW plEventCallbackMsg; eventMsg->AddReceiver(GetKey()); eventMsg->fRepeats = 0; if (immediate) { eventMsg->fUser = ((!flipBackwards) ? 0x01 : 0x00) | 0x02; eventMsg->fEvent = kSingleFrameAdjust; } else { eventMsg->fUser = (flipBackwards ? 0x01 : 0x00); eventMsg->fEvent = kStop; } msg->SetCmd(plAnimCmdMsg::kAddCallbacks); msg->AddCallback(eventMsg); hsRefCnt_SafeUnRef(eventMsg); if (!immediate) { // We want a second callback to tell us when, indeed, the page has started turning // and is thus visible and thus we can actually, really, honestly, safely fill in the // page behind it eventMsg = TRACKED_NEW plEventCallbackMsg; eventMsg->AddReceiver(GetKey()); eventMsg->fRepeats = 0; eventMsg->fUser = !flipBackwards ? (0x04 | 0x01) : 0x04; eventMsg->fEvent = kBegin; // Should cause it to be triggered once it seeks at the start of the command msg->AddCallback(eventMsg); hsRefCnt_SafeUnRef(eventMsg); } fCurrentlyTurning = true; msg->Send(); } //// StartTriggeredFlip ///////////////////////////////////////////////////// // Finishes the start of the triggered page flip (once we're sure the // animation is at the new frame) void pfBookData::StartTriggeredFlip(hsBool flipBackwards) { if(flipBackwards) { ITriggerPageFlip(true, false); } else { ITriggerPageFlip(false, false); } } //// Kill the page flipping cause, we're closing the book void pfBookData::KillPageFlip() { if ( fCurrentlyTurning ) { //ITriggerPageFlip(false, true); fTurnPageButton->SetVisible(false); } } //// IFinishTriggeredFlip //////////////////////////////////////////////////// // Finishes the triggered page flip, on callback void pfBookData::IFinishTriggeredFlip(hsBool wasBackwards) { if (fCurrBook && fCurrBook->fAreEditing) // this is handled differently when we are editing { fLeftEditCtrl->SetNext(fRightEditCtrl); // relink the original path if (!wasBackwards) { // adjust the starting point of the control (not needed if we weren't backwards since that was done when we started turning Int32 newStart = fRightEditCtrl->GetLastVisibleLine(); fLeftEditCtrl->SetGlobalStartLine(newStart); } if (fAdjustCursorTo >= 0) { if (wasBackwards) { fRightEditCtrl->SetCursorToLoc(fAdjustCursorTo); fRightEditCtrl->GetOwnerDlg()->SetFocus(fRightEditCtrl); } else { fLeftEditCtrl->SetCursorToLoc(fAdjustCursorTo); fLeftEditCtrl->GetOwnerDlg()->SetFocus(fLeftEditCtrl); } fAdjustCursorTo = -1; } fTurnFrontEditCtrl->SetVisible(false); // hide the controls fTurnBackEditCtrl->SetVisible(false); fLeftEditCtrl->SetVisible(true); fRightEditCtrl->SetVisible(true); fLeftEditCtrl->ForceUpdate(); fRightEditCtrl->ForceUpdate(); } else if(wasBackwards) { // Grab the DTMaps for the front of the flip page and the right page, so we can // copy the front into the right page plDynamicTextMap *turnFront = GetDTMap(pfJournalDlgProc::kTagTurnFrontDTMap); plDynamicTextMap *right = GetDTMap(pfJournalDlgProc::kTagRightDTMap); // right->Swap( turnFront ); if ( turnFront->IsValid() && right->IsValid() ) { memcpy(right->GetImage(), turnFront->GetImage(), right->GetLevelSize(0)); if(right->GetDeviceRef() != nil) right->GetDeviceRef()->SetDirty(true); } // we are going to attempt to re-render the left-hand page // sometimes, the book stutters on a page flip and screws up the book if (fCurrBook) { fCurrBook->IRenderPage(fCurrBook->fCurrentPage, pfJournalDlgProc::kTagLeftDTMap); // move the videos over fCurrBook->IMoveMovies(PageMaterial(kTurnFrontPage),PageMaterial(kRightPage)); } } else { // Grab the DTMaps for the back of the flip page and the left page, so we can // copy the back into the left page plDynamicTextMap *turnBack = GetDTMap(pfJournalDlgProc::kTagTurnBackDTMap); plDynamicTextMap *left = GetDTMap(pfJournalDlgProc::kTagLeftDTMap); // right->Swap( turnFront ); if ( turnBack->IsValid() && left->IsValid() ) { memcpy(left->GetImage(), turnBack->GetImage(), left->GetLevelSize(0)); if(left->GetDeviceRef() != nil) left->GetDeviceRef()->SetDirty(true); } // we are going to attempt to re-render the right-hand page // sometimes, the book stutters on a page flip and screws up the book if (fCurrBook) { fCurrBook->IRenderPage(fCurrBook->fCurrentPage + 1, pfJournalDlgProc::kTagRightDTMap); // move the videos over fCurrBook->IMoveMovies(PageMaterial(kTurnBackPage),PageMaterial(kLeftPage)); } } // Hide our page flipping button/checkbox/whatever fTurnPageButton->SetVisible(false); // Update page corners UpdatePageCorners(kBothSides); fCurrentlyTurning = false; // Start our FX once the page is done turning fResetSFXFlag = true; } //// UpdatePageCorners ////////////////////////////////////////////////////// // Enables or disables the left and right page corners, to indicate current turnage state void pfBookData::UpdatePageCorners(WhichSide which) { // make sure there is a book to update! if (fCurrBook) { if (!fCurrBook->fAllowTurning || !fCurrBook->fAreWeShowing) { fLeftCorner->SetVisible(false); fLeftCorner->SetEnabled(false); fRightCorner->SetVisible(false); fRightCorner->SetEnabled(false); return; } if((which == kLeftSide)||(which == kBothSides)) { if (fCurrBook->fAreEditing) fLeftCorner->SetVisible(!fLeftEditCtrl->ShowingBeginningOfBuffer()); // only show if the control is not viewing the beginning of the buffer else fLeftCorner->SetVisible((fCurrBook->fCurrentPage >= 2) ? true : false); // Note: always disabled (we just go on the page click itself) fLeftCorner->SetEnabled(false); } if((which == kRightSide)||(which == kBothSides)) { if (fCurrBook->fAreEditing) fRightCorner->SetVisible(!fRightEditCtrl->ShowingEndOfBuffer()); // only show if the control is not viewing the end of the buffer else fRightCorner->SetVisible((fCurrBook->fCurrentPage + 2 <= fCurrBook->fLastPage) ? true : false); fRightCorner->SetEnabled(false); } } } //// SetCurrSize //////////////////////////////////////////////////////////// // Seeks the width and height animations to set the desired book size. Sizes are in % across the animation void pfBookData::SetCurrSize(hsScalar w, hsScalar h) { fWidthCtrl->SetCurrValue(w); fHeightCtrl->SetCurrValue(h); } //// PlayBookCloseAnim ////////////////////////////////////////////////////// // Triggers our animation for closing or opening the book. void pfBookData::PlayBookCloseAnim(hsBool closeIt /*= true*/, hsBool immediate /*= false*/) { // Disable the book cover button if we're opening, enable otherwise fCoverButton->SetEnabled(closeIt); // Tell our cover button to check or uncheck fCoverButton->SetChecked(!closeIt, immediate); // Trigger the open (or close) sound if(!immediate) fCoverButton->PlaySound(closeIt ? pfGUICheckBoxCtrl::kMouseUp : pfGUICheckBoxCtrl::kMouseDown); fCurrentlyOpen = !closeIt; } //// Event routines from a linked multi-line edit control //////////////////// void pfBookData::HitEndOfControlList(Int32 cursorPos) { fAdjustCursorTo = cursorPos; if (fCurrBook) fCurrBook->NextPage(); } void pfBookData::HitBeginningOfControlList(Int32 cursorPos) { fAdjustCursorTo = cursorPos; if (fCurrBook) fCurrBook->PreviousPage(); } void pfBookData::EnableEditGUI(hsBool enable/* =true */) { if (fEditable) { fLeftEditCtrl->SetEnabled(enable); fLeftEditCtrl->SetVisible(enable); fRightEditCtrl->SetEnabled(enable); fRightEditCtrl->SetVisible(enable); // we don't make these editable because they are temps used for the turning page fTurnFrontEditCtrl->SetVisible(false); // we don't want these visible initially either fTurnBackEditCtrl->SetVisible(false); } } //// Our Singleton Stuff ///////////////////////////////////////////////////// //pfJournalBook *pfJournalBook::fInstance = nil; std::map pfJournalBook::fBookGUIs; void pfJournalBook::SingletonInit( void ) { fBookGUIs["BkBook"] = TRACKED_NEW pfBookData(); // load the default book data object hsgResMgr::ResMgr()->NewKey("BkBook",fBookGUIs["BkBook"],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation()); fBookGUIs["BkBook"]->LoadGUI(); } void pfJournalBook::SingletonShutdown( void ) { std::map::iterator i = fBookGUIs.begin(); while (i != fBookGUIs.end()) { pfBookData *bookData = i->second; bookData->GetKey()->UnRefObject(); i->second = nil; i++; } fBookGUIs.clear(); } void pfJournalBook::LoadGUI( const char *guiName ) { if (fBookGUIs.find(guiName) == fBookGUIs.end()) // is it already loaded? { // nope, load it fBookGUIs[guiName] = TRACKED_NEW pfBookData(guiName); hsgResMgr::ResMgr()->NewKey(guiName,fBookGUIs[guiName],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation()); fBookGUIs[guiName]->LoadGUI(); } } void pfJournalBook::UnloadGUI( const char *guiName ) { if (strcmp(guiName,"BkBook")==0) return; // do not allow people to unload the default book gui std::map::iterator loc = fBookGUIs.find(guiName); if (loc != fBookGUIs.end()) // make sure it's loaded { fBookGUIs[guiName]->GetKey()->UnRefObject(); fBookGUIs[guiName] = nil; fBookGUIs.erase(loc); } } void pfJournalBook::UnloadAllGUIs() { std::map::iterator i = fBookGUIs.begin(); std::vector names; while (i != fBookGUIs.end()) { std::string name = i->first; names.push_back(name); // store a list of keys i++; } int idx; for (idx = 0; idx < names.size(); idx++) UnloadGUI(names[idx].c_str()); // UnloadGUI won't unload BkBook } //// Constructor ///////////////////////////////////////////////////////////// // The constructor takes in the esHTML source for the journal, along with // the name of the mipmap to use as the cover of the book. The callback // key is the keyed object to send event messages to (see tag). pfJournalBook::pfJournalBook( const char *esHTMLSource, plKey coverImageKey, plKey callbackKey /*= nil*/, const plLocation &hintLoc /* = plLocation::kGlobalFixedLoc */, const char *guiName /* = nil */ ) { if (guiName && (strcmp(guiName,"") != 0)) fCurBookGUI = guiName; else fCurBookGUI = "BkBook"; if (fBookGUIs.find(fCurBookGUI) == fBookGUIs.end()) { fBookGUIs[fCurBookGUI] = TRACKED_NEW pfBookData(fCurBookGUI.c_str()); hsgResMgr::ResMgr()->NewKey(fCurBookGUI.c_str(),fBookGUIs[fCurBookGUI],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation()); fBookGUIs[fCurBookGUI]->LoadGUI(); } fCurrentPage = 0; fLastPage = -1; fCoverMipKey = coverImageKey; fCoverFromHTML = false; fCallbackKey = callbackKey; fWidthScale = fHeightScale = 0.f; fPageTMargin = fPageLMargin = fPageBMargin = fPageRMargin = 16; fAllowTurning = true; fAreWeShowing = false; fCoverTint.Set( 0.f, 0.f, 0.f, 1.f ); fTintFirst = true; fTintCover = false; fAreEditing = false; fWantEditing = false; fDefLoc = hintLoc; wchar_t *wESHTMLSource = hsStringToWString(esHTMLSource); fUncompiledSource = wESHTMLSource; ICompileSource( wESHTMLSource, hintLoc ); delete [] wESHTMLSource; } pfJournalBook::pfJournalBook( const wchar_t *esHTMLSource, plKey coverImageKey, plKey callbackKey /*= nil*/, const plLocation &hintLoc /* = plLocation::kGlobalFixedLoc */, const char *guiName /* = nil */ ) { if (guiName && (strcmp(guiName,"") != 0)) fCurBookGUI = guiName; else fCurBookGUI = "BkBook"; if (fBookGUIs.find(fCurBookGUI) == fBookGUIs.end()) { fBookGUIs[fCurBookGUI] = TRACKED_NEW pfBookData(fCurBookGUI.c_str()); hsgResMgr::ResMgr()->NewKey(fCurBookGUI.c_str(),fBookGUIs[fCurBookGUI],pfGameGUIMgr::GetInstance()->GetKey()->GetUoid().GetLocation()); fBookGUIs[fCurBookGUI]->LoadGUI(); } fCurrentPage = 0; fLastPage = -1; fCoverMipKey = coverImageKey; fCoverFromHTML = false; fCallbackKey = callbackKey; fWidthScale = fHeightScale = 0.f; fPageTMargin = fPageLMargin = fPageBMargin = fPageRMargin = 16; fAllowTurning = true; fAreWeShowing = false; fCoverTint.Set( 1.f, 1.f, 1.f, 1.f ); fTintFirst = true; fTintCover = false; fAreEditing = false; fWantEditing = false; fDefLoc = hintLoc; fUncompiledSource = esHTMLSource; ICompileSource( esHTMLSource, hintLoc ); } pfJournalBook::~pfJournalBook() { if (fBookGUIs.find(fCurBookGUI) != fBookGUIs.end()) // it might have been deleted before we got here if( fBookGUIs[fCurBookGUI] && fBookGUIs[fCurBookGUI]->CurBook() == this ) Hide(); IFreeSource(); } //// MsgReceive ////////////////////////////////////////////////////////////// hsBool pfJournalBook::MsgReceive( plMessage *pMsg ) { return hsKeyedObject::MsgReceive( pMsg ); } void pfJournalBook::SetGUI( const char *guiName ) { if (guiName && (strcmp(guiName,"") != 0)) fCurBookGUI = guiName; if (fBookGUIs.find(fCurBookGUI) == fBookGUIs.end()) fCurBookGUI = "BkBook"; // requested GUI isn't loaded, so use default GUI SetEditable(fWantEditing); // make sure that if we want editing, to set it ICompileSource(fUncompiledSource.c_str(), fDefLoc); // recompile the source to be safe } //// Show //////////////////////////////////////////////////////////////////// // Shows the book, optionally starting open or closed void pfJournalBook::Show( hsBool startOpened /*= false */) { fBookGUIs[fCurBookGUI]->StartedOpen(startOpened); fBookGUIs[fCurBookGUI]->CurBook(this); fBookGUIs[fCurBookGUI]->SetCurrSize(fWidthScale, fHeightScale); ILoadAllImages( false ); hsGMaterial *cover = fBookGUIs[fCurBookGUI]->CoverMaterial(); if( cover != nil ) { hsTArray layers; plMipmap *mip = fCoverMipKey ? plMipmap::ConvertNoRef( fCoverMipKey->ObjectIsLoaded() ) : nil; if( mip != nil ) { layers.Append(IMakeBaseLayer(mip)); int i; for (i=0; ifType == pfEsHTMLChunk::kDecal) { plMipmap *decal = plMipmap::ConvertNoRef( fCoverDecals[i]->fImageKey != nil ? fCoverDecals[i]->fImageKey->ObjectIsLoaded() : nil ); if (decal != nil) layers.Append(IMakeDecalLayer(fCoverDecals[i],decal,mip)); } else { // it's a cover movie, not a decal, so we make a layer, thinking it's at 0,0 and a left map (which gives us the results we want) plLayerBink *movieLayer = IMakeMovieLayer(fCoverDecals[i],0,0,mip,pfJournalDlgProc::kTagLeftDTMap,false); loadedMovie *movie = TRACKED_NEW loadedMovie; movie->movieLayer = movieLayer; movie->movieChunk = fCoverDecals[i]; fLoadedMovies.Append(movie); layers.Append(plLayerInterface::ConvertNoRef(movieLayer)); fVisibleLinks.Reset(); // remove any links that the make movie layer might have added, since a cover movie can't link } } ISetDecalLayers(cover,layers); } else { layers.Append(IMakeBaseLayer(fBookGUIs[fCurBookGUI]->DefaultCover())); ISetDecalLayers(cover,layers); } // release our ref on the cover layers since the material will take care of them now int i; for (i=0; iRelease(layers[i]->GetKey()); } // fInstance->IPlayBookCloseAnim( !startOpened, true ); fBookGUIs[fCurBookGUI]->TurnPageButton()->SetVisible( false ); ITriggerCloseWithNotify( !startOpened, true ); } //// IFinishShow ///////////////////////////////////////////////////////////// // Finish showing the book, due to the animation being done seeking void pfJournalBook::IFinishShow( hsBool startOpened ) { fBookGUIs[fCurBookGUI]->Dialog()->Show(); fAreWeShowing = true; if( startOpened ) { // Render initial pages fCurrentPage = 0; fVisibleLinks.Reset(); IRenderPage( 0, pfJournalDlgProc::kTagLeftDTMap ); IRenderPage( 1, pfJournalDlgProc::kTagRightDTMap ); fBookGUIs[fCurBookGUI]->UpdatePageCorners( pfBookData::kBothSides ); } ISendNotify( kNotifyShow ); } //// Hide //////////////////////////////////////////////////////////////////// void pfJournalBook::Hide( void ) { if (fBookGUIs[fCurBookGUI]) { // we can only hide our own dialog if (fBookGUIs[fCurBookGUI]->CurBook() == this ) { if (fBookGUIs[fCurBookGUI]->Dialog()) fBookGUIs[fCurBookGUI]->Dialog()->Hide(); fBookGUIs[fCurBookGUI]->CurBook(nil); ISendNotify( kNotifyHide ); ILoadAllImages( true ); // purge the dynaTextMaps, we're done with them for now IPurgeDynaTextMaps(); // nuke the movies so they don't stay in memory (they're big!) int i; for( i = 0; i < fLoadedMovies.GetCount(); i++ ) { plLayerBink *movie = fLoadedMovies[ i ]->movieLayer; movie->GetKey()->UnRefObject(); delete fLoadedMovies[ i ]; } fLoadedMovies.Reset(); } } } //// Open //////////////////////////////////////////////////////////////////// // Opens the book, optionally to the given page void pfJournalBook::Open( UInt32 startingPage /*= 0 */) { if( !fBookGUIs[fCurBookGUI]->CurrentlyOpen() ) { fBookGUIs[fCurBookGUI]->PlayBookCloseAnim( false ); // Render initial pages fCurrentPage = startingPage; fVisibleLinks.Reset(); IRenderPage( startingPage, pfJournalDlgProc::kTagLeftDTMap ); IRenderPage( startingPage + 1, pfJournalDlgProc::kTagRightDTMap ); fBookGUIs[fCurBookGUI]->UpdatePageCorners( pfBookData::kBothSides ); } } //// Close /////////////////////////////////////////////////////////////////// // Closes the book. void pfJournalBook::Close( void ) { // don't allow them to close the book if the book started open if( !fBookGUIs[fCurBookGUI]->StartedOpen() && fBookGUIs[fCurBookGUI]->CurrentlyOpen() ) { ISendNotify( kNotifyClose ); fBookGUIs[fCurBookGUI]->PlayBookCloseAnim( true ); } } //// CloseAndHide //////////////////////////////////////////////////////////// // Closes the book, then calls Hide() once it's done closing void pfJournalBook::CloseAndHide( void ) { // if they start with the book open, then don't allow them to close it if( !fBookGUIs[fCurBookGUI]->StartedOpen() && fBookGUIs[fCurBookGUI]->CurrentlyOpen() ) { // if we are flipping a book then kill the page flipping animation if ( fBookGUIs[fCurBookGUI]->CurrentlyTurning() ) fBookGUIs[fCurBookGUI]->KillPageFlip(); ISendNotify( kNotifyClose ); ITriggerCloseWithNotify( true, false ); // Don't hide until we get the callback! } else // Already closed, just hide Hide(); } //// ITriggerCloseWithNotify ///////////////////////////////////////////////// // Close with a notify void pfJournalBook::ITriggerCloseWithNotify( hsBool closeNotOpen, hsBool immediate ) { // Disable the book cover button if we're opening, enable otherwise fBookGUIs[fCurBookGUI]->CoverButton()->SetEnabled( closeNotOpen ); // Do the animation manually so we can get a callback fBookGUIs[fCurBookGUI]->CurrentlyOpen(!closeNotOpen); const hsTArray &keys = fBookGUIs[fCurBookGUI]->CoverButton()->GetAnimationKeys(); const char *animName = fBookGUIs[fCurBookGUI]->CoverButton()->GetAnimationName(); plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg(); if( !immediate ) { msg->SetCmd( plAnimCmdMsg::kContinue ); msg->SetCmd( closeNotOpen ? plAnimCmdMsg::kSetBackwards : plAnimCmdMsg::kSetForewards ); } else { msg->SetCmd( plAnimCmdMsg::kStop ); msg->SetCmd( closeNotOpen ? plAnimCmdMsg::kGoToBegin : plAnimCmdMsg::kGoToEnd ); } msg->SetAnimName( animName ); msg->AddReceivers( keys ); plEventCallbackMsg *eventMsg = TRACKED_NEW plEventCallbackMsg; eventMsg->AddReceiver( fBookGUIs[fCurBookGUI]->GetKey() ); eventMsg->fRepeats = 0; eventMsg->fUser = 0x08 | ( closeNotOpen ? 0x00 : 0x01 ); // So we know which this is for eventMsg->fEvent = immediate ? ( kSingleFrameEval ) : kStop; msg->SetCmd( plAnimCmdMsg::kAddCallbacks ); msg->AddCallback( eventMsg ); hsRefCnt_SafeUnRef( eventMsg ); msg->Send(); // Trigger the open (or close) sound if( !immediate ) fBookGUIs[fCurBookGUI]->CoverButton()->PlaySound(closeNotOpen ? pfGUICheckBoxCtrl::kMouseUp : pfGUICheckBoxCtrl::kMouseDown); } //// NextPage //////////////////////////////////////////////////////////////// // Advances forward one page void pfJournalBook::NextPage( void ) { if( (fBookGUIs[fCurBookGUI]->CurrentlyTurning()) || (!fAllowTurning) || (!fAreWeShowing) ) return; if ((fAreEditing)&&!(fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl)->ShowingEndOfBuffer())) // we're editing the book, so page turning is different here { fCurrentPage += 2; // we just go to the next page, an editable book has "infinite" pages anyway pfGUIMultiLineEditCtrl *right = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl); pfGUIMultiLineEditCtrl *left = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl); pfGUIMultiLineEditCtrl *turnFront = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl); pfGUIMultiLineEditCtrl *turnBack = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl); // re-link the controls with the turn page in the middle left->SetNext(turnFront); turnBack->SetNext(right); // At this point, only the left and right pages are visible, we don't want to actually update anything until the animation // starts so that nothing flashes or overdraws. fBookGUIs[fCurBookGUI]->StartTriggeredFlip( false ); fBookGUIs[fCurBookGUI]->TurnPageButton()->PlaySound( pfGUICheckBoxCtrl::kMouseUp ); ISendNotify(kNotifyNextPage); } else if( fCurrentPage + 2 <= fLastPage ) { fCurrentPage += 2; fVisibleLinks.Reset(); // Swap the right DT map into the turn page front DTMap, then render // the new current page into turn page back and currPage+1 into // the right DTMap plDynamicTextMap *turnFront = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagTurnFrontDTMap ); plDynamicTextMap *right = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagRightDTMap ); if ( turnFront->IsValid() && right->IsValid() ) { memcpy( turnFront->GetImage(), right->GetImage(), right->GetLevelSize( 0 ) ); if( turnFront->GetDeviceRef() != nil ) turnFront->GetDeviceRef()->SetDirty( true ); } // copy the videos over IMoveMovies( fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kRightPage), fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kTurnFrontPage) ); IRenderPage( fCurrentPage, pfJournalDlgProc::kTagTurnBackDTMap ); // This will fire a callback when it's done that'll let us continue the setup fBookGUIs[fCurBookGUI]->StartTriggeredFlip( false ); // Play us a sound too, if defined on our button fBookGUIs[fCurBookGUI]->TurnPageButton()->PlaySound( pfGUICheckBoxCtrl::kMouseUp ); ISendNotify( kNotifyNextPage ); } } //// PreviousPage //////////////////////////////////////////////////////////// // Same, only back void pfJournalBook::PreviousPage( void ) { if(( fBookGUIs[fCurBookGUI]->CurrentlyTurning() )||( !fAllowTurning )) return; if (fAreEditing) // we're editing the book, so page turning is different here { if (!(fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl)->ShowingBeginningOfBuffer())) // make sure we don't flip past the beginning { if (fCurrentPage >= 2) // this variable can get out of whack if we open the book to a page in the middle fCurrentPage -= 2; // just making sure that this doesn't go below zero (and therefore wrap around) pfGUIMultiLineEditCtrl *right = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl); pfGUIMultiLineEditCtrl *left = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl); pfGUIMultiLineEditCtrl *turnFront = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl); pfGUIMultiLineEditCtrl *turnBack = fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl); // adjust the starting position of the left control to the new start Int32 newStartLine = left->GetFirstVisibleLine() - ((left->GetNumVisibleLines()-1)*2); left->SetGlobalStartLine(newStartLine); // re-link the controls with the turn page in the middle left->SetNext(turnFront); turnBack->SetNext(right); // At this point, only the left and right pages are visible, we don't want to actually update anything until the animation // starts so that nothing flashes or overdraws. fBookGUIs[fCurBookGUI]->StartTriggeredFlip( true ); fBookGUIs[fCurBookGUI]->TurnPageButton()->PlaySound( pfGUICheckBoxCtrl::kMouseUp ); ISendNotify(kNotifyPreviousPage); } else { Close(); } } else if( fCurrentPage > 1 ) { fCurrentPage -= 2; fVisibleLinks.Reset(); // Swap the left DT map into the turn page back DTMap, then render // the new current page into the left and currPage+1 into // the turn page front DTMap plDynamicTextMap *turnBack = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagTurnBackDTMap ); plDynamicTextMap *left = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagLeftDTMap ); if ( turnBack->IsValid() && left->IsValid() ) { memcpy( turnBack->GetImage(), left->GetImage(), left->GetLevelSize( 0 ) ); if( turnBack->GetDeviceRef() != nil ) turnBack->GetDeviceRef()->SetDirty( true ); } // copy the videos over IMoveMovies( fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kLeftPage), fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kTurnBackPage) ); IRenderPage( fCurrentPage + 1, pfJournalDlgProc::kTagTurnFrontDTMap ); // This will fire a callback when it's done that'll let us continue the setup fBookGUIs[fCurBookGUI]->StartTriggeredFlip( true ); // Play us a sound too, if defined on our button fBookGUIs[fCurBookGUI]->TurnPageButton()->PlaySound( pfGUICheckBoxCtrl::kMouseUp ); ISendNotify( kNotifyPreviousPage ); } else { Close(); } } //// IFindCurrVisibleLink //////////////////////////////////////////////////// // Find the current moused link, if any Int32 pfJournalBook::IFindCurrVisibleLink( hsBool rightNotLeft, hsBool hoverNotUp ) { pfGUIClickMapCtrl *ctrl = ( rightNotLeft ) ? fBookGUIs[fCurBookGUI]->RightPageMap() : fBookGUIs[fCurBookGUI]->LeftPageMap(); hsPoint3 pt = hoverNotUp ? ctrl->GetLastMousePt() : ctrl->GetLastMouseUpPt(); // This should be 0-1 in the context of the control, so scale to our DTMap size plDynamicTextMap *dtMap = fBookGUIs[fCurBookGUI]->GetDTMap( rightNotLeft ? pfJournalDlgProc::kTagRightDTMap : pfJournalDlgProc::kTagLeftDTMap ); pt.fX *= (hsScalar)dtMap->GetWidth(); pt.fY *= (hsScalar)dtMap->GetHeight(); if( rightNotLeft ) { // Clicks on the right side are offsetted in x by the left side's width dtMap = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagLeftDTMap ); pt.fX += dtMap->GetWidth(); } // Search through the list of visible hotspots UInt32 i; for( i = 0; i < fVisibleLinks.GetCount(); i++ ) { if( fVisibleLinks[ i ]->fLinkRect.Contains( (Int16)pt.fX, (Int16)pt.fY ) ) { // Found a visible link return (Int32)i; } } return -1; } //// IHandleLeftSideClick //////////////////////////////////////////////////// void pfJournalBook::IHandleLeftSideClick( void ) { if( fBookGUIs[fCurBookGUI]->CurrentlyTurning() ) return; Int32 idx = IFindCurrVisibleLink( false, false ); if( idx != -1 ) { if( fVisibleLinks[ idx ]->fFlags & pfEsHTMLChunk::kActAsCB ) IHandleCheckClick( idx, pfBookData::kLeftSide ); else ISendNotify( kNotifyImageLink, fVisibleLinks[ idx ]->fEventID ); return; } // No link found that we're inside of, so just do the default behavior of turning the page PreviousPage(); } void pfJournalBook::IHandleRightSideClick( void ) { if( fBookGUIs[fCurBookGUI]->CurrentlyTurning() ) return; Int32 idx = IFindCurrVisibleLink( true, false ); if( idx != -1 ) { if( fVisibleLinks[ idx ]->fFlags & pfEsHTMLChunk::kActAsCB ) IHandleCheckClick( idx, pfBookData::kRightSide ); else ISendNotify( kNotifyImageLink, fVisibleLinks[ idx ]->fEventID ); return; } // No link found that we're inside of, so just do the default behavior of turning the page NextPage(); } //// IHandleCheckClick /////////////////////////////////////////////////////// // Process a click on the given "check box" image void pfJournalBook::IHandleCheckClick( UInt32 idx, pfBookData::WhichSide which ) { // Special processing for checkboxes--toggle our state, switch our opacity // and then send a notify about our new state hsBool check = ( fVisibleLinks[ idx ]->fFlags & pfEsHTMLChunk::kChecked ) ? false : true; if( check ) { fVisibleLinks[ idx ]->fFlags |= pfEsHTMLChunk::kChecked; // fVisibleLinks[ idx ]->fCurrOpacity = fVisibleLinks[ idx ]->fMaxOpacity; } else { fVisibleLinks[ idx ]->fFlags &= ~pfEsHTMLChunk::kChecked; // fVisibleLinks[ idx ]->fCurrOpacity = fVisibleLinks[ idx ]->fMinOpacity; } // Re-render the page we're on, to show the change in state IRenderPage( fCurrentPage + ( ( which == pfBookData::kLeftSide ) ? 0 : 1 ), ( which == pfBookData::kLeftSide ) ? pfJournalDlgProc::kTagLeftDTMap: pfJournalDlgProc::kTagRightDTMap ); ISendNotify( check ? kNotifyImageLink : kNotifyCheckUnchecked, fVisibleLinks[ idx ]->fEventID ); // Register for FX processing, so we can fade the checkbox in fBookGUIs[fCurBookGUI]->RegisterForSFX( (pfBookData::WhichSide)( fBookGUIs[fCurBookGUI]->CurSFXPages() | which ) ); } //// GoToPage //////////////////////////////////////////////////////////////// // For completeness... void pfJournalBook::GoToPage( UInt32 pageNumber ) { // Put us here, but only on an even page (odd pages go on the right, y'know) // (no need for a range check, going past the end simply puts you on a blank page, able to go backward but not forward) fCurrentPage = pageNumber & ~0x00000001; fVisibleLinks.Reset(); IRenderPage( fCurrentPage, pfJournalDlgProc::kTagLeftDTMap ); IRenderPage( fCurrentPage + 1, pfJournalDlgProc::kTagRightDTMap ); fBookGUIs[fCurBookGUI]->UpdatePageCorners( pfBookData::kBothSides ); } //// SetEditable ///////////////////////////////////////////////////////////// void pfJournalBook::SetEditable(hsBool editable) { if (fBookGUIs[fCurBookGUI]->IsEditable()) // make sure this GUI supports editing { fBookGUIs[fCurBookGUI]->EnableEditGUI(editable); fAreEditing = editable; // we may be editing the book, so change rendering/page flipping methods if (editable) fLastPage = 0; // setting this to 0 since editable books don't know what the last page is (it always changes) } else fWantEditing = editable; // we want to edit, but the gui doesn't support it, check again if the GUI changes }; //// ForceCacheCalculations ////////////////////////////////////////////////// // Just forces a full calc of the cached info void pfJournalBook::ForceCacheCalculations( void ) { // Make sure our page starts are up-to-snuff, at least to this point IRecalcPageStarts( -1 ); } // Tiny helper to convert hex values the *right* way static UInt32 IConvertHex( const wchar_t *str ) { UInt32 value = 0; while( *str != 0 ) { value <<= 4; switch( *str ) { case L'0': value |= 0x0; break; case L'1': value |= 0x1; break; case L'2': value |= 0x2; break; case L'3': value |= 0x3; break; case L'4': value |= 0x4; break; case L'5': value |= 0x5; break; case L'6': value |= 0x6; break; case L'7': value |= 0x7; break; case L'8': value |= 0x8; break; case L'9': value |= 0x9; break; case L'a': case L'A': value |= 0xa; break; case L'b': case L'B': value |= 0xb; break; case L'c': case L'C': value |= 0xc; break; case L'd': case L'D': value |= 0xd; break; case L'e': case L'E': value |= 0xe; break; case L'f': case L'F': value |= 0xf; break; } str++; } return value; } //// ICompileSource ////////////////////////////////////////////////////////// // Compiles the given string of esHTML source into our compiled chunk list hsBool pfJournalBook::ICompileSource( const wchar_t *source, const plLocation &hintLoc ) { IFreeSource(); pfEsHTMLChunk *chunk, *lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); const wchar_t *c, *start; wchar_t name[ 128 ], option[ 256 ]; float bookWidth=1.0, bookHeight=1.0; UInt8 movieIndex = 0; // the index of a movie in the source (used for id purposes) plKey anotherKey; // Parse our source! for( start = c = source; *c != 0; ) { // Are we on a tag? UInt8 type = IGetTagType( c ); if( type != pfEsHTMLChunk::kEmpty ) { // First, end the current paragraph chunk, which is a special case 'cause its // text is defined outside the tag if( start == c ) { // No actual text, just delete delete lastParChunk; lastParChunk = nil; } else if( lastParChunk != nil ) { UInt32 count = ((UInt32)c - (UInt32)start)/2; // wchar_t is 2 bytes wchar_t *temp = TRACKED_NEW wchar_t[ count + 1 ]; wcsncpy( temp, start, count ); temp[count] = L'\0'; lastParChunk->fText = temp; delete [] temp; // Special case to remove any last trailing carriage return // if( count > 1 && lastParChunk->fText[ count - 1 ] == '\n' ) // lastParChunk->fText[ count - 1 ] = 0; fHTMLSource.Append( lastParChunk ); } // What chunk are we making now? switch( type ) { case pfEsHTMLChunk::kParagraph: c += 2; chunk = TRACKED_NEW pfEsHTMLChunk( nil ); chunk->fFlags = IFindLastAlignment(); while( IGetNextOption( c, name, option ) ) { if( wcsicmp( name, L"align" ) == 0 ) { if( wcsicmp( option, L"left" ) == 0 ) chunk->fFlags = pfEsHTMLChunk::kLeft; else if( wcsicmp( option, L"center" ) == 0 ) chunk->fFlags = pfEsHTMLChunk::kCenter; else if( wcsicmp( option, L"right" ) == 0 ) chunk->fFlags = pfEsHTMLChunk::kRight; } } // Append text to this one (don't add to source just yet) lastParChunk = chunk; break; case pfEsHTMLChunk::kImage: c += 4; chunk = TRACKED_NEW pfEsHTMLChunk( nil, 0 ); while( IGetNextOption( c, name, option ) ) { if( wcsicmp( name, L"align" ) == 0 ) { chunk->fFlags &= ~pfEsHTMLChunk::kAlignMask; if( wcsicmp( option, L"left" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kLeft; else if( wcsicmp( option, L"center" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kCenter; else if( wcsicmp( option, L"right" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kRight; } else if( wcsicmp( name, L"src" ) == 0 ) { // Name of mipmap source chunk->fImageKey = IGetMipmapKey( option, hintLoc ); } else if( wcsicmp( name, L"link" ) == 0 ) { chunk->fEventID = _wtoi( option ); chunk->fFlags |= pfEsHTMLChunk::kCanLink; } else if( wcsicmp( name, L"blend" ) == 0 ) { if( wcsicmp( option, L"alpha" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kBlendAlpha; } else if( wcsicmp( name, L"pos" ) == 0 ) { chunk->fFlags |= pfEsHTMLChunk::kFloating; wchar_t *comma = wcschr( option, L',' ); if( comma != nil ) { chunk->fAbsoluteY = _wtoi( comma + 1 ); *comma = 0; } chunk->fAbsoluteX = _wtoi( option ); } else if( wcsicmp( name, L"glow" ) == 0 ) { chunk->fFlags |= pfEsHTMLChunk::kGlowing; chunk->fFlags &= ~pfEsHTMLChunk::kActAsCB; char *cOption = hsWStringToString(option); char *comma = strchr( cOption, ',' ); if( comma != nil ) { char *comma2 = strchr( comma + 1, ',' ); if( comma2 != nil ) { chunk->fMaxOpacity = (hsScalar)atof( comma2 + 1 ); *comma2 = 0; } chunk->fMinOpacity = (hsScalar)atof( comma + 1 ); *comma = 0; } chunk->fSFXTime = (hsScalar)atof( cOption ); delete [] cOption; } else if( wcsicmp( name, L"opacity" ) == 0 ) { chunk->fFlags |= pfEsHTMLChunk::kTranslucent; char *cOption = hsWStringToString(option); chunk->fCurrOpacity = (hsScalar)atof( cOption ); delete [] cOption; } else if( wcsicmp( name, L"check" ) == 0 ) { chunk->fFlags |= pfEsHTMLChunk::kActAsCB; chunk->fFlags &= ~pfEsHTMLChunk::kGlowing; wchar_t *comma = wcschr( option, L',' ); if( comma != nil ) { wchar_t *comma2 = wcschr( comma + 1, L',' ); if( comma2 != nil ) { if( _wtoi( comma2 + 1 ) != 0 ) chunk->fFlags |= pfEsHTMLChunk::kChecked; *comma2 = 0; } UInt32 c = IConvertHex( comma + 1 ); if( wcslen( comma + 1 ) <= 6 ) c |= 0xff000000; // Add in full alpha if none specified chunk->fOffColor.FromARGB32( c ); *comma = 0; } UInt32 c = IConvertHex( option ); if( wcslen( option ) <= 6 ) c |= 0xff000000; // Add in full alpha if none specified chunk->fOnColor.FromARGB32( c ); if( chunk->fFlags & pfEsHTMLChunk::kChecked ) chunk->fCurrColor = chunk->fOnColor; else chunk->fCurrColor = chunk->fOffColor; } else if (wcsicmp(name,L"resize")==0) { if (wcsicmp(option,L"no")==0) chunk->fNoResizeImg = true; } } if( chunk->fImageKey != nil ) fHTMLSource.Append( chunk ); else delete chunk; // Start new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kCover: // Don't create an actual chunk for this one, just use the "src" and // grab the mipmap key for our cover c += 6; while( IGetNextOption( c, name, option ) ) { if( wcsicmp( name, L"src" ) == 0 ) { // Name of mipmap source anotherKey = IGetMipmapKey( option, hintLoc ); if( anotherKey != nil ) { fCoverMipKey = anotherKey; fCoverFromHTML = true; } } if( wcsicmp( name, L"tint" ) == 0 ) { fTintCover = true; fCoverTint.FromARGB32( wcstol( option, nil, 16 ) | 0xff000000 ); } if( wcsicmp( name, L"tintfirst" ) == 0 ) { if (wcsicmp(option,L"no")==0) fTintFirst = false; } } // Still gotta create a new par chunk lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kPageBreak: c += 3; chunk = TRACKED_NEW pfEsHTMLChunk(); while( IGetNextOption( c, name, option ) ) { } fHTMLSource.Append( chunk ); // Start new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kFontChange: c += 5; chunk = TRACKED_NEW pfEsHTMLChunk( nil, 0, 0 ); while( IGetNextOption( c, name, option ) ) { if( wcsicmp( name, L"style" ) == 0 ) { UInt8 guiFlags = 0; if( wcsicmp( option, L"b" ) == 0 ) { chunk->fFlags = pfEsHTMLChunk::kFontBold; guiFlags = plDynamicTextMap::kFontBold; } else if( wcsicmp( option, L"i" ) == 0 ) { chunk->fFlags = pfEsHTMLChunk::kFontItalic; guiFlags = plDynamicTextMap::kFontItalic; } else if( wcsicmp( option, L"bi" ) == 0 ) { chunk->fFlags = pfEsHTMLChunk::kFontBold | pfEsHTMLChunk::kFontItalic; guiFlags = plDynamicTextMap::kFontBold | plDynamicTextMap::kFontItalic; } else chunk->fFlags = pfEsHTMLChunk::kFontRegular; if (fBookGUIs[fCurBookGUI]->IsEditable()) { fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl)->SetFontStyle(guiFlags); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl)->SetFontStyle(guiFlags); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl)->SetFontStyle(guiFlags); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl)->SetFontStyle(guiFlags); } } else if( wcsicmp( name, L"face" ) == 0 ) { // Name of mipmap source chunk->fText = option; if (fBookGUIs[fCurBookGUI]->IsEditable()) { char *fontFace = hsWStringToString(option); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl)->SetFontFace(fontFace); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl)->SetFontFace(fontFace); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl)->SetFontFace(fontFace); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl)->SetFontFace(fontFace); delete [] fontFace; } } else if( wcsicmp( name, L"size" ) == 0 ) { chunk->fFontSize = _wtoi( option ); if (fBookGUIs[fCurBookGUI]->IsEditable()) { fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl)->SetFontSize(chunk->fFontSize); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl)->SetFontSize(chunk->fFontSize); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl)->SetFontSize(chunk->fFontSize); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl)->SetFontSize(chunk->fFontSize); } } else if( wcsicmp( name, L"color" ) == 0 ) { chunk->fColor.FromARGB32( wcstol( option, nil, 16 ) | 0xff000000 ); chunk->fFlags |= pfEsHTMLChunk::kFontColor; if (fBookGUIs[fCurBookGUI]->IsEditable()) { fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl)->SetFontColor(chunk->fColor); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl)->SetFontColor(chunk->fColor); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl)->SetFontColor(chunk->fColor); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl)->SetFontColor(chunk->fColor); } } else if( wcsicmp( name, L"spacing" ) == 0 ) { chunk->fLineSpacing = _wtoi(option); chunk->fFlags |= pfEsHTMLChunk::kFontSpacing; } } fHTMLSource.Append( chunk ); // Start new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kMargin: c += 7; while(IGetNextOption(c,name,option)) { if (wcsicmp(name,L"top") == 0) fPageTMargin = _wtoi(option); else if (wcsicmp(name,L"left") == 0) fPageLMargin = _wtoi(option); else if (wcsicmp(name,L"bottom") == 0) fPageBMargin = _wtoi(option); else if (wcsicmp(name,L"right") == 0) fPageRMargin = _wtoi(option); } // set the edit controls to the margins we just set if (fBookGUIs[fCurBookGUI]->IsEditable()) { fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagRightEditCtrl)->SetMargins(fPageTMargin,fPageLMargin,fPageBMargin,fPageRMargin); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagLeftEditCtrl)->SetMargins(fPageTMargin,fPageLMargin,fPageBMargin,fPageRMargin); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnFrontEditCtrl)->SetMargins(fPageTMargin,fPageLMargin,fPageBMargin,fPageRMargin); fBookGUIs[fCurBookGUI]->GetEditCtrl(pfJournalDlgProc::kTagTurnBackEditCtrl)->SetMargins(fPageTMargin,fPageLMargin,fPageBMargin,fPageRMargin); } // Start a new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk(nil); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kBook: c += 5; // don't actually create a chunk, just set the book size while (IGetNextOption(c,name,option)) { if (wcsicmp(name,L"height") == 0) { char *temp = hsWStringToString(option); bookHeight = (float)atof(temp); delete [] temp; } else if (wcsicmp(name,L"width") == 0) { char *temp = hsWStringToString(option); bookWidth = (float)atof(temp); delete [] temp; } } fHeightScale = 1.f - bookHeight; fWidthScale = 1.f - bookWidth; // Still gotta create a new par chunk lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kDecal: c += 6; chunk = TRACKED_NEW pfEsHTMLChunk( nil, 0 ); chunk->fType = pfEsHTMLChunk::kDecal; while( IGetNextOption( c, name, option ) ) { if( wcsicmp( name, L"align" ) == 0 ) { chunk->fFlags &= ~pfEsHTMLChunk::kAlignMask; if( wcsicmp( option, L"left" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kLeft; else if( wcsicmp( option, L"center" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kCenter; else if( wcsicmp( option, L"right" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kRight; } else if( wcsicmp( name, L"src" ) == 0 ) { // Name of mipmap source chunk->fImageKey = IGetMipmapKey( option, hintLoc ); } else if( wcsicmp( name, L"pos" ) == 0 ) { chunk->fFlags |= pfEsHTMLChunk::kFloating; wchar_t *comma = wcschr( option, L',' ); if( comma != nil ) { chunk->fAbsoluteY = _wtoi( comma + 1 ); *comma = 0; } chunk->fAbsoluteX = _wtoi( option ); } else if (wcsicmp(name,L"resize")==0) { if (wcsicmp(option,L"no")==0) chunk->fNoResizeImg = true; } else if (wcsicmp(name,L"tint")==0) { if (wcsicmp(option,L"yes")==0) chunk->fTintDecal = true; } } // add it to our cover decals list (this is tag is essentially thrown away as far as the parser cares) if( chunk->fImageKey != nil ) fCoverDecals.Append( chunk ); else delete chunk; // Start new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kMovie: c += 6; chunk = TRACKED_NEW pfEsHTMLChunk( nil, 0 ); chunk->fType = pfEsHTMLChunk::kMovie; while( IGetNextOption( c, name, option ) ) { if( wcsicmp( name, L"align" ) == 0 ) { chunk->fFlags &= ~pfEsHTMLChunk::kAlignMask; if( wcsicmp( option, L"left" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kLeft; else if( wcsicmp( option, L"center" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kCenter; else if( wcsicmp( option, L"right" ) == 0 ) chunk->fFlags |= pfEsHTMLChunk::kRight; } else if( wcsicmp( name, L"src" ) == 0 ) { chunk->fText = option; } else if( wcsicmp( name, L"link" ) == 0 ) { chunk->fEventID = _wtoi( option ); chunk->fFlags |= pfEsHTMLChunk::kCanLink; } else if( wcsicmp( name, L"pos" ) == 0 ) { chunk->fFlags |= pfEsHTMLChunk::kFloating; wchar_t *comma = wcschr( option, L',' ); if( comma != nil ) { chunk->fAbsoluteY = _wtoi( comma + 1 ); *comma = 0; } chunk->fAbsoluteX = _wtoi( option ); } else if (wcsicmp(name,L"resize")==0) { if (wcsicmp(option,L"no")==0) chunk->fNoResizeImg = true; } else if (wcsicmp(name,L"oncover")==0) { if (wcsicmp(option,L"yes")==0) chunk->fOnCover = true; } else if (wcsicmp(name,L"loop")==0) { if (wcsicmp(option,L"no")==0) chunk->fLoopMovie = false; } } chunk->fMovieIndex = movieIndex; movieIndex++; if (chunk->fOnCover) { if( chunk->fText != L"" ) fCoverDecals.Append( chunk ); else delete chunk; } else { if( chunk->fText != L"" ) fHTMLSource.Append( chunk ); else delete chunk; } // Start new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; case pfEsHTMLChunk::kEditable: c += 9; SetEditable(true); chunk = TRACKED_NEW pfEsHTMLChunk(); while( IGetNextOption( c, name, option ) ) { } fHTMLSource.Append( chunk ); // Start new paragraph chunk after this one lastParChunk = TRACKED_NEW pfEsHTMLChunk( nil ); lastParChunk->fFlags = IFindLastAlignment(); break; } start = c; } else { // Keep looking c++; } } // Final bit goes into the last paragraph chunk we had if( start == c ) { // No actual text, just delete delete lastParChunk; lastParChunk = nil; } else if( lastParChunk != nil ) { UInt32 count = (UInt32)c - (UInt32)start; wchar_t *temp = TRACKED_NEW wchar_t[ count + 1 ]; wcsncpy( temp, start, count + 1 ); lastParChunk->fText = temp; delete [] temp; // Special case to remove any last trailing carriage return // if( count > 1 && lastParChunk->fText[ count - 1 ] == '\n' ) // lastParChunk->fText[ count - 1 ] = 0; fHTMLSource.Append( lastParChunk ); } // Reset a few fPageStarts.Reset(); fPageStarts.Append( 0 ); if (fAreEditing) fLastPage = 0; else fLastPage = -1; return true; } UInt8 pfJournalBook::IGetTagType( const wchar_t *string ) { if( string[ 0 ] != '<' ) return pfEsHTMLChunk::kEmpty; struct TagRec { const wchar_t *fTag; UInt8 fType; } tags[] = { { L"p", pfEsHTMLChunk::kParagraph }, { L"img", pfEsHTMLChunk::kImage }, { L"pb", pfEsHTMLChunk::kPageBreak }, { L"font", pfEsHTMLChunk::kFontChange }, { L"margin", pfEsHTMLChunk::kMargin }, { L"cover", pfEsHTMLChunk::kCover }, { L"book", pfEsHTMLChunk::kBook }, { L"decal", pfEsHTMLChunk::kDecal }, { L"movie", pfEsHTMLChunk::kMovie }, { L"editable", pfEsHTMLChunk::kEditable }, { nil, pfEsHTMLChunk::kEmpty } }; UInt32 i; for( i = 0; tags[ i ].fTag != nil; i++ ) { if( wcsnicmp( string + 1, tags[ i ].fTag, wcslen( tags[ i ].fTag ) ) == 0 ) { // Found tag--but only space or end tag marker allowed afterwards char end = (char)string[ wcslen( tags[ i ].fTag ) + 1 ]; if( end == '>' || end == ' ' ) return tags[ i ].fType; } } return pfEsHTMLChunk::kEmpty; } hsBool pfJournalBook::IGetNextOption( const wchar_t *&string, wchar_t *name, wchar_t *option ) { const wchar_t *c; // Advance past any white space while( *string == L' ' ) string++; if( *string == L'>' ) { string++; return false; } // Advance to = c = string; while( *string != L'>' && *string != L' ' && *string != L'=' && *string != L'\0' ) string++; if( *string != L'=' ) return false; // Copy name UInt32 len = ((UInt32)string - (UInt32)c)/2; // divide length by 2 because each character is two bytes wcsncpy( name, c, len ); name[len] = L'\0'; // Find start of option value string++; while( *string == L' ' ) string++; if( *string == L'\0' || *string == L'>' ) return false; if( *string == L'\"' ) { // Search for other quote string++; c = string; while( *string != L'>' && *string != L'\"' && *string != L'\0' ) string++; len = ((UInt32)string - (UInt32)c)/2; // divide length by 2 because each character is two bytes wcsncpy( option, c, len ); option[len] = L'\0'; if( *string == L'\"' ) string++; return true; } // Non-quoted token c = string; while( *string != L' ' && *string != L'>' && *string != L'\0' ) string++; len = ((UInt32)string - (UInt32)c)/2; // divide length by 2 because each character is two bytes wcsncpy( option, c, len ); option[len] = L'\0'; return true; } void pfJournalBook::IFreeSource( void ) { UInt32 i; for( i = 0; i < fHTMLSource.GetCount(); i++ ) delete fHTMLSource[ i ]; fHTMLSource.Reset(); for( i = 0; i < fCoverDecals.GetCount(); i++ ) delete fCoverDecals[ i ]; fCoverDecals.Reset(); for( i = 0; i < fLoadedMovies.GetCount(); i++ ) { plLayerBink *movie = fLoadedMovies[ i ]->movieLayer; movie->GetKey()->UnRefObject(); delete fLoadedMovies[ i ]; } fLoadedMovies.Reset(); } //// IGetMipmapKey /////////////////////////////////////////////////////////// // Looks up the key for a mipmap given the image name. Note that the given // location is treated as a hint; if the image isn't found in that location, // the code will attempt to look in the currently loaded age for a matching // image name. #ifndef PLASMA_EXTERNAL_RELEASE #include "../plJPEG/plJPEG.h" #endif plKey pfJournalBook::IGetMipmapKey( const wchar_t *name, const plLocation &loc ) { char *cName = hsWStringToString(name); #ifndef PLASMA_EXTERNAL_RELEASE if( strchr( cName, '/' ) != nil || strchr( cName, '\\' ) != nil ) { // For internal use only--we allow local path names of JPEG images, to // facilitate fast prototyping plMipmap *mip = plJPEG::Instance().ReadFromFile( cName ); hsgResMgr::ResMgr()->NewKey( cName, mip, loc ); delete [] cName; return mip->GetKey(); } #endif // Try first to find in the given location plUoid myUoid( loc, plMipmap::Index(), cName ); plKey key = hsgResMgr::ResMgr()->FindKey( myUoid ); if( key != nil ) { delete [] cName; return key; } // Next, try our "global" pre-defined age const plLocation &globLoc = plKeyFinder::Instance().FindLocation( "GUI", "BkBookImages" ); myUoid = plUoid( globLoc, plMipmap::Index(), cName ); key = hsgResMgr::ResMgr()->FindKey( myUoid ); if( key != nil ) { delete [] cName; return key; } // Do a search through our current age with just the name given if( plNetClientMgr::GetInstance() != nil ) { const char *thisAge = plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeName(); if( thisAge != nil ) { key = plKeyFinder::Instance().StupidSearch( thisAge, nil, plMipmap::Index(), cName, true ); if( key != nil ) { delete [] cName; return key; } } } delete [] cName; return nil; } //// IRenderPage ///////////////////////////////////////////////////////////// // Takes the given page out of the source and renders it into the specified // DTMap (by GUI tag ID). If no page is cached after this one, also updates // the various cached info about page endings, etc. void pfJournalBook::IRenderPage( UInt32 page, UInt32 whichDTMap, hsBool suppressRendering /*= false*/ ) { if (fAreEditing) return; // we don't render if we are editing the book // Grab the DTMap via the GUI system plDynamicTextMap *dtMap = fBookGUIs[fCurBookGUI]->GetDTMap( whichDTMap ); hsAssert( dtMap != nil, "Invalid DT map in IRenderPage()" ); loadedMovie *movie = nil; bool movieAlreadyLoaded = false; // Make sure our page starts are up-to-snuff, at least to this point IRecalcPageStarts( page ); // Render! hsColorRGBA color; color.Set( 0, 0, 0, 0 ); if( !suppressRendering ) dtMap->ClearToColor( color ); hsGMaterial *material = nil; if (whichDTMap == pfJournalDlgProc::kTagLeftDTMap) material = fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kLeftPage); else if (whichDTMap == pfJournalDlgProc::kTagRightDTMap) material = fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kRightPage); else if (whichDTMap == pfJournalDlgProc::kTagTurnFrontDTMap) material = fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kTurnFrontPage); else if (whichDTMap == pfJournalDlgProc::kTagTurnBackDTMap) material = fBookGUIs[fCurBookGUI]->PageMaterial(pfBookData::kTurnBackPage); if (material) { // clear any exiting layers (movies) from the material int i; for( i = 0; i < material->GetNumLayers(); i++ ) // remove all plLayerBink layers { plLayerInterface *matLayer = material->GetLayer(i); plLayerBink *bink = plLayerBink::ConvertNoRef(matLayer); if (bink) // if it was a bink layer { plMatRefMsg* refMsg = TRACKED_NEW plMatRefMsg(material->GetKey(), plRefMsg::kOnRemove, i, plMatRefMsg::kLayer); // remove it hsgResMgr::ResMgr()->SendRef(material->GetLayer(i)->GetKey(), refMsg, plRefFlags::kActiveRef); } } } hsAssert(page < fPageStarts.GetCount() || page > fLastPage, "UnInitialized page start!"); if( page <= fLastPage && page < fPageStarts.GetCount()) // Added this as a crash-prevention bandaid - MT { UInt32 idx; UInt16 width, height, y, x, ascent, lastX, lastY; UInt8 fontFlags, fontSize; const wchar_t *fontFace; hsColorRGBA fontColor; Int16 fontSpacing; hsBool needSFX = false; // Find and set initial font properties IFindFontProps( fPageStarts[ page ], fontFace, fontSize, fontFlags, fontColor, fontSpacing ); dtMap->SetFont( fontFace, fontSize, fontFlags, false ); dtMap->SetTextColor( fontColor, true ); dtMap->SetLineSpacing(fontSpacing); for( idx = fPageStarts[ page ], x = (UInt16)fPageLMargin, y = (UInt16)fPageTMargin; y < (UInt16)(512 - fPageTMargin - fPageBMargin) && idx < fHTMLSource.GetCount(); idx++ ) { if( fPageStarts.GetCount() > page + 1 && idx == fPageStarts[ page + 1 ] ) break; // Just go ahead and break at the start of the next page, since we already found it pfEsHTMLChunk *chunk = fHTMLSource[ idx ]; switch( chunk->fType ) { case pfEsHTMLChunk::kParagraph: if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kLeft ) { dtMap->SetJustify( plDynamicTextMap::kLeftJustify ); x = (UInt16)fPageLMargin; // reset X if our justification changes } else if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kRight ) { dtMap->SetJustify( plDynamicTextMap::kRightJustify ); x = (UInt16)fPageLMargin; // reset X if our justification changes } else if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kCenter ) { dtMap->SetJustify( plDynamicTextMap::kCenter ); x = (UInt16)fPageLMargin; // reset X if our justification changes } dtMap->SetFirstLineIndent( (Int16)(x - fPageLMargin) ); width = (UInt16)(512 - fPageLMargin - fPageRMargin); height = (UInt16)(512 - fPageBMargin - y); UInt32 lastChar; dtMap->CalcWrappedStringSize( chunk->fText.c_str(), &width, &height, &lastChar, &ascent, &lastX, &lastY ); width = (UInt16)(512 - fPageLMargin - fPageRMargin); if( !suppressRendering ) dtMap->DrawWrappedString( (UInt16)fPageLMargin, y, chunk->fText.c_str(), width, (UInt16)(512 - fPageBMargin - y), &lastX, &lastY ); if( lastChar == 0 ) { // This paragraph didn't fit on this page at *all*, so just bump it to the next // one artificially (the -- is to account for the for loop; see image handling below) y += 512; if( idx > fPageStarts[ page ] ) idx--; break; } if( chunk->fText[ lastChar ] != 0 ) { // Didn't get to render the whole paragraph in this go, so we're going to cheat // and split the paragraph up into two so that we can handle it properly. Note: // this changes the chunk array beyond this point, so we need to invalidate the // cache, but that's ok 'cause if we're doing this, it's probably invalid (or empty) // anyway int fTextLen = chunk->fText.length(); wchar_t *s = TRACKED_NEW wchar_t[fTextLen+1]; wcscpy(s,chunk->fText.c_str()); s[fTextLen] = L'\0'; // Note: Makes a copy of the string pfEsHTMLChunk *c2 = TRACKED_NEW pfEsHTMLChunk( &s[ lastChar ] ); c2->fFlags = chunk->fFlags; fHTMLSource.Insert( idx + 1, c2 ); // Clip and reallocate so we don't have two copies laying around s[ lastChar ] = L'\0'; chunk->fText = s; delete [] s; // Invalidate our cache starting with the next page if( fPageStarts.GetCount() > page + 1 ) fPageStarts.SetCount( page + 1 ); y += 512; break; } x = lastX; y = (UInt16)(lastY - dtMap->GetCurrFont()->GetAscent()); // Since our text is top-justified if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) != pfEsHTMLChunk::kLeft ) { // Ending X is not guaranteed to be anything useful if we're not left justified x = (UInt16)fPageLMargin; } break; case pfEsHTMLChunk::kImage: { plMipmap *mip = plMipmap::ConvertNoRef( chunk->fImageKey != nil ? chunk->fImageKey->ObjectIsLoaded() : nil ); if( mip != nil ) { // First, determine if we need to be processing FX messages if( chunk->fFlags & pfEsHTMLChunk::kGlowing ) needSFX = true; else if( chunk->fFlags & pfEsHTMLChunk::kActAsCB ) { // If our color doesn't match our checked state, we want to be fading it in hsColorRGBA &want = ( chunk->fFlags & pfEsHTMLChunk::kChecked ) ? chunk->fOnColor : chunk->fOffColor; if( want != chunk->fCurrColor ) needSFX = true; } if( chunk->fFlags & pfEsHTMLChunk::kFloating ) { // Floating image, ignore the text flow completely and just splat the image on! IDrawMipmap( chunk, chunk->fAbsoluteX, chunk->fAbsoluteY, mip, dtMap, whichDTMap, suppressRendering ); } else { if( y + mip->GetHeight() >= 512 - fPageBMargin ) { // Mipmap overlaps the bottom of this page, so forcibly break so we'll // end up marking the page break here (note that, unlike paragraphs, we // can't really break the mipmap into two...well, OK, we could, but it // wouldn't make much sense :) y += (UInt16)(mip->GetHeight()); // Wonderful, the break breaks us from the switch(), which means the for() // loops runs once more and increments idx. So this is to counter that. // (We better check tho, just to make sure nobody feeds us an extra-large // image and sends us on an infinite loop) if( idx > fPageStarts[ page ] ) idx--; break; } if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kLeft ) x = (UInt16)fPageLMargin; else if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kRight ) x = (UInt16)(512 - fPageRMargin - mip->GetWidth()); else if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kCenter ) x = (UInt16)(256 - ( mip->GetWidth() >> 1 )); IDrawMipmap( chunk, x, y, mip, dtMap, whichDTMap, suppressRendering ); y += (UInt16)(mip->GetHeight()); x = (UInt16)fPageLMargin; } } } break; case pfEsHTMLChunk::kPageBreak: // Time for some creative guesswork. See, if the user put a in at the end of a page, // but coincidentally we already broke to a new page, then the explicit is redundant, // so we don't want it. However, if we're at a new page *because* of a , then a new // is intentional, so we DO want to process it. if( idx == fPageStarts[ page ] ) { // Did we get here b/c the last chunk was a pb? if( idx > 0 && fHTMLSource[ idx - 1 ]->fType != pfEsHTMLChunk::kPageBreak ) { // Nope, so we DO want to ignore it! continue; } } y = (UInt16)(512 - fPageTMargin - fPageBMargin); x = (UInt16)fPageLMargin; break; case pfEsHTMLChunk::kFontChange: IFindFontProps( idx, fontFace, fontSize, fontFlags, fontColor, fontSpacing ); dtMap->SetFont( fontFace, fontSize, fontFlags, false ); dtMap->SetTextColor( fontColor, true ); dtMap->SetLineSpacing(fontSpacing); break; case pfEsHTMLChunk::kMovie: movieAlreadyLoaded = (IMovieAlreadyLoaded(chunk) != nil); // have we already cached it? plLayerBink *movieLayer = IMakeMovieLayer(chunk, x, y, (plMipmap*)dtMap, whichDTMap, suppressRendering); if (movieLayer) { // adjust the starting height of the movie if we are keeping it inline with the text UInt32 movieHeight = 0, movieWidth = 0; movieHeight = movieLayer->GetHeight(); movieWidth = movieLayer->GetWidth(); if(!(chunk->fFlags & pfEsHTMLChunk::kFloating )) { if( y + movieHeight >= 512 - fPageBMargin ) { // Movie overlaps the bottom of this page, so forcibly break so we'll // end up marking the page break here (note that, unlike paragraphs, we // can't really break the Movie into two) y += (UInt16)movieHeight; // Wonderful, the break breaks us from the switch(), which means the for() // loops runs once more and increments idx. So this is to counter that. // (We better check tho, just to make sure nobody feeds us an extra-large // image and sends us on an infinite loop) if( idx > fPageStarts[ page ] ) idx--; break; } y += (UInt16)movieHeight; x = (UInt16)fPageLMargin; } if (!movieAlreadyLoaded) // if the movie wasn't already cached, cache it { movie = TRACKED_NEW loadedMovie; movie->movieLayer = movieLayer; // save the layer and chunk data movie->movieChunk = chunk; fLoadedMovies.Append(movie); movie = nil; movieAlreadyLoaded = false; } if (material && !suppressRendering) material->AddLayerViaNotify(movieLayer); } break; } } if( fPageStarts.GetCount() <= page + 1 ) fPageStarts.ExpandAndZero( page + 2 ); fPageStarts[ page + 1 ] = idx; if( idx == fHTMLSource.GetCount() ) fLastPage = page; pfBookData::WhichSide thisWhich = ( whichDTMap == pfJournalDlgProc::kTagRightDTMap ) ? pfBookData::kRightSide : ( whichDTMap == pfJournalDlgProc::kTagLeftDTMap ) ? pfBookData::kLeftSide : pfBookData::kNoSides; if( needSFX ) fBookGUIs[fCurBookGUI]->RegisterForSFX( (pfBookData::WhichSide)( fBookGUIs[fCurBookGUI]->CurSFXPages() | thisWhich ) ); else fBookGUIs[fCurBookGUI]->RegisterForSFX( (pfBookData::WhichSide)( fBookGUIs[fCurBookGUI]->CurSFXPages() & ~thisWhich ) ); } if( !suppressRendering ) dtMap->FlushToHost(); } //// IMoveMovies ///////////////////////////////////////////////////////////// void pfJournalBook::IMoveMovies( hsGMaterial *source, hsGMaterial *dest ) { hsTArray moviesOnPage; if (source && dest) { // clear any exiting layers (movies) from the material and save them to our local array int i; for( i = 0; i < source->GetNumLayers(); i++ ) // remove all plLayerBink layers { plLayerInterface *matLayer = source->GetLayer(i); plLayerBink *bink = plLayerBink::ConvertNoRef(matLayer); if (bink) // if it was a bink layer { plMatRefMsg* refMsg = TRACKED_NEW plMatRefMsg(source->GetKey(), plRefMsg::kOnRemove, i, plMatRefMsg::kLayer); // remove it hsgResMgr::ResMgr()->SendRef(source->GetLayer(i)->GetKey(), refMsg, plRefFlags::kActiveRef); moviesOnPage.Append(bink); } } // clear the destination's movies (if it has any) for( i = 0; i < dest->GetNumLayers(); i++ ) // remove all plLayerBink layers { plLayerInterface *matLayer = dest->GetLayer(i); plLayerBink *bink = plLayerBink::ConvertNoRef(matLayer); if (bink) // if it was a bink layer { plMatRefMsg* refMsg = TRACKED_NEW plMatRefMsg(dest->GetKey(), plRefMsg::kOnRemove, i, plMatRefMsg::kLayer); // remove it hsgResMgr::ResMgr()->SendRef(dest->GetLayer(i)->GetKey(), refMsg, plRefFlags::kActiveRef); } } // put the movies we ripped off the old page onto the new one for( i = 0; i < moviesOnPage.GetCount(); i++ ) { dest->AddLayerViaNotify(moviesOnPage[i]); } } } //// IDrawMipmap ///////////////////////////////////////////////////////////// void pfJournalBook::IDrawMipmap( pfEsHTMLChunk *chunk, UInt16 x, UInt16 y, plMipmap *mip, plDynamicTextMap *dtMap, UInt32 whichDTMap, hsBool dontRender ) { plMipmap *copy = TRACKED_NEW plMipmap(); copy->CopyFrom(mip); if (chunk->fNoResizeImg) { // book is NOT square, there is a h/w ratio of 1/0.7 // calc new size based on how the book has been skewed float xScale = (fWidthScale == 0) ? 1 : 1/(1-fWidthScale); float yScale = (fHeightScale == 0) ? 1 : 1/(1-fHeightScale); yScale *= 0.7; // adjust because the book isn't square UInt32 width = (UInt32)(mip->GetWidth()*xScale); UInt32 height = (UInt32)(mip->GetHeight()*yScale); UInt16 xShift; UInt16 yShift; if (dtMap->GetWidth() < width) width = dtMap->GetWidth(); if (dtMap->GetHeight() < height) height = dtMap->GetHeight(); if (height < mip->GetHeight()) { yShift = (UInt16)((mip->GetHeight()-height)/2); if (y+yShift+height > dtMap->GetHeight()) y = (UInt16)(dtMap->GetHeight()-height); else y += yShift; } else { yShift = (UInt16)((height-mip->GetHeight())/2); if (yShift > y) y = 0; else y -= yShift; } if (width < mip->GetWidth()) { xShift = (UInt16)((mip->GetWidth()-width)/2); if (x+xShift+width > dtMap->GetWidth()) x = (UInt16)(dtMap->GetWidth()-width); else x += xShift; } else { xShift = (UInt16)((width-mip->GetWidth())/2); if (xShift > x) x = 0; else x -= xShift; } copy->SetCurrLevel(0); // resize the image so it will look unchanged when rendered on the altered book copy->ResizeNicely((UInt16)width,(UInt16)height,plMipmap::kDefaultFilter); } if( !dontRender ) { plMipmap::CompositeOptions opts; if( chunk->fFlags & pfEsHTMLChunk::kActAsCB ) { opts.fFlags = ( chunk->fFlags & pfEsHTMLChunk::kBlendAlpha ) ? 0 : plMipmap::kBlendWriteAlpha; opts.fRedTint = chunk->fCurrColor.r; opts.fGreenTint = chunk->fCurrColor.g; opts.fBlueTint = chunk->fCurrColor.b; opts.fOpacity = (UInt8)(chunk->fCurrColor.a * 255.f); } else { if( chunk->fFlags & pfEsHTMLChunk::kGlowing ) opts.fFlags = ( chunk->fFlags & pfEsHTMLChunk::kBlendAlpha ) ? 0 : plMipmap::kMaskSrcAlpha; else if (chunk->fFlags & pfEsHTMLChunk::kTranslucent) opts.fFlags = plMipmap::kMaskSrcAlpha; else opts.fFlags = ( chunk->fFlags & pfEsHTMLChunk::kBlendAlpha ) ? plMipmap::kCopySrcAlpha : plMipmap::kForceOpaque; opts.fOpacity = (UInt8)(chunk->fCurrOpacity * 255.f); } dtMap->Composite( copy, x, y, &opts ); } if( chunk->fFlags & pfEsHTMLChunk::kCanLink ) { if( whichDTMap == pfJournalDlgProc::kTagRightDTMap || whichDTMap == pfJournalDlgProc::kTagTurnFrontDTMap ) x += (UInt16)(dtMap->GetWidth()); // Right page rects are offsetted to differentiate if (dontRender) // if we aren't rendering then this link isn't visible, but the index still needs to be valid, so give it a rect of 0,0,0,0 chunk->fLinkRect.Set(0,0,0,0); else chunk->fLinkRect.Set( x, y, (Int16)(copy->GetWidth()), (Int16)(copy->GetHeight()) ); fVisibleLinks.Append( chunk ); } delete copy; } pfJournalBook::loadedMovie *pfJournalBook::IMovieAlreadyLoaded(pfEsHTMLChunk *chunk) { int i; for (i=0; ifText == fLoadedMovies[i]->movieChunk->fText)&&(chunk->fMovieIndex == fLoadedMovies[i]->movieChunk->fMovieIndex)) return fLoadedMovies[i]; } return nil; } plKey pfJournalBook::GetMovie(UInt8 index) { loadedMovie *movie = IGetMovieByIndex(index); if (movie) return movie->movieLayer->GetKey(); return plKey(nil); } pfJournalBook::loadedMovie *pfJournalBook::IGetMovieByIndex(UInt8 index) { int i; for (i=0; imovieChunk->fMovieIndex == index) return fLoadedMovies[i]; } return nil; } plLayerBink *pfJournalBook::IMakeMovieLayer(pfEsHTMLChunk *chunk, UInt16 x, UInt16 y, plMipmap *baseMipmap, UInt32 whichDTMap, hsBool dontRender) { // see if it's already loaded loadedMovie *movie = IMovieAlreadyLoaded(chunk); plLayer* layer = nil; plLayerBink* movieLayer = nil; UInt16 movieWidth=0,movieHeight=0; if (movie) { movieLayer = movie->movieLayer; layer = plLayer::ConvertNoRef(movieLayer->BottomOfStack()); movieWidth = movieLayer->GetWidth(); movieHeight = movieLayer->GetHeight(); } else { // Create the layer and register it. // We'll need a unique name. This is a hack, but an effective hack. static int uniqueSuffix = 0; char buff[256]; sprintf(buff, "%s_%d_ml", GetKey()->GetName(), uniqueSuffix); layer = TRACKED_NEW plLayer; hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation()); sprintf(buff, "%s_%d_m", GetKey()->GetName(), uniqueSuffix++); movieLayer = TRACKED_NEW plLayerBink; hsgResMgr::ResMgr()->NewKey(buff, movieLayer, GetKey()->GetUoid().GetLocation()); movieLayer->GetKey()->RefObject(); // we want to own a ref so we can nuke it at will movieLayer->AttachViaNotify(layer); // Initialize it. char *name = hsWStringToString(chunk->fText.c_str()); movieLayer->SetMovieName(name); delete [] name; movieLayer->Eval(0,0,0); // set up the movie movieWidth = movieLayer->GetWidth(); movieHeight = movieLayer->GetHeight(); if (movieHeight == 0 || movieWidth == 0) // problem loading the file { movieLayer->GetKey()->UnRefObject(); return nil; } } if (layer) { layer->InitToDefault(); layer->SetAmbientColor(hsColorRGBA().Set(0.f, 0.f, 0.f, 1.0f)); layer->SetOpacity(1.0f); // Blend flags, movies are opaque, but they don't take the whole page, so alphamapping them layer->SetBlendFlags(hsGMatState::kBlendAlpha); // Movie shouldn't have to ZWrite layer->SetZFlags(hsGMatState::kZNoZWrite); // No special shading. layer->SetShadeFlags(0); // Clamp all textures. layer->SetClampFlags(hsGMatState::kClampTexture); // Draw passes individually. layer->SetMiscFlags(hsGMatState::kMiscRestartPassHere); // Shared UV coordinates. layer->SetUVWSrc(0); if( chunk->fFlags & pfEsHTMLChunk::kFloating ) { // Floating movie, ignore the text flow completely and just splat the movie on! x = chunk->fAbsoluteX; y = chunk->fAbsoluteY; } if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kLeft ) x = (UInt16)fPageLMargin; else if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kRight ) x = (UInt16)(baseMipmap->GetWidth() - fPageRMargin - movieWidth); else if( ( chunk->fFlags & pfEsHTMLChunk::kAlignMask ) == pfEsHTMLChunk::kCenter ) x = (UInt16)((baseMipmap->GetWidth() >> 1) - (movieWidth >> 1)); // x and y are in pixels, need to convert to a range of 0 to 1 float xRel = (float)x/(float)baseMipmap->GetWidth(); float yRel = (float)y/(float)baseMipmap->GetHeight(); // Need to convert the scaling to texture space float xScale = (float)baseMipmap->GetWidth()/(float)movieWidth; float yScale = (float)baseMipmap->GetHeight()/(float)movieHeight; if (chunk->fNoResizeImg) { // book is NOT square, there is a h/w ratio of 1/0.7 // calc new size based on how the book has been skewed xScale *= (fWidthScale == 0) ? 1 : (1-fWidthScale); yScale *= (fHeightScale == 0) ? 1 : (1-fHeightScale); yScale *= 1/0.7; // adjust because the book isn't square } hsVector3 scaleVec(xScale,yScale,1), translateVec(-(xRel*xScale),-(yRel*yScale),0); hsMatrix44 scaleMat, translateMat; scaleMat.MakeScaleMat(&scaleVec); translateMat.MakeTranslateMat(&translateVec); hsMatrix44 flipMat; if (chunk->fOnCover) // cover movies need to be y flipped { hsVector3 yTransVec(0,-1,0), invertYVec(1,-1,1); hsMatrix44 invertY, transY; invertY.MakeScaleMat(&invertYVec); transY.MakeTranslateMat(&yTransVec); flipMat = invertY * transY; } else // left page movies need to be x flipped { if ((whichDTMap == pfJournalDlgProc::kTagLeftDTMap) || (whichDTMap == pfJournalDlgProc::kTagTurnBackDTMap)) { hsVector3 xTransVec(-1,0,0), invertXVec(-1,1,1); hsMatrix44 invertX, transX; invertX.MakeScaleMat(&invertXVec); transX.MakeTranslateMat(&xTransVec); flipMat = invertX * transX; } else flipMat = hsMatrix44::IdentityMatrix(); } hsMatrix44 xfm; xfm = translateMat * scaleMat * flipMat; layer->SetTransform(xfm); } if( chunk->fFlags & pfEsHTMLChunk::kCanLink ) { if( whichDTMap == pfJournalDlgProc::kTagRightDTMap || whichDTMap == pfJournalDlgProc::kTagTurnFrontDTMap ) x += (UInt16)(baseMipmap->GetWidth()); // Right page rects are offsetted to differentiate if (dontRender) // if we aren't rendering then this link isn't visible, but the index still needs to be valid, so give it a rect of 0,0,0,0 chunk->fLinkRect.Set(0,0,0,0); else chunk->fLinkRect.Set( x, y, movieWidth, movieHeight ); fVisibleLinks.Append( chunk ); } plAnimTimeConvert &timeConvert = movieLayer->GetTimeConvert(); timeConvert.SetBegin(0); timeConvert.SetEnd(movieLayer->GetLength()); if (chunk->fLoopMovie) { timeConvert.SetLoopPoints(0,movieLayer->GetLength()); timeConvert.Loop(); } timeConvert.Start(); // start the show! return movieLayer; } plLayerInterface *pfJournalBook::IMakeBaseLayer(plMipmap *image) { // Create the layer and register it. // We'll need a unique name. This is a hack, but an effective hack. static int uniqueSuffix = 0; char buff[256]; sprintf(buff, "%s_%d", GetKey()->GetName(), uniqueSuffix++); plLayer* layer = TRACKED_NEW plLayer; hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation()); // Initialize it. layer->InitToDefault(); layer->SetAmbientColor(hsColorRGBA().Set(0.f, 0.f, 0.f, 1.f)); if (fTintCover) layer->SetRuntimeColor(hsColorRGBA().Set(fCoverTint.r, fCoverTint.g, fCoverTint.b, 1.f)); layer->SetOpacity(1.f); // Blend flags, opaque for the bottom layer. layer->SetBlendFlags(0); // Only the bottom layer writes it's Z value. layer->SetZFlags(0); // No special shading. layer->SetShadeFlags(hsGMatState::kShadeReallyNoFog); // Clamp all textures. layer->SetClampFlags(hsGMatState::kClampTexture); // Draw passes individually. layer->SetMiscFlags(hsGMatState::kMiscRestartPassHere); // Shared UV coordinates. layer->SetUVWSrc(0); // Set up the transform. hsVector3 yTransVec(0,-1,0), invertYVec(1,-1,1); hsMatrix44 xfm, invertY, transY, flipY; invertY.MakeScaleMat(&invertYVec); transY.MakeTranslateMat(&yTransVec); flipY = invertY * transY; xfm = flipY; layer->SetTransform(xfm); // Set the texture (assumes mipmap is non-nil). plLayRefMsg* refMsg = TRACKED_NEW plLayRefMsg(layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture); hsgResMgr::ResMgr()->SendRef(image->GetKey(), refMsg, plRefFlags::kActiveRef); return plLayerInterface::ConvertNoRef(layer); } plLayerInterface *pfJournalBook::IMakeDecalLayer(pfEsHTMLChunk *decalChunk, plMipmap *decal, plMipmap *baseMipmap) { // Create the layer and register it. // We'll need a unique name. This is a hack, but an effective hack. static int uniqueSuffix = 0; char buff[256]; sprintf(buff, "%s_%d_d", GetKey()->GetName(), uniqueSuffix++); plLayer* layer = TRACKED_NEW plLayer; hsgResMgr::ResMgr()->NewKey(buff, layer, GetKey()->GetUoid().GetLocation()); // Initialize it. layer->InitToDefault(); // tint the layer only if the decal wants to be tinted layer->SetAmbientColor(hsColorRGBA().Set(0.f, 0.f, 0.f, 1.f)); if (decalChunk->fTintDecal) layer->SetRuntimeColor(hsColorRGBA().Set(fCoverTint.r, fCoverTint.g, fCoverTint.b, 1.f)); layer->SetOpacity(1.f); // Blend flags, decals are alpha blended. layer->SetBlendFlags(hsGMatState::kBlendAlpha); // Only the bottom layer writes it's Z value. layer->SetZFlags(hsGMatState::kZNoZWrite); // No special shading. layer->SetShadeFlags(hsGMatState::kShadeReallyNoFog); // Clamp all textures. layer->SetClampFlags(hsGMatState::kClampTexture); // Draw passes individually. layer->SetMiscFlags(hsGMatState::kMiscRestartPassHere); // Shared UV coordinates. layer->SetUVWSrc(0); // Set up the transform. UInt16 x,y; x = decalChunk->fAbsoluteX; y = decalChunk->fAbsoluteY; if((decalChunk->fFlags & pfEsHTMLChunk::kAlignMask) == pfEsHTMLChunk::kLeft) x = (UInt16)fPageLMargin; else if((decalChunk->fFlags & pfEsHTMLChunk::kAlignMask) == pfEsHTMLChunk::kRight) x = (UInt16)(baseMipmap->GetWidth() - decal->GetWidth()); else if((decalChunk->fFlags & pfEsHTMLChunk::kAlignMask) == pfEsHTMLChunk::kCenter) x = (UInt16)((baseMipmap->GetWidth() >> 1) - (decal->GetWidth() >> 1)); // x and y are in pixels, need to convert to a range of 0 to 1 float xRel = (float)x/(float)baseMipmap->GetWidth(); float yRel = (float)y/(float)baseMipmap->GetHeight(); // Need to convert the scaling to texture space float xScale = (float)baseMipmap->GetWidth()/(float)decal->GetWidth(); float yScale = (float)baseMipmap->GetHeight()/(float)decal->GetHeight(); if (decalChunk->fNoResizeImg) { // book is NOT square, there is a h/w ratio of 1/0.7 // calc new size based on how the book has been skewed xScale *= (fWidthScale == 0) ? 1 : (1-fWidthScale); yScale *= (fHeightScale == 0) ? 1 : (1-fHeightScale); yScale *= 1/0.7; // adjust because the book isn't square } hsVector3 scaleVec(xScale,yScale,1), translateVec(-(xRel*xScale),-(yRel*yScale),0), yTransVec(0,-1,0), invertYVec(1,-1,1); hsMatrix44 scaleMat, translateMat, invertY, transY; scaleMat.MakeScaleMat(&scaleVec); translateMat.MakeTranslateMat(&translateVec); invertY.MakeScaleMat(&invertYVec); transY.MakeTranslateMat(&yTransVec); hsMatrix44 xfm, flipY; flipY = invertY * transY; xfm = translateMat * scaleMat * flipY; layer->SetTransform(xfm); // Set the texture (assumes mipmap is non-nil). plLayRefMsg* refMsg = TRACKED_NEW plLayRefMsg(layer->GetKey(), plRefMsg::kOnCreate, 0, plLayRefMsg::kTexture); hsgResMgr::ResMgr()->SendRef(decal->GetKey(), refMsg, plRefFlags::kActiveRef); return plLayerInterface::ConvertNoRef(layer); } void pfJournalBook::ISetDecalLayers(hsGMaterial *material,hsTArray layers) { // First, clear out the existing layers. int i; for( i = material->GetNumLayers()-1; i >= 0; i-- ) { plMatRefMsg* refMsg = TRACKED_NEW plMatRefMsg(material->GetKey(), plRefMsg::kOnRemove, i, plMatRefMsg::kLayer); hsgResMgr::ResMgr()->SendRef(material->GetLayer(i)->GetKey(), refMsg, plRefFlags::kActiveRef); } // Now append our new layers in order. for( i = 0; i < layers.GetCount(); i++ ) { material->AddLayerViaNotify(layers[i]); } } //// IFindFontProps ////////////////////////////////////////////////////////// // Starting at the given chunk, works backwards to determine the full set of current // font properties at that point, or assigns defaults if none were specified void pfJournalBook::IFindFontProps( UInt32 chunkIdx, const wchar_t *&face, UInt8 &size, UInt8 &flags, hsColorRGBA &color, Int16 &spacing ) { enum Which { kFace = 0x01, kSize = 0x02, kFlags = 0x04, kColor = 0x08, kSpacing= 0x10, kAllFound = kFace | kSize | kFlags | kColor | kSpacing }; // Start empty UInt8 found = 0; // Work backwards and fill in our properties chunkIdx++; do { chunkIdx--; if (fHTMLSource.Count() <= chunkIdx) break; // apparently it's sometimes possible for fHTMLSource to be empty (parse errors?) pfEsHTMLChunk *chunk = fHTMLSource[ chunkIdx ]; if( chunk->fType == pfEsHTMLChunk::kFontChange ) { // What do we (still) need? if( !( found & kFace ) && chunk->fText != L"" ) { face = chunk->fText.c_str(); found |= kFace; } if( !( found & kSize ) && chunk->fFontSize > 0 ) { size = chunk->fFontSize; found |= kSize; } if( !( found & kFlags ) && ( chunk->fFlags & pfEsHTMLChunk::kFontMask ) != 0 ) { flags = 0; if( chunk->fFlags & pfEsHTMLChunk::kFontBold ) flags |= plDynamicTextMap::kFontBold; if( chunk->fFlags & pfEsHTMLChunk::kFontItalic ) flags |= plDynamicTextMap::kFontItalic; found |= kFlags; } if( !( found & kColor ) && ( chunk->fFlags & pfEsHTMLChunk::kFontColor ) ) { color = chunk->fColor; found |= kColor; } if( !( found & kSpacing ) && ( chunk->fFlags & pfEsHTMLChunk::kFontSpacing ) ) { spacing = chunk->fLineSpacing; found |= kSpacing; } } } while( chunkIdx != 0 && found != kAllFound ); // Set any un-found defaults if( !( found & kFace ) ) face = L"Arial"; if( !( found & kSize ) ) size = 24; if( !( found & kFlags ) ) flags = 0; if( !( found & kColor ) ) color.Set( 0.f, 0.f, 0.f, 1.f ); if( !( found & kSpacing ) ) spacing = 0; } //// IFindLastAlignment ////////////////////////////////////////////////////// // Find the last paragraph chunk and thus the last par alignment settings UInt8 pfJournalBook::IFindLastAlignment( void ) const { Int32 idx; for( idx = fHTMLSource.GetCount() - 1; idx >= 0; idx-- ) { if( fHTMLSource[ idx ]->fType == pfEsHTMLChunk::kParagraph && fHTMLSource[ idx ]->fFlags != 0 ) return (UInt8)(fHTMLSource[ idx ]->fFlags); } return pfEsHTMLChunk::kLeft; } //// IRecalcPageStarts /////////////////////////////////////////////////////// // Ensures that all the page starts are calced up to the given page (but not including it) void pfJournalBook::IRecalcPageStarts( UInt32 upToPage ) { UInt32 page; // Well, sadly, we can't really calc the page starts without at least a DTMap // we can change things on...so we just pick one and render. Note: this WILL // trash the font settings on the given DTMap! // We assume that the stored page starts we already have are accurate, so // just start from there and calc onward for( page = fPageStarts.GetCount()-1; page < upToPage && page <= fLastPage; page++ ) { // normally we would surpress rendering the pages, but that seems to have a bug in it // that causes lost text that the rendering doesn't have. Since it isn't very costly to // actually draw them all (even in large journals), we're just going to do it IRenderPage( page, pfJournalDlgProc::kTagTurnBackDTMap, false ); // Reset any "visible" links since they aren't really visible UInt16 i; for (i=0; ifLinkRect.Set(0,0,0,0); } } } //// ISendNotify ///////////////////////////////////////////////////////////// // Just sends out a notify to our currently set receiver key void pfJournalBook::ISendNotify( UInt32 type, UInt32 linkID ) { if( fCallbackKey != nil ) { plNotifyMsg *pMsg = TRACKED_NEW plNotifyMsg; pMsg->AddBookEvent( type, linkID ); pMsg->SetBCastFlag( plMessage::kNetPropagate, false ); // don't deliver networked! pMsg->Send( fCallbackKey ); } } //// SetBookSize ///////////////////////////////////////////////////////////// // Sets the book size scaling. 1,1 would be full size, 0,0 is the smallest size possible // Note: internally we store these as the seek positions on our animations, // so the incoming parameters are actually inverse of what we finally want void pfJournalBook::SetBookSize( hsScalar width, hsScalar height ) { fWidthScale = 1.f - width; fHeightScale = 1.f - height; if( fBookGUIs[fCurBookGUI]->CurBook() == this ) fBookGUIs[fCurBookGUI]->SetCurrSize( fWidthScale, fHeightScale ); } //// ILoadAllImages ////////////////////////////////////////////////////////// // Load (or unload) all the images for the book void pfJournalBook::ILoadAllImages( hsBool unload ) { UInt32 i; // load the cover if( fCoverFromHTML && fCoverMipKey != nil ) { if( unload ) fBookGUIs[fCurBookGUI]->GetKey()->Release( fCoverMipKey ); else { plGenRefMsg *ref = TRACKED_NEW plGenRefMsg( fBookGUIs[fCurBookGUI]->GetKey(), plRefMsg::kOnCreate, -1, kRefImage ); hsgResMgr::ResMgr()->AddViaNotify( fCoverMipKey, ref, plRefFlags::kActiveRef ); } } for( i = 0; i < fHTMLSource.GetCount(); i++ ) { if( fHTMLSource[ i ]->fType == pfEsHTMLChunk::kImage && fHTMLSource[ i ]->fImageKey != nil ) { if( unload ) fBookGUIs[fCurBookGUI]->GetKey()->Release( fHTMLSource[ i ]->fImageKey ); else { plGenRefMsg *ref = TRACKED_NEW plGenRefMsg( fBookGUIs[fCurBookGUI]->GetKey(), plRefMsg::kOnCreate, -1, kRefImage ); hsgResMgr::ResMgr()->AddViaNotify( fHTMLSource[ i ]->fImageKey, ref, plRefFlags::kActiveRef ); } } } } void pfJournalBook::IPurgeDynaTextMaps( ) { plDynamicTextMap* turnFront = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagTurnFrontDTMap ); if (turnFront) turnFront->PurgeImage(); plDynamicTextMap* right = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagRightDTMap ); if (right) right->PurgeImage(); plDynamicTextMap* turnBack = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagTurnBackDTMap ); if (turnBack) turnBack->PurgeImage(); plDynamicTextMap* left = fBookGUIs[fCurBookGUI]->GetDTMap( pfJournalDlgProc::kTagLeftDTMap ); if (left) left->PurgeImage(); pfGUIMultiLineEditCtrl *leftEdit = fBookGUIs[fCurBookGUI]->GetEditCtrl( pfJournalDlgProc::kTagLeftEditCtrl ); if (leftEdit) leftEdit->PurgeDynaTextMapImage(); pfGUIMultiLineEditCtrl *rightEdit = fBookGUIs[fCurBookGUI]->GetEditCtrl( pfJournalDlgProc::kTagRightEditCtrl ); if (rightEdit) rightEdit->PurgeDynaTextMapImage(); pfGUIMultiLineEditCtrl *turnFrontEdit = fBookGUIs[fCurBookGUI]->GetEditCtrl( pfJournalDlgProc::kTagTurnFrontEditCtrl ); if (turnFrontEdit) turnFrontEdit->PurgeDynaTextMapImage(); pfGUIMultiLineEditCtrl *turnBackEdit = fBookGUIs[fCurBookGUI]->GetEditCtrl( pfJournalDlgProc::kTagTurnBackEditCtrl ); if (turnBackEdit) turnBackEdit->PurgeDynaTextMapImage(); } std::string pfJournalBook::GetEditableText() { pfGUIMultiLineEditCtrl *left = fBookGUIs[fCurBookGUI]->GetEditCtrl( pfJournalDlgProc::kTagLeftEditCtrl ); if (left) { char *temp = left->GetNonCodedBuffer(); std::string retVal = temp; delete [] temp; return retVal; } return ""; } void pfJournalBook::SetEditableText(std::string text) { pfGUIMultiLineEditCtrl *left = fBookGUIs[fCurBookGUI]->GetEditCtrl( pfJournalDlgProc::kTagLeftEditCtrl ); if (left) { left->SetBuffer(text.c_str()); left->ForceUpdate(); } }