зеркало из https://github.com/mozilla/pjs.git
503 строки
14 KiB
C++
503 строки
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.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.
|
|
*/
|
|
//
|
|
|
|
#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);
|
|
}
|
|
|
|
|