bool fl_ContainerLayout::canContainPoint() const
{
if(isCollapsed())
return false;
FV_View* pView = getDocLayout()->getView();
bool bShowHidden = pView->getShowPara();
bool bHidden = ((m_eHidden == FP_HIDDEN_TEXT && !bShowHidden)
|| m_eHidden == FP_HIDDEN_REVISION
|| m_eHidden == FP_HIDDEN_REVISION_AND_TEXT);
if(bHidden)
return false;
if(!_canContainPoint())
return false;
// see if we are not inside a containing layout that cannot contain point
fl_ContainerLayout * pMyLayout = myContainingLayout();
if(!pMyLayout || pMyLayout->getContainerType() == FL_CONTAINER_DOCSECTION)
return true;
return pMyLayout->canContainPoint();
}
void fl_FootnoteLayout::_insertFootnoteContainer(fp_Container * pNewFC)
{
UT_DEBUGMSG(("inserting footnote container into container list\n"));
fl_ContainerLayout * pUPCL = myContainingLayout();
fl_ContainerLayout * pPrevL = static_cast<fl_ContainerLayout *>(m_pLayout->findBlockAtPosition(getDocPosition()-1));
fp_Container * pPrevCon = NULL;
fp_Container * pUpCon = NULL;
fp_Page * pPage = NULL;
// get the owning container
if(pPrevL != NULL)
{
pPrevCon = pPrevL->getLastContainer();
if(pPrevL->getContainerType() == FL_CONTAINER_BLOCK)
{
//
// Code to find the Line that contains the footnote reference
//
PT_DocPosition posFL = getDocPosition() - 1;
UT_ASSERT(pPrevL->getContainerType() == FL_CONTAINER_BLOCK);
fl_BlockLayout * pBL = static_cast<fl_BlockLayout *>(pPrevL);
fp_Run * pRun = pBL->getFirstRun();
PT_DocPosition posBL = pBL->getPosition();
while(pRun && ((posBL + pRun->getBlockOffset() + pRun->getLength()) < posFL))
{
pRun = pRun->getNextRun();
}
if(pRun && pRun->getLine())
{
pPrevCon = static_cast<fp_Container *>(pRun->getLine());
}
}
if(pPrevCon == NULL)
{
pPrevCon = pPrevL->getLastContainer();
}
pUpCon = pPrevCon->getContainer();
}
else
{
pUpCon = pUPCL->getLastContainer();
}
if(pPrevCon)
{
pPage = pPrevCon->getPage();
}
else
{
pPage = pUpCon->getPage();
}
pNewFC->setContainer(NULL);
// need to put onto page as well, in the appropriate place.
// UT_ASSERT(pPage);
if(pPage)
{
pPage->insertFootnoteContainer(static_cast<fp_FootnoteContainer*>(pNewFC));
m_bIsOnPage = true;
}
}
/*!
* This code actually inserts a block AFTER the frame in the docsectionlayout
* Code copied from tablelayout
*/
bool fl_FrameLayout::insertBlockAfter(fl_ContainerLayout* /*pLBlock*/,
const PX_ChangeRecord_Strux * pcrx,
PL_StruxDocHandle sdh,
PL_ListenerId lid,
void (* pfnBindHandles)(PL_StruxDocHandle sdhNew,
PL_ListenerId lid,
PL_StruxFmtHandle sfhNew))
{
UT_ASSERT(pcrx->getType()==PX_ChangeRecord::PXT_InsertStrux);
UT_ASSERT(pcrx->getStruxType()==PTX_Block);
fl_ContainerLayout * pNewCL = NULL;
fl_ContainerLayout * pMyCL = myContainingLayout();
pNewCL = pMyCL->insert(sdh,this,pcrx->getIndexAP(), FL_CONTAINER_BLOCK);
fl_BlockLayout * pBlock = static_cast<fl_BlockLayout *>(pNewCL);
//
// Set the sectionlayout of this frame to that of the block since it is that scope
//
pBlock->setSectionLayout(static_cast<fl_SectionLayout *>(myContainingLayout()));
pNewCL->setContainingLayout(myContainingLayout());
// Must call the bind function to complete the exchange of handles
// with the document (piece table) *** before *** anything tries
// to call down into the document (like all of the view
// listeners).
PL_StruxFmtHandle sfhNew = static_cast<PL_StruxFmtHandle>(pNewCL);
pfnBindHandles(sdh,lid,sfhNew);
//
// increment the insertion point in the view.
//
FV_View* pView = m_pLayout->getView();
if (pView && (pView->isActive() || pView->isPreview()))
{
pView->setPoint(pcrx->getPosition() + fl_BLOCK_STRUX_OFFSET);
}
else if(pView && pView->getPoint() > pcrx->getPosition())
{
pView->setPoint(pView->getPoint() + fl_BLOCK_STRUX_OFFSET);
}
if(pView)
pView->updateCarets(pcrx->getPosition(),1);
return true;
}
fl_SectionLayout * fl_FrameLayout::getSectionLayout(void) const
{
fl_ContainerLayout * pDSL = myContainingLayout();
while(pDSL)
{
if(pDSL->getContainerType() == FL_CONTAINER_DOCSECTION)
{
return static_cast<fl_SectionLayout *>(pDSL);
}
pDSL = pDSL->myContainingLayout();
}
return NULL;
}
fl_EndnoteLayout::fl_EndnoteLayout(FL_DocLayout* pLayout,
fl_DocSectionLayout* pDocSL,
pf_Frag_Strux* sdh,
PT_AttrPropIndex indexAP,
fl_ContainerLayout * pMyContainerLayout)
: fl_EmbedLayout(pLayout,
pDocSL,
sdh,
indexAP,
pMyContainerLayout,
FL_SECTION_ENDNOTE,
FL_CONTAINER_ENDNOTE,
PTX_SectionEndnote),
m_iEndnotePID(0)
{
UT_DEBUGMSG(("Create Endnote section %p from pos %d \n",this,getPosition()));
m_pLayout->addEndnote(this);
UT_DEBUGMSG(("myContaining Layout %s \n",myContainingLayout()->getContainerString()));
_createEndnoteContainer();
}
/*!
* This method creates a new footnote with its properties initially set
* from the Attributes/properties of this Layout
*/
void fl_AnnotationLayout::_createAnnotationContainer(void)
{
lookupProperties();
fp_AnnotationContainer * pAnnotationContainer = new fp_AnnotationContainer(static_cast<fl_SectionLayout *>(this));
setFirstContainer(pAnnotationContainer);
setLastContainer(pAnnotationContainer);
fl_ContainerLayout * pCL = myContainingLayout();
while(pCL!= NULL && pCL->getContainerType() != FL_CONTAINER_DOCSECTION)
{
pCL = pCL->myContainingLayout();
}
fl_DocSectionLayout * pDSL = static_cast<fl_DocSectionLayout *>(pCL);
UT_return_if_fail(pDSL != NULL);
fp_Container * pCon = pCL->getLastContainer();
UT_return_if_fail(pCon);
UT_sint32 iWidth = pCon->getPage()->getWidth();
iWidth = iWidth - pDSL->getLeftMargin() - pDSL->getRightMargin();
pAnnotationContainer->setWidth(iWidth);
}
fl_DocSectionLayout * fl_ContainerLayout::getDocSectionLayout(void) const
{
fl_ContainerLayout * pCL = myContainingLayout();
while(pCL!= NULL && ((pCL->getContainerType() != FL_CONTAINER_DOCSECTION) && (pCL->getContainerType() != FL_CONTAINER_HDRFTR)))
{
pCL = pCL->myContainingLayout();
}
if(pCL== NULL)
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return NULL;
}
fl_DocSectionLayout * pDSL = NULL;
if(pCL->getContainerType() == FL_CONTAINER_HDRFTR)
{
pDSL = static_cast<fl_HdrFtrSectionLayout *>(pCL)->getDocSectionLayout();
}
else
{
pDSL = static_cast<fl_DocSectionLayout *>(pCL);
}
return pDSL;
}
/*!
* Create a new containerLayout and insert it into the linked list of
* layouts held by this class.
* Returns a pointer to the generated ContainerLayout class.
*/
fl_ContainerLayout * fl_ContainerLayout::insert(pf_Frag_Strux* sdh, fl_ContainerLayout * pPrev, PT_AttrPropIndex indexAP,fl_ContainerType iType)
{
fl_ContainerLayout* pL=NULL;
switch (iType)
{
case FL_CONTAINER_BLOCK:
// we have a problem here -- the block needs to be in the list before the consturction is completed
if(getContainerType() == FL_CONTAINER_HDRFTR)
{
pL = static_cast<fl_ContainerLayout *>(new fl_BlockLayout(sdh, pPrev, static_cast<fl_SectionLayout *>(this), indexAP,true));
}
else if ((pPrev!= NULL) && (pPrev->getContainerType() == FL_CONTAINER_TABLE))
{
pL = static_cast<fl_ContainerLayout *>(new fl_BlockLayout(sdh,pPrev, static_cast<fl_SectionLayout *>(pPrev->myContainingLayout()), indexAP));
}
else if ((pPrev!= NULL) && (pPrev->getContainerType() == FL_CONTAINER_ANNOTATION))
{
pL = static_cast<fl_ContainerLayout *>(new fl_BlockLayout(sdh,pPrev, static_cast<fl_SectionLayout *>(this), indexAP));
fp_Container * pFirstC = pL->getFirstContainer();
//
// This sets indent for a annotation label.
//
if(pFirstC)
pFirstC->recalcMaxWidth(true);
}
else if ((pPrev!= NULL) && (pPrev->getContainerType() == FL_CONTAINER_RDFANCHOR))
{
pL = static_cast<fl_ContainerLayout *>(new fl_BlockLayout(sdh,pPrev, static_cast<fl_SectionLayout *>(this), indexAP));
}
else
{
pL = static_cast<fl_ContainerLayout *>(new fl_BlockLayout(sdh, static_cast<fl_BlockLayout *>(pPrev), static_cast<fl_SectionLayout *>(this), indexAP));
}
break;
case FL_CONTAINER_TABLE:
pL = static_cast<fl_ContainerLayout *>(new fl_TableLayout(getDocLayout(),sdh, indexAP, this));
if(pPrev && (pPrev == this))
{
fl_ContainerLayout * pOldFirst = pPrev->getFirstLayout();
pPrev->setFirstLayout(pL);
pL->setNext(pOldFirst);
if(pOldFirst)
{
pOldFirst->setPrev(pL);
}
if(pPrev->getLastLayout() == NULL)
{
pPrev->setLastLayout(pL);
}
}
else if (pPrev)
{
pPrev->_insertIntoList(pL);
}
//
// Now put the Physical Container into the vertical container that contains it.
//
{
fp_TableContainer * pTab = static_cast<fp_TableContainer *>(static_cast<fl_TableLayout *>(pL)->getLastContainer());
static_cast<fl_TableLayout *>(pL)->insertTableContainer(static_cast<fp_TableContainer *>(pTab));
}
if(getContainerType() == FL_CONTAINER_CELL)
{
fl_CellLayout * pCell = static_cast<fl_CellLayout *>(this);
pCell->incNumNestedTables();
fl_TableLayout * pTab = static_cast<fl_TableLayout *>(pCell->myContainingLayout());
pTab->incNumNestedTables();
}
break;
case FL_CONTAINER_CELL:
pL = static_cast<fl_ContainerLayout *>(new fl_CellLayout(getDocLayout(),sdh, indexAP, this));
if (pPrev)
{
pPrev->_insertIntoList(pL);
}
else
{
_insertFirst(pL);
}
break;
case FL_CONTAINER_FRAME:
{
pL = static_cast<fl_ContainerLayout *>
(new fl_FrameLayout(getDocLayout(),
sdh, indexAP, this));
if (pPrev)
{
while(pPrev && pPrev->getContainerType() != FL_CONTAINER_BLOCK)
{
pPrev = pPrev->getPrev();
}
//
// Add the frame to the list in te previous block.
//
if(pPrev)
{
pPrev->_insertIntoList(pL);
pPrev->addFrame(static_cast<fl_FrameLayout *>(pL));
}
}
break;
}
case FL_CONTAINER_FOOTNOTE:
{
fl_DocSectionLayout * pDSL = getDocSectionLayout();
pL = static_cast<fl_ContainerLayout *>(new fl_FootnoteLayout(getDocLayout(),
pDSL,
sdh, indexAP, this));
if (pPrev)
pPrev->_insertIntoList(pL);
break;
}
case FL_CONTAINER_ANNOTATION:
{
fl_DocSectionLayout * pDSL = getDocSectionLayout();
pL = static_cast<fl_ContainerLayout *>(new fl_AnnotationLayout(getDocLayout(),
pDSL,
sdh, indexAP, this));
if (pPrev)
pPrev->_insertIntoList(pL);
break;
}
case FL_CONTAINER_TOC:
{
fl_DocSectionLayout * pDSL = getDocSectionLayout();
pL = static_cast<fl_ContainerLayout *>(new fl_TOCLayout(getDocLayout(),
pDSL,
sdh, indexAP, this));
if (pPrev)
pPrev->_insertIntoList(pL);
static_cast<fl_TOCLayout *>(pL)->getNewContainer(NULL);
break;
}
case FL_CONTAINER_ENDNOTE:
{
fl_DocSectionLayout * pDSL = getDocSectionLayout();
pL = static_cast<fl_ContainerLayout *>(new fl_EndnoteLayout(getDocLayout(),
pDSL,
sdh, indexAP, this));
if (pPrev)
pPrev->_insertIntoList(pL);
break;
}
default:
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
break;
}
if (pL == NULL)
{
return pL;
}
if (!m_pLastL)
{
UT_ASSERT(!m_pFirstL);
m_pFirstL = pL;
m_pLastL = pL;
}
else if (m_pLastL == pPrev)
{
m_pLastL = pL;
}
else if (!pPrev)
{
m_pFirstL = pL;
}
if(getContainerType() == FL_CONTAINER_CELL)
{
static_cast<fl_TableLayout *>(myContainingLayout())->setDirty();
}
return pL;
}
fl_BlockLayout* fl_ContainerLayout::getPrevBlockInDocument(void) const
{
fl_ContainerLayout * pPrev = getPrev();
fl_ContainerLayout * pOld = NULL;
UT_uint32 depth = 0;
if(pPrev == NULL)
{
while((pPrev == NULL) && ((pOld != NULL) || (depth == 0)))
{
fl_ContainerLayout * pPrevOld = pOld;
if(depth > 0)
{
pOld = pOld->myContainingLayout();
}
else
{
pOld = myContainingLayout();
}
depth++;
if(pOld != NULL) // HdrFtr's can have NULL myContainingLayout's
{
pPrev = pOld->getPrev();
}
if(pPrevOld == pOld )
{
pOld = NULL;
}
}
}
while(pPrev)
{
pOld = pPrev;
if(pPrev->getContainerType() == FL_CONTAINER_BLOCK)
{
return static_cast<fl_BlockLayout *>(pPrev);
}
else if(pPrev->getContainerType() == FL_CONTAINER_DOCSECTION)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_FRAME)
{
if(pPrev->getLastLayout() == NULL)
{
pPrev = pPrev->getPrev();
}
else
{
pPrev = pPrev->getLastLayout();
}
}
else if(pPrev->getContainerType() == FL_CONTAINER_TABLE)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_CELL)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_FOOTNOTE)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_ANNOTATION)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_RDFANCHOR)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_TOC)
{
pPrev = pPrev->getLastLayout();
}
else if(pPrev->getContainerType() == FL_CONTAINER_ENDNOTE)
{
pPrev = pPrev->getLastLayout();
}
else
{
pPrev = NULL;
break;
}
if(pPrev == NULL)
{
if(pOld && pOld->myContainingLayout())
{
pPrev = pOld->myContainingLayout()->getPrev();
}
}
}
return NULL;
}
fl_BlockLayout* fl_ContainerLayout::getNextBlockInDocument(void) const
{
fl_ContainerLayout * pNext = getNext();
if(getContainerType() != FL_CONTAINER_BLOCK)
{
pNext = getFirstLayout();
}
fl_ContainerLayout * pOld = NULL;
UT_uint32 depth = 0;
next_is_null :
if(pNext == NULL)
{
while((pNext == NULL) && ((pOld != NULL) || (depth == 0)))
{
fl_ContainerLayout * pPrevOld = pOld;
if(depth > 0)
{
pOld = pOld->myContainingLayout();
}
else
{
pOld = myContainingLayout();
}
depth++;
if(pOld != NULL) // HdrFtr's have myContainingLayout == NULL
{
pNext = pOld->getNext();
}
if(pPrevOld == pOld)
{
pOld = NULL;
}
}
}
while(pNext)
{
pOld = pNext;
if(pNext->getContainerType() == FL_CONTAINER_BLOCK)
{
return static_cast<fl_BlockLayout *>(pNext);
}
else if(pNext->getContainerType() == FL_CONTAINER_DOCSECTION)
{
pNext = pNext->getFirstLayout();
}
else if(pNext->getContainerType() == FL_CONTAINER_TABLE)
{
pNext = pNext->getFirstLayout();
}
else if(pNext->getContainerType() == FL_CONTAINER_FRAME)
{
if(pNext->getFirstLayout() == NULL)
{
pNext = pNext->getNext();
}
else
{
pNext = pNext->getFirstLayout();
}
}
else if(pNext->getContainerType() == FL_CONTAINER_CELL)
{
pNext = pNext->getFirstLayout();
}
else if(pNext->getContainerType() == FL_CONTAINER_TOC)
{
pNext = pNext->getNext();
if(pNext == NULL)
{
goto next_is_null;
}
}
else if(pNext->getContainerType() == FL_CONTAINER_FOOTNOTE)
{
pNext = pNext->getNext();
if(pNext == NULL)
{
goto next_is_null;
}
}
else if(pNext->getContainerType() == FL_CONTAINER_ANNOTATION)
{
pNext = pNext->getNext();
if(pNext == NULL)
{
goto next_is_null;
}
}
else if(pNext->getContainerType() == FL_CONTAINER_RDFANCHOR)
{
pNext = pNext->getNext();
if(pNext == NULL)
{
goto next_is_null;
}
}
else if(pNext->getContainerType() == FL_CONTAINER_ENDNOTE)
{
pNext = pNext->getNext();
if(pNext == NULL)
{
goto next_is_null;
}
}
else
{
pNext = NULL;
break;
}
if(pNext == NULL)
{
goto next_is_null;
}
}
return NULL;
}
void fl_FrameLayout::setNeedsReformat(fl_ContainerLayout * /*pCL*/,UT_uint32 /*offset*/)
{
m_bNeedsReformat = true;
myContainingLayout()->setNeedsReformat(this);
}
bool fl_FrameLayout::doclistener_deleteStrux(const PX_ChangeRecord_Strux * pcrx)
{
UT_UNUSED(pcrx);
UT_ASSERT(pcrx->getType()==PX_ChangeRecord::PXT_DeleteStrux);
#if 0
fp_FrameContainer * pFrameC = getFirstContainer();
if(pFrameC && pFrameC->getPage())
{
pFrameC->getPage()->markDirtyOverlappingRuns(pFrameC);
}
#endif
fp_FrameContainer * pFrameC = static_cast<fp_FrameContainer *>(getFirstContainer());
UT_GenericVector<fl_BlockLayout *> vecBlocks;
pFrameC->getBlocksAroundFrame(vecBlocks);
UT_sint32 i = 0;
for(i=0; i< vecBlocks.getItemCount();i++)
{
fl_BlockLayout * pBL = vecBlocks.getNthItem(i);
pBL->collapse();
xxx_UT_DEBUGMSG(("Collapse block %x \n",pBL));
}
//
// Remove all remaining structures
//
collapse();
// UT_ASSERT(pcrx->getStruxType()== PTX_SectionFrame);
//
fl_ContainerLayout * pCL = getPrev();
myContainingLayout()->remove(this);
UT_DEBUGMSG(("Unlinking frame Layout %p \n",this));
//
// Remove from the list of frames in the previous block
//
while(pCL && pCL->getContainerType() != FL_CONTAINER_BLOCK)
{
pCL = pCL->getPrev();
}
if(pCL == NULL)
{
UT_DEBUGMSG(("No BlockLayout before this frame! \n"));
return false;
}
fl_BlockLayout * pBL = static_cast<fl_BlockLayout *>(pCL);
bool bFound = false;
for(i=0; i<pBL->getNumFrames() && !bFound;i++)
{
fl_FrameLayout * pF = pBL->getNthFrameLayout(i);
if(pF == this)
{
bFound = true;
}
}
if(bFound)
{
pBL->removeFrame(this);
}
else
{
UT_DEBUGMSG(("Whoops! not Frame found. Try ahead \n"));
pCL = this;
while(pCL && pCL->getContainerType() != FL_CONTAINER_BLOCK)
{
pCL = pCL->getNext();
}
if(pCL == NULL)
{
UT_DEBUGMSG(("No BlockLayout before this frame! \n"));
return false;
}
pBL = static_cast<fl_BlockLayout *>(pCL);
pBL->removeFrame(this);
}
for(i=0; i< vecBlocks.getItemCount();i++)
{
pBL = vecBlocks.getNthItem(i);
pBL->format();
xxx_UT_DEBUGMSG(("format block %x \n",pBL));
}
delete this; // TODO whoa! this construct is VERY dangerous.
return true;
}
