gecko-dev/include/hotlist.h
1998-03-28 02:44:41 +00:00

251 lines
7.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.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.
*/
#ifndef HOTLIST_H
#define HOTLIST_H
#include "xp_mcom.h"
#include "ntypes.h"
XP_BEGIN_PROTOS
typedef enum HOT_Type {
HOT_URLType, HOT_HeaderType, HOT_SeparatorType } HOT_Type;
typedef struct HotlistStruct_ {
HOT_Type type;
Bool is_folded; /* if it's a header is it folded? */
XP_List *children; /* a list of children, only headers have these */
char *name; /* a title */
char *address; /* the URL address */
char *description; /* random text */
time_t last_visit;
time_t addition_date;
char *content_type;
struct HotlistStruct_ *parent; /* My hotlist parent */
XP_List *lParent; /* The XP_List object that points to my parent or NULL */
} HotlistStruct;
/* tell the hotlist code that the hotlist has been modified
* so that it gets saved the next time SaveHotlist is called
*/
extern void HOT_SetModified(void);
/* changes a entry to a header type from a non header type
* and vice versa. If the object was a header and
* has children, the children will be blown away. (very bad)
*/
extern void HOT_ChangeEntryType(HotlistStruct * entry, HOT_Type new_type);
/* Fold or unfold a hotlist header
*
* set the Boolean to True to fold the list and
* False to unfold
*/
extern void HOT_FoldHeader(HotlistStruct * item, Bool fold);
/* checks the hotlist for a url and updates the last accessed
* time
*/
extern void HOT_UpdateHotlistTime(URL_Struct *URL_s, time_t cur_time);
/* Performs regular expression match on hotlist name and address
* fields. Returns the found object, or NULL if not
* found.
*
* start_obj specifies the object to start searching
* on. The start_num object WILL NOT be searched but all those
* after it will be.
* To search the whole list give NULL as start_obj.
*
* If headers became unfolded because of the search then redisplay_all
* will be set to TRUE
*/
extern HotlistStruct * HOT_SearchHotlist(char * search_string,
HotlistStruct * start_obj,
Bool * redisplay_all);
/* returns TRUE if the second argument is a direct
* descendent of the first argument.
*
* returns FALSE otherwise
*/
extern Bool HOT_IsDescendent(HotlistStruct *parent, HotlistStruct *possible_child);
/* Reads the hostlist from disk, what else?
*
* pass in the hotlist filename and a relative URL which represents
* the original location of the html file. If you are reading the
* default hotlist you should pass in a file URL of the form
* file://localhost/PATH
*
*/
extern void HOT_ReadHotlistFromDisk (char * filename, char * relative_url);
/* returns an integer index of the item in the list
*/
extern int HOT_GetIndex(HotlistStruct * item);
/* returns an integer index of the item in the list
* and does not pay attention to the is_folded value
*/
extern int HOT_GetUnfoldedIndex(HotlistStruct * item);
/* returns the object associated with the index returned by
* HOT_GetIndex()
*/
extern HotlistStruct * HOT_IndexOf(int index);
/* returns the object associated with the index returned by
* HOT_GetUnfoldedIndex()
*/
extern HotlistStruct * HOT_UnfoldedIndexOf(int index);
/* returns an integer depth of the item in the list starting at zero
*/
extern int HOT_GetDepth(HotlistStruct * item);
/* return a pointer to the main hotlist list
*
* returns NULL if nothing has ever been
* added to the hotlist
*/
extern XP_List * HOT_GetHotlistList(void);
/* saves the hotlist to a configuration file
*/
extern int HOT_SaveHotlist (char * filename);
/* Free's the entire hotlist
*/
extern void HOT_FreeHotlist (void);
/* create a hotlist entry struct and fill it in with
* the passed in data
*
* returns NULL on out of memory error.
*/
extern HotlistStruct *
HOT_CreateEntry(HOT_Type type,
const char *name,
const char *address,
const char *content_type,
time_t last_visit);
/* free's a hotlist entry
*/
extern void HOT_FreeEntry(HotlistStruct * entry);
/* create a completely new copy of the entry passed in
*/
extern HotlistStruct * HOT_CopyEntry(HotlistStruct * entry);
/* insert an item before another item in the hotlist
*
* if the insert_before item is NULL or not found the item
* will be inserted at the begining of the list
*/
extern void HOT_InsertItemBefore(HotlistStruct * insert_before, HotlistStruct * insertee);
/* insert an item after another item in the hotlist
*
* if the insert_after item is NULL or not found the item
* will be inserted at the end of the list
*/
extern void HOT_InsertItemAfter(HotlistStruct * insert_after, HotlistStruct * insertee);
/* insert an item in a header if "insert_after" is a
* Header type, or after the item if "insert after" is
* not a header type.
*
* if the insert_after item is NULL or not found the item
* will be inserted at the end of the hotlist
*/
extern void
HOT_InsertItemInHeaderOrAfterItem(HotlistStruct * insert_after,
HotlistStruct * insertee);
/* remove an item from the hotlist and free's it
*
* returns TRUE on success, FALSE if not found
*/
extern Bool HOT_RemoveItem(HotlistStruct * old_item);
/* remove an item from the hotlist and doesn't free it
*
* returns TRUE on success, FALSE if not found
*/
extern Bool HOT_RemoveItemFromList(HotlistStruct * old_item);
/* move an item up in the list
*/
extern void HOT_MoveObjectUp(HotlistStruct * item);
/* move an item down in the list
*/
extern void HOT_MoveObjectDown(HotlistStruct * item);
/* returns True if the object can be moved Up
* False if the object cannot be moved Up or if
* it cannot be found in the list
*/
extern Bool HOT_ObjectCanGoUp(HotlistStruct * item);
/* returns True if the object can be moved down
* False if the object cannot be moved down or if
* it cannot be found in the list
*/
extern Bool HOT_ObjectCanGoDown(HotlistStruct * item);
/* Whether the file will be written when Save is called. */
extern Bool HOT_Modified(void);
/*
* Gets the top node of the hotlist
*/
extern HotlistStruct*
HOT_GetHotlist (void);
/*
* Convert a number of selections in a hotlist list into a block of
* memory that the user can use for cut and paste operations
*/
extern char *
HOT_ConvertSelectionsToBlock(HotlistStruct ** list,
int iCount,
int bLongFormat,
int32 * lTotalLen);
/*
* Take a block of memory and insert the hotlist items it represents into
* the current hotlist
*/
extern void
HOT_InsertBlockAt(char * pOriginalBlock,
HotlistStruct * item,
int bLongFormat,
int32 lTotalLen);
XP_END_PROTOS
#endif /* HOTLIST_H */