gecko-dev/lib/mailto/msgurlq.h

211 lines
9.4 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):
*/
//
//
//
#ifndef _MSGURLQ_H_
#define _MSGURLQ_H_
#include "ptrarray.h"
#include "net.h"
class MSG_Pane;
class ABook;
class MSG_UrlQueue;
/********************************************************************************************************************
Notes: Each URL in a MSG_UrlQueue is represented by a queue element for any instance data it
needs. Since a pane can have one and only one URL queue, it would be nice to be able to have queue elements
for different types of URLs (local copy message urls, LDAP to AB, etc.) To support this effort, it will be common
practice to subclass MSG_UrlQueueElement with a queue element capable of handling your new type of url. In addition,
your new subclass should support a virtual method called PrepareToRun() if you need to make any specific changes to
things like the current context for your new url before it is run. MSG_UrlQueue will always call the element's
PrepareToRun method before actually running that URL in the queue. You will also need to modify MSG_UrlQueue to
add methods for adding urls of your new type.
*********************************************************************************************************************/
//*****************************************************************************
// MSG_UrlQueueElement -- Each URL in a MSG_UrlQueue is represented by a
// MSG_UrlQueueElement for any instance data it needs
//*****************************************************************************
class MSG_UrlQueueElement
{
friend MSG_UrlQueue;
public:
MSG_UrlQueueElement (const char *, MSG_UrlQueue *, Net_GetUrlExitFunc *, MSG_Pane *, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD, FO_Present_Types outputFormat = FO_CACHE_AND_PRESENT);
MSG_UrlQueueElement (URL_Struct *, MSG_UrlQueue *, Net_GetUrlExitFunc *, MSG_Pane *, XP_Bool skipFE = FALSE, FO_Present_Types outputFormat = FO_CACHE_AND_PRESENT);
MSG_UrlQueueElement (URL_Struct * urls, MSG_UrlQueue *q);
virtual ~MSG_UrlQueueElement ();
virtual URL_Struct* GetURLStruct();
virtual char* GetURLString();
virtual void PrepareToRun(); // the queue element is about to be run....(added in particular for subclasses)
protected:
char *m_urlString;
XP_Bool m_callGetURLDirectly;
MSG_Pane *m_pane;
URL_Struct *m_url;
MSG_UrlQueue *m_queue;
Net_GetUrlExitFunc *m_exitFunction;
NET_ReloadMethod m_reloadMethod;
FO_Present_Types m_outputFormat;
};
//************************************************************************************
// MSG_UrlLocalMsgCopyQueueElement - we want a queue element type which can handle
// LOCAL message copy urls. Don't try this with IMAP
// copy URLs.
//************************************************************************************
class MSG_UrlLocalMsgCopyQueueElement : public MSG_UrlQueueElement
{
public:
MSG_UrlLocalMsgCopyQueueElement (MessageCopyInfo *, const char *, MSG_UrlQueue *, Net_GetUrlExitFunc *,
MSG_Pane *, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
MSG_UrlLocalMsgCopyQueueElement (MessageCopyInfo *, URL_Struct *, MSG_UrlQueue *, Net_GetUrlExitFunc *,
MSG_Pane *, XP_Bool skipFE = FALSE);
MSG_UrlLocalMsgCopyQueueElement (MessageCopyInfo *, URL_Struct * urls, MSG_UrlQueue * q);
virtual ~MSG_UrlLocalMsgCopyQueueElement();
virtual void PrepareToRun(); // element is about to be run, we need to clobber context's copy info and replace with ours
protected:
MessageCopyInfo * m_copyInfo;
};
//******************************************************************************************************
// MSG_UrlQueue -- Handles a queue of URLs which get fired in serial. This is
// a stopgap measure to compensate for the lack of multiple running
// URLs per MWContext
//
// Note: Must always call the queue element's PrepareToRun method before running a URL for that element.
//*******************************************************************************************************
typedef void MSG_UrlQueueInterruptFunc (MSG_UrlQueue *queue, URL_Struct *URL_s, int status, MWContext *window_id);
class MSG_UrlQueue : public XPPtrArray
{
public:
MSG_UrlQueue (MSG_Pane *pane);
virtual ~MSG_UrlQueue ();
// it would be nice to use signature overloading for adding urls. Later, we might want to do this!!!
// Use this for regular add-to-tail functionality
static MSG_UrlQueue *AddUrlToPane (const char *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
static MSG_UrlQueue * AddLocalMsgCopyUrlToPane (MessageCopyInfo * info, const char *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
// Use this for regular add-to-tail functionality with URL_Struct filled in
static MSG_UrlQueue * AddUrlToPane (URL_Struct *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, XP_Bool skipFE = FALSE, FO_Present_Types outputFormat = FO_CACHE_AND_PRESENT);
static MSG_UrlQueue * AddLocalMsgCopyUrlToPane (MessageCopyInfo * info, URL_Struct * url, Net_GetUrlExitFunc * exitFunction = NULL, MSG_Pane * pane = NULL, XP_Bool skipFE = FALSE);
void AddUrl (const char *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
void AddUrl(URL_Struct *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, XP_Bool skipFE = FALSE, FO_Present_Types outputFormat = FO_CACHE_AND_PRESENT);
void AddLocalMsgCopyUrl(MessageCopyInfo * info, const char *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane * pane = NULL, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
// Use this if you need to insert a URL in the middle of the queue
virtual void AddUrlAt (int where, const char *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
virtual void AddLocalMsgCopyUrlAt (MessageCopyInfo * info, int where, const char * url, Net_GetUrlExitFunc * exitFunction = NULL, MSG_Pane * pane = NULL, NET_ReloadMethod reloadmethod = NET_DONT_RELOAD);
// Use this if you need to know which URL is running
virtual int GetCursor () { return m_runningUrl; }
// start the queue by calling this
virtual void GetNextUrl ();
// which pane is this queue running url's in?
virtual MSG_Pane* GetPane() { return m_pane; }
// Use this if you need to know which queue a URL is on
static MSG_UrlQueue *FindQueue (const char *url, MWContext *context);
static MSG_UrlQueue *FindQueue (MSG_Pane *pane);
static MSG_UrlQueue *FindQueueWithSameContext(MSG_Pane *pane);
// Use this if you need to know the queue for a pane
static MSG_UrlQueue *FindQueue (const char *url, MSG_Pane *pane);
// used by subclasses who are designed to use other meta data for ordering urls.
// an example is MSG_ImapLoadFolderUrlQueue
static const int kNoSpecialIndex;
void SetSpecialIndexOfNextUrl(int index) { m_IndexOfNextUrl = index; }
virtual XP_Bool IsIMAPLoadFolderUrlQueue();
static void HandleFolderLoadInterrupt(MSG_UrlQueue *queue, URL_Struct *URL_s, int status, MWContext *window_id);
virtual void AddInterruptCallback(MSG_UrlQueueInterruptFunc *interruptFunc);
protected:
MSG_UrlQueueElement *GetAt(int i) { return (MSG_UrlQueueElement*) XPPtrArray::GetAt(i); }
// called if ExitFunction status == MK_INTERRUPTED
virtual void HandleUrlQueueInterrupt(URL_Struct *URL_s, int status, MWContext *window_id);
static void ExitFunction (URL_Struct *URL_s, int status, MWContext *window_id);
void CallExitAndChain (URL_Struct *URL_s, int status, MWContext *window_id);
static MSG_UrlQueue * GetOrCreateUrlQueue (MSG_Pane * pane, XP_Bool * newQueue);
int m_runningUrl;
MSG_Pane *m_pane;
static XPPtrArray *m_queueArray;
int m_IndexOfNextUrl;
XP_Bool m_inExitFunc;
XPPtrArray m_interruptCallbacks;
static XPPtrArray *GetQueueArray();
};
class MSG_AddLdapToAddressBookQueue : public MSG_UrlQueue
{
public:
MSG_AddLdapToAddressBookQueue (MSG_Pane *);
virtual void GetNextUrl ();
ABook *m_addressBook;
};
class MSG_ImapLoadFolderUrlQueue : public MSG_UrlQueue
{
public:
MSG_ImapLoadFolderUrlQueue(MSG_Pane *pane);
// Use this for regular add-to-tail functionality, or use the index of it has been set.
// Used to ensure ordering of message copy urls when going offline
virtual void AddUrl (const char *url, Net_GetUrlExitFunc *exitFunction = NULL, MSG_Pane *pane = NULL, NET_ReloadMethod reloadMethod = NET_DONT_RELOAD);
virtual XP_Bool IsIMAPLoadFolderUrlQueue();
protected:
// called if ExitFunction status == MK_INTERRUPTED
// virtual void HandleUrlQueueInterrupt(URL_Struct *URL_s, int status, MWContext *window_id);
};
#endif