gecko-dev/lib/mailto/msgurlq.cpp

507 lines
14 KiB
C++

/* -*- 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.1 (the "License"); you may not use this file
* except in compliance with the License. You may obtain a copy of
* the License at http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
* implied. See the License for the specific language governing
* rights and limitations under the License.
*
* The Original Code is mozilla.org code.
*
* The Initial Developer of the Original Code is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All
* Rights Reserved.
*
* Contributor(s):
*/
//
#include "msg.h"
#include "msgurlq.h"
#include "msgpane.h"
MSG_UrlQueueElement::MSG_UrlQueueElement (const char *url, MSG_UrlQueue *queue, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, NET_ReloadMethod reloadMethod, FO_Present_Types outputFormat)
{
m_queue = queue;
m_pane = pane;
m_urlString = XP_STRDUP(url);
m_exitFunction = exitFunction;
m_reloadMethod = reloadMethod;
m_url = NULL;
m_callGetURLDirectly = FALSE;
m_outputFormat = outputFormat;
}
MSG_UrlQueueElement::MSG_UrlQueueElement (URL_Struct *url, MSG_UrlQueue *queue, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, XP_Bool skipFE, FO_Present_Types outputFormat)
{
m_queue = queue;
m_pane = pane;
m_urlString = XP_STRDUP(url->address);
m_exitFunction = exitFunction;
m_reloadMethod = url->force_reload;
m_url = url;
m_callGetURLDirectly = skipFE;
m_outputFormat = outputFormat;
}
MSG_UrlQueueElement::MSG_UrlQueueElement (URL_Struct *urls, MSG_UrlQueue *q)
{
m_queue = q;
m_pane = urls->msg_pane;
m_urlString = XP_STRDUP(urls->address);;
m_url = urls;
m_exitFunction = NULL;
m_reloadMethod = NET_DONT_RELOAD;
m_callGetURLDirectly = FALSE;
m_outputFormat = FO_CACHE_AND_PRESENT;
}
MSG_UrlQueueElement::~MSG_UrlQueueElement()
{
FREEIF(m_urlString);
// if (m_url && m_callGetURLDirectly)
// NET_FreeURLStruct(m_url); // Tempting, but not our job
}
void MSG_UrlQueueElement::PrepareToRun()
{
// nothing we have to do right now for queue elements.
return;
}
char* MSG_UrlQueueElement::GetURLString()
{
if (m_urlString)
return m_urlString;
if (m_url)
return(m_url->address);
return(NULL);
}
URL_Struct* MSG_UrlQueueElement::GetURLStruct()
{
if (!m_url)
m_url = NET_CreateURLStruct( m_urlString, NET_DONT_RELOAD);
return(m_url);
}
MSG_UrlLocalMsgCopyQueueElement::MSG_UrlLocalMsgCopyQueueElement(MessageCopyInfo * info, const char * url, MSG_UrlQueue * q,
Net_GetUrlExitFunc * func, MSG_Pane * pane, NET_ReloadMethod reloadMethod)
: MSG_UrlQueueElement (url, q, func, pane, reloadMethod)
{
m_copyInfo = info;
}
MSG_UrlLocalMsgCopyQueueElement::MSG_UrlLocalMsgCopyQueueElement(MessageCopyInfo * info, URL_Struct * url, MSG_UrlQueue * q,
Net_GetUrlExitFunc * func, MSG_Pane * pane, XP_Bool skipFE)
: MSG_UrlQueueElement (url, q, func, pane, skipFE)
{
m_copyInfo = info;
}
MSG_UrlLocalMsgCopyQueueElement::MSG_UrlLocalMsgCopyQueueElement (MessageCopyInfo * info, URL_Struct * urls, MSG_UrlQueue * q)
: MSG_UrlQueueElement(urls, q)
{
m_copyInfo = info;
}
MSG_UrlLocalMsgCopyQueueElement::~MSG_UrlLocalMsgCopyQueueElement()
{
// should we delete the copy info? I don't think so!!
// when copy was finished, a call to MSG_FolderInfo::CleanUpCopy deletes
// the copy info in the current context. Assuming our queue element isn't deleted before
// it is executed upon......we don't need to delete it.
}
void MSG_UrlLocalMsgCopyQueueElement::PrepareToRun()
{
MWContext * context = m_pane->GetContext();
MessageCopyInfo * victim = NULL;
if (context)
{
victim = context->msgCopyInfo;
XP_ASSERT(!victim); // we actually should never have a victim....but if we do:
// the last copy info is done.
if (victim)
XP_FREEIF(victim); // local copies never have copy info chains, don't have to worry about nextCopyInfo
context->msgCopyInfo = m_copyInfo; // set ourselves up as the next copy info
}
}
//*****************************************************************************
// MSG_UrlQueue -- Intended to be a general purpose way to chain several
// URLs together using the exit functions
//*****************************************************************************
const int MSG_UrlQueue::kNoSpecialIndex = -1;
MSG_UrlQueue::MSG_UrlQueue (MSG_Pane *pane)
{
#ifdef DEBUG
MSG_UrlQueue *existingQueue = FindQueue(pane);
if (existingQueue)
{
MSG_UrlQueueElement *elem = existingQueue->GetAt (existingQueue->m_runningUrl);
if (elem)
XP_Trace("trying to create queue while %s is running\n", elem->m_urlString);
}
XP_ASSERT(!existingQueue);
#endif
m_pane = pane;
m_runningUrl = -1;
m_IndexOfNextUrl = kNoSpecialIndex;
m_inExitFunc = FALSE;
GetQueueArray()->Add (this);
}
MSG_UrlQueue::~MSG_UrlQueue ()
{
GetQueueArray()->Remove(this);
for (int i = 0; i < GetSize (); i++)
{
MSG_UrlQueueElement *e = GetAt(i);
delete e;
}
}
XPPtrArray *
MSG_UrlQueue::GetQueueArray()
{
if (!m_queueArray)
m_queueArray = new XPPtrArray();
return m_queueArray;
}
XP_Bool MSG_UrlQueue::IsIMAPLoadFolderUrlQueue()
{
return FALSE;
}
void MSG_UrlQueue::AddUrl (const char *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, NET_ReloadMethod reloadMethod)
{
MSG_UrlQueueElement *elem = NULL;
if (!pane)
pane = m_pane;
elem = new MSG_UrlQueueElement (url, this, exitFunction, pane, reloadMethod);
if (elem)
Add(elem);
}
void MSG_UrlQueue::AddUrl (URL_Struct *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, XP_Bool skipFE, FO_Present_Types outputFormat)
{
MSG_UrlQueueElement * elem = NULL;
if (!pane)
pane = m_pane;
elem = new MSG_UrlQueueElement(url, this, exitFunction, pane, skipFE, outputFormat);
if (elem)
Add(elem);
}
void MSG_UrlQueue::AddLocalMsgCopyUrl(MessageCopyInfo * info, const char *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane * pane, NET_ReloadMethod reloadMethod)
{
MSG_UrlLocalMsgCopyQueueElement *elem = NULL;
if (!pane)
pane = m_pane;
elem = new MSG_UrlLocalMsgCopyQueueElement (info, url, this, exitFunction, pane, reloadMethod);
if (elem)
Add(elem);
}
/* static */ MSG_UrlQueue * MSG_UrlQueue::FindQueueWithSameContext(MSG_Pane *pane)
{
MSG_UrlQueue * q = NULL;
XP_ASSERT(pane);
if (pane)
{
q = MSG_UrlQueue::FindQueue(pane);
MSG_Pane *QPane = pane->GetFirstPaneForContext(pane->GetContext());
while (!q && QPane)
{
q = MSG_UrlQueue::FindQueue(QPane);
if (!q)
QPane = pane->GetNextPaneForContext(QPane, pane->GetContext());
}
#ifdef DEBUG_bienvenu
if (q && QPane != pane)
XP_Trace("found queue for different pane with same context!\n");
#endif
}
return q;
}
/* static */ MSG_UrlQueue * MSG_UrlQueue::GetOrCreateUrlQueue (MSG_Pane * pane, XP_Bool * newQueue)
// The following code appeared in just about every AddUrl method or variant thereof. I've generalized it in this single
// routine.
// Returns: pointer to the queue for the pane. If we had to create the queue, then newQueue is set to TRUE;
{
*newQueue = FALSE;
MSG_UrlQueue *q = FindQueueWithSameContext(pane);
if (!q)
{
q = new MSG_UrlQueue(pane);
*newQueue = TRUE;
}
// we seem to get in this state where we're not running a url but the queue
// thinks we are.
if (! (q->m_inExitFunc || q->m_runningUrl == -1 || XP_IsContextBusy(pane->GetContext())))
{
#ifdef DEBUG
MSG_UrlQueueElement *runningElement = q->GetAt(q->m_runningUrl);
if (runningElement)
XP_Trace("q was running url %s\n", runningElement->GetURLString());
XP_ASSERT(FALSE);
#endif
}
return q;
}
/* static */ MSG_UrlQueue * MSG_UrlQueue::AddUrlToPane (const char *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, NET_ReloadMethod reloadMethod)
{
MSG_UrlQueue *q;
MSG_UrlQueueElement *elem = NULL;
XP_Bool newQ = FALSE;
q = GetOrCreateUrlQueue(pane, &newQ);
if (q)
{
elem = new MSG_UrlQueueElement (url, q, exitFunction, pane, reloadMethod);
if (elem)
q->Add(elem);
if (newQ)
q->GetNextUrl();
}
return q;
}
/* static*/ MSG_UrlQueue *MSG_UrlQueue::AddLocalMsgCopyUrlToPane (MessageCopyInfo * info, const char *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, NET_ReloadMethod reloadMethod)
{
MSG_UrlQueue *q;
MSG_UrlLocalMsgCopyQueueElement *elem = NULL;
XP_Bool newQ = FALSE;
q = GetOrCreateUrlQueue(pane, &newQ);
if (q)
{
elem = new MSG_UrlLocalMsgCopyQueueElement (info, url, q, exitFunction, pane, reloadMethod);
if (elem)
q->Add(elem);
if (newQ)
q->GetNextUrl();
}
return q;
}
/* static */ MSG_UrlQueue *MSG_UrlQueue::AddUrlToPane (URL_Struct *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, XP_Bool skipFE, FO_Present_Types outputFormat)
{
MSG_UrlQueue *q;
MSG_UrlQueueElement *elem = NULL;
XP_Bool newQ = FALSE;
q = GetOrCreateUrlQueue(pane, &newQ);
if (q)
{
elem = new MSG_UrlQueueElement (url, q, exitFunction, pane, skipFE, outputFormat);
if (elem)
q->Add(elem);
if (newQ)
q->GetNextUrl();
}
return q;
}
/* static */ MSG_UrlQueue *MSG_UrlQueue::AddLocalMsgCopyUrlToPane(MessageCopyInfo * info, URL_Struct * url, Net_GetUrlExitFunc * exitFunction, MSG_Pane * pane, XP_Bool skipFE)
{
MSG_UrlQueue *q;
MSG_UrlLocalMsgCopyQueueElement *elem = NULL;
XP_Bool newQ = FALSE;
q = GetOrCreateUrlQueue(pane, &newQ);
if (q)
{
elem = new MSG_UrlLocalMsgCopyQueueElement (info, url, q, exitFunction, pane, skipFE);
if (elem)
q->Add(elem);
if (newQ)
q->GetNextUrl();
}
return q;
}
void MSG_UrlQueue::AddUrlAt (int where, const char *url, Net_GetUrlExitFunc *exitFunction, MSG_Pane *pane, NET_ReloadMethod reloadMethod)
{
if (!pane)
pane = m_pane;
MSG_UrlQueueElement *elem = new MSG_UrlQueueElement (url, this, exitFunction, pane, reloadMethod);
if (elem)
InsertAt (where, elem);
}
void MSG_UrlQueue::AddLocalMsgCopyUrlAt (MessageCopyInfo * info, int where, const char * url, Net_GetUrlExitFunc * exitFunction, MSG_Pane * pane, NET_ReloadMethod reloadMethod)
{
if (!pane)
pane = m_pane;
MSG_UrlLocalMsgCopyQueueElement *elem = new MSG_UrlLocalMsgCopyQueueElement (info, url, this, exitFunction, pane, reloadMethod);
if (elem)
InsertAt (where, elem);
}
void MSG_UrlQueue::GetNextUrl()
{
int err = 0;
MSG_UrlQueueElement *elem = GetAt(++m_runningUrl);
XP_ASSERT(elem);
if (elem)
{
// we need to make sure the queue element is ready to be run!!!
elem->PrepareToRun();
if (!elem->m_url)
{
elem->m_url = NET_CreateURLStruct (elem->m_urlString, elem->m_reloadMethod);
if (!elem->m_url)
return; // (MsgERR) MK_OUT_OF_MEMORY;
}
if (elem->m_url && XP_STRLEN(elem->m_url->address) > 0)
{
elem->m_url->internal_url = TRUE;
elem->m_url->pre_exit_fn = &MSG_UrlQueue::ExitFunction;
if (elem->m_callGetURLDirectly)
{
elem->m_url->pre_exit_fn = NULL;
err = NET_GetURL(elem->m_url, elem->m_outputFormat, elem->m_pane->GetContext(), MSG_UrlQueue::ExitFunction);
} else
{
#ifdef MOZ_MAIL_NEWS
err = elem->m_pane->GetURL (elem->m_url, FALSE);
#else /* MOZ_MAIL_NEWS */
XP_ASSERT(0);
#endif /* MOZ_MAIL_NEWS */
}
}
else
{
elem->m_url->msg_pane = m_pane;
CallExitAndChain(elem->m_url, 0, elem->m_pane->GetContext());
}
}
}
void MSG_UrlQueue::HandleUrlQueueInterrupt(URL_Struct * URL_s, int status, MWContext * window_id)
{
for (int i = 0; i < m_interruptCallbacks.GetSize(); i++)
{
MSG_UrlQueueInterruptFunc *exitFunc = (MSG_UrlQueueInterruptFunc *) m_interruptCallbacks.GetAt(i);
if (exitFunc)
(*exitFunc) (this, URL_s, status, window_id);
}
// default is to do nothing
}
/*static*/ XPPtrArray *MSG_UrlQueue::m_queueArray = NULL;
/*static*/ MSG_UrlQueue *MSG_UrlQueue::FindQueue (const char *url, MWContext *context)
{
for (int i = 0; i < GetQueueArray()->GetSize(); i++)
{
MSG_UrlQueue *queue = (MSG_UrlQueue*)(GetQueueArray()->GetAt(i));
for (int j = 0; j < queue->GetSize(); j++)
{
MSG_UrlQueueElement *elem = queue->GetAt(j);
// pane has been deleted - remove element from queue
if (!MSG_Pane::PaneInMasterList(elem->m_pane))
{
#ifdef DEBUG_akkana
printf("FindQueue: Removing deleted pane\n");
#endif /* DEBUG */
queue->RemoveAt(j--);
delete elem;
}
else if (elem->m_pane->GetContext() == context)
{
if (elem->m_urlString && !XP_STRCMP(elem->m_urlString, url))
return queue;
}
}
}
return NULL;
}
/*static*/ MSG_UrlQueue *MSG_UrlQueue::FindQueue (MSG_Pane *pane)
{
for (int i = 0; i < GetQueueArray()->GetSize (); i++)
{
MSG_UrlQueue *queue = (MSG_UrlQueue*)(GetQueueArray()->GetAt(i));
if (queue->m_pane == pane)
return queue;
}
return NULL;
}
/*static*/ void MSG_UrlQueue::ExitFunction (URL_Struct *URL_s, int status, MWContext *window_id)
{
MSG_UrlQueue *queue = FindQueue (URL_s->address, window_id);
XP_ASSERT(queue);
if (queue)
queue->CallExitAndChain(URL_s, status, window_id);
}
// Note that this can delete itself if at the end of its list.
void MSG_UrlQueue::CallExitAndChain(URL_Struct *URL_s, int status, MWContext *window_id)
{
MSG_UrlQueueElement *elem = GetAt (m_runningUrl);
if (elem->m_exitFunction)
{
m_inExitFunc = TRUE;
elem->m_exitFunction (URL_s, status, window_id);
m_inExitFunc = FALSE;
}
if ((m_runningUrl >= GetSize() - 1) || status == MK_INTERRUPTED)
{
if (status == MK_INTERRUPTED)
HandleUrlQueueInterrupt(URL_s, status, window_id);
delete this;
}
else
GetNextUrl();
}
extern "C" int MSG_GetUrlQueueSize (const char *url, MWContext *context)
{
MSG_UrlQueue *queue = MSG_UrlQueue::FindQueue (url, context);
if (queue)
return queue->GetSize();
return 0;
}
void MSG_UrlQueue::AddInterruptCallback(MSG_UrlQueueInterruptFunc *interruptFunc)
{
m_interruptCallbacks.Add((void *) interruptFunc);
}