Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-11-01 14:45:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
a4ae2cd79f
gecko-dev/lib/layout/edtsave.cpp
cmanske%netscape.com 65a3224235 Fixed more Composer bugs
1998-09-30 00:01:40 +00:00

1809 lines
60 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
//
// Editor save stuff. LWT 06/01/95
//
// Added all ITapeFileSystem stuff, hardts 10/96
#ifdef EDITOR
#include "editor.h"
#include "streams.h"
#include "shist.h"
#include "xpgetstr.h"
#include "net.h"
#include "mime.h"
#include "prefapi.h"
// Other error values are created from ALLXPSTR.RC during compiling
//extern "C" int MK_UNABLE_TO_LOCATE_FILE;
//extern "C" int MK_MALFORMED_URL_ERROR;
//-----------------------------------------------------------------------------
// CEditImageLoader
//-----------------------------------------------------------------------------
CEditImageLoader::CEditImageLoader( CEditBuffer *pBuffer, EDT_ImageData *pImageData,
XP_Bool bReplaceImage ):
m_pBuffer( pBuffer ),
m_pImageData( edt_DupImageData( pImageData ) ),
m_bReplaceImage( bReplaceImage )
{
char *pStr;
if( !pBuffer->m_pContext->is_new_document ){
intn retVal = NET_MakeRelativeURL( LO_GetBaseURL( m_pBuffer->m_pContext ),
m_pImageData->pSrc,
&pStr );
if( retVal != NET_URL_FAIL ){
XP_FREE( m_pImageData->pSrc );
m_pImageData->pSrc = pStr;
}
retVal = NET_MakeRelativeURL( LO_GetBaseURL( m_pBuffer->m_pContext ),
m_pImageData->pLowSrc,
&pStr );
if( retVal != NET_URL_FAIL ){
XP_FREE( m_pImageData->pLowSrc );
m_pImageData->pLowSrc = pStr;
}
}
}
CEditImageLoader::~CEditImageLoader(){
m_pBuffer->m_pLoadingImage = 0;
FE_ImageLoadDialogDestroy( m_pBuffer->m_pContext );
FE_EnableClicking( m_pBuffer->m_pContext );
edt_FreeImageData( m_pImageData );
}
void CEditImageLoader::LoadImage(){
char *pStr;
XP_ObserverList image_obs_list; // List of image observers.
m_pLoImage = LO_NewImageElement( m_pBuffer->m_pContext );
// convert the URL to an absolute path
pStr = NET_MakeAbsoluteURL( LO_GetBaseURL( m_pBuffer->m_pContext ),
m_pImageData->pSrc );
m_pLoImage->image_url = PA_strdup( pStr );
XP_FREE( pStr );
// convert the URL to an absolute path
pStr = NET_MakeAbsoluteURL( LO_GetBaseURL( m_pBuffer->m_pContext ),
m_pImageData->pLowSrc );
m_pLoImage->lowres_image_url = PA_strdup( pStr );
XP_FREE( pStr );
// tell layout to pass the size info back to us.
m_pLoImage->ele_id = ED_IMAGE_LOAD_HACK_ID;
FE_ImageLoadDialog( m_pBuffer->m_pContext );
image_obs_list = lo_NewImageObserverList(m_pBuffer->m_pContext,
m_pLoImage);
if (!image_obs_list) {
XP_ASSERT(FALSE); // Out of memory.
return;
}
lo_GetImage(m_pBuffer->m_pContext, m_pBuffer->m_pContext->img_cx,
m_pLoImage, image_obs_list, NET_DONT_RELOAD);
}
// The image library is telling us the size of the image. Actually do the
// insert now.
void CEditImageLoader::SetImageInfo(int32 width, int32 height){
if( m_pImageData->iHeight == 0 || m_pImageData->iWidth == 0 ){
m_pImageData->iHeight = height;
m_pImageData->iWidth = width;
m_pImageData->iOriginalHeight = height;
m_pImageData->iOriginalWidth = width;
}
if( m_bReplaceImage ){
// whack this in here...
m_pBuffer->m_pCurrent->Image()->SetImageData( m_pImageData );
// we could be doing a better job here. We probably repaint too much...
CEditElement *pContainer = m_pBuffer->m_pCurrent->FindContainer();
m_pBuffer->Relayout( pContainer, 0, pContainer->GetLastMostChild(),
RELAYOUT_NOCARET );
m_pBuffer->SelectCurrentElement();
}
else {
m_pBuffer->InsertImage( m_pImageData );
}
delete this;
}
//-----------------------------------------------------------------------------
// CEditSaveObject
//-----------------------------------------------------------------------------
#if defined(XP_OS2)
extern "C"
#else
PRIVATE
#endif
unsigned int edt_file_save_stream_write_ready( NET_StreamClass * /* stream */ ){
return MAX_WRITE_READY;
}
#if defined(XP_OS2)
extern "C"
#else
PRIVATE
#endif
int edt_FileSaveStreamWrite (NET_StreamClass *stream, const char *block, int32 length) {
CFileSaveObject *pSaver = (CFileSaveObject*)stream->data_object;
return pSaver->NetStreamWrite( block, length );
}
#if defined(XP_OS2)
extern "C"
#else
PRIVATE
#endif
void edt_file_save_stream_complete( NET_StreamClass * /* stream */ ){
}
#if defined(XP_OS2)
extern "C"
#else
PRIVATE
#endif
void edt_file_save_stream_abort (NET_StreamClass * /* stream */, int /* status */ ) {
}
#if defined(XP_OS2)
extern "C"
#else
PRIVATE
#endif
void edt_UrlExit( URL_Struct *pURL, int status, MWContext * /* context */ )
{
// hardts, changed from CEditSaveObject to CFileSaveObject
((CFileSaveObject*)(pURL->fe_data))->NetFetchDone(status);
NET_FreeURLStruct(pURL);
}
#if defined(XP_OS2)
extern "C"
#else
PRIVATE
#endif
NET_StreamClass * edt_MakeFileSaveStream (int /* format_out */, void * /* closure */,
URL_Struct *url, MWContext *context ) {
NET_StreamClass *stream;
CFileSaveObject *pSaver = (CFileSaveObject*)url->fe_data;
// OpenOutputFile will return 0 if OK
if( !pSaver || pSaver->OpenOutputFile() != 0 ){
return (NULL);
}
// ### mwelch Relay the information stored in this URL. We do it here instead of
// in the url exit routine because edt_MakeFileSaveStream could
// have been invoked by an inferior URL which represents a parsed
// piece of a mail or news message. If this URL is what was originally
// invoked, the correct mime type should still be present here.
if (url)
pSaver->CopyURLInfo(url);
TRACEMSG(("Setting up attachment stream. Have URL: %s\n", url->address));
stream = XP_NEW (NET_StreamClass);
if (stream == NULL)
return (NULL);
XP_MEMSET (stream, 0, sizeof (NET_StreamClass));
stream->name = "editor file save";
stream->complete = edt_file_save_stream_complete;
stream->abort = edt_file_save_stream_abort;
stream->put_block = edt_FileSaveStreamWrite;
stream->is_write_ready = edt_file_save_stream_write_ready;
stream->data_object = url->fe_data;
stream->window_id = context;
return stream;
}
static XP_Bool bNetRegistered = FALSE;
#ifdef MOZ_MAIL_NEWS
extern "C"
{
NET_StreamClass *MIME_MessageConverter (int format_out, void *closure,
URL_Struct *url,
MWContext *context);
}
#endif
//-----------------------------------------------------------------------------
// CFileSaveObject
//-----------------------------------------------------------------------------
CFileSaveObject::CFileSaveObject( MWContext *pContext,
ITapeFileSystem *tapeFS, XP_Bool bAutoSave,
CEditSaveToTempData *pSaveToTempData) :
m_pContext( pContext ) ,
m_bOverwriteAll( FALSE ),
m_bDontOverwriteAll( FALSE ),
m_bDontOverwrite( FALSE ),
m_iCurFile(0),
m_pOutStream(0),
m_bOpenOutputHandledError(FALSE),
m_tapeFS(tapeFS),
m_status( ED_ERROR_NONE ),
m_bFromAutoSave(bAutoSave),
m_pSaveToTempData(pSaveToTempData)
{
if( !bNetRegistered ){
#ifdef MOZ_MAIL_NEWS
// ### mwelch Need to pass mail/news messages through
// MIME_MessageConverter since we're likely to be
// extracting a part of the message.
NET_RegisterContentTypeConverter( MESSAGE_RFC822, FO_EDT_SAVE_IMAGE,
NULL, MIME_MessageConverter);
NET_RegisterContentTypeConverter( MESSAGE_NEWS, FO_EDT_SAVE_IMAGE,
NULL, MIME_MessageConverter);
#endif
// For everything else, just write to the tapefs.
NET_RegisterContentTypeConverter( "*", FO_EDT_SAVE_IMAGE,
NULL, edt_MakeFileSaveStream );
//// Why is this duplicated? hardts
#if defined(XP_WIN) || defined(XP_OS2)
NET_RegisterContentTypeConverter( "*", FO_EDT_SAVE_IMAGE,
NULL, edt_MakeFileSaveStream );
#else
NET_RegisterContentTypeConverter( "*", FO_EDT_SAVE_IMAGE,
NULL, edt_MakeFileSaveStream );
#endif /* XP_WIN */
bNetRegistered = TRUE;
}
// MUST DISABLE WINDOW INTERACTION HERE!
// (It will always be cleared in the GetURLExitRoutine)
// (This is normally set TRUE by front end before calling NET_GetURL)
m_pContext->waitingMode = TRUE;
// Set a flag so we know when we are saving a file
// (also set in CEditBuffer::SaveFile() - may not be needed here, but its safe to set again)
m_pContext->edit_saving_url = TRUE;
// set base URL for the tape file system.
char *pBaseURL = edt_GetDocRelativeBaseURL(m_pContext);
if (pBaseURL) {
m_tapeFS->SetSourceBaseURL(pBaseURL);
XP_FREE(pBaseURL);
}
}
CFileSaveObject::~CFileSaveObject(){
// Success message for publishing. Moved from WinFE to back end.
if (m_tapeFS->GetType() == ITapeFileSystem::Publish &&
m_status == ED_ERROR_NONE) {
char *msg = NULL;
// Different message for 1 or multiple files.
// Subtract count of files that failed.
int iCount = m_tapeFS->GetNumFiles() - m_iErrorCount;
if ( iCount > 1) {
char *tmplate = XP_GetString(XP_EDT_PUBLISH_REPORT_MSG);
if (tmplate) {
msg = PR_smprintf(tmplate, iCount);
}
}
else {
msg = XP_STRDUP(XP_GetString(XP_EDT_PUBLISH_REPORT_ONE_FILE));
}
if (msg) {
char * pBrowse = NULL, *pPub = NULL, *pLastPub = NULL;
PREF_CopyCharPref("editor.publish_browse_location",&pBrowse);
PREF_CopyCharPref("editor.publish_location",&pPub);
PREF_CopyCharPref("editor.publish_last_loc",&pLastPub);
#if defined(XP_WIN) || defined(XP_OS2)
/* FE_LoadUrl needs to be implemented in X */
if( EDT_IsSameURL(pPub, pLastPub,0,0) && pBrowse && *pBrowse ){
// We just saved to the default home location
StrAllocCat(msg, XP_GetString(XP_EDT_BROWSE_TO_DEFAULT));
if( FE_Confirm(m_pContext,msg) ){
// User said Yes - load location into a BROWSER window (FALSE param)
FE_LoadUrl(pBrowse, FALSE );
}
} else {
FE_Alert(m_pContext,msg);
}
XP_FREEIF(pBrowse);
XP_FREEIF(pPub);
#else
// mac and unix
FE_Message(m_pContext,msg);
#endif
XP_FREE(msg);
}
}
// LOU: What should I do here. There appear to be connections on the
// window that are still open....
if( NET_AreThereActiveConnectionsForWindow( m_pContext ) ){
//XP_ASSERT(FALSE);
//NET_SilentInterruptWindow( m_pContext );
XP_TRACE(("NET_AreThereActiveConnectionsForWindow is TRUE in ~CFileSaveObject"));
}
////XP_FREE( m_pDestPathURL );
// Allow front end interaction
m_pContext->waitingMode = FALSE;
// Clear flag (also done in CEditBuffer::FinishedLoad2)
m_pContext->edit_saving_url = FALSE;
#ifdef XP_WIN
// Tell front end we finished autosave
// so it can gray the Save toolbar button
if( m_bFromAutoSave )
FE_UpdateEnableStates(m_pContext);
#endif
// Tape File system should not be deleted yet.
if (m_tapeFS &&
m_tapeFS->GetType() == ITapeFileSystem::Publish &&
m_status == ED_ERROR_NONE) {
// Call publishComplete event.
char *pDestURL = m_tapeFS->GetDestAbsURL();
EDT_PerformEvent(m_pContext,"publishComplete",pDestURL,TRUE,FALSE,0,0);
XP_FREEIF(pDestURL);
}
///// This code will have to change if we implement a "saveComplete" event for
///// composer plugins.
// Call callback for saving file to temporary location.
if (m_tapeFS &&
m_tapeFS->GetType() == ITapeFileSystem::File &&
m_pSaveToTempData && m_pSaveToTempData->doneFn) {
if (m_status == ED_ERROR_NONE) {
(*m_pSaveToTempData->doneFn)(m_pSaveToTempData->pFileURL,m_pSaveToTempData->hook);
}
else {
// Failed, pass in NULL as the temporary file name.
(*m_pSaveToTempData->doneFn)(NULL,m_pSaveToTempData->hook);
}
}
delete m_pSaveToTempData;
}
// Callback from tape file system.
//
//** Don't make this function static because it is a friend of CFileSaveObject
//** so it must be extern. (at least on MAC)
void edt_CFileSaveObjectDone(XP_Bool success,void *arg) {
CFileSaveObject *saveObject = (CFileSaveObject *)arg;
if (!saveObject) {
XP_ASSERT(0);
return;
}
if (!success) {
saveObject->m_status = ED_ERROR_TAPEFS_COMPLETION;
}
// Tape File system should not be deleted yet.
delete saveObject;
}
void
CFileSaveObject::CopyURLInfo(const URL_Struct *pURL)
{
XP_ASSERT((m_tapeFS) && (m_iCurFile <= m_tapeFS->GetNumFiles()));
if ((m_tapeFS) && (m_iCurFile <= m_tapeFS->GetNumFiles()))
m_tapeFS->CopyURLInfo(m_iCurFile-1, pURL);
}
ED_FileError CFileSaveObject::FileFetchComplete() {
XP_ASSERT(m_tapeFS->GetNumFiles());
if( !m_bFromAutoSave && // Don't want dialogs from autosave, bug 43878
m_tapeFS->GetType() != ITapeFileSystem::MailSend ){ // Suppress dialog for mail send.
FE_SaveDialogDestroy( m_pContext, m_status, 0);
}
if (!m_tapeFS) {
XP_ASSERT(0);
return ED_ERROR_BLOCKED; // is this the right thing to return?
}
ED_FileError statusResult = m_status;
m_tapeFS->Complete( m_status == ED_ERROR_NONE,
edt_CFileSaveObjectDone, (void *)this );
// "this" may already be deleted at this point, so we can't just return m_status.
return statusResult;
}
ED_FileError CFileSaveObject::SaveFiles(){
XP_ASSERT(m_tapeFS && m_tapeFS->GetNumFiles());
// Next param indicates if we are downloading (FALSE)
// or uploading (TRUE), so this can be used for publishing
if( !m_bFromAutoSave && // Don't want dialogs from autosave, bug 43878
m_tapeFS->GetType() != ITapeFileSystem::MailSend ){ // Suppress dialog for mail send.
ED_SaveDialogType saveType;
switch (m_tapeFS->GetType()) {
case ITapeFileSystem::File:
saveType = ED_SAVE_DLG_SAVE_LOCAL;
break;
case ITapeFileSystem::Publish:
saveType = ED_SAVE_DLG_PREPARE_PUBLISH;
break;
default:
XP_ASSERT(0);
}
FE_SaveDialogCreate( m_pContext, m_tapeFS->GetNumFiles(), saveType );
}
// Count number of files we fail to save
// to subtract from total number when reporting at the end
m_iErrorCount = 0;
if (SaveFirstFile()) {
// Child of CFileSaveObject took care of the first file.
m_iCurFile++;
}
// loop through the tree getting all the image elements...
return FetchNextFile();
}
// Just a wrapper around the Tape File System.
intn CFileSaveObject::AddFile( char *pSrcURL, char *pMIMEType, int16 iDocCharSetID){
XP_ASSERT(m_tapeFS);
return m_tapeFS->AddFile(pSrcURL,pMIMEType,iDocCharSetID);
}
//
// open the file and get the Netlib to fetch it from the cache.
//
ED_FileError CFileSaveObject::FetchNextFile(){
XP_ASSERT(m_tapeFS);
if( m_status != ED_ERROR_NONE || m_iCurFile >= m_tapeFS->GetNumFiles() ){
return FileFetchComplete();
}
// m_iCurFile is 1-based, so i is 0-based.
int i = m_iCurFile++;
char *srcURL = m_tapeFS->GetSourceURL(i);
if (!srcURL) {
XP_ASSERT(0);
return ED_ERROR_FILE_READ;
}
URL_Struct *pUrl;
pUrl= NET_CreateURLStruct( srcURL, NET_DONT_RELOAD );
if (!pUrl) {
XP_ASSERT(0);
XP_FREE(srcURL);
return ED_ERROR_FILE_READ;
}
XP_FREE(srcURL);
// Store file save object so we can access OpenOutputFile etc.
pUrl->fe_data = this;
//TODO: Should we be setting the referer field as well?
NET_GetURL( pUrl, FO_EDT_SAVE_IMAGE, m_pContext, edt_UrlExit );
return m_status;
}
void CFileSaveObject::CheckFinishedSave(intn oneBased,ED_FileError iError) // one-based index.
{
if (m_tapeFS->IsLocalPersistentFile(oneBased - 1)) {
char *pAbsURL = GetDestAbsoluteURL(oneBased - 1);
if (pAbsURL) {
// Tell the front end that a new local file has been created.
// We use number to tell between Main image (1) and Low-Res image (2)
FE_FinishedSave( m_pContext, iError, pAbsURL, oneBased );
XP_FREE(pAbsURL);
}
}
}
void CFileSaveObject::NetFetchDone( int status ){
// close the file in any case.
if( m_pOutStream ){
m_tapeFS->CloseStream(m_iCurFile-1);
m_pOutStream = 0;
}
// Default: No error, show destination name for most errors
ED_FileError iError = ED_ERROR_NONE;
// NOTE: This is the NETLIB error code: (see merrors.h)
// < 0 is an error
if( status < 0 ){
// As we become familiar with typical errors,
// add specialized error types here
// Use " extern MK_..." to access the error value
if( status == MK_UNABLE_TO_LOCATE_FILE ||
status == MK_MALFORMED_URL_ERROR ) {
// Couldn't find source -- use source filename
// for error report
iError = ED_ERROR_SRC_NOT_FOUND;
} else if( m_bDontOverwrite ) {
// We get status = MK_UNABLE_TO_CONVERT
// if user said NO to overwriting an existing file:
// edt_MakeFileSaveStream returns 0,
// making NET_GetURL think it failed,
// but its not really an error
iError = ED_ERROR_NONE;
} else if( m_status == ED_ERROR_CANCEL ) {
// User selected CANCEL at overwrite warning dialog,
// thus stream was not created and returns error status,
// but its not really an error
iError = ED_ERROR_CANCEL;
} else {
// "Unknown" error default
iError = ED_ERROR_FILE_READ;
}
m_iErrorCount++;
}
// ED_ERROR_FILE_OPEN was already handled in CFileSaveObject::OpenOutputFile()
if (!m_bOpenOutputHandledError) {
// No longer uses FE_SaveErrorContinueDialog()
if (!SaveErrorContinueDialog(iError) ) {
Cancel();
}
CheckFinishedSave(m_iCurFile,iError);
}
FetchNextFile();
}
intn CFileSaveObject::OpenOutputFile(){
m_bOpenOutputHandledError = FALSE;
// Return if we already have an open stream
if( m_pOutStream != NULL){
return 0;
}
// Current number incremented before comming here,
// or think of it as 1-based counting
int i = m_iCurFile-1;
XP_Bool bWriteThis = TRUE;
char *pHumanName = m_tapeFS->GetHumanName(i);
// Tell front end the filename even if we are not writing the file
//
if (!m_bDontOverwriteAll &&
!m_bFromAutoSave && // Don't want dialogs from autosave, bug 43878
m_tapeFS->GetType() != ITapeFileSystem::MailSend) { // Suppress dialog for mail send.
FE_SaveDialogSetFilename( m_pContext, pHumanName );
}
m_bDontOverwrite = m_bDontOverwriteAll;
if( !m_bOverwriteAll){
if( m_tapeFS->FileExists(i) ){
// file exists.
if( m_bDontOverwriteAll ){
bWriteThis = FALSE;
CheckFinishedSave(m_iCurFile,ED_ERROR_FILE_EXISTS);
}
else {
ED_SaveOption e;
e = FE_SaveFileExistsDialog( m_pContext, pHumanName);
switch( e ){
case ED_SAVE_OVERWRITE_THIS:
break;
case ED_SAVE_OVERWRITE_ALL:
m_bOverwriteAll = TRUE;
break;
case ED_SAVE_DONT_OVERWRITE_ALL:
m_bDontOverwriteAll = TRUE;
// intentionally fall through
case ED_SAVE_DONT_OVERWRITE_THIS:
// This flag prevents us from reporting
// "failed" file stream creation as an error
m_bDontOverwrite = TRUE;
bWriteThis = FALSE;
CheckFinishedSave(m_iCurFile,ED_ERROR_FILE_EXISTS);
break;
case ED_SAVE_CANCEL:
Cancel();
bWriteThis = FALSE;
}
}
}
}
if( bWriteThis ){
m_pOutStream = m_tapeFS->OpenStream( i );
}
else {
// We are returning, not doing the save, but not an error condition
XP_FREE(pHumanName);
return -1;
}
XP_TRACE(("Opening stream number %d gives %d.", i, (int)m_pOutStream));
if ( m_pOutStream == NULL ) {
// No longer uses FE_SaveErrorContinueDialog()
if(!SaveErrorContinueDialog( ED_ERROR_FILE_OPEN ) ){
Cancel();
}
XP_FREE(pHumanName);
CheckFinishedSave(m_iCurFile,ED_ERROR_FILE_OPEN);
// So we don't report error twice, once on opening file and once
// when netlib is unable to write to it.
m_bOpenOutputHandledError = TRUE;
return -1;
}
XP_FREE(pHumanName);
return 0; // success
}
int CFileSaveObject::NetStreamWrite( const char *block, int32 length ){
XP_TRACE(("NetStreamWrite: length = %lu", length));
XP_ASSERT(m_pOutStream);
m_pOutStream->Write((char *)block,length);
return m_pOutStream->Status() == IStreamOut::EOS_NoError;
}
void CFileSaveObject::Cancel(){
// tell net URL to stop...
m_status = ED_ERROR_CANCEL;
// Above alone does seem to work! Don't we need this?
// NET_InterruptWindow causes a "reentrant interrupt" error message now!
NET_SilentInterruptWindow( m_pContext );
}
char *CFileSaveObject::GetDestName( intn index ){
if (!m_tapeFS) {
XP_ASSERT(0);
return NULL;
}
return m_tapeFS->GetDestURL(index);
}
char *CFileSaveObject::GetDestAbsoluteURL( intn index ){
if (!m_tapeFS) {
XP_ASSERT(0);
return NULL;
}
char *pDestPathURL = m_tapeFS->GetDestPathURL();
char *pDestRelativeURL = m_tapeFS->GetDestURL(index);
if (!pDestRelativeURL) {
XP_ASSERT(0);
XP_FREEIF(pDestPathURL);
return NULL;
}
// Maybe should use NET_MakeAbsolute() instead of concatenation.
char *pDestAbsURL = pDestPathURL ?
PR_smprintf( "%s%s", pDestPathURL, pDestRelativeURL ) :
XP_STRDUP(pDestRelativeURL);
XP_FREEIF(pDestPathURL);
XP_FREE(pDestRelativeURL);
return pDestAbsURL;
}
char *CFileSaveObject::GetSrcName( intn index ){
if (!m_tapeFS) {
XP_ASSERT(0);
return NULL;
}
return m_tapeFS->GetSourceURL(index);
/*if( index >= m_srcImageURLs.Size() ){
return 0;
}
else {
return XP_STRDUP( m_srcImageURLs[index] );
} */
}
// Convert file:// URLs into local file names for display to user.
PRIVATE void edt_url_make_human(char **pURL) {
if (NET_IsLocalFileURL(*pURL)) {
char *pTemp;
XP_ConvertUrlToLocalFile(*pURL,&pTemp);
XP_FREEIF(*pURL);
*pURL = pTemp;
}
}
XP_Bool CFileSaveObject::SaveErrorContinueDialog(ED_FileError iError) {
// No user interaction for these conditions.
if (iError == ED_ERROR_NONE ||
iError == ED_ERROR_CANCEL ||
iError == ED_ERROR_FILE_EXISTS) {
return TRUE;
}
char *tmplate = NULL;
char *msg = NULL;
// m_iCurFile is 1-based.
char *pAbsDest = GetDestAbsoluteURL(m_iCurFile-1);
char *pRelDest = m_tapeFS->GetHumanName(m_iCurFile-1);
char *pAbsSrc = GetSrcName(m_iCurFile-1);
char *pRootAbsDest = GetDestAbsoluteURL(0);
edt_url_make_human(&pAbsDest);
edt_url_make_human(&pAbsSrc);
edt_url_make_human(&pRootAbsDest);
// Two level switch, first on different types of file systems,
// second on different classes of errors.
switch (m_tapeFS->GetType()) {
case ITapeFileSystem::File:
switch (iError) {
case ED_ERROR_FILE_OPEN:
case ED_ERROR_FILE_WRITE:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_SAVE_FILE_WRITE));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_SAVE_CONTINUE));
msg = PR_smprintf(tmplate,pRelDest,pRootAbsDest,pRelDest);
break;
case ED_ERROR_SRC_NOT_FOUND:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_SAVE_SRC_NOT_FOUND));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_SAVE_CONTINUE));
msg = PR_smprintf(tmplate,pAbsSrc,pAbsSrc);
break;
case ED_ERROR_FILE_READ:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_SAVE_FILE_READ));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_SAVE_CONTINUE));
msg = PR_smprintf(tmplate,pRelDest,pRelDest);
break;
default:
break;
}
break;
case ITapeFileSystem::Publish:
switch (iError) {
case ED_ERROR_FILE_OPEN:
case ED_ERROR_FILE_WRITE:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_PUBLISH_FILE_WRITE));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_PUBLISH_CONTINUE));
msg = PR_smprintf(tmplate,pRelDest,pRelDest);
break;
case ED_ERROR_SRC_NOT_FOUND:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_PUBLISH_SRC_NOT_FOUND));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_PUBLISH_CONTINUE));
msg = PR_smprintf(tmplate,pAbsSrc,pAbsSrc);
break;
case ED_ERROR_FILE_READ:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_PUBLISH_FILE_READ));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_PUBLISH_CONTINUE));
msg = PR_smprintf(tmplate,pRelDest,pRelDest);
break;
default:
break;
}
break;
case ITapeFileSystem::MailSend:
switch (iError) {
case ED_ERROR_FILE_OPEN:
case ED_ERROR_FILE_WRITE:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_MAIL_FILE_WRITE));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_MAIL_CONTINUE));
msg = PR_smprintf(tmplate,pRelDest,pRelDest);
break;
case ED_ERROR_SRC_NOT_FOUND:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_MAIL_SRC_NOT_FOUND));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_MAIL_CONTINUE));
msg = PR_smprintf(tmplate,pAbsSrc,pAbsSrc);
break;
case ED_ERROR_FILE_READ:
tmplate = XP_STRDUP(XP_GetString(XP_EDT_ERR_MAIL_FILE_READ));
StrAllocCat(tmplate,XP_GetString(XP_EDT_ERR_MAIL_CONTINUE));
msg = PR_smprintf(tmplate,pRelDest,pRelDest);
break;
default:
break;
}
break;
}
XP_Bool retVal = FALSE;
if (msg) {
retVal = FE_Confirm(m_pContext,msg);
}
else {
XP_ASSERT(0);
}
XP_FREEIF(tmplate);
XP_FREEIF(msg);
XP_FREEIF(pAbsDest);
XP_FREEIF(pRelDest);
XP_FREEIF(pAbsSrc);
XP_FREEIF(pRootAbsDest);
return retVal;
}
char * CEditSaveObject::m_pFailedPublishUrl = NULL;
//-----------------------------------------------------------------------------
// CEditSaveObject
//-----------------------------------------------------------------------------
CEditSaveObject::CEditSaveObject( CEditBuffer *pBuffer,
ED_SaveFinishedOption finishedOpt,
char *pSrcURL,
ITapeFileSystem *tapeFS,
XP_Bool, // bSaveAs is ignored.
XP_Bool bKeepImagesWithDoc,
XP_Bool bAutoAdjustLinks,
XP_Bool bAutoSave,
CEditSaveToTempData *pSaveToTempData ) :
CFileSaveObject( pBuffer->m_pContext,tapeFS,bAutoSave, pSaveToTempData ),
m_pBuffer( pBuffer ),
m_pDocStateSave( 0 ),
m_pSrcURL( XP_STRDUP( pSrcURL ) ),
m_finishedOpt( finishedOpt ),
m_bKeepImagesWithDoc( bKeepImagesWithDoc ),
m_bAutoAdjustLinks( bAutoAdjustLinks ),
m_backgroundIndex(IgnoreImage) {
}
CEditSaveObject::~CEditSaveObject(){
XP_Bool bRevertBuffer = FALSE;
XP_Bool bRelayout = FALSE;
/*
* possible values for m_finishedOpt:
* ED_FINISHED_GOTO_NEW, Point the editor to the location of the
* newly saved document if successful, otherwise revert buffer.
* ED_FINISHED_REVERT_BUFFER, Revert the buffer to the state before
* the save operation began, regardless.
* ED_FINISHED_SAVE_DRAFT Like ED_FINISHED_REVERT_BUFFER, except clears the dirty flag
* on success.
* ED_FINISHED_MAIL_SEND If we succeed we're going to throw the buffer
* away, so don't revert it, but don't bother gotoNew.
* If failure, revert the buffer.
* Used for mail compose, we don't
* want the editor to start any operation that
* causes problems when libmsg destroys the editor
* context.
*/
if ( m_finishedOpt == ED_FINISHED_GOTO_NEW && m_status == ED_ERROR_NONE )
{
//// Go to new location.
m_pBuffer->m_pContext->is_new_document = FALSE;
// Set the document title and history entry to the new location.
char *pDestFileURL = GetDestAbsoluteURL(0);
if ( !pDestFileURL )
{
XP_ASSERT( 0 );
m_status = ED_ERROR_FILE_WRITE; // Not really the right thing to set.
return;
}
// We used to do the ftp://username@path here, but it's moved to earlier in
// the save process, in EDT_PublishFile.
// Set this first - FE_SetDocTitle will get URL from it
LO_SetBaseURL( m_pBuffer->m_pContext, pDestFileURL );
History_entry * hist_ent =
SHIST_GetCurrent(&(m_pBuffer->m_pContext->hist));
char * pTitle = NULL;
if(hist_ent)
{
if ( hist_ent->title && XP_STRLEN(hist_ent->title) > 0 ){
// Note: hist_ent->title should always = m_pContext->title?
// Change "file:///Untitled" into URL
// Use the new address if old title == old address
char* utf8_edit_new_doc_name = (char*)
INTL_ConvertLineWithoutAutoDetect(
INTL_CharSetNameToID(INTL_ResourceCharSet()),
CS_UTF8,
(unsigned char*) XP_GetString(XP_EDIT_NEW_DOC_NAME),
XP_STRLEN(XP_GetString(XP_EDIT_NEW_DOC_NAME))
);
if( 0 != XP_STRCMP(hist_ent->title, utf8_edit_new_doc_name ) &&
0 != XP_STRCMP(hist_ent->title, hist_ent->address) )
{
// pTitle = XP_STRDUP(hist_ent->title);
pTitle = (char*)INTL_ConvertLineWithoutAutoDetect(
CS_UTF8,
m_pBuffer->GetRAMCharSetID(),
(unsigned char*) hist_ent->title,
XP_STRLEN(hist_ent->title)
);
} else {
pTitle = XP_STRDUP(pDestFileURL);
XP_FREE(hist_ent->title);
hist_ent->title = XP_STRDUP(pDestFileURL);
}
XP_FREEIF(utf8_edit_new_doc_name);
} else {
// Use the URL if no Document title
pTitle = XP_STRDUP(pDestFileURL);
XP_FREEIF(hist_ent->title);
hist_ent->title = XP_STRDUP(pDestFileURL);
}
// Test if new URL is same as current before we replace the latter
XP_Bool bSameURL = EDT_IsSameURL( hist_ent->address, pDestFileURL, NULL, NULL);
// Set history entry address to new URL
XP_FREEIF(hist_ent->address);
hist_ent->address = XP_STRDUP(pDestFileURL);
// We may inherit this URL (used for faster reloading in browser)
// when saving a remote URL to local disk,
// so always clear it since Editor never uses it.
XP_FREEIF(hist_ent->wysiwyg_url);
// This changes doc title, window caption, history title,
/// but not history address
if (pTitle)
{
FE_SetDocTitle(m_pBuffer->m_pContext, pTitle);
XP_FREE(pTitle);
}
if( !bSameURL )
{
// Make the new URL (now in current history entry)
// as the most-recently-used URL in prefs. list
// (Note: We should never be here in mail message composer)
EDT_SyncEditHistory(m_pBuffer->m_pContext);
}
} // if (hist_ent)
XP_FREE(pDestFileURL);
// Saved successfully.
m_pBuffer->DocumentStored();
// This flag must be cleared before GetFileWriteTime,
// else the write time will not be recorded
m_pContext->edit_saving_url = FALSE;
// Get the current file time
m_pBuffer->GetFileWriteTime();
// Some of the links may have changed, so relayout
bRelayout = TRUE;
}
else if ( m_finishedOpt == ED_FINISHED_MAIL_SEND && m_status == ED_ERROR_NONE )
{
//// Do nothing.
// Don't relayout, we're throwing the buffer away.
}
else if (m_pDocStateSave) {
//// Don't go to the new document, revert to m_pDocStateSave.
bRevertBuffer = TRUE;
// Don't relayout, reverting the buffer will take care of it.
}
if ( m_finishedOpt == ED_FINISHED_SAVE_DRAFT && m_status == ED_ERROR_NONE )
{
// Note that we are still reverting the buffer.
// Saved successfully.
m_pBuffer->DocumentStored();
}
// Originally, this was only called if m_status == ED_ERROR_NONE.
m_pBuffer->FileFetchComplete(m_status);
if (bRelayout)
{
// Don't always relayout because we may have "cid:" links which cause an error.
// reverting the buffer will take care of it.
m_pBuffer->RefreshLayout();
}
// Already cleared above if ED_FINISHED_GOTO_NEW and success,
// but it must be cleared eventually in all cases.
m_pContext->edit_saving_url = FALSE;
m_pBuffer->m_pSaveObject = 0;
if (bRevertBuffer) {
// Must be after CEditBuffer::FileFetchComplete(), because it deletes CEditBuffer.
m_pBuffer->RestoreState(m_pDocStateSave);
}
if( m_tapeFS->GetType() == ITapeFileSystem::Publish ){
XP_FREEIF(m_pFailedPublishUrl);
if( m_status == ED_ERROR_NONE ){
// Save the last-used location into the history list
edt_SyncPublishingHistory(m_pBuffer->m_pContext);
} else {
// Save this URL so we can supply the "bad" location
// to user if they try to publish that URL again
m_pFailedPublishUrl = XP_STRDUP(m_pSrcURL);
}
}
XP_FREE( m_pSrcURL );
delete m_pDocStateSave;
}
// Add all images in document that are also in ppIncludedFiles.
//
// If ppIncludedFiles is NULL, this should add exactly those files that would be returned by
// CEditBuffer::GetAllDocumentFiles() with the selected flag set TRUE.
// i.e. Regular Saving should save exactly those files that are published by default in remote publishing.
XP_Bool CEditSaveObject::AddAllFiles(char **ppIncludedFiles){
//////// WARNING: if you change this function, fix CEditBuffer::GetAllDocumentFiles and CEditSaveObject::FixupLinks() also.
EDT_ImageData *pData;
EDT_PageData *pPageData;
// Make sure all URLs in ppIncludedFiles are absolute
if (ppIncludedFiles) {
char **ppFile = ppIncludedFiles;
while (*ppFile) {
char *pAbs = NET_MakeAbsoluteURL(m_pSrcURL,*ppFile);
if (pAbs) {
// If making *ppFile absolute changed it, replace it with absolute URL.
if (XP_STRCMP(pAbs,*ppFile)) {
XP_FREE(*ppFile);
*ppFile = pAbs;
}
else {
XP_FREE(pAbs);
}
}
ppFile++;
}
}
// Add actual HTML document.
intn firstIndex = AddFile(m_pSrcURL,TEXT_HTML,m_pBuffer->GetDocCharSetID());
if (firstIndex != 0) {
m_status = ED_ERROR_BAD_URL;
FreeList(ppIncludedFiles);
return FALSE;
}
CEditElement *pImage = m_pBuffer->m_pRoot->FindNextElement(
&CEditElement::FindImage, 0 );
// If there is a background Image, make it the first image.
pPageData = m_pBuffer->GetPageData();
if( pPageData ) {
if ( pPageData->pBackgroundImage && *pPageData->pBackgroundImage){
m_backgroundIndex = CheckAddFile( pPageData->pBackgroundImage, NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !pPageData->bBackgroundNoSave );
}
// We now support > 1 FontDefURL per page
int iFontDefCount = m_pBuffer->m_FontDefURL.Size();
for( int i = 0; i < iFontDefCount; i++ )
{
intn iIndex = CheckAddFile( m_pBuffer->m_FontDefURL[i], NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !m_pBuffer->m_FontDefNoSave[i] );
m_FontDefIndex.Add(iIndex);
}
#if 0
if ( pPageData->pFontDefURL && *pPageData->pFontDefURL ){
m_fontDefIndex = CheckAddFile( pPageData->pFontDefURL, NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !pPageData->bFontDefNoSave );
}
#endif
}
m_pBuffer->FreePageData( pPageData );
while( pImage )
{
// If this assert fails, it is probably because FinishedLoad
// didn't get called on the image. And that's probably because
// of some bug in the recursive FinishedLoad code.
// If the size isn't known, the relayout after the save will block,
// and the fourth .. nth images in the document will get zero size.
// XP_ASSERT(pImage->Image()->SizeIsKnown());
pImage->Image()->m_iSaveIndex = IgnoreImage;
pImage->Image()->m_iSaveLowIndex = IgnoreImage;
pData = pImage->Image()->GetImageData();
if( pData )
{
// Only consider images that are not server-generated
if( EDT_IsImageURL(pData->pSrc) )
{
pImage->Image()->m_iSaveIndex = CheckAddFile( pData->pSrc, NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !pData->bNoSave );
}
if( EDT_IsImageURL(pData->pLowSrc) )
{
pImage->Image()->m_iSaveLowIndex = CheckAddFile( pData->pLowSrc, NULL,ppIncludedFiles,
m_bKeepImagesWithDoc && !pData->bNoSave );
}
edt_FreeImageData( pData );
}
pImage = pImage->FindNextElement( &CEditElement::FindImage, 0 );
}
//// Sure would be nice to abstract all the different types of table
//// backgrounds.
// table backgrounds <table>
CEditElement *pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindTable, 0 )) ){
EDT_TableData *pData = ((CEditTableElement *)pNext)->GetData();
if (pData) {
if ( pData->pBackgroundImage && *pData->pBackgroundImage) {
((CEditTableElement *)pNext)->m_iBackgroundSaveIndex = CheckAddFile( pData->pBackgroundImage, NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !pData->bBackgroundNoSave);
}
CEditTableElement::FreeData(pData);
}
}
// table row backgrounds <tr>
pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindTableRow, 0 )) ){
EDT_TableRowData *pData = ((CEditTableRowElement *)pNext)->GetData();
if (pData) {
if ( pData->pBackgroundImage && *pData->pBackgroundImage) {
((CEditTableRowElement *)pNext)->m_iBackgroundSaveIndex = CheckAddFile( pData->pBackgroundImage, NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !pData->bBackgroundNoSave);
}
CEditTableRowElement::FreeData(pData);
}
}
// table cell backgrounds <td> <th>
pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindTableCell, 0 )) ){
EDT_TableCellData *pData = ((CEditTableCellElement *)pNext)->GetData(0);
if (pData) {
if ( pData->pBackgroundImage && *pData->pBackgroundImage) {
((CEditTableCellElement *)pNext)->m_iBackgroundSaveIndex = CheckAddFile( pData->pBackgroundImage, NULL, ppIncludedFiles,
m_bKeepImagesWithDoc && !pData->bBackgroundNoSave);
}
CEditTableCellElement::FreeData(pData);
}
}
// UnknownHTML tags with LOCALDATA attribute.
pNext = m_pBuffer->m_pRoot;
if ( pNext ) {
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindUnknownHTML, 0 )) ){
CEditIconElement *pIcon = CEditIconElement::Cast(pNext);
if (pIcon) {
char **pMimeTypes;
char **pURLs;
int count = pIcon->ParseLocalData(&pMimeTypes,&pURLs);
// Remember indices into save object.
if (count) {
XP_FREEIF(pIcon->m_piSaveIndices);
// allocate memory.
pIcon->m_piSaveIndices = new intn[count];
}
// Maybe should make a check that pURLs[n] is a relative URL
// in current directory.
for (int n = 0; n < count; n++) {
pIcon->m_piSaveIndices[n] = CheckAddFile(pURLs[n],pMimeTypes[n],ppIncludedFiles,TRUE);
}
CEditIconElement::FreeLocalDataLists(pMimeTypes,pURLs,count);
}
} // while
}
// Go through ppIncludedFiles once more to add anything we missed.
//
// This is for the "add all files in directory" button in publishing,
// here ppIncludedFiles may contain files that CEditSaveObject knows
// nothing about.
//
// Doesn't hurt to add files twice to tape file system, it'll just
// return the previous index.
if (ppIncludedFiles) {
char **pFile = ppIncludedFiles;
while (*pFile) {
// Ignore returned index, we're not going to update any links here.
AddFile(*pFile,NULL,m_pBuffer->GetDocCharSetID());
pFile++;
}
}
FreeList(ppIncludedFiles);
return TRUE;
}
// Returns the URL that should be used as the base for relative URLs in
// the document. Similar to just calling LO_GetBaseURL(), except returns
// the document temp directory for untitled documents.
// Must free returned memory.
char *edt_GetDocRelativeBaseURL(MWContext *pContext) {
char *pDocURL = NULL;
// Interpret URLs relative to temp directory if a new document.
if (EDT_IS_NEW_DOCUMENT(pContext)) {
char *pxpURL = EDT_GetDocTempDir(pContext);
if (!pxpURL) {
return pDocURL;
}
// prepend "file://" to make a URL.
StrAllocCat(pDocURL,"file://");
StrAllocCat(pDocURL,pxpURL);
XP_FREE(pxpURL);
}
else {
pDocURL = edt_StrDup(LO_GetBaseURL(pContext));
}
return pDocURL;
}
// Mostly a wrapper for CFileSaveObject::AddFile, except deals with adjusting links.
//
// Analogous to AddToBufferUnique() in edtbuf.cpp
intn CEditSaveObject::CheckAddFile( char *pSrc, char *pMIMEType,
char **ppIncludedFiles, XP_Bool bSaveDefault ){
intn retVal = IgnoreImage;
if( EDT_IS_LIVEWIRE_MACRO( pSrc ) ){
return IgnoreImage;
}
char *pDocURL = edt_GetDocRelativeBaseURL(m_pContext);
if (!pDocURL) {
return IgnoreImage;
}
char *pAbsoluteSrc = NET_MakeAbsoluteURL(pDocURL,pSrc);
XP_FREE(pDocURL);
if (!pAbsoluteSrc) {
return IgnoreImage;
}
// If ppIncludedFiles is passed in, use it to decide whether to add file.
// Otherwise, use bSaveDefault to decide.
XP_Bool saveMe;
if (ppIncludedFiles) {
saveMe = URLInList(ppIncludedFiles,pAbsoluteSrc);
}
else {
saveMe = bSaveDefault;
}
if (saveMe) {
retVal = AddFile(pSrc,pMIMEType,m_pBuffer->GetDocCharSetID());
if (retVal == ITapeFileSystem::Error || retVal == ITapeFileSystem::SourceDestSame) {
// couldn't make a good local name, so try to fix it.
retVal = AttemptAdjust;
}
}
else if ( m_bAutoAdjustLinks ) {
retVal = AttemptAdjust;
}
XP_FREE(pAbsoluteSrc);
return retVal;
}
void CEditSaveObject::FreeList(char **ppList) {
if (!ppList)
return;
int n = 0;
while (ppList[n]) {
XP_FREE(ppList[n]);
n++;
}
XP_FREE(ppList);
}
// ppList and pURL must be absolute URLs.
XP_Bool CEditSaveObject::URLInList(char **ppList, char *pURL ) {
for (int n = 0; ppList[n]; n++) {
if (EDT_IsSameURL(ppList[n],pURL,NULL,NULL))
return TRUE;
}
return FALSE;
}
// Should be called no matter what, even if error or cancel occurs.
ED_FileError CEditSaveObject::FileFetchComplete(){
XP_ASSERT(XP_IsContextInList(m_pBuffer->m_pContext));
return CFileSaveObject::FileFetchComplete();
}
// Always return TRUE.
XP_Bool CEditSaveObject::SaveFirstFile() {
if ( m_status != ED_ERROR_NONE ) {
XP_ASSERT(0);
return TRUE;
}
XP_ASSERT(!m_pDocStateSave);
m_pDocStateSave = m_pBuffer->RecordState();
char *pBadLinks = FixupLinks();
PRBool needEncrypt = EDT_EncryptState( m_pContext );
// Tell user some links may be broken by this operation, give choice
// of continuing or not.
if (pBadLinks) {
XP_Bool bCancel = FALSE;
char *tmplate = XP_GetString(XP_EDT_BREAKING_LINKS);
char *msg = NULL;
if (tmplate) {
msg = PR_smprintf(tmplate,pBadLinks);
bCancel = !FE_Confirm(m_pContext,msg);
}
XP_FREEIF(msg);
XP_FREEIF(pBadLinks);
if (bCancel) {
Cancel();
return TRUE;
}
}
// Write root HTML document
char *pHumanName = m_tapeFS->GetHumanName(0);
if (pHumanName == NULL) {
XP_ASSERT(0);
return TRUE;
}
// Tell front end the filename.
if( !m_bFromAutoSave && // Don't want dialogs from autosave, bug 43878
m_tapeFS->GetType() != ITapeFileSystem::MailSend ){// Suppress dialog for mail send.
FE_SaveDialogSetFilename( m_pContext, pHumanName );
}
IStreamOut *out = NULL;
URL_Struct *URL_s = NULL;
if (needEncrypt) {
// by the time the file gets to the tapeFS, it will be binary.
m_tapeFS->SetFirstBinary();
out = new CNetStreamToTapeFS(m_pContext,m_tapeFS);
}
else {
out = m_tapeFS->OpenStream(0);
}
if (out == NULL) {
m_status = ED_ERROR_FILE_OPEN;
}
else {
m_pBuffer->WriteToStream( out );
if ( out->Status() != IStreamOut::EOS_NoError ) {
m_status = ED_ERROR_FILE_WRITE;
}
if (!needEncrypt) {
m_tapeFS->CloseStream(0);
}
else {
delete out;
}
}
if( m_status != ED_ERROR_NONE ){
char *tmplate = NULL;
char *msg = NULL;
char *pAbsDest = GetDestAbsoluteURL(0);
char *pAbsSrc = GetSrcName(0);
edt_url_make_human(&pAbsDest);
edt_url_make_human(&pAbsSrc);
switch (m_tapeFS->GetType()) {
case ITapeFileSystem::File:
tmplate = XP_GetString(XP_EDT_ERR_SAVE_WRITING_ROOT);
if (tmplate) {
char *pRelDest = m_tapeFS->GetHumanName(0);
msg = PR_smprintf(tmplate,pRelDest,pAbsDest);
XP_FREEIF(pRelDest);
}
break;
case ITapeFileSystem::Publish:
tmplate = XP_GetString(XP_EDT_ERR_PUBLISH_PREPARING_ROOT);
if (tmplate) {
msg = PR_smprintf(tmplate,pAbsSrc);
StrAllocCat(msg,XP_GetString(XP_EDT_ERR_CHECK_DISK));
}
break;
case ITapeFileSystem::MailSend:
msg = XP_STRDUP(XP_GetString(XP_EDT_ERR_MAIL_PREPARING_ROOT));
break;
}
if (msg) {
FE_Alert(m_pContext,msg);
}
XP_FREEIF(msg);
XP_FREEIF(pAbsDest);
XP_FREEIF(pAbsSrc);
}
// We know this is file number 1, CFileSaveObject::m_iCurFile is 1-based.
CheckFinishedSave(1,m_status);
XP_FREE(pHumanName);
return TRUE;
}
void CEditSaveObject::FixupLink(intn iIndex, // index to tape file system
char **ppImageURL, // Value to fixup.
char *pDestPathURL,
ED_HREFList *badLinks) {
if( iIndex == IgnoreImage ){
return;
}
if( iIndex == AttemptAdjust ){
CEditLinkManager::AdjustLink(ppImageURL,m_pSrcURL,pDestPathURL,badLinks);
}
else {
// Look it up from tape file system.
char *pNewURL = GetDestName(iIndex);
if (pNewURL) {
XP_FREEIF(*ppImageURL);
*ppImageURL = pNewURL;
}
}
}
char *CEditSaveObject::FixupLinks(){
//////// WARNING: if you change this function, fix CEditSaveObject::AddAllFiles() and CEditBuffer::GetAllDocumentFiles() also.
ED_HREFList badLinks;
EDT_ImageData *pData;
char *pDestPathURL = m_tapeFS->GetDestPathURL();
// Note: pDestPathURL may legally be NULL.
// If there is a background Image, make it the first one.
FixupLink(m_backgroundIndex,&m_pBuffer->m_pBackgroundImage,pDestPathURL,&badLinks);
// We now support > 1 FontDefURLs
int iFontDefCount = m_pBuffer->m_FontDefURL.Size();
for( int i=0; i < iFontDefCount; i++ )
FixupLink(m_FontDefIndex[i], &m_pBuffer->m_FontDefURL[i], pDestPathURL, &badLinks);
// regular images.
CEditElement *pImage = m_pBuffer->m_pRoot->FindNextElement( &CEditElement::FindImage, 0 );
while( pImage )
{
pData = pImage->Image()->GetImageData();
if( pData )
{
// Only consider images that are not server-generated
if( EDT_IsImageURL(pData->pSrc) )
{
// do the normal image
FixupLink(pImage->Image()->m_iSaveIndex,&pData->pSrc,pDestPathURL,&badLinks);
}
if( EDT_IsImageURL(pData->pLowSrc) )
{
// do the lowres image
FixupLink(pImage->Image()->m_iSaveLowIndex,&pData->pLowSrc,pDestPathURL,&badLinks);
}
pImage->Image()->SetImageData( pData );
edt_FreeImageData( pData );
}
pImage = pImage->FindNextElement( &CEditElement::FindImage, 0 );
}
//// Sure would be nice to abstract all the different types of table
//// backgrounds.
// table backgrounds <table>
CEditElement *pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindTable, 0 )) ){
CEditTableElement *pTable = (CEditTableElement *)pNext;
EDT_TableData *pData = pTable->GetData();
if (pData) {
if ( pData->pBackgroundImage && *pData->pBackgroundImage) {
FixupLink(pTable->m_iBackgroundSaveIndex,&pData->pBackgroundImage,pDestPathURL,&badLinks);
pTable->SetData(pData);
}
CEditTableElement::FreeData(pData);
}
}
// table row backgrounds <tr>
pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindTableRow, 0 )) ){
CEditTableRowElement *pTable = (CEditTableRowElement *)pNext;
EDT_TableRowData *pData = pTable->GetData();
if (pData) {
if ( pData->pBackgroundImage && *pData->pBackgroundImage) {
FixupLink(pTable->m_iBackgroundSaveIndex,&pData->pBackgroundImage,pDestPathURL,&badLinks);
pTable->SetData(pData);
}
CEditTableRowElement::FreeData(pData);
}
}
// table cell backgrounds <td> <th>
pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindTableCell, 0 )) ){
CEditTableCellElement *pTable = (CEditTableCellElement *)pNext;
EDT_TableCellData *pData = pTable->GetData(0);
if (pData) {
if ( pData->pBackgroundImage && *pData->pBackgroundImage) {
FixupLink(pTable->m_iBackgroundSaveIndex,&pData->pBackgroundImage,pDestPathURL,&badLinks);
pTable->SetData(pData);
}
CEditTableCellElement::FreeData(pData);
}
}
// UnknownHTML tags with LOCALDATA attribute.
pNext = m_pBuffer->m_pRoot;
while(NULL != (pNext = pNext->FindNextElement( &CEditElement::FindUnknownHTML, 0 )) ){
CEditIconElement *pIcon = CEditIconElement::Cast(pNext);
if (pIcon) {
char **pMimeTypes;
char **pURLs;
int count = pIcon->ParseLocalData(&pMimeTypes,&pURLs);
if (count) {
if (pIcon->m_piSaveIndices) {
// Change all occurances of pURLs[n] in the unknown tag to
// take account of the new location.
for (int n = 0; n < count; n++) {
char *pPrev = XP_STRDUP(pURLs[n]); // Remember, so we can se if pURLs[n] changes.
FixupLink(pIcon->m_piSaveIndices[n],&pURLs[n],pDestPathURL,&badLinks);
// Note: ReplaceParamValue checks if the two are the same.
// Also note: the LOCALDATA parameter itself will be updated.
pIcon->ReplaceParamValues(pPrev,pURLs[n]);
XP_FREEIF(pPrev);
}
}
else {
XP_ASSERT(0);
}
}
// kill and zero memory for saved indices.
XP_FREEIF(pIcon->m_piSaveIndices);
CEditIconElement::FreeLocalDataLists(pMimeTypes,pURLs,count);
}
} // while
// Adjust the HREFs.
if( m_bAutoAdjustLinks && pDestPathURL ){
// No longer use CEditLinkManager::AdjustAllLinks because its ref counting is
// messed up and has more links than are currently in document. It adds too
// many lines to badLinks (which is actually displayed to the user.)
// m_pBuffer->linkManager.AdjustAllLinks( m_pSrcURL, pDestPathURL, &badLinks );
// Walk the tree and find all HREFs.
CEditElement *pLeaf = m_pBuffer->m_pRoot->FindNextElement(
&CEditElement::FindLeafAll,0 );
// First sweep, mark all HREFs as not adjusted.
while (pLeaf) {
m_pBuffer->linkManager.SetAdjusted(pLeaf->Leaf()->GetHREF(),FALSE);
pLeaf = pLeaf->FindNextElement(&CEditElement::FindLeafAll,0 );
}
// Second sweep, actually adjust the HREFs.
pLeaf = m_pBuffer->m_pRoot->FindNextElement(
&CEditElement::FindLeafAll,0 );
while (pLeaf) {
ED_LinkId linkId = pLeaf->Leaf()->GetHREF();
if (linkId && !m_pBuffer->linkManager.GetAdjusted(linkId)) {
// linkManager can deal with NULL HREF.
m_pBuffer->linkManager.AdjustLink(linkId,m_pSrcURL, pDestPathURL, &badLinks );
m_pBuffer->linkManager.SetAdjusted(linkId,TRUE);
}
pLeaf = pLeaf->FindNextElement(&CEditElement::FindLeafAll,0 );
}
}
XP_FREEIF(pDestPathURL);
// Package up a string of all the bad links found.
char *pRet = NULL;
if (badLinks.Size() > 0) {
int n;
for (n = 0; n < badLinks.Size(); n++) {
StrAllocCat(pRet,badLinks[n]);
StrAllocCat(pRet,"\n");
XP_FREEIF(badLinks[n]);
}
}
return pRet;
}
#if 0 //// Now obsolete
//-----------------------------------------------------------------------------
// CEditImageSaveObject
//-----------------------------------------------------------------------------
CEditImageSaveObject::CEditImageSaveObject( CEditBuffer *pBuffer,
EDT_ImageData *pData, XP_Bool bReplaceImage )
:
CFileSaveObject( pBuffer->m_pContext ),
m_pBuffer( pBuffer ),
m_pData( edt_DupImageData( pData ) ),
m_srcIndex(-1),
m_lowSrcIndex(-1),
m_bReplaceImage( bReplaceImage )
{
// we are going to write the image files into
SetDestPathURL( LO_GetBaseURL( pBuffer->m_pContext ) );
}
CEditImageSaveObject::~CEditImageSaveObject(){
edt_FreeImageData( m_pData );
m_pBuffer->m_pSaveObject = 0;
}
ED_FileError CEditImageSaveObject::FileFetchComplete(){
if( m_status == ED_ERROR_NONE ){
char *pName = 0;
if( m_srcIndex != -1 && (pName = GetDestName(m_srcIndex)) != 0 ){
if( m_pData->pSrc) XP_FREE( m_pData->pSrc );
m_pData->pSrc = pName;
}
if( m_lowSrcIndex != -1 && (pName = GetDestName(m_lowSrcIndex)) != 0 ){
XP_FREE( m_pData->pLowSrc );
m_pData->pLowSrc = pName;
}
m_pBuffer->m_pLoadingImage = new CEditImageLoader( m_pBuffer,
m_pData, m_bReplaceImage );
m_pBuffer->m_pLoadingImage->LoadImage();
}
return CFileSaveObject::FileFetchComplete();
}
#endif
#if 0 // now obsolete
//-----------------------------------------------------------------------------
// CEditBackgroundImageSaveObject
//-----------------------------------------------------------------------------
CEditBackgroundImageSaveObject::CEditBackgroundImageSaveObject( CEditBuffer *pBuffer)
:
CFileSaveObject( pBuffer->m_pContext ),
m_pBuffer( pBuffer )
{
// we are going to write the image files into
SetDestPathURL( LO_GetBaseURL( pBuffer->m_pContext ) );
}
CEditBackgroundImageSaveObject::~CEditBackgroundImageSaveObject(){
m_pBuffer->m_pSaveObject = 0;
}
ED_FileError CEditBackgroundImageSaveObject::FileFetchComplete(){
// Note: If user canceled in overwrite dialog, then we don't change the background
if( m_status == ED_ERROR_NONE ){
if( m_pBuffer->m_pBackgroundImage ) XP_FREE(m_pBuffer->m_pBackgroundImage);
// Get the one and only image file (without local or URL path)
m_pBuffer->m_pBackgroundImage = GetDestName(0);
// This will set background image
m_pBuffer->RefreshLayout();
// LO_SetBackgroundImage( m_pBuffer->m_pContext, m_pBuffer->m_pBackgroundImage );
}
return CFileSaveObject::FileFetchComplete();
}
#endif
//
// Sigh, why did the editor invent a new streaming type? This function
// allows the preencrypted file standard streamer to point back to the
// Editor's stream without turning the C++ virus loose on the security
// library.
//
typedef struct edtPrivStructStr {
ITapeFileSystem *tapeFS;
IStreamOut *out;
} edtPrivStruct;
static unsigned int
edt_TapeIsReady(NET_StreamClass * /* stream */ ) {
return MAX_WRITE_READY;
}
static void
edt_TapeComplete(NET_StreamClass *stream) {
edtPrivStruct *obj = (edtPrivStruct *)stream->data_object;
obj->tapeFS->CloseStream(0);
XP_FREE(obj);
return;
}
static void
edt_TapeAbort(NET_StreamClass *stream, int /* status */) {
edt_TapeComplete(stream);
}
static int
edt_TapeWrite(NET_StreamClass *stream, char *str, int32 len) {
edtPrivStruct *obj= (edtPrivStruct *)stream->data_object;
obj->out->Write(str,len);
if ( obj->out->Status() != IStreamOut::EOS_NoError ) {
return -1;
}
return 0;
}
extern "C" NET_StreamClass *EDT_NetToTape(void *data) {
NET_StreamClass *stream;
edtPrivStruct *obj;
stream = (NET_StreamClass *) XP_ALLOC(sizeof(NET_StreamClass));
if (stream == NULL) {
return NULL;
}
obj = (edtPrivStruct *)XP_ALLOC(sizeof(edtPrivStruct));
if (obj == NULL) {
XP_FREE(stream);
return NULL;
}
stream->name = "Editor Tape FS stream";
stream->complete = edt_TapeComplete;
stream->abort = edt_TapeAbort;
stream->is_write_ready = edt_TapeIsReady;
stream->data_object = obj;
stream->window_id = NULL; // if this were a real stream we would need a
// url and a window context.
stream->put_block = (MKStreamWriteFunc)edt_TapeWrite;
obj->tapeFS = (ITapeFileSystem *)data;
obj->out = obj->tapeFS->OpenStream(0);
if (obj->out == NULL) {
XP_FREE(obj);
XP_FREE(stream);
return NULL;
}
return stream;
}
#endif
Reference in New Issue View Git Blame Copy Permalink