filter_result MenuFilter::Filter(BMessage *message, BHandler **target)
{
if (message->what != ABI_BEOS_MENU_EV)
{
return(B_DISPATCH_MESSAGE);
}
//XAP_Menu_Id id = 0;
BMenuItem* sourceItem;
int32 id = 0;
message->FindInt32(ABI_BEOS_MENU_EV_NAME, &id);
message->FindPointer("source" , (void **)&sourceItem);
//if(sourceItem->IsMarked())
// sourceItem->SetMarked(false);
const EV_Menu_ActionSet * pMenuActionSet = m_pBeOSApp->getMenuActionSet();
UT_ASSERT(pMenuActionSet);
const EV_Menu_Action * pAction = pMenuActionSet->getAction(id);
UT_ASSERT(pAction);
#if 0
if(m_pBeOSFrame->getCurrentView() && pAction->hasGetStateFunction())
{
if(pAction->isCheckable() || pAction->isRadio())
{
EV_Menu_ItemState mis = pAction->getMenuItemState(m_pBeOSFrame->getCurrentView());
if (mis & EV_MIS_Toggled)
sourceItem->SetMarked(false);
else
sourceItem->SetMarked(true);
}
}
#endif
const char * szMethodName = pAction->getMethodName();
if (!szMethodName)
return(B_SKIP_MESSAGE);
const EV_EditMethodContainer * pEMC = m_pBeOSApp->getEditMethodContainer();
UT_ASSERT(pEMC);
EV_EditMethod * pEM = pEMC->findEditMethodByName(szMethodName);
UT_ASSERT(pEM); // make sure it's bound to something
UT_String script_name(pAction->getScriptName());
m_pEVMenu->invokeMenuMethod(m_pBeOSFrame->getCurrentView(), pEM, script_name);
((EV_BeOSMenu *)m_pEVMenu)->synthesize();
return(B_SKIP_MESSAGE);
}
//
// 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;
}
static gboolean focus_out_event_Modeless(GtkWidget *widget,GdkEvent */*event*/,gpointer /*user_data*/)
{
XAP_App *pApp = static_cast<XAP_App *>(g_object_get_data(G_OBJECT(widget), "pApp"));
XAP_Frame *pFrame = pApp->getLastFocussedFrame();
if(pFrame ==static_cast<XAP_Frame *>(NULL))
{
UT_uint32 nframes = pApp->getFrameCount();
if(nframes > 0 && nframes < 10)
{
pFrame = pApp->getFrame(0);
}
else
{
return FALSE;
}
}
if(pFrame == static_cast<XAP_Frame *>(NULL)) return FALSE;
AV_View * pView = pFrame->getCurrentView();
UT_ASSERT_HARMLESS(pView);
if(pView!= NULL)
{
pView->focusChange(AV_FOCUS_NONE);
}
return FALSE;
}
//
// 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;
}
FV_View * AP_Dialog_Modeless::getView(void) const
{
XAP_Frame * pFrame = getActiveFrame();
if (pFrame)
return (FV_View *) pFrame->getCurrentView();
else
return NULL;
}
//
// 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;
}
UT_Error IE_Exp_EPUB::doOptions()
{
XAP_Frame * pFrame = XAP_App::getApp()->getLastFocussedFrame();
if (!pFrame || isCopying()) return UT_OK;
if (pFrame)
{
AV_View * pView = pFrame->getCurrentView();
if (pView)
{
GR_Graphics * pG = pView->getGraphics();
if (pG && pG->queryProperties(GR_Graphics::DGP_PAPER))
{
return UT_OK;
}
}
}
//FIXME:FIDENCIO: Remove this clause when Cocoa's dialog is implemented
#ifdef TOOLKIT_COCOA
return UT_OK;
#else
/* run the dialog
*/
XAP_Dialog_Id id = m_iDialogExport;
XAP_DialogFactory * pDialogFactory
= static_cast<XAP_DialogFactory *> (XAP_App::getApp()->getDialogFactory());
AP_Dialog_EpubExportOptions* pDialog
= static_cast<AP_Dialog_EpubExportOptions*> (pDialogFactory->requestDialog(id));
if (pDialog == NULL)
{
return UT_OK;
}
pDialog->setEpubExportOptions(&m_exp_opt, XAP_App::getApp());
pDialog->runModal(pFrame);
/* extract what they did
*/
bool bSave = pDialog->shouldSave();
pDialogFactory->releaseDialog(pDialog);
if (!bSave)
{
return UT_SAVE_CANCELLED;
}
return UT_OK;
#endif
}
/*!
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);
}
}
//
// 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;
}
/*!
translate given language tag into static UT_LangRecord stored in
UT_Language class and set m_pKbdLang to it; do addtional
processing to ensure the change propagates into the status bar
*/
void XAP_App::setKbdLanguage(const char * pszLang)
{
if(!pszLang)
{
m_pKbdLang = NULL;
}
else
{
UT_Language Lang;
m_pKbdLang = Lang.getLangRecordFromCode(pszLang);
// ensure that the change is shown in our status bar
bool bChangeLang = false;
getPrefsValueBool(XAP_PREF_KEY_ChangeLanguageWithKeyboard, &bChangeLang);
if(bChangeLang && m_pKbdLang)
{
UT_return_if_fail(m_pKbdLang->m_szLangCode);
// invoke appropriate formatting method if it exists
const EV_EditMethodContainer * pEMC = getEditMethodContainer();
if(pEMC)
{
EV_EditMethod * pEM = pEMC->findEditMethodByName("language");
if (pEM)
{
XAP_Frame * pFrame = getLastFocussedFrame();
if(pFrame)
{
AV_View * pView = pFrame->getCurrentView();
if(pView)
{
EV_EditMethodCallData CallData(m_pKbdLang->m_szLangCode,
strlen(m_pKbdLang->m_szLangCode));
pEM->Fn(pView,&CallData);
}
}
}
}
}
}
}
/*!
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_FormatFrame::setAllSensitivities(void)
{
XAP_Frame * frame = m_pApp->getLastFocussedFrame();
if (frame) {
FV_View * pView = static_cast<FV_View *>(frame->getCurrentView());
if (pView) {
bool bInFrame = m_bSensitive; // pView->isInFrame(pView->getPoint());
setSensitivity(bInFrame);
}
else {
setSensitivity(false);
}
}
else {
setSensitivity(false);
}
}
//
// AbiGoogle_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
AbiGoogle_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.
if (pView->isSelectionEmpty()) {
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
UT_UTF8String url ("http://www.google.com/search?hl=en&ie=UTF-8&oe=UTF-8&q=");
// url escaping should be moved somewhere more generic
UT_UCS4Char *ucs4ST;
pView->getSelectionText(*&ucs4ST);
UT_UCS4String data (ucs4ST);
bool last_was_space = false;
for (size_t i = 0; i < data.length (); i++) {
UT_UCS4Char ch = data[i];
if (!UT_UCS4_isspace (ch)) {
url.appendUCS4 (&ch, 1);
last_was_space = false;
}
else if (!last_was_space) {
ch = '+';
url.appendUCS4 (&ch, 1);
last_was_space = true;
}
}
XAP_App::getApp()->openURL( url.utf8_str() );
FREEP(ucs4ST);
return true;
}
/*!
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;
}
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 );
}
bool ev_EditMethod_invoke (const EV_EditMethod * pEM,
EV_EditMethodCallData * pData)
{
// no method or no call data == bad joo joo - return false
UT_ASSERT(pEM);
UT_ASSERT(pData);
if ( !pEM || !pData )
return false ;
// no controlling view == bad joo joo - return false
// Actually allow this for plugins invoked from the command line
//
AV_View * pView = NULL;
XAP_Frame * pFrame = XAP_App::getApp()->getLastFocussedFrame();
if(!pFrame)
{
return pEM->Fn(pView, pData);
}
pView = pFrame->getCurrentView() ;
UT_return_val_if_fail(pView, false);
// return whatever the method says to based on the data at hand
return pEM->Fn(pView, pData);
}
//
// BabelFish_invoke
// -------------------
// This is the function that we actually call to invoke the
// online babelfish translation
// It should be called when the user selects from the context menu
//
static bool BabelFish_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());
UT_String url ("http://babelfish.altavista.com");
if (!pView->isSelectionEmpty())
{
// TODO: generate the correct language binding via the current
// TODO: language and then the language dialog. Currently
// TODO: english->german is hardcoded
UT_String langCode;
if ( _getTranslationCode ( pView, langCode ) )
{
// Now we will figure out what words to translate
url = "http://babelfish.altavista.com/tr?doit=done&tt=urltext";
url += "&lp=";
url += langCode;
url += "&urltext=";
// We need to get the UTF-8 version of the current word.
UT_String utf8;
UT_UCS4Char *ucs4ST;
pView->getSelectionText(*&ucs4ST);
_ucsToUTF8(
utf8,
ucs4ST
);
// URL encode the string (' ' -> %20, ...)
// TODO this is not complete
UT_String srcText;
//for (char *p = utf8; p && *p; ++p)
for (UT_uint32 i = 0; i < utf8.size(); ++i)
{
if (utf8[i] == ' ' || utf8[i] == '%'
|| utf8[i] == '&' || utf8[i] == '?' || (utf8[i] & 128))
{
char temp[4] = "";
sprintf(&temp[0], "%%%x", utf8[i]);
srcText += temp;
} else
srcText += utf8[i];
}
url += srcText;
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;
}
//
// AbiPaint saveAsBmp
// ------------------
// This is the function exports selected image as a Windows BMP file.
//
// parameters are:
// AV_View* v
// EV_EditMethodCallData *d)
//
static DECLARE_ABI_PLUGIN_METHOD(saveAsBmp)
{
// Get a frame (for error messages) and (to) 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());
char *szTempFileName = NULL;
GError *err = NULL;
gint fp = g_file_open_tmp ("XXXXXX", &szTempFileName, &err);
if (err) {
g_warning (err->message);
g_error_free (err); err = NULL;
return FALSE;
}
close(fp);
UT_String szTmpPng = szTempFileName;
szTmpPng += ".png";
remove(szTempFileName);
g_free (szTempFileName); szTempFileName = NULL;
PT_DocPosition pos = pView->saveSelectedImage((const char *)szTmpPng.c_str());
if(pos == 0)
{
pFrame->showMessageBox("You must select an Image before trying to save it as a BMP file!", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
return false;
}
//
// Convert png into bmp
// NOTE: probably looses detail/information though!!!
//
UT_String szBMPFile = pFrame->getFilename(); // perhaps a different default directory should be used???
{
const char * szDescList[2];
const char * szSuffixList[2];
IEGraphicFileType ft[2];
{
// IE_ImpGraphicBMP_Sniffer tmp;
// tmp.getDlgLabels(szDescList, szSuffixList, ft);
szDescList[0] = "Windows Bitmap (*.bmp)";
szSuffixList[0] = "*.bmp";
ft[0] = IEGFT_BMP;
}
szDescList[1] = szSuffixList[1] = NULL;
ft[1] = IEGFT_Unknown;
if (getFileName(szBMPFile, pFrame, XAP_DIALOG_ID_FILE_SAVEAS, szDescList, szSuffixList, ft))
{
// user canceled
remove(szTmpPng.c_str());
return true;
}
}
if (convertPNG2BMP(szTmpPng.c_str(), szBMPFile.c_str()))
{
pFrame->showMessageBox("Unable to convert PNG image data to BMP.", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
remove(szTmpPng.c_str());
return false;
}
remove(szTmpPng.c_str());
return true;
}
/*!
* Take a packet, interpret it's contents and apply the implied operations on the document.
*/
bool ABI_Collab_Import::_import(const SessionPacket& packet, UT_sint32 iImportAdjustment, BuddyPtr pCollaborator, bool inGlob)
{
UT_DEBUGMSG(("ABI_Collab_Import::_import() - packet class type: %d, iImportAdjustment: %d\n", packet.getClassType(), iImportAdjustment));
UT_return_val_if_fail(pCollaborator, false);
switch (packet.getClassType())
{
case PCT_GlobSessionPacket:
{
const GlobSessionPacket* gp = static_cast<const GlobSessionPacket*>(&packet);
UT_return_val_if_fail(gp->getPackets().size() > 0, false);
// store the last seen revision from this collaborator (it is immediately used by the export)
m_remoteRevs[pCollaborator] = gp->getRev();
for (UT_uint32 j = 0; j < gp->getPackets().size(); j++)
{
SessionPacket* pGlobPacket = gp->getPackets()[j];
if (pGlobPacket)
{
bool res = _import(*pGlobPacket, iImportAdjustment, pCollaborator, true); // yay for recursion :)
if (!res)
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
}
}
return true;
}
case PCT_SignalSessionPacket:
{
const SignalSessionPacket* sp = static_cast<const SignalSessionPacket*>(&packet);
m_pDoc->signalListeners(sp->getSignalType());
return true;
}
case PCT_RevertSessionPacket:
{
const RevertSessionPacket* rrp = static_cast<const RevertSessionPacket*>(&packet);
UT_DEBUGMSG(("Revert packet seen on import for rev: %d\n", rrp->getRev()));
if (m_iAlreadyRevertedRevs.size() == 0 || m_iAlreadyRevertedRevs.front() != rrp->getRev())
{
UT_DEBUGMSG(("Incoming revert for revision %d, which we didn't detect locally (m_iAlreadyRevertedRev: %d)!\n", rrp->getRev(), m_iAlreadyRevertedRevs.front()));
UT_DEBUGMSG(("DOCUMENT OUT OF SYNC DETECTED!!!!\n"));
UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED);
return false;
}
m_iAlreadyRevertedRevs.pop_front();
return true;
}
case PCT_RevertAckSessionPacket:
{
UT_DEBUGMSG(("RevertAck packet seen on import for rev: %d\n", static_cast<const RevertAckSessionPacket*>(&packet)->getRev()));
// remove this collaborator from our revert ack list; he can play again...
for (std::vector<std::pair<BuddyPtr, UT_sint32> >::iterator it = m_revertSet.begin(); it != m_revertSet.end(); it++)
{
if ((*it).first == pCollaborator)
{
UT_DEBUGMSG(("Found collaborator %s on our revert ack list with rev %d! Removing him from the list...\n", (*it).first->getDescription().utf8_str(), (*it).second));
UT_ASSERT_HARMLESS((*it).second == static_cast<const RevertAckSessionPacket*>(&packet)->getRev());
m_revertSet.erase(it);
return true;
}
}
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return false;
}
default:
// silly C++ can't switch on ranges
if (packet.getClassType() >= _PCT_FirstChangeRecord && packet.getClassType() <= _PCT_LastChangeRecord)
{
const ChangeRecordSessionPacket* crp = static_cast<const ChangeRecordSessionPacket*>(&packet);
UT_DEBUGMSG(("It's safe to import this packet\n"));
UT_DEBUGMSG(("For CR number %d requested point %d adjustment %d \n", crp->getRev(), crp->getPos(), iImportAdjustment));
PT_DocPosition pos = static_cast<PT_DocPosition>(crp->getPos() + iImportAdjustment);
UT_ASSERT(pos <= getEndOfDoc());
if (!inGlob)
{
// store the last seen revision from this collaborator (it is immediately used by the export)
// NOTE: if this changerecord is part of a glob, then we don't do this; we'll have
// already set the revision of the glob itself as the last seen one
m_remoteRevs[pCollaborator] = crp->getRev();
}
// todo: remove these temp vars
PT_DocPosition iPos2 = 0;
// process the packet
switch(crp->getPXType())
{
case PX_ChangeRecord::PXT_GlobMarker:
{
UT_DEBUGMSG(("Found GLOB marker (ignoring)\n"));
return true;
}
case PX_ChangeRecord::PXT_InsertSpan:
{
const InsertSpan_ChangeRecordSessionPacket* icrsp = static_cast<const InsertSpan_ChangeRecordSessionPacket*>( crp );
UT_UCS4String UCSChars = const_cast<UT_UTF8String&>(icrsp->m_sText).ucs4_str(); // ugly, ucs4_str should be const func!
PP_AttrProp attrProp;
attrProp.setAttributes(const_cast<const gchar**>(icrsp->getAtts()));
attrProp.setProperties(const_cast<const gchar**>(icrsp->getProps()));
m_pDoc->insertSpan(pos,UCSChars.ucs4_str(),UCSChars.length(), &attrProp);
break;
}
case PX_ChangeRecord::PXT_DeleteSpan:
{
iPos2 = pos + crp->getLength();
PP_AttrProp *p_AttrProp_Before = NULL;
UT_uint32 icnt = 0;
m_pDoc->deleteSpan(pos,iPos2,p_AttrProp_Before,icnt,true);
break;
}
case PX_ChangeRecord::PXT_ChangeSpan:
{
const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp );
gchar** szAtts = pcrsp->getAtts();
gchar** szProps = pcrsp->getProps();
iPos2 = pos + pcrsp->getLength();
if((szProps == NULL) && (szAtts == NULL))
{
//
// This happens if we remove all formats
// we have to handle this seperately
//
// Get style of containing block
//
pf_Frag_Strux* sdh = NULL;
m_pDoc->getStruxOfTypeFromPosition(pos,PTX_Block,&sdh);
if(!sdh)
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return false;
}
PD_Style * pStyle = m_pDoc->getStyleFromSDH(sdh);
if(!pStyle)
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return false;
}
const gchar * szName = pStyle->getName();
const gchar * atts[3] = {PT_STYLE_ATTRIBUTE_NAME,szName,NULL};
m_pDoc->changeSpanFmt(PTC_SetExactly, pos, iPos2, atts, const_cast<const gchar**>( szProps ) );
}
else
{
m_pDoc->changeSpanFmt(PTC_SetExactly, pos, iPos2, const_cast<const gchar**>(szAtts), const_cast<const gchar**>( szProps ) );
}
break;
}
case PX_ChangeRecord::PXT_InsertStrux:
{
const ChangeStrux_ChangeRecordSessionPacket* pcrsp = static_cast<const ChangeStrux_ChangeRecordSessionPacket*>( crp );
PTStruxType pts = pcrsp->m_eStruxType;
gchar** szAtts = pcrsp->getAtts();
gchar** szProps = pcrsp->getProps();
if((szProps != NULL) || (szAtts != NULL))
{
m_pDoc->insertStrux( pos, pts, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ) );
}
else
{
m_pDoc->insertStrux(pos, pts);
}
break;
}
case PX_ChangeRecord::PXT_DeleteStrux:
{
const DeleteStrux_ChangeRecordSessionPacket* pcrsp = static_cast<const DeleteStrux_ChangeRecordSessionPacket*>( crp );
PTStruxType pts = pcrsp->m_eStruxType;
m_pDoc->deleteStrux(pos,pts,true);
break;
}
case PX_ChangeRecord::PXT_ChangeStrux:
{
const ChangeStrux_ChangeRecordSessionPacket* pcrsp = static_cast<const ChangeStrux_ChangeRecordSessionPacket*>( crp );
PTStruxType pts = pcrsp->m_eStruxType;
gchar** szAtts = pcrsp->getAtts();
gchar** szProps = pcrsp->getProps();
UT_return_val_if_fail(szProps != NULL || szAtts != NULL, false);
UT_DEBUGMSG(("Executing ChangeStrux pos= %d \n",pos));
m_pDoc->changeStruxFmt(PTC_SetExactly, pos, pos, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ), pts);
// TODO: this mask is waaaay to generic
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
if (pFrame)
{
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
if (pView)
pView->notifyListeners(AV_CHG_TYPING | AV_CHG_FMTCHAR | AV_CHG_FMTBLOCK | AV_CHG_PAGECOUNT | AV_CHG_FMTSTYLE );
}
break;
}
case PX_ChangeRecord::PXT_InsertObject:
{
const Object_ChangeRecordSessionPacket* ocrsp = static_cast<const Object_ChangeRecordSessionPacket*>( crp );
PTObjectType pto = ocrsp->getObjectType();
gchar** szAtts = ocrsp->getAtts();
gchar** szProps = ocrsp->getProps();
if((szProps == NULL) && (szAtts == NULL))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return false;
}
m_pDoc->insertObject(pos, pto, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ) );
break;
}
case PX_ChangeRecord::PXT_DeleteObject:
{
iPos2 = pos + 1;
PP_AttrProp *p_AttrProp_Before = NULL;
UT_uint32 icnt = 0;
m_pDoc->deleteSpan(pos, iPos2, p_AttrProp_Before, icnt, true);
break;
}
case PX_ChangeRecord::PXT_ChangeObject:
{
const Object_ChangeRecordSessionPacket* ccrsp = static_cast<const Object_ChangeRecordSessionPacket*>( crp );
//PTObjectType pto = ccrsp->m_eObjectType;
gchar** szAtts = ccrsp->getAtts();
gchar** szProps = ccrsp->getProps();
if ((szProps == NULL) && (szAtts == NULL))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return false;
}
m_pDoc->changeSpanFmt(PTC_SetExactly, pos, pos + 1, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ));
break;
}
case PX_ChangeRecord::PXT_ChangeDocRDF:
{
// down cast crp to get dcrp
const RDF_ChangeRecordSessionPacket* dcrp = static_cast<const RDF_ChangeRecordSessionPacket*>( crp );
gchar** szAtts = dcrp->getAtts();
gchar** szProps = dcrp->getProps();
if ((szProps == NULL) && (szAtts == NULL))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return false;
}
{
// update the local document RDF to remove
// szAtts RDF and then add the szProps RDF
m_pDoc->getDocumentRDF()->handleCollabEvent( szAtts, szProps );
}
break;
}
case PX_ChangeRecord::PXT_InsertFmtMark:
{
const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp );
gchar** szAtts = pcrsp->getAtts();
gchar** szProps = pcrsp->getProps();
if((szProps == NULL) && (szAtts == NULL))
{
// nothing to do here, please move along
// NOTE: why does this happen anyway?
// This happens when for example when sending over tables:
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return false;
}
return m_pDoc->changeSpanFmt(PTC_SetExactly, pos, pos, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ));
}
case PX_ChangeRecord::PXT_DeleteFmtMark:
{
return m_pDoc->deleteFmtMark(pos);
}
case PX_ChangeRecord::PXT_ChangeFmtMark:
{
const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp );
gchar** szAtts = pcrsp->getAtts();
gchar** szProps = pcrsp->getProps();
if ((szProps == NULL) && (szAtts == NULL))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
return false;
}
return m_pDoc->changeSpanFmt(PTC_SetExactly, pos, pos, const_cast<const gchar**>( szAtts ), const_cast<const gchar**>( szProps ));
}
case PX_ChangeRecord::PXT_ChangePoint:
{
UT_DEBUGMSG(("Change Point CR \n"));
return m_pDoc->createAndSendCR(pos, crp->getPXType(), true, 0);
}
case PX_ChangeRecord::PXT_ListUpdate:
{
UT_DEBUGMSG(("ListUpdate CR \n"));
return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0);
}
case PX_ChangeRecord::PXT_StopList:
{
UT_DEBUGMSG(("StopList CR \n"));
return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0);
}
case PX_ChangeRecord::PXT_UpdateField:
{
UT_DEBUGMSG(("UpdateFiled CR \n"));
return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0);
}
case PX_ChangeRecord::PXT_RemoveList:
{
UT_DEBUGMSG(("RemoveList CR \n"));
return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0);
}
case PX_ChangeRecord::PXT_UpdateLayout:
{
UT_DEBUGMSG(("UpdateLayout CR \n"));
return m_pDoc->createAndSendCR(pos, crp->getPXType(), true,0);
}
case PX_ChangeRecord::PXT_CreateDataItem:
{
const Data_ChangeRecordSessionPacket* dp = static_cast<const Data_ChangeRecordSessionPacket*>( crp );
const char * szNameV = g_strdup(dp->getAttribute(PT_DATAITEM_ATTRIBUTE_NAME));
PD_DataItemHandle pHandle = NULL;
std::string sToken = dp->m_bTokenSet ? dp->m_sToken : "";
UT_ByteBuf * pBuf= new UT_ByteBuf();
UT_DEBUGMSG(("PXT_CreateDataItem: append image buffer @ 0x%p, %lu bytes, sToken %s\n", &dp->m_vecData[0], (long unsigned)dp->m_vecData.size(), sToken.c_str()));
pBuf->append(reinterpret_cast<const UT_Byte *>( &dp->m_vecData[0] ), dp->m_vecData.size() );
bool res = m_pDoc->createDataItem(szNameV,false,pBuf,sToken,&pHandle);
delete pBuf;
return res;
}
case PX_ChangeRecord::PXT_ChangeDocProp:
{
UT_DEBUGMSG(("ChangeDocProp CR \n"));
const Props_ChangeRecordSessionPacket* pcrsp = static_cast<const Props_ChangeRecordSessionPacket*>( crp );
//
// Assemble the Attributes for different properties
//
const gchar** szAtts = const_cast<const gchar **>(pcrsp->getAtts());
const gchar** szProps = const_cast<const gchar **>(pcrsp->getProps());
//
// Now direct the document to make the changes
//
return m_pDoc->changeDocPropeties(szAtts,szProps);
}
default:
{
UT_DEBUGMSG(("Unimplemented crp->getPXType(): %d\n", crp->getPXType()));
UT_ASSERT_HARMLESS(UT_NOT_IMPLEMENTED);
break;
}
}
return true;
}
else
{
UT_DEBUGMSG(("ABI_Collab_Import::import called with unhandled packet class type: %d!\n", packet.getClassType()));
return false;
}
break;
}
return false;
}
//
// AbiPaint editImage
// ------------------
// This is the function that we actually call to invoke the image editor.
//
// parameters are:
// AV_View* v
// EV_EditMethodCallData *d
//
static DECLARE_ABI_PLUGIN_METHOD(editImage)
{
UT_UNUSED(v);
// 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());
//
// get values from preference (initial plugin execution should have set sensible defaults)
//
UT_String imageApp; // holds MAXPATH\appName <space> MAXPATH\imagefilename
bool bLeaveImageAsPNG;
// read stuff from the preference value
if (!prefsScheme->getValue(ABIPAINT_PREF_KEY_szProgramName, imageApp))
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
getDefaultApp(imageApp, bLeaveImageAsPNG);
}
// now that we have program name, try to get other flag (allows overriding default value)
// Note: we allow overriding, otherwise if we don't adhere to user's setting
// then the use BMP or not menu should be greyed to note it has no effect
prefsScheme->getValueBool(ABIPAINT_PREF_KEY_bLeaveImageAsPNG, &bLeaveImageAsPNG);
//
// generate a temp file name...
//
char *szTempFileName = NULL;
GError *err = NULL;
gint fp = g_file_open_tmp ("XXXXXX", &szTempFileName, &err);
if (err) {
g_warning ("%s", err->message);
g_error_free (err); err = NULL;
return FALSE;
}
close(fp);
UT_String szTmpPng = szTempFileName;
szTmpPng += ".png";
UT_String szTmp = szTmpPng; // default: our temp file is the created png file
PT_DocPosition pos = pView->saveSelectedImage((const char *)szTmpPng.c_str());
if(pos == 0)
{
remove(szTempFileName);
g_free (szTempFileName); szTempFileName = NULL;
pFrame->showMessageBox("You must select an Image before editing it", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
return false;
}
#ifdef ENABLE_BMP
//
// Convert png into bmp for best compatibility with Windows programs
// NOTE: probably looses detail/information though!!! so if possible use PNG
//
if (!bLeaveImageAsPNG)
{
szTmp = szTempFileName;
szTmp += ".bmp"; // our temp file is a bmp file
if (convertPNG2BMP(szTmpPng.c_str(), szTmp.c_str()))
{
pFrame->showMessageBox("Unable to convert PNG image data to BMP for external program use!", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
remove(szTempFileName);
g_free (szTempFileName); szTempFileName = NULL;
remove(szTmpPng.c_str());
return false;
}
// remove(szTmpPng.c_str());
}
#endif
// remove the temp file (that lacks proper extension)
remove(szTempFileName);
g_free (szTempFileName); szTempFileName = NULL;
//
// Get the initial file status.
//
struct stat myFileStat;
int ok = stat(szTmp.c_str(),&myFileStat);
if(ok < 0)
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
remove(szTmpPng.c_str());
remove(szTmp.c_str()); // should silently fail if exporting as PNG file
return false;
}
time_t mod_time = myFileStat.st_mtime;
//
// Fire up the image editor...
//
ProcessInfo procInfo;
if (!createChildProcess(imageApp.c_str(), szTmp.c_str(), &procInfo))
{
UT_String msg = "Unable to run program: "; msg += imageApp + " " + szTmp;
pFrame->showMessageBox(msg.c_str(), XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
// failed to spawn stuff, so do some cleanup and return failure
remove(szTmpPng.c_str());
remove(szTmp.c_str()); // should silently fail if exporting as PNG file
return false;
}
lockGUI(d);
while (isProcessStillAlive(procInfo))
{
UT_usleep(10000); // wait 10 milliseconds
pFrame->nullUpdate();
ok = stat(szTmp.c_str(),&myFileStat);
if(ok == 0)
{
if(myFileStat.st_mtime != mod_time)
{
// wait for changes to settle (program done writing changes)
// we use both modified time & file size, but really we
// could just use file size as mod time doesn't appear to change for small images
mod_time = myFileStat.st_mtime;
off_t size = myFileStat.st_size;
UT_usleep(100000); // wait 100 milliseconds (so program may have time to write something)
ok = stat(szTmp.c_str(),&myFileStat);
while((mod_time != myFileStat.st_mtime) || !size || (size > 0 && size != myFileStat.st_size))
{
mod_time = myFileStat.st_mtime;
size = myFileStat.st_size;
ok = stat(szTmp.c_str(),&myFileStat);
UT_usleep(500000); // wait a while, let program write its data
// just make sure the program is still running, otherwise we could get stuck in a loop
if (!isProcessStillAlive(procInfo))
{
pFrame->showMessageBox("External image editor appears to have been terminated unexpectedly.",
XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
//procInfo.hProcess = 0;
goto Cleanup;
}
}
mod_time = myFileStat.st_mtime;
UT_usleep(100000); // wait a while just to make sure program is done with file
//
// OK replace the current image with this.
//
IEGraphicFileType iegft = IEGFT_Unknown;
FG_Graphic* pFG;
UT_Error errorCode;
#ifdef ENABLE_BMP
//
// Convert bmp back to png (as we can not assume AbiWord has builtin BMP support [as its now an optional plugin])
// NOTE: probably looses detail/information though!!! so if possible use only PNG
//
if (!bLeaveImageAsPNG)
{
if (convertBMP2PNG(szTmp.c_str(), szTmpPng.c_str()))
{
pFrame->showMessageBox("Unable to convert BMP image data back to PNG for AbiWord to import!", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
goto Cleanup;
}
}
#endif
errorCode = IE_ImpGraphic::loadGraphic(szTmpPng.c_str(), iegft, &pFG);
if(errorCode)
{
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
pFrame->showMessageBox("Error making pFG. Could not put image back into Abiword", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
goto Cleanup;
}
unlockGUI(d);
pView->cmdUnselectSelection();
pView->setPoint(pos);
pView->extSelHorizontal(true, 1); // move point forward one
errorCode = pView->cmdInsertGraphic(pFG);
if (errorCode)
{
pFrame->showMessageBox("Could not put image back into Abiword", XAP_Dialog_MessageBox::b_O,XAP_Dialog_MessageBox::a_OK);
UT_ASSERT(UT_SHOULD_NOT_HAPPEN);
DELETEP(pFG);
goto Cleanup;
}
DELETEP(pFG);
//
// Reselect the image
//
pView->setPoint(pos);
pView->extSelHorizontal(true, 1); // move point forward one
lockGUI(d);
}
}
}
//
// Normal exit, delete the tempfile and return success
//
remove(szTmpPng.c_str());
remove(szTmp.c_str()); // should silently fail if exporting as PNG file
unlockGUI(d);
return true;
//
// Something went wrong.
//
Cleanup:
remove(szTmpPng.c_str());
remove(szTmp.c_str()); // should silently fail if exporting as PNG file
unlockGUI(d);
//
// Kill the image editor.
//
endProcess(procInfo);
return false;
}
AV_View * AP_Dialog_Lists::getAvView(void)
{
XAP_Frame * pFrame = getActiveFrame();
return pFrame->getCurrentView();
}
void AP_Dialog_FormatFrame::setCurFrameProps(void)
{
XAP_Frame * frame = m_pApp->getLastFocussedFrame();
if (!frame) {
if (m_bSensitive) {
m_bSensitive = false;
setAllSensitivities();
}
return;
}
FV_View * pView = static_cast<FV_View *>(frame->getCurrentView());
if (!pView) {
if (m_bSensitive) {
m_bSensitive = false;
setAllSensitivities();
}
return;
}
PT_DocPosition pos = pView->getPoint();
if (/* m_bSettingsChanged || */ m_iOldPos == pos) {
// comparing the actual cell pos would be even better; but who cares :)
return;
}
m_iOldPos = pos;
if (!pView->isInFrame(pos)) {
if (m_bSensitive) {
m_bSensitive = false;
setAllSensitivities();
}
return;
}
m_bLineToggled = false;
m_borderLineStyleRight = LS_NORMAL;
m_borderLineStyleLeft = LS_NORMAL;
m_borderLineStyleTop = LS_NORMAL;
m_borderLineStyleBottom = LS_NORMAL;
UT_RGBColor black(0,0,0);
UT_RGBColor white(255,255,255);
m_borderColor = black;
m_borderColorRight = black;
m_borderColorLeft = black;
m_borderColorTop = black;
m_borderColorBottom = black;
m_borderThicknessRight = 1.0f;
m_borderThicknessLeft = 1.0f;
m_borderThicknessTop = 1.0f;
m_borderThicknessBottom = 1.0f;
m_sBorderThickness = "1.00pt",
m_sBorderThicknessRight = "1.00pt";
m_sBorderThicknessLeft = "1.00pt";
m_sBorderThicknessTop = "1.00pt";
m_sBorderThicknessBottom = "1.00pt";
m_backgroundColor = white;
m_bSetWrapping = false;
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_BLOCK;
PD_Document * pDoc = pView->getDocument();
PL_StruxDocHandle sdh;
m_bSensitive = false;
if (pDoc->getStruxOfTypeFromPosition(pos, PTX_SectionFrame, &sdh))
if (PT_AttrPropIndex api = pDoc->getAPIFromSDH(sdh)) {
const PP_AttrProp * pAP = 0;
if (pDoc->getAttrProp(api, &pAP))
if (pAP) {
m_bSensitive = true;
#define REPLACE_CELL_PROPERTY(X) \
do { \
const gchar * prop = 0; \
if (pAP->getProperty(X, prop)) \
m_vecProps.addOrReplaceProp(X, prop); \
else \
m_vecProps.removeProp(X); \
} while (0)
REPLACE_CELL_PROPERTY("right-style");
REPLACE_CELL_PROPERTY("left-style");
REPLACE_CELL_PROPERTY("top-style");
REPLACE_CELL_PROPERTY("bot-style");
REPLACE_CELL_PROPERTY("right-thickness");
REPLACE_CELL_PROPERTY("left-thickness");
REPLACE_CELL_PROPERTY("top-thickness");
REPLACE_CELL_PROPERTY("bot-thickness");
REPLACE_CELL_PROPERTY("right-color");
REPLACE_CELL_PROPERTY("left-color");
REPLACE_CELL_PROPERTY("top-color");
REPLACE_CELL_PROPERTY("bot-color");
REPLACE_CELL_PROPERTY("background-color");
REPLACE_CELL_PROPERTY("wrap-mode");
REPLACE_CELL_PROPERTY("position-to");
}
}
if (!m_bSensitive) {
setAllSensitivities();
return;
}
if(pView->isImageAtStrux(m_iOldPos,PTX_SectionFrame))
{
if(true /* 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);
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
else
{
FG_Graphic * pFG = FG_GraphicRaster::createFromStrux(pFrame);
if(pFG)
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
m_pGraphic = pFG;
m_sImagePath = pFG->getDataId();
GR_Graphics * pG = m_pFormatFramePreview->getGraphics();
m_pImage = _makeImageForRaster(m_sImagePath, pG, m_pGraphic);
}
}
}
else
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
}
else
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
UT_String bstmp = UT_String_sprintf("%d", FS_FILL);
m_vecProps.addOrReplaceProp("bg-style", bstmp.c_str()); // FIXME ??
const gchar * pszStyle = 0;
m_vecProps.getProp("background-color", pszStyle);
if (pszStyle) {
m_backgroundColor.setColor(pszStyle);
}
/* update border properties
*/
long linestyle;
pszStyle = 0;
m_vecProps.getProp("right-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleRight = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("left-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleLeft = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("top-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleTop = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("bot-style", pszStyle);
if (pszStyle) {
linestyle = LS_NORMAL;
sscanf(pszStyle, "%ld", &linestyle);
m_borderLineStyleBottom = linestyle;
}
pszStyle = 0;
m_vecProps.getProp("right-color", pszStyle);
if (pszStyle) {
m_borderColorRight.setColor(pszStyle);
}
pszStyle = 0;
m_vecProps.getProp("left-color", pszStyle);
if (pszStyle) {
m_borderColorLeft.setColor(pszStyle);
}
pszStyle = 0;
m_vecProps.getProp("top-color", pszStyle);
if (pszStyle) {
m_borderColorTop.setColor(pszStyle);
}
pszStyle = 0;
m_vecProps.getProp("bot-color", pszStyle);
if (pszStyle) {
m_borderColorBottom.setColor(pszStyle);
}
UT_UTF8String thickness;
pszStyle = 0;
m_vecProps.getProp("right-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessRight(thickness);
}
pszStyle = 0;
m_vecProps.getProp("left-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessLeft(thickness);
}
pszStyle = 0;
m_vecProps.getProp("top-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessTop(thickness);
}
pszStyle = 0;
m_vecProps.getProp("bot-thickness", pszStyle);
if (pszStyle) {
thickness = pszStyle;
setBorderThicknessBottom(thickness);
}
/* update wrap properties
*/
pszStyle = 0;
m_vecProps.getProp("wrap-mode", pszStyle);
if (pszStyle) {
if (strcmp (pszStyle, "wrapped-both") == 0) {
m_bSetWrapping = true;
}
}
/* update position properties
*/
pszStyle = 0;
m_vecProps.getProp("position-to", pszStyle);
if (pszStyle) {
if (strcmp (pszStyle, "block-above-text") == 0) {
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_BLOCK;
}
else if (strcmp (pszStyle, "column-above-text") == 0) {
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_COLUMN;
}
else if (strcmp (pszStyle, "page-above-text") == 0) {
m_iFramePositionTo = FL_FRAME_POSITIONED_TO_PAGE;
}
}
/* draw the preview with the changed properties
*/
if(m_pFormatFramePreview) {
m_pFormatFramePreview->draw();
}
m_bSettingsChanged = false;
setActiveFrame(frame); // this is just to trigger the subclass to update the dialog
}
void AP_Dialog_FormatTable::setCurCellProps(void)
{
XAP_Frame *frame = XAP_App::getApp()->getLastFocussedFrame();
if (frame) {
FV_View * pView = static_cast<FV_View *>(frame->getCurrentView());
if (m_bSettingsChanged ||
m_iOldPos == pView->getPoint()) // comparing the actual cell pos would be even better; but who cares :)
return;
m_iOldPos = pView->getPoint();
/*
* update the border colors
*/
gchar * color = NULL;
if (pView->getCellProperty("left-color", color))
m_vecProps.addOrReplaceProp("left-color", color);
else
m_vecProps.removeProp("left-color");
if (pView->getCellProperty("right-color", color))
m_vecProps.addOrReplaceProp("right-color", color);
else
m_vecProps.removeProp("right-color");
if (pView->getCellProperty("top-color", color))
m_vecProps.addOrReplaceProp("top-color", color);
else
m_vecProps.removeProp("top-color");
if (pView->getCellProperty("bot-color", color))
m_vecProps.addOrReplaceProp("bot-color", color);
else
m_vecProps.removeProp("bot-color");
/*
* update the background color
*/
UT_RGBColor clr;
gchar * bgColor = NULL;
if (pView->getCellProperty("background-color", bgColor))
{
m_vecProps.addOrReplaceProp("background-color", bgColor);
clr.setColor(bgColor);
setBackgroundColorInGUI(clr);
}
else
{
m_vecProps.removeProp("background-color");
setBackgroundColorInGUI(UT_RGBColor(255,255,255)); // No color == white for now - MARCM
}
if(pView->isImageAtStrux(m_iOldPos,PTX_SectionCell))
{
if(pView->isInTable())
{
fl_BlockLayout * pBL = pView->getCurrentBlock();
fl_CellLayout * pCell = static_cast<fl_CellLayout *>(pBL->myContainingLayout());
if(pCell->getContainerType() != FL_CONTAINER_CELL)
{
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
else
{
FG_Graphic * pFG = FG_GraphicRaster::createFromStrux(pCell);
if(pFG)
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
m_pGraphic = pFG;
m_sImagePath = pFG->getDataId();
GR_Graphics * pG = m_pFormatTablePreview->getGraphics();
const UT_ByteBuf * pBB = pFG->getBuffer();
if(m_pGraphic->getType() == FGT_Raster)
{
m_pImage = static_cast<GR_Image *>(
pG->createNewImage( m_sImagePath.c_str(),
pBB, pFG->getMimeType(),
pFG->getWidth(),
pFG->getHeight(),
GR_Image::GRT_Raster));
}
else
{
m_pImage = static_cast<GR_Image *>(
pG->createNewImage( m_sImagePath.c_str(),
pBB, pFG->getMimeType(),
m_pFormatTablePreview->getWindowWidth()-2,
m_pFormatTablePreview->getWindowHeight()-2,
GR_Image::GRT_Vector));
}
}
}
}
else
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
}
else
{
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_sImagePath.clear();
}
UT_String bstmp = UT_String_sprintf("%d", FS_FILL);
m_vecProps.addOrReplaceProp("bg-style", bstmp.c_str());
// draw the preview with the changed properties
if(m_pFormatTablePreview)
m_pFormatTablePreview->queueDraw();
}
}
bool XAP_App::retrieveState()
{
XAP_StateData sd;
bool bRet = true;
if(!_retrieveState(sd))
return false;
UT_return_val_if_fail(sd.iFileCount <= XAP_SD_MAX_FILES, false);
// now do our thing with it:
// * open the files stored in the data
// * move carets and scrollbars to the saved positions
// * make the first saved frame to be the current frame
// we should only be restoring state with no docs already
// opened
UT_return_val_if_fail(m_vecFrames.getItemCount() <= 1, false);
XAP_Frame * pFrame = NULL;
if(m_vecFrames.getItemCount())
pFrame = m_vecFrames.getNthItem(0);
// if there is a frame, it should be one with unmodified untitled document
UT_return_val_if_fail( !pFrame || (!pFrame->getFilename() && !pFrame->isDirty()), false );
UT_Error errorCode = UT_IE_IMPORTERROR;
for(UT_uint32 i = 0; i < sd.iFileCount; ++i)
{
if(!pFrame)
pFrame = newFrame();
if (!pFrame)
return false;
// Open a complete but blank frame, then load the document into it
errorCode = pFrame->loadDocument((const char *)NULL, 0 /*IEFT_Unknown*/);
bRet &= (errorCode == UT_OK);
if (errorCode == UT_OK)
pFrame->show();
else
continue;
errorCode = pFrame->loadDocument(sd.filenames[i], 0 /*IEFT_Unknown*/);
bRet &= (errorCode == UT_OK);
if (errorCode != UT_OK)
continue;
pFrame->show();
AV_View* pView = pFrame->getCurrentView();
if(!pView)
{
UT_ASSERT_HARMLESS( UT_SHOULD_NOT_HAPPEN );
bRet = false;
continue;
}
pView->setPoint(sd.iDocPos[i]);
pView->setXScrollOffset(sd.iXScroll[i]);
pView->setYScrollOffset(sd.iYScroll[i]);
// now we check if this doc was autosaved Untitled* doc at hibernation
char * p = strstr(sd.filenames[i], HIBERNATED_EXT);
if(p)
{
// remove extension
p = 0;
AD_Document * pDoc = pFrame->getCurrentDoc();
if(pDoc)
{
pDoc->clearFilename();
pDoc->forceDirty();
pFrame->updateTitle();
}
}
// frame used -- next doc needs a new one
pFrame = NULL;
}
// set focus to the first frame
pFrame = m_vecFrames.getNthItem(0);
UT_return_val_if_fail( pFrame, false );
AV_View* pView = pFrame->getCurrentView();
UT_return_val_if_fail( pView, false );
pView->focusChange(AV_FOCUS_HERE);
return bRet;
}
bool XAP_App::saveState(bool bQuit)
{
// gather the state data for platform code to deal with
XAP_StateData sd;
bool bRet = true;
// We will store data for up to XAP_SD_MAX_FILES, making sure we save it for the last
// focussed frame in the first slot
XAP_Frame * pLastFrame = getLastFocussedFrame();
UT_sint32 i;
UT_sint32 j;
for(i = 0, j = 0; i < m_vecFrames.getItemCount(); ++i, ++j)
{
XAP_Frame * pFrame = NULL;
if(i == 0)
pFrame = pLastFrame;
else
pFrame = m_vecFrames[i];
if(pLastFrame == pFrame && j != 0)
{
// we have done this frame, but need to do the one at pos 0 in its place
pFrame = m_vecFrames[0];
}
if(!pFrame)
{
--j;
continue;
}
AD_Document * pDoc = pFrame->getCurrentDoc();
if(!pDoc)
{
--j;
continue;
}
UT_Error e = UT_OK;
if(pDoc->isDirty())
{
// need to decide what to do about dirty documents; perhaps we should keep a
// copy of the unsaved state under a different name?
// for now just save (otherwise the user will loose the changes when app
// hibernates)
e = pDoc->save();
if(e == UT_SAVE_NAMEERROR)
{
// this is an Untitled document
UT_UTF8String s = pFrame->getNonDecoratedTitle();
s += HIBERNATED_EXT;
e = pDoc->saveAs(s.utf8_str(), 0);
}
bRet &= (UT_OK == e);
}
if(j >= XAP_SD_MAX_FILES || e != UT_OK)
{
// no storage space left -- nothing more we can do with this document, so move
// to the next one (do not break, we need to deal with anything that is not
// saved)
--j; // we want to preserve the j value
continue;
}
const char * file = pDoc->getFilename();
if(file && strlen(file) < XAP_SD_FILENAME_LENGTH)
{
strncpy(sd.filenames[j], file, XAP_SD_FILENAME_LENGTH);
AV_View * pView = pFrame->getCurrentView();
if(pView)
{
sd.iDocPos[j] = pView->getPoint();
sd.iXScroll[j] = pView->getXScrollOffset();
sd.iYScroll[j] = pView->getYScrollOffset();
}
}
else
{
--j;
continue;
}
}
sd.iFileCount = j;
if(!_saveState(sd))
return false;
if(bQuit)
{
// we have dealt with unsaved docs above, so just clean up any modeless dlgs and quit
closeModelessDlgs();
reallyExit();
}
return bRet;
}
static void
changed_cb (GOComponent *component, gpointer data)
{
if (data != NULL)
{
GOComponentView * pGOComponentView = static_cast<GOComponentView*> (data);
pGOComponentView->update ();
}
else
{
XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame();
FV_View* pView = static_cast<FV_View*>(pFrame->getCurrentView());
UT_Byte *buf;
int length;
void (*clearfunc) (gpointer);
gpointer user_data = NULL;
if (go_component_get_data (component, (void**) &buf, &length, &clearfunc, &user_data)) {
if (buf && length) {
UT_ByteBufPtr myByteBuf(new UT_ByteBuf);
myByteBuf->append(buf, length);
UT_String Props="embed-type: GOComponent";
guint i, nbprops;
GType prop_type;
GValue value = G_VALUE_INIT;
char *prop = NULL;
GParamSpec **specs = g_object_class_list_properties (
G_OBJECT_GET_CLASS (component), &nbprops);
for (i = 0; i < nbprops; i++) {
if (specs[i]->flags & GO_PARAM_PERSISTENT) {
prop_type = G_PARAM_SPEC_VALUE_TYPE (specs[i]);
memset(&value, 0, sizeof(value));
g_value_init (&value, prop_type);
g_object_get_property (G_OBJECT (component), specs[i]->name, &value);
if (!g_param_value_defaults (specs[i], &value))
switch (G_TYPE_FUNDAMENTAL (prop_type)) {
case G_TYPE_CHAR:
case G_TYPE_UCHAR:
case G_TYPE_BOOLEAN:
case G_TYPE_INT:
case G_TYPE_UINT:
case G_TYPE_LONG:
case G_TYPE_ULONG:
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE: {
GValue str;
memset(&str, 0, sizeof(str));
g_value_init (&str, G_TYPE_STRING);
g_value_transform (&value, &str);
prop = g_strdup (g_value_get_string (&str));
g_value_unset (&str);
break;
}
case G_TYPE_STRING: {
prop = g_strdup (g_value_get_string (&value));
break;
}
default:
prop = NULL;
break;
}
g_value_unset (&value);
if (prop) {
Props += UT_String_sprintf("; %s:%s", specs[i]->name, prop);
g_free (prop);
prop = NULL;
}
}
}
PT_DocPosition pos = pView->getPoint();
pView->cmdInsertEmbed(myByteBuf, pView->getPoint(), component->mime_type, Props.c_str ());
pView->cmdSelect(pos,pos+1);
}
if (clearfunc)
clearfunc ((user_data)? user_data: buf);
}
g_object_unref (component); // destroy since we created a new one this will close the editor
}
}
//
// AiksaurusABI_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.
//
bool
AiksaurusABI_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.
char* search = 0;
if (!pView->isSelectionEmpty())
{
// We need to get the Ascii version of the current word.
UT_UCS4Char * ucs4ST;
pView->getSelectionText(*&ucs4ST);
search = AiksaurusABI_ucsToAscii(
ucs4ST
);
}
// Now we will run the thesaurus dialog and get a response.
// We will automatically do a search for the selected/current word.
#ifdef _WIN32
AiksaurusApp thesaurus;
thesaurus.setInstance( (HINSTANCE)s_hModule );
#else
AiksaurusGTK thesaurus;
#endif
thesaurus.setTitle("Abiword Thesaurus");
thesaurus.setInitialMessage("Welcome to Aiksaurus");
const char* response = thesaurus.runThesaurus(search);
if (response)
{
// Now that we have our replacement, we need to convert it to UCS-2.
int length;
UT_UCSChar* replacement = AiksaurusABI_asciiToUcs(response, length);
// Now, if our replacement has length, we can go ahead and run the
// replacement. If the replacement has no length, we will do nothing.
if (length)
pView->cmdCharInsert(replacement, length);
// all done with replacement.
delete[] replacement;
}
// Finally, we need to remember to delete search and replacement strings.
// Note that "search" might be null so we only want to delete[] it if it
// was actually initialized above.
if (search)
delete[] search;
return true;
}
/*!
* Import graphic for cell background.
*/
void AP_Dialog_FormatFrame::askForGraphicPathName(void)
{
UT_return_if_fail(m_pApp);
XAP_Frame * pFrame = m_pApp->getLastFocussedFrame();
UT_return_if_fail(pFrame);
XAP_DialogFactory * pDialogFactory
= static_cast<XAP_DialogFactory *>(pFrame->getDialogFactory());
UT_return_if_fail(pDialogFactory);
XAP_Dialog_FileOpenSaveAs * pDialog
= static_cast<XAP_Dialog_FileOpenSaveAs *>(pDialogFactory->requestDialog(XAP_DIALOG_ID_INSERT_PICTURE));
UT_return_if_fail (pDialog);
pDialog->setCurrentPathname(NULL);
pDialog->setSuggestFilename(false);
// to fill the file types popup list, we need to convert AP-level
// ImpGraphic descriptions, suffixes, and types into strings.
UT_uint32 filterCount = IE_ImpGraphic::getImporterCount();
const char ** szDescList = static_cast<const char **>(UT_calloc(filterCount + 1, sizeof(char *)));
const char ** szSuffixList = static_cast<const char **>(UT_calloc(filterCount + 1, sizeof(char *)));
IEGraphicFileType * nTypeList = (IEGraphicFileType *)
UT_calloc(filterCount + 1, sizeof(IEGraphicFileType));
UT_uint32 k = 0;
while (IE_ImpGraphic::enumerateDlgLabels(k, &szDescList[k], &szSuffixList[k], &nTypeList[k]))
k++;
pDialog->setFileTypeList(szDescList, szSuffixList, static_cast<const UT_sint32 *>(nTypeList));
pDialog->runModal(pFrame);
XAP_Dialog_FileOpenSaveAs::tAnswer ans = pDialog->getAnswer();
bool bOK = (ans == XAP_Dialog_FileOpenSaveAs::a_OK);
if (bOK)
{
m_sImagePath = pDialog->getPathname();
UT_sint32 type = pDialog->getFileType();
// If the number is negative, it's a special type.
// Some operating systems which depend solely on filename
// suffixes to identify type (like Windows) will always
// want auto-detection.
if (type < 0)
switch (type)
{
case XAP_DIALOG_FILEOPENSAVEAS_FILE_TYPE_AUTO:
// do some automagical detecting
m_iGraphicType = IEGFT_Unknown;
break;
default:
// it returned a type we don't know how to handle
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
}
else
m_iGraphicType = static_cast<IEGraphicFileType>(pDialog->getFileType());
}
FREEP(szDescList);
FREEP(szSuffixList);
FREEP(nTypeList);
pDialogFactory->releaseDialog(pDialog);
if(m_sImagePath.size() == 0)
{
return;
}
FG_Graphic* pFG = NULL;
UT_Error errorCode;
errorCode = IE_ImpGraphic::loadGraphic(m_sImagePath.c_str(), m_iGraphicType, &pFG);
if(errorCode != UT_OK || !pFG)
{
ShowErrorBox(m_sImagePath, errorCode);
return;
}
DELETEP(m_pGraphic);
DELETEP(m_pImage);
m_pGraphic = pFG->clone();
GR_Graphics * pG = m_pFormatFramePreview->getGraphics();
FV_View * pView = static_cast<FV_View *>(pFrame->getCurrentView());
UT_return_if_fail(pView && pView->getDocument());
UT_uint32 uid = pView->getDocument()->getUID(UT_UniqueId::Image); //see Bug 10851
m_sImagePath.clear();
m_sImagePath = UT_std_string_sprintf("%d",uid);
m_pImage = _makeImageForRaster(m_sImagePath, pG, m_pGraphic);
// draw the preview with the changed properties
if(m_pFormatFramePreview)
m_pFormatFramePreview->draw();
}