bool AP_Win32App::canPasteFromClipboard(void)
{
if (!getLastFocussedFrame())
return false;
AP_Win32FrameImpl * pFrameImp = static_cast<AP_Win32FrameImpl*>(getLastFocussedFrame()->getFrameImpl());
UT_return_val_if_fail(pFrameImp, false);
if (!m_pClipboard->openClipboard(pFrameImp->getHwndDocument()))
return false;
// TODO decide if we need to support .ABW format on the clipboard.
if (m_pClipboard->hasFormat(AP_CLIPBOARD_RTF))
goto ReturnTrue;
if (m_pClipboard->hasFormat(AP_CLIPBOARD_TEXTPLAIN_UCS2))
goto ReturnTrue;
if (m_pClipboard->hasFormat(AP_CLIPBOARD_TEXTPLAIN_8BIT))
goto ReturnTrue;
// If IEGFT_BMP!=0 we have a plugin that can deal with BMP format
if (m_pClipboard->hasFormat(AP_CLIPBOARD_BMP) && IEGFT_BMP)
goto ReturnTrue;
m_pClipboard->closeClipboard();
return false;
ReturnTrue:
m_pClipboard->closeClipboard();
return true;
}
/*!
copy data to the clipboard; this is what gets called when the user
presses Ctrl+C
*/
void AP_Win32App::copyToClipboard(PD_DocumentRange * pDocRange, bool /*bUseClipboard*/)
{
// copy the given subset of the given document to the
// system clipboard in a variety of formats.
// MSFT requests that we post them in the order of
// importance to us (most preserving to most lossy).
//
// TODO do we need to put something in .ABW format on the clipboard ??
AP_Win32FrameImpl * pFrameImp = static_cast<AP_Win32FrameImpl*>(getLastFocussedFrame()->getFrameImpl());
UT_return_if_fail(pFrameImp);
if (!m_pClipboard->openClipboard(pFrameImp->getHwndDocument()))
return;
m_pClipboard->clearClipboard(); // this also gives us the ownership
// Be smart: always place RTF on clipboard; the
// remaining formats we will generate on demand.
// most of the time it will save us creating multiple importers,
// but when the user requests other than the default format, it
// will be a little bit more involved
// Tomas, June 28, 2003.
#ifndef COPY_ON_DEMAND
_copyFmtToClipboard(pDocRange, AP_CLIPBOARD_RTF);
#else
// we need to both cache the present doc and put rtf version on
// the clipboard, because win32 will ask for it immediately;
// appart from that, the rtf exporter needs some layout info to
// deal with bidi issues, which means we cannot construct the rtf
// from the chached doc properly
_cacheClipboardDoc(pDocRange);
_copyFmtToClipboard(pDocRange, AP_CLIPBOARD_RTF);
#endif
// TODO Should use a finer-grain technique than IsWinNT()
// since Win98 supports unicode clipboard.
if (UT_IsWinNT())
{
// put raw unicode text on the clipboard
#ifndef COPY_ON_DEMAND
_copyFmtToClipboard(pDocRange, AP_CLIPBOARD_TEXTPLAIN_UCS2);
#else
_indicateFmtToClipboard(AP_CLIPBOARD_TEXTPLAIN_UCS2);
#endif
}
else
{
// put raw 8bit text on the clipboard
#ifndef COPY_ON_DEMAND
_copyFmtToClipboard(pDocRange, AP_CLIPBOARD_TEXTPLAIN_8BIT);
#else
_indicateFmtToClipboard(AP_CLIPBOARD_TEXTPLAIN_8BIT);
#endif
}
m_pClipboard->closeClipboard(); // release clipboard lock
}
/*!
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);
}
}
}
}
}
}
}
void AP_Win32App::pasteFromClipboard(PD_DocumentRange * pDocRange, bool /*bUseClipboard*/, bool bHonorFormatting)
{
// paste from the system clipboard using the best-for-us format
// that is present.
// We get a handle to the object in the requested format
// and then lock it an use the system buffer -- rather
// then copying it into our own.
//
// we jump thru a few bogus steps w/r/t the length of the
// object because MSFT docs state that the length of the
// object may be less than the length actually returned by
// GlobalSize().
//
// therefore, we do a strlen() and **hope** that this is
// right. Oh, and the value returned by GlobalSize() varies
// from call-to-call on the same object.... sigh.
AP_Win32FrameImpl * pFrameImp = static_cast<AP_Win32FrameImpl*>(getLastFocussedFrame()->getFrameImpl());
UT_return_if_fail(pFrameImp);
if (!m_pClipboard->openClipboard(pFrameImp->getHwndDocument())) // lock clipboard
return;
{
// TODO Paste the most detailed version unless user overrides.
// TODO decide if we need to support .ABW on the clipboard.
if (!((bHonorFormatting && _pasteFormatFromClipboard(pDocRange, AP_CLIPBOARD_RTF, ".rtf", false)) ||
_pasteFormatFromClipboard(pDocRange, AP_CLIPBOARD_TEXTPLAIN_UCS2, ".txt", true) ||
_pasteFormatFromClipboard(pDocRange, AP_CLIPBOARD_BMP, ".bmp", false) ||
_pasteFormatFromClipboard(pDocRange, AP_CLIPBOARD_TEXTPLAIN_8BIT, ".txt", false)))
{
// TODO figure out what to do with an image and other formats....
UT_DEBUGMSG(("PasteFromClipboard: TODO support this format..."));
}
}
m_pClipboard->closeClipboard(); // release clipboard lock
return;
}
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;
}
/*!
paste from the system clipboard using the best-for-us format
that is present. try to get the content in the order listed.
\todo currently i have this set so that a ^v or Menu[Edit/Paste] will
use the CLIPBOARD property and a MiddleMouseClick will use the
PRIMARY property -- this seems to be the "X11 way" (sigh).
consider having a preferences switch to allow ^v and Menu[Edit/Paste]
to use the most recent property... this might be a nice way of
unifying things -- or it might not -- this is probably an area
for investigation or some usability testing.
*/
void AP_UnixApp::pasteFromClipboard(PD_DocumentRange * pDocRange, bool bUseClipboard,
bool bHonorFormatting)
{
XAP_UnixClipboard::T_AllowGet tFrom = ((bUseClipboard)
? XAP_UnixClipboard::TAG_ClipboardOnly
: XAP_UnixClipboard::TAG_PrimaryOnly);
const char * szFormatFound = NULL;
const unsigned char * pData = NULL;
UT_uint32 iLen = 0;
bool bFoundOne = false;
bool bSuccess = false;
if ( bHonorFormatting )
bFoundOne = m_pClipboard->getSupportedData(tFrom,reinterpret_cast<const void **>(&pData),&iLen,&szFormatFound);
else
bFoundOne = m_pClipboard->getTextData(tFrom,reinterpret_cast<const void **>(&pData),&iLen, &szFormatFound);
#ifdef DUMP_CLIPBOARD_PASTE
if (bFoundOne)
{
std::ofstream oss("/tmp/clips");
oss.write( (const char*)pData, iLen );
oss.close();
}
#endif
if (!bFoundOne)
{
UT_DEBUGMSG(("PasteFromClipboard: did not find anything to paste.\n"));
return;
}
if (AP_UnixClipboard::isDynamicTag (szFormatFound))
{
UT_DEBUGMSG(("Dynamic Format Found = %s \n",szFormatFound));
}
if (AP_UnixClipboard::isRichTextTag(szFormatFound))
{
IE_Imp_RTF * pImpRTF = new IE_Imp_RTF(pDocRange->m_pDoc);
bSuccess = pImpRTF->pasteFromBuffer(pDocRange,pData,iLen);
DELETEP(pImpRTF);
}
else if (AP_UnixClipboard::isHTMLTag (szFormatFound))
{
IE_Imp_Text_Sniffer SniffBuf;
const char * szRes = SniffBuf.recognizeContentsType(reinterpret_cast<const char *>(pData),iLen);
if(szRes && strcmp(szRes,"none") != 0)
{
UT_uint32 iread,iwritten = 0;
const char * szutf8= static_cast<const char *>(UT_convert(reinterpret_cast<const char *>(pData),iLen,szRes,"UTF-8",&iread,&iwritten));
IE_Imp_XHTML * pImpHTML = new IE_Imp_XHTML(pDocRange->m_pDoc);
bSuccess = pImpHTML->pasteFromBuffer(pDocRange,reinterpret_cast<const unsigned char *>(szutf8),iwritten,"UTF-8");
g_free(const_cast<char *>(szutf8));
DELETEP(pImpHTML);
}
else
{
IE_Imp_XHTML * pImpHTML = new IE_Imp_XHTML(pDocRange->m_pDoc);
bSuccess = pImpHTML->pasteFromBuffer(pDocRange,reinterpret_cast<const unsigned char *>(pData),iLen);
DELETEP(pImpHTML);
}
}
else if (AP_UnixClipboard::isDynamicTag (szFormatFound))
{
UT_DEBUGMSG(("Format Found = %s \n",szFormatFound));
IE_Imp * pImp = NULL;
IEFileType ieft = IE_Imp::fileTypeForMimetype(szFormatFound);
UT_DEBUGMSG(("found file type %d\n",ieft));
IE_Imp::constructImporter(pDocRange->m_pDoc,ieft,&pImp);
if(pImp == NULL)
goto retry_text;
bSuccess = pImp->pasteFromBuffer(pDocRange,pData,iLen);
DELETEP(pImp);
}
else if (AP_UnixClipboard::isImageTag(szFormatFound))
{
UT_DEBUGMSG(("Format Found = %s \n",szFormatFound));
if(strncmp(szFormatFound,"application",11) == 0) // embedded object
{
IE_Imp * pImp = NULL;
IEGraphicFileType iegft = IE_Imp::fileTypeForMimetype(szFormatFound);
IE_Imp::constructImporter(pDocRange->m_pDoc,iegft,&pImp);
if(pImp == NULL)
{
goto retry_text;
}
/*bool b = */ pImp->pasteFromBuffer(pDocRange,pData,iLen);
DELETEP(pImp);
return;
}
FG_Graphic * pFG = NULL;
IEGraphicFileType iegft = IEGFT_Unknown;
UT_Error error = UT_OK;
UT_ByteBuf bytes( iLen );
bytes.append (pData, iLen);
error = IE_ImpGraphic::loadGraphic(bytes, iegft, &pFG);
if(!pFG || error)
{
UT_DEBUGMSG(("DOM: could not import graphic (%d)\n", error));
goto retry_text;
}
// at this point, 'bytes' is owned by pFG
FV_View * pView = static_cast<FV_View*>(getLastFocussedFrame ()->getCurrentView());
error = pView->cmdInsertGraphic(pFG);
DELETEP(pFG);
if (!error)
bSuccess = true;
}
else // ( AP_UnixClipboard::isTextTag(szFormatFound) )
{
IE_Imp_Text * pImpText = new IE_Imp_Text(pDocRange->m_pDoc,"UTF-8");
bSuccess = pImpText->pasteFromBuffer(pDocRange,pData,iLen);
DELETEP(pImpText);
}
retry_text:
// we failed to paste *anything.* try plaintext as a last-ditch effort
if(!bSuccess && m_pClipboard->getTextData(tFrom,reinterpret_cast<const void **>(&pData),&iLen, &szFormatFound)) {
UT_DEBUGMSG(("DOM: pasting text as an absolute fallback (bug 7666)\n"));
IE_Imp_Text * pImpText = new IE_Imp_Text(pDocRange->m_pDoc,"UTF-8");
bSuccess = pImpText->pasteFromBuffer(pDocRange,pData,iLen);
DELETEP(pImpText);
}
}
/*!
copy the given subset of the given document to the
system clipboard in a variety of formats.
to minimize the effects of race-conditions, we create
all of the buffers we need and then post them to the
server (well sorta) all at one time.
\param pDocRange a range of the document to be copied
*/
void AP_UnixApp::copyToClipboard(PD_DocumentRange * pDocRange, bool bUseClipboard)
{
UT_ByteBuf bufRTF;
UT_ByteBuf bufHTML4;
UT_ByteBuf bufXHTML;
UT_ByteBuf bufTEXT;
UT_ByteBuf bufODT;
// create RTF buffer to put on the clipboard
IE_Exp_RTF * pExpRtf = new IE_Exp_RTF(pDocRange->m_pDoc);
if (pExpRtf)
{
pExpRtf->copyToBuffer(pDocRange,&bufRTF);
DELETEP(pExpRtf);
}
// create XHTML buffer to put on the clipboard
IE_Exp_HTML * pExpHtml = new IE_Exp_HTML(pDocRange->m_pDoc);
if (pExpHtml)
{
pExpHtml->set_HTML4 (false);
pExpHtml->copyToBuffer (pDocRange, &bufXHTML);
DELETEP(pExpHtml);
}
// create HTML4 buffer to put on the clipboard
pExpHtml = new IE_Exp_HTML(pDocRange->m_pDoc);
if (pExpHtml)
{
pExpHtml->set_HTML4 (true);
pExpHtml->copyToBuffer(pDocRange, &bufHTML4);
DELETEP(pExpHtml);
}
// Look to see if the ODT plugin is loaded
IEFileType ftODT = IE_Exp::fileTypeForMimetype("application/vnd.oasis.opendocument.text");
bool bExpODT = false;
if(ftODT != IEFT_Unknown)
{
// ODT plugin is present construct an exporter
//
IE_Exp * pODT = NULL;
IEFileType genIEFT = IEFT_Unknown;
GsfOutput * outBuf = gsf_output_memory_new();
UT_Error err = IE_Exp::constructExporter(pDocRange->m_pDoc,outBuf,
ftODT,&pODT,& genIEFT);
if(pODT && (genIEFT == ftODT))
{
//
// Copy to the buffer
//
err = pODT->copyToBuffer(pDocRange, &bufODT);
bExpODT = (err == UT_OK);
UT_DEBUGMSG(("Putting ODF on the clipboard...e:%d bExpODT:%d\n", err, bExpODT ));
#ifdef DUMP_CLIPBOARD_COPY
std::ofstream oss("/tmp/abiword-clipboard-copy.odt");
oss.write( (const char*)bufODT.getPointer (0), bufODT.getLength () );
oss.close();
#endif
}
}
// create UTF-8 text buffer to put on the clipboard
IE_Exp_Text * pExpText = new IE_Exp_Text(pDocRange->m_pDoc, "UTF-8");
if (pExpText)
{
pExpText->copyToBuffer(pDocRange,&bufTEXT);
DELETEP(pExpText);
}
// NOTE: this clearData() will actually release our ownership of
// NOTE: the CLIPBOARD property in addition to clearing any
// NOTE: stored buffers. I'm omitting it since we seem to get
// NOTE: clr callback after we have done some other processing
// NOTE: (like adding the new stuff).
// m_pClipboard->clearData(true,false);
// TODO: handle CLIPBOARD vs PRIMARY
XAP_UnixClipboard::T_AllowGet target = ((bUseClipboard)
? XAP_UnixClipboard::TAG_ClipboardOnly
: XAP_UnixClipboard::TAG_PrimaryOnly);
if (bufRTF.getLength () > 0)
m_pClipboard->addRichTextData (target, bufRTF.getPointer (0), bufRTF.getLength ());
if (bufXHTML.getLength () > 0)
m_pClipboard->addHtmlData (target, bufXHTML.getPointer (0), bufXHTML.getLength (), true);
if (bufHTML4.getLength () > 0)
m_pClipboard->addHtmlData (target, bufHTML4.getPointer (0), bufHTML4.getLength (), false);
if (bExpODT && bufODT.getLength () > 0)
m_pClipboard->addODTData (target, bufODT.getPointer (0), bufODT.getLength ());
if (bufTEXT.getLength () > 0)
m_pClipboard->addTextData (target, bufTEXT.getPointer (0), bufTEXT.getLength ());
{
// TODO: we have to make a good way to tell if the current selection is just an image
FV_View * pView = NULL;
if(getLastFocussedFrame())
pView = static_cast<FV_View*>(getLastFocussedFrame()->getCurrentView());
if (pView && !pView->isSelectionEmpty())
{
// don't own, don't g_free
const UT_ByteBuf * png = 0;
pView->saveSelectedImage (&png);
if (png && png->getLength() > 0)
{
m_pClipboard->addPNGData(target, static_cast<const UT_Byte*>(png->getPointer(0)), png->getLength());
}
}
}
m_pClipboard->finishedAddingData();
return;
}
/*!
get the current contents of the selection in the
window last known to have a selection using one
of the formats in the given list.
\param formatList the list of acceptable formats
\param ppData
\param pLen a pointer to an integer representing the length
\param pszFormatFound a pointer for the data to be returned in
\return True if successful, false otherwise.
*/
bool AP_UnixApp::getCurrentSelection(const char** formatList,
void ** ppData, UT_uint32 * pLen,
const char **pszFormatFound)
{
int j;
*ppData = NULL; // assume failure
*pLen = 0;
*pszFormatFound = NULL;
if (!m_pViewSelection || !m_pFrameSelection || !m_bHasSelection)
return false; // can't do it, give up.
PD_DocumentRange dr;
if (m_cacheSelectionView == m_pViewSelection)
{
dr = m_cacheDocumentRangeOfSelection;
}
else
{
// TODO if we ever support multiple view types, we'll have to
// TODO change this.
FV_View * pFVView = static_cast<FV_View *>(m_pViewSelection);
pFVView->getDocumentRangeOfCurrentSelection(&dr);
}
m_selectionByteBuf.truncate(0);
for (j=0; (formatList[j]); j++)
{
if ( AP_UnixClipboard::isRichTextTag(formatList[j]) )
{
IE_Exp_RTF * pExpRtf = new IE_Exp_RTF(dr.m_pDoc);
if (!pExpRtf)
return false; // give up on memory errors
pExpRtf->copyToBuffer(&dr,&m_selectionByteBuf);
DELETEP(pExpRtf);
goto ReturnThisBuffer;
}
if ( AP_UnixClipboard::isHTMLTag(formatList[j]) )
{
IE_Exp_HTML * pExpHTML = new IE_Exp_HTML(dr.m_pDoc);
if (!pExpHTML)
return false;
pExpHTML->set_HTML4 (!strcmp (formatList[j], "text/html"));
pExpHTML->copyToBuffer(&dr,&m_selectionByteBuf);
DELETEP(pExpHTML);
goto ReturnThisBuffer;
}
if ( AP_UnixClipboard::isImageTag(formatList[j]) )
{
// TODO: we have to make a good way to tell if the current selection is just an image
FV_View * pView = NULL;
if(getLastFocussedFrame())
pView = static_cast<FV_View*>(getLastFocussedFrame()->getCurrentView());
if (pView && !pView->isSelectionEmpty())
{
// don't own, don't g_free
const UT_ByteBuf * png = 0;
pView->saveSelectedImage (&png);
if (png && png->getLength() > 0)
{
m_selectionByteBuf.ins (0, png->getPointer (0), png->getLength ());
goto ReturnThisBuffer;
}
}
}
if ( AP_UnixClipboard::isTextTag(formatList[j]) )
{
IE_Exp_Text * pExpText = new IE_Exp_Text(dr.m_pDoc, "UTF-8");
if (!pExpText)
return false;
pExpText->copyToBuffer(&dr,&m_selectionByteBuf);
DELETEP(pExpText);
goto ReturnThisBuffer;
}
// TODO add other formats as necessary
}
UT_DEBUGMSG(("Clipboard::getCurrentSelection: cannot create anything in one of requested formats.\n"));
return false;
ReturnThisBuffer:
UT_DEBUGMSG(("Clipboard::getCurrentSelection: copying %d bytes in format [%s].\n",
m_selectionByteBuf.getLength(),formatList[j]));
*ppData = const_cast<void *>(static_cast<const void *>(m_selectionByteBuf.getPointer(0)));
*pLen = m_selectionByteBuf.getLength();
*pszFormatFound = formatList[j];
return true;
}
bool AP_Win32App::_pasteFormatFromClipboard(PD_DocumentRange * pDocRange, const char * szFormat,
const char * szType, bool bWide)
{
HANDLE hData;
bool bSuccess = false;
if (!(hData = m_pClipboard->getHandleInFormat(szFormat)))
return bSuccess;
// It's a bitmap
if (g_ascii_strcasecmp(szFormat, AP_CLIPBOARD_BMP)==0)
{
HBITMAP hBitmap;
PBITMAPINFO bi;
HWND hWnd;
HDC hdc;
IE_ImpGraphic* pIEG = NULL;
FG_Graphic* pFG = NULL;
UT_Error errorCode;
UT_ByteBuf byteBuf;
IEGraphicFileType iegft = IEGFT_BMP;
XAP_Frame* pFrame;
AP_FrameData* pFrameData;
FL_DocLayout* pDocLy;
FV_View* pView;
UT_ByteBuf* bBufBMP = new UT_ByteBuf;
hBitmap = (HBITMAP)hData;
hWnd = GetDesktopWindow();
hdc = GetDC(hWnd);
// Create a BMP file from a BITMAP
bi = CreateBitmapInfoStruct(hBitmap);
CreateBMP(hWnd, *bBufBMP, bi, hBitmap,hdc);
// Since we are providing the file type, there is not need to pass the bytebuff filled up
errorCode = IE_ImpGraphic::constructImporter(*bBufBMP, iegft, &pIEG);
if(errorCode != UT_OK)
return false;
errorCode = pIEG->importGraphic(bBufBMP, &pFG);
if(errorCode != UT_OK || !pFG)
{
DELETEP(bBufBMP);
DELETEP(pIEG);
return false;
}
// sunk in importGraphic
bBufBMP = NULL;
// Insert graphic in the view
pFrame = getLastFocussedFrame();
pFrameData = (AP_FrameData*) pFrame->getFrameData();
pDocLy = pFrameData->m_pDocLayout;
pView = pDocLy->getView();
errorCode = pView->cmdInsertGraphic(pFG);
DELETEP(pIEG);
//DELETEP(pFG);
bSuccess = true;
}
else
{
unsigned char * pData = static_cast<unsigned char *>(GlobalLock(hData));
UT_DEBUGMSG(("Paste: [fmt %s %s][hdata 0x%08lx][pData 0x%08lx]\n",
szFormat, szType, hData, pData));
UT_uint32 iSize = GlobalSize(hData);
UT_uint32 iStrLen = bWide
? wcslen(reinterpret_cast<const wchar_t *>(pData)) * 2
: strlen(reinterpret_cast<const char *>(pData));
UT_uint32 iLen = UT_MIN(iSize,iStrLen);
IE_Imp * pImp = 0;
IE_Imp::constructImporter(pDocRange->m_pDoc, IE_Imp::fileTypeForSuffix(szType), &pImp, 0);
if (pImp)
{
const char * szEncoding = 0;
if (bWide)
szEncoding = XAP_EncodingManager::get_instance()->getUCS2LEName();
else
; // TODO Get code page using CF_LOCALE
pImp->pasteFromBuffer(pDocRange,pData,iLen,szEncoding);
delete pImp;
}
GlobalUnlock(hData);
bSuccess = true;
}
return bSuccess;
}