void AP_Dialog_FormatFrame::applyChanges()
{
UT_sint32 count = m_vecProps.getItemCount();
UT_DEBUGMSG(("Doing apply changes number props %d \n", count));
if (!count)
return;
FV_View * pView = static_cast<FV_View *>(m_pApp->getLastFocussedFrame()->getCurrentView());
if (!pView)
return;
const gchar ** propsArray = new const gchar * [count + 2];
for (UT_sint32 j = 0; j < count; j = j + 2)
{
propsArray[j ] = static_cast<gchar *>(m_vecProps.getNthItem(j));
propsArray[j+1] = static_cast<gchar *>(m_vecProps.getNthItem(j+1));
}
propsArray[count ] = 0;
propsArray[count+1] = 0;
pView->setFrameFormat(propsArray, m_pGraphic, m_sImagePath);
delete [] propsArray;
m_bSettingsChanged = false;
}
//
// GDict_invoke
// -------------------
// This is the function that we actually call to invoke the thesaurus.
// It should be called when the user hits the thesaurus key (shift+f7?)
// or chooses "thesaurus" from a menu.
//
static bool
GDict_invoke(AV_View* /*v*/, EV_EditMethodCallData */*d*/)
{
// Get the current view that the user is in.
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
// If the user is on a word, but does not have it selected, we need
// to go ahead and select that word so that the search/replace goes
// correctly.
pView->moveInsPtTo(FV_DOCPOS_EOW_MOVE);
pView->moveInsPtTo(FV_DOCPOS_BOW);
pView->extSelTo(FV_DOCPOS_EOW_SELECT);
// We need to get the utf-8 version of the current word.
UT_UCS4Char *ucs4ST = NULL;
pView->getSelectionText(*&ucs4ST);
if (ucs4ST) {
UT_UTF8String search(ucs4ST);
GDict_exec (search.utf8_str());
FREEP(ucs4ST);
}
return true;
}
gint AP_UnixLeftRuler::_fe::button_release_event(GtkWidget * w, GdkEventButton * e)
{
// a static function
AP_UnixLeftRuler * pUnixLeftRuler = static_cast<AP_UnixLeftRuler *>(g_object_get_data(G_OBJECT(w), "user_data"));
EV_EditModifierState ems = 0;
EV_EditMouseButton emb = 0;
FV_View * pView = static_cast<FV_View *>(pUnixLeftRuler->m_pFrame->getCurrentView());
if (!pView || pView->getPoint() == 0 || !pUnixLeftRuler->m_pG)
return 1;
if (e->state & GDK_SHIFT_MASK)
ems |= EV_EMS_SHIFT;
if (e->state & GDK_CONTROL_MASK)
ems |= EV_EMS_CONTROL;
if (e->state & GDK_MOD1_MASK)
ems |= EV_EMS_ALT;
if (e->state & GDK_BUTTON1_MASK)
emb = EV_EMB_BUTTON1;
else if (e->state & GDK_BUTTON2_MASK)
emb = EV_EMB_BUTTON2;
else if (e->state & GDK_BUTTON3_MASK)
emb = EV_EMB_BUTTON3;
pUnixLeftRuler->mouseRelease(ems, emb,
pUnixLeftRuler->m_pG->tlu(static_cast<UT_uint32>(e->x)),
pUnixLeftRuler->m_pG->tlu(static_cast<UT_uint32>(e->y)));
// release the mouse after we are done.
gtk_grab_remove(w);
return 1;
}
/*!
* This method sets the height and width of the preview from
* the size of the comment in the annotation.
*/
void AP_Preview_Annotation::setSizeFromAnnotation(void)
{
FV_View * pView = static_cast<FV_View *>(getActiveFrame()->getCurrentView());
GR_Graphics * pG = NULL;
UT_return_if_fail(pView);
pG = pView->getGraphics();
UT_return_if_fail(pG);
GR_Font * pFont = pG->findFont("Times New Roman", "normal",
"normal", "normal",
"normal", "12pt",
NULL);
UT_return_if_fail(pFont);
double rat = 100./static_cast<double>(pG->getZoomPercentage());
UT_sint32 iHeight = pG->getFontAscent(pFont) + pG->tlu(7);
iHeight = static_cast<UT_sint32>(static_cast<double>(iHeight));
m_drawString = m_sDescription;
UT_sint32 len = m_drawString.size();
pG->setFont(pFont);
UT_sint32 iwidth = pG->measureString(m_drawString.ucs4_str(),0,len,NULL) + pG->tlu(6);
iwidth = static_cast<UT_sint32>(static_cast<double>(iwidth));
m_width = static_cast<UT_sint32>(static_cast<double>(pG->tdu(iwidth))*rat);
m_height = static_cast<UT_sint32>(static_cast<double>(pG->tdu(iHeight))*rat);
if(pG->tdu(pView->getWindowWidth()) < m_width)
m_width = pG->tdu(pView->getWindowWidth());
UT_DEBUGMSG(("SetSize from Annotation width %d rat %f \n",m_width,rat));
}
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 AP_UnixApp::cacheCurrentSelection(AV_View * pView)
{
if (pView)
{
// remember a temporary copy of the extent of the current
// selection in the given view. this is intended for the
// X11 middle mouse trick -- where we need to warp to a
// new location and paste the current selection (not the
// clipboard) and the act of warping clears the selection.
// TODO if we ever support multiple view types, we'll have to
// TODO change this.
FV_View * pFVView = static_cast<FV_View *>(pView);
pFVView->getDocumentRangeOfCurrentSelection(&m_cacheDocumentRangeOfSelection);
m_cacheSelectionView = pView;
m_cacheDeferClear = false;
}
else
{
if (m_cacheDeferClear)
{
m_cacheDeferClear = false;
m_bHasSelection = false;
}
m_cacheSelectionView = NULL;
}
}
/*!
* Autoupdater of the dialog.
*/
void AP_Dialog_SplitCells::autoUpdateMC(UT_Worker * pTimer)
{
UT_return_if_fail(pTimer);
// this is a static callback method and does not have a 'this' pointer
AP_Dialog_SplitCells * pDialog = static_cast<AP_Dialog_SplitCells *>(pTimer->getInstanceData());
if (pDialog->m_bDestroy_says_stopupdating != true)
{
FV_View * pView = 0;
PD_Document * pDoc = NULL;
if (XAP_Frame * pFrame = pDialog->getApp()->getLastFocussedFrame())
{
pView = static_cast<FV_View *>(pFrame->getCurrentView());
}
if (pView)
{
pDoc = pView->getDocument();
}
if (!pView || (pDoc && !pDoc->isPieceTableChanging()))
{
pDialog->m_bAutoUpdate_happening_now = true;
pDialog->setAllSensitivities();
pDialog->m_bAutoUpdate_happening_now = false;
}
}
}
//
// AbiMathView_LatexInsert
// -------------------
// This is the function that we actually call to insert the MathML from
// a Latex expression.
//
bool
AbiMathView_LatexInsert(AV_View* v, EV_EditMethodCallData* /*d*/)
{
FV_View * pView = static_cast<FV_View *>(v);
XAP_Frame * pFrame = static_cast<XAP_Frame *> ( pView->getParentData());
pFrame->raise();
XAP_DialogFactory * pDialogFactory
= static_cast<XAP_DialogFactory *>(XAP_App::getApp()->getDialogFactory());
AP_Dialog_Latex * pDialog
= static_cast<AP_Dialog_Latex *>(pDialogFactory->requestDialog(AP_DIALOG_ID_LATEX));
UT_return_val_if_fail(pDialog, false);
if (pDialog->isRunning())
{
pDialog->activate();
}
else
{
pDialog->runModeless(pFrame);
}
return true;
}
void ABI_Collab_Import::_enableUpdates(UT_GenericVector<AV_View *> vecViews, bool bIsGlob)
{
if (bIsGlob)
{
// allow updates again
m_pDoc->enableListUpdates();
m_pDoc->updateDirtyLists();
m_pDoc->setDontImmediatelyLayout(false);
m_pDoc->endUserAtomicGlob();
}
m_pDoc->notifyPieceTableChangeEnd();
bool bDone = false;
for (UT_sint32 i = 0; i<vecViews.getItemCount(); i++)
{
FV_View * pView = static_cast<FV_View *>( vecViews.getNthItem(i));
if(pView && !bDone && pView->shouldScreenUpdateOnGeneralUpdate())
{
m_pDoc->signalListeners(PD_SIGNAL_UPDATE_LAYOUT);
bDone = true;
}
if(pView)
{
pView->fixInsertionPointCoords();
pView->setActivityMask(true);
}
}
}
PD_DocumentRDFHandle
AP_Dialog_RDFEditor::getRDF()
{
FV_View* view = getView();
PD_Document* doc = view->getDocument();
PD_DocumentRDFHandle rdf = doc->getDocumentRDF();
return rdf;
}
//
// FreeTranslate_invoke
// -------------------
// This is the function that we actually call to invoke the
// online freetranslation translation
// It should be called when the user selects from the context menu
//
static
bool FreeTranslation_invoke(AV_View * /*v*/, EV_EditMethodCallData * /*d*/)
{
// Get the current view that the user is in.
XAP_Frame * pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View * pView =
static_cast <FV_View *>(pFrame->getCurrentView());
std::string url("http://www.freetranslation.com");
if (!pView->isSelectionEmpty())
{
std::string langCode;
if (_getTranslationCode(pView, langCode))
{
// Now we will figure out what words to translate
// We need to get the Latin1 version of the current word.
UT_UCS4Char *ucs4ST;
pView->getSelectionText(*&ucs4ST);
char * translate = _ucs4ToLatin1(ucs4ST);
// URL encode the string (' ' -> %20, ...)
// TODO this is not complete
std::string srcText;
for (char *p = translate; p && *p; ++p)
{
if (*p == ' ' || *p == '%' || *p == '&' || *p == '?'
|| (*p & 128)) // sometime char is signed.
// do bitwise comparison for portability
{
char temp[4] = "";
sprintf(&temp[0], "%%%x", *p);
srcText += temp;
} else
srcText += *p;
}
url = "http://ets.freetranslation.com/?Sequence=core";
url += "&Language=";
url += langCode;
url += "&SrcText=";
url += srcText;
DELETEPV(translate);
FREEP(ucs4ST);
XAP_App::getApp()->openURL(url.c_str());
}
// else didn't get the translation code. don't show anything
} else {
XAP_App::getApp()->openURL(url.c_str());
}
return true;
}
bool s_abicollab_authors(AV_View* v, EV_EditMethodCallData* /*d*/)
{
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_val_if_fail(pManager, false);
FV_View * pView = static_cast<FV_View *>(v);
PD_Document * pDoc = pView->getDocument();
bool b = pDoc->isShowAuthors();
pDoc->setShowAuthors(!b);
return true;
}
/*!
Sets the sensitivity of the radio buttons to top/bottom/left/right line buttons
Call this right after contructing the widget and before dropping into the main loop.
*/
void AP_Dialog_FormatTable::setAllSensitivities(void)
{
XAP_Frame *frame = XAP_App::getApp()->getLastFocussedFrame();
if (frame) {
FV_View * pView = static_cast<FV_View *>(frame->getCurrentView());
setSensitivity(pView->isInTable());
}
else {
setSensitivity(false);
}
}
PD_RDFModelHandle
AP_Dialog_RDFEditor::getModel()
{
if( m_restrictedModel )
return m_restrictedModel;
FV_View* view = getView();
PD_Document* doc = view->getDocument();
PD_DocumentRDFHandle model = doc->getDocumentRDF();
return model;
}
void AP_Dialog_Paragraph::_createPreviewFromGC(GR_Graphics * gc,
UT_uint32 width,
UT_uint32 height)
{
UT_return_if_fail (gc);
// g_free any attached preview
DELETEP(m_paragraphPreview);
// platform's runModal should have set this
UT_return_if_fail (m_pFrame);
AV_View * baseview = m_pFrame->getCurrentView();
UT_return_if_fail (baseview);
FV_View * view = static_cast<FV_View *> (baseview);
FL_DocLayout * dl = view->getLayout();
UT_return_if_fail (dl);
fl_BlockLayout * bl = dl->findBlockAtPosition((PT_DocPosition) view->getPoint());
UT_return_if_fail (bl);
UT_GrowBuf gb;
bool hadMem = bl->getBlockBuf(&gb);
UT_UCSChar * tmp = NULL;
if (hadMem && gb.getLength() > 0)
{
gb.truncate(NUM_CHARS_FOR_SAMPLE);
UT_UCS4_cloneString(&tmp, (UT_UCSChar *) gb.getPointer(0));
}
else
{
const XAP_StringSet * pSS = m_pApp->getStringSet();
// if the paragraph was empty, use our sample
UT_UCS4_cloneString_char(&tmp, pSS->getValue(AP_STRING_ID_DLG_Para_PreviewSampleFallback));
}
m_paragraphPreview = new AP_Preview_Paragraph(gc, tmp, this);
FREEP(tmp);
UT_return_if_fail (m_paragraphPreview);
m_paragraphPreview->setWindowSize(width, height);
// TODO : any setup of the GC for drawing
}
/*!
* Method to actually do the cell merge.
*/
void AP_Dialog_SplitCells::onSplit(void)
{
FV_View * pView = 0;
if (XAP_Frame * pFrame = getApp()->getLastFocussedFrame())
{
pView = static_cast<FV_View *>(pFrame->getCurrentView());
}
if (pView)
{
pView->cmdSplitCells(m_SplitType);
}
setAllSensitivities();
}
bool fl_FrameLayout::bl_doclistener_insertEndFrame(fl_ContainerLayout*,
const PX_ChangeRecord_Strux * pcrx,
PL_StruxDocHandle sdh,
PL_ListenerId lid,
void (* pfnBindHandles)(PL_StruxDocHandle sdhNew,
PL_ListenerId lid,
PL_StruxFmtHandle sfhNew))
{
// The endFrame strux actually needs a format handle to to this Frame layout.
// so we bind to this layout.
PL_StruxFmtHandle sfhNew = static_cast<PL_StruxFmtHandle>(this);
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);
m_bHasEndFrame = true;
return true;
}
/*!
* Background abi repaint function.
\param XAP_UnixFrame * p pointer to the Frame that initiated this background
repainter.
*/
gint AP_UnixLeftRuler::_fe::abi_expose_repaint( gpointer p)
{
//
// Grab our pointer so we can do useful stuff.
//
UT_Rect localCopy;
AP_UnixLeftRuler * pR = static_cast<AP_UnixLeftRuler *>(p);
GR_Graphics * pG = pR->getGraphics();
if(pG == NULL || pG->isDontRedraw())
{
//
// Come back later
//
return TRUE;
}
FV_View * pView = static_cast<FV_View *>(pR->m_pFrame->getCurrentView());
if(pView && pView->getPoint()==0)
{
//
// Come back later
//
return TRUE;
}
pG->setSpawnedRedraw(true);
if(pG->isExposePending())
{
while(pG->isExposedAreaAccessed())
{
UT_usleep(10); // 10 microseconds
}
pG->setExposedAreaAccessed(true);
localCopy.set(pG->getPendingRect()->left,pG->getPendingRect()->top,
pG->getPendingRect()->width,pG->getPendingRect()->height);
//
// Clear out this set of expose info
//
pG->setExposePending(false);
pG->setExposedAreaAccessed(false);
xxx_UT_DEBUGMSG(("Painting area on Left ruler: left=%d, top=%d, width=%d, height=%d\n", localCopy.left, localCopy.top, localCopy.width, localCopy.height));
xxx_UT_DEBUGMSG(("SEVIOR: Repaint now \n"));
pR->draw(&localCopy);
}
//
// OK we've finshed. Wait for the next signal
//
pG->setSpawnedRedraw(false);
return TRUE;
}
//
// AbiMathView_FileInsert
// -------------------
// This is the function that we actually call to insert the MathML.
//
bool
AbiMathView_FileInsert(AV_View* /*v*/, EV_EditMethodCallData* /*d*/)
{
// Get the current view that the user is in.
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
PD_Document * pDoc = static_cast<PD_Document *>(pFrame->getCurrentDoc());
char* pNewFile = NULL;
bool bOK = s_AskForMathMLPathname(pFrame,&pNewFile);
if (!bOK || !pNewFile)
{
UT_DEBUGMSG(("ARRG! bOK = %d pNewFile = %s \n",bOK,pNewFile));
return false;
}
UT_UTF8String sNewFile = pNewFile;
// we own storage for pNewFile and must free it.
FREEP(pNewFile);
UT_DEBUGMSG(("fileInsertMathML: loading [%s]\n",sNewFile.utf8_str()));
IE_Imp_MathML * pImpMathML = new IE_Imp_MathML(pDoc, pMathManager->EntityTable());
UT_Error errorCode = pImpMathML->importFile(sNewFile.utf8_str());
if (errorCode != UT_OK)
{
s_CouldNotLoadFileMessage(pFrame, sNewFile.utf8_str(), errorCode);
DELETEP(pImpMathML);
return false;
}
/* Create the data item */
UT_uint32 uid = pDoc->getUID(UT_UniqueId::Image);
UT_UTF8String sUID;
UT_UTF8String_sprintf(sUID,"%d",uid);
pDoc->createDataItem(sUID.utf8_str(), false, pImpMathML->getByteBuf(),
"application/mathml+xml", NULL);
/* Insert the MathML Object */
PT_DocPosition pos = pView->getPoint();
pView->cmdInsertMathML(sUID.utf8_str(),pos);
DELETEP(pImpMathML);
return true;
}
/*!
this method goes with setSelectionStatus().
we are called by the clipboard (thru the callback chain)
in response to another application stealing the X Selection.
we need to notify the view so that it can clear the screen
as is the custom on X -- only one selection at any time.
we have to watch out here because when we call up to clear
the selection, the view will notify the view-listeners of
the change, which may cause setSelectionStatus() to get
called and thus update the clipboard -- this could recurse
a while....
*/
void AP_UnixApp::clearSelection(void)
{
if (m_bSelectionInFlux)
return;
m_bSelectionInFlux = true;
if (m_pViewSelection && m_pFrameSelection && m_bHasSelection)
{
FV_View *pView = static_cast<FV_View *>(m_pViewSelection);
pView->cmdUnselectSelection();
m_bHasSelection = false;
}
m_bSelectionInFlux = false;
}
void fl_ContainerLayout::getSpanAP(UT_uint32 blockPos, bool bLeft, const PP_AttrProp * &pSpanAP) const
{
//first we need to ascertain if this revision is visible
FL_DocLayout* pDL = getDocLayout();
UT_return_if_fail(pDL);
FV_View* pView = pDL->getView();
UT_return_if_fail(pView);
UT_uint32 iId = pView->getRevisionLevel();
bool bShow = pView->isShowRevisions();
bool bHiddenRevision = false;
getSpanAttrProp(blockPos, bLeft, &pSpanAP,NULL,bShow,iId,bHiddenRevision);
}
bool fl_EmbedLayout::bl_doclistener_insertEndEmbed(fl_ContainerLayout*,
const PX_ChangeRecord_Strux * pcrx,
pf_Frag_Strux* sdh,
PL_ListenerId lid,
void (* pfnBindHandles)(pf_Frag_Strux* sdhNew,
PL_ListenerId lid,
fl_ContainerLayout* sfhNew))
{
// The endFootnote strux actually needs a format handle to to this Footnote layout.
// so we bind to this layout.
fl_ContainerLayout* sfhNew = this;
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);
}
m_bHasEndFootnote = true;
fl_BlockLayout * pBL = static_cast<fl_BlockLayout *>(getFirstLayout());
pBL->updateEnclosingBlockIfNeeded();
return true;
}
static bool
Presentation_context (AV_View * v, EV_EditMethodCallData * d)
{
FV_View * pView = static_cast<FV_View *>(v);
XAP_Frame * pFrame = static_cast<XAP_Frame *> (pView->getParentData());
UT_sint32 xPos = d->m_xPos;
UT_sint32 yPos = d->m_yPos;
const char * szContextMenuName = XAP_App::getApp()->getMenuFactory()->FindContextMenu(PresentationContextID);
UT_DEBUGMSG(("Context Menu Name is........ %s \n",szContextMenuName));
if (!szContextMenuName)
return false;
bool res = pFrame->runModalContextMenu(pView,szContextMenuName,
xPos,yPos);
pFrame->nullUpdate();
GR_Graphics * pG = pView->getGraphics();
if(pG)
pG->allCarets()->disable();
return res;
}
void fl_EndnoteLayout::format(void)
{
UT_DEBUGMSG(("SEVIOR: Formatting Endnote first container is %p \n",getFirstContainer()));
if(getFirstContainer() == NULL)
{
getNewContainer();
}
if(!m_bIsOnPage)
{
_insertEndnoteContainer(getFirstContainer());
}
fl_ContainerLayout* pBL = getFirstLayout();
while (pBL)
{
pBL->format();
UT_sint32 count = 0;
while(pBL->getLastContainer() == NULL || pBL->getFirstContainer()==NULL)
{
UT_DEBUGMSG(("Error formatting a block try again \n"));
count = count + 1;
pBL->format();
if(count > 3)
{
UT_DEBUGMSG(("Give up trying to format. Hope for the best :-( \n"));
break;
}
}
pBL = pBL->getNext();
}
static_cast<fp_EndnoteContainer *>(getFirstContainer())->layout();
m_bNeedsFormat = false;
m_bNeedsReformat = false;
bool bOnPage = (getFirstContainer()->getPage() != NULL);
FV_View * pView = NULL;
if(m_pLayout)
pView = m_pLayout->getView();
if(bOnPage && pView && !pView->isLayoutFilling())
{
getDocSectionLayout()->setNeedsSectionBreak(true,NULL);
}
UT_ASSERT(getFirstContainer()->getPage());
}
/*!
Parse stream contents into the document
\param stream Stream to import from
This code is used for both files and the clipboard
*/
UT_Error IE_Imp_Object::_parseStream(ImportStream * pStream)
{
UT_return_val_if_fail(pStream, UT_ERROR);
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
UT_UCSChar c;
unsigned char uc;
while (pStream->getChar(c))
{
uc = static_cast<unsigned char>(c);
m_pByteBuf->append(&uc,1);
}
const char* mimetypeGOChart = "application/x-goffice-graph";
const char * szProps="embed-type: GOChart";
PT_DocPosition pos = pView->getPoint();
pView->cmdInsertEmbed(m_pByteBuf,pView->getPoint(),mimetypeGOChart,szProps);
pView->cmdSelect(pos,pos+1);
return UT_OK;
}
//
// URLDict_invoke
// -------------------
// This is the function that we actually call to invoke the on-line dictionary.
// It should be called when the user selects from the context menu
//
static bool
URLDict_invoke(AV_View* /*v*/, EV_EditMethodCallData * /*d*/)
{
// Get the current view that the user is in.
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
// If the user is on a word, but does not have it selected, we need
// to go ahead and select that word so that the search/replace goes
// correctly.
pView->moveInsPtTo(FV_DOCPOS_EOW_MOVE);
pView->moveInsPtTo(FV_DOCPOS_BOW);
pView->extSelTo(FV_DOCPOS_EOW_SELECT);
// Now we will figure out what word to look up when we open our dialog.
UT_String url ("http://www.dict.org/bin/Dict?Form=Dict1&Database=*&Strategy=*&Query=");
if (!pView->isSelectionEmpty())
{
// We need to get the Ascii version of the current word.
UT_UCS4Char *ucs4ST;
pView->getSelectionText(*&ucs4ST);
char* search = _ucsToAscii(
ucs4ST
);
url += search;
DELETEPV(search);
FREEP(ucs4ST);
}
XAP_App::getApp()->openURL( url.c_str() );
return true;
}
std::pair< PT_DocPosition, PT_DocPosition >
IE_Imp_RDF::insertTextWithXMLID( const std::string& textconst,
const std::string& xmlid )
{
std::string text = " " + textconst + " ";
PT_DocPosition startpos = getDocPos();
// FIXME
/*bool bRes =*/ appendSpan( text );
PT_DocPosition endpos = getDocPos();
startpos++;
endpos--;
XAP_Frame* lff = XAP_App::getApp()->getLastFocussedFrame();
if(lff)
{
FV_View * pView = static_cast<FV_View*>( lff->getCurrentView() );
pView->selectRange( startpos, endpos );
pView->cmdInsertXMLID( xmlid );
}
return std::make_pair( startpos, endpos );
}
void AP_UnixDialog_FormatFrame::notifyActiveFrame(XAP_Frame *_pFrame)
{
UT_ASSERT(m_windowMain);
ConstructWindowName();
gtk_window_set_title (GTK_WINDOW (m_windowMain), m_WindowName);
setAllSensitivities();
FV_View * pView = static_cast<FV_View *>(_pFrame->getCurrentView());
if(pView && pView->isInFrame(pView->getPoint()))
{
fl_BlockLayout * pBL = pView->getCurrentBlock();
fl_FrameLayout * pFrame = static_cast<fl_FrameLayout *>(pBL->myContainingLayout());
if(pFrame->getContainerType() != FL_CONTAINER_FRAME)
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return;
}
if(pFrame->getFrameWrapMode() >= FL_FRAME_WRAPPED_TO_RIGHT)
{
setWrapping(true);
}
else
{
setWrapping(false);
}
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_wWrapButton),getWrapping());
if(positionMode() == FL_FRAME_POSITIONED_TO_BLOCK)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON( m_wPosParagraph),TRUE);
}
else if(positionMode() == FL_FRAME_POSITIONED_TO_COLUMN)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_wPosColumn),TRUE);
}
else if(positionMode() == FL_FRAME_POSITIONED_TO_PAGE)
{
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(m_wPosPage),TRUE);
}
}
}
void AP_Dialog_FormatTable::applyChanges()
{
UT_DEBUGMSG(("Doing apply changes number props %d \n",m_vecProps.getItemCount()));
if (m_vecProps.getItemCount() == 0)
return;
FV_View * pView = static_cast<FV_View *>(XAP_App::getApp()->getLastFocussedFrame()->getCurrentView());
const gchar ** propsArray = new const gchar * [m_vecProps.getItemCount()+1];
propsArray[m_vecProps.getItemCount()] = NULL;
UT_sint32 i = m_vecProps.getItemCount();
UT_sint32 j;
for(j= 0; j<i; j=j+2)
{
propsArray[j] = static_cast<gchar *>(m_vecProps.getNthItem(j));
propsArray[j+1] = static_cast<gchar *>(m_vecProps.getNthItem(j+1));
}
pView->setCellFormat(propsArray, m_ApplyTo,m_pGraphic,m_sImagePath);
delete [] propsArray;
m_bSettingsChanged = false;
}
void fl_FrameLayout::collapse(void)
{
FV_View * pView = getDocLayout()->getView();
if(pView)
{
if(pView->getFrameEdit()->getFrameLayout() == this)
{
pView->getFrameEdit()->setMode(FV_FrameEdit_NOT_ACTIVE);
}
}
localCollapse();
fp_FrameContainer *pFC = static_cast<fp_FrameContainer *>(getFirstContainer());
if (pFC)
{
//
// Remove it from the page.
//
if(pFC->getPage())
{
pFC->getPage()->removeFrameContainer(pFC);
pFC->setPage(NULL);
}
//
// remove it from the linked list.
//
fp_FrameContainer * pPrev = static_cast<fp_FrameContainer *>(pFC->getPrev());
if(pPrev)
{
pPrev->setNext(pFC->getNext());
}
if(pFC->getNext())
{
pFC->getNext()->setPrev(pPrev);
}
delete pFC;
}
setFirstContainer(NULL);
setLastContainer(NULL);
}
