mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

bug#41040: cruft removal.

This commit is contained in:
pnunn%netscape.com 2000-08-07 22:16:30 +00:00
Родитель 01ca1eb997
Коммит d8faa2e9d1
20 изменённых файлов: 33 добавлений и 1475 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

1
modules/libimg/gifcom/Makefile.in
Просмотреть файл

@ -34,7 +34,6 @@ CPPSRCS = \
gif.cpp \
nsGIFModule.cpp \
nsGIFDecoder.cpp \
dllcompat.cpp \
$(NULL)
LOCAL_INCLUDES = -I$(srcdir)

396
modules/libimg/gifcom/dllcompat.cpp
Просмотреть файл

@ -1,396 +0,0 @@
/* -*- 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):
*/
/*
* The purpose of this file is to help phase out XP_ library
* from the image library. In general, XP_ data structures and
* functions will be replaced with the PR_ or PL_ equivalents.
* In cases where the PR_ or PL_ equivalents don't yet exist,
* this file (and its header equivalent) will play the role
* of the XP_ library.
*/
/* This file has func's from
xpcompat that are needed by
the local dll. So far,
1> Mac stuff.
*/
#include "prtypes.h"
#include "prlog.h"
#include "prmem.h"
#include "nsCRT.h"
//#include "xp_mcom.h"
PR_BEGIN_EXTERN_C
int MK_UNABLE_TO_LOCATE_FILE = -1;
int MK_OUT_OF_MEMORY = -2;
PR_END_EXTERN_C
#if defined(XP_MAC)
#ifndef UNIXMINUSMACTIME
#define UNIXMINUSMACTIME 2082844800UL
#endif
/* prototypes for local routines */
static void shortsort(char *lo, char *hi, unsigned width,
int ( *comp)(const void *, const void *));
static void swap(char *p, char *q, unsigned int width);
/* this parameter defines the cutoff between using quick sort and
insertion sort for arrays; arrays with lengths shorter or equal to the
below value use insertion sort */
#define CUTOFF 8 /* testing shows that this is good value */
/***
*XP_QSORT(base, num, wid, comp) - quicksort function for sorting arrays
*
*Purpose:
* quicksort the array of elements
* side effects: sorts in place
*
*Entry:
* char *base = pointer to base of array
* unsigned num = number of elements in the array
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
* 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
/* sort the array between lo and hi (inclusive) */
void XP_QSORT (
void *base,
size_t num,
size_t width,
int ( *comp)(const void *, const void *)
)
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
unsigned size; /* size of the sub-array */
char *lostk[30], *histk[30];
int stkptr; /* stack for saving sub-array to be processed */
/* Note: the number of stack entries required is no more than
1 + log2(size), so 30 is sufficient for any array */
if (num < 2 || width == 0)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = (char*)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
prserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size <= CUTOFF) {
shortsort(lo, hi, width, comp);
}
else {
/* First we pick a partititioning element. The efficiency of the
algorithm demands that we find one that is approximately the
median of the values, but also that we select one fast. Using
the first one produces bad performace if the array is already
sorted, so we use the middle one, which would require a very
wierdly arranged array for worst case performance. Testing shows
that a median-of-three algorithm does not, in general, increase
performance. */
mid = lo + (size / 2) * width; /* find middle element */
swap(mid, lo, width); /* swap it to beginning of array */
/* We now wish to partition the array into three pieces, one
consisiting of elements <= partition element, one of elements
equal to the parition element, and one of element >= to it. This
is done below; comments indicate conditions established at every
step. */
loguy = lo;
higuy = hi + width;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo <= loguy < hi, lo < higuy <= hi + 1,
A[i] <= A[lo] for lo <= i <= loguy,
A[i] >= A[lo] for higuy <= i <= hi */
do {
loguy += width;
} while (loguy <= hi && comp(loguy, lo) <= 0);
/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
either loguy > hi or A[loguy] > A[lo] */
do {
higuy -= width;
} while (higuy > lo && comp(higuy, lo) >= 0);
/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
either higuy <= lo or A[higuy] < A[lo] */
if (higuy < loguy)
break;
/* if loguy > hi or higuy <= lo, then we would have exited, so
A[loguy] > A[lo], A[higuy] < A[lo],
loguy < hi, highy > lo */
swap(loguy, higuy, width);
/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
of loop is re-established */
}
/* A[i] >= A[lo] for higuy < i <= hi,
A[i] <= A[lo] for lo <= i < loguy,
higuy < loguy, lo <= higuy <= hi
implying:
A[i] >= A[lo] for loguy <= i <= hi,
A[i] <= A[lo] for lo <= i <= higuy,
A[i] = A[lo] for higuy < i < loguy */
swap(lo, higuy, width); /* put partition element in place */
/* OK, now we have the following:
A[i] >= A[higuy] for loguy <= i <= hi,
A[i] <= A[higuy] for lo <= i < higuy
A[i] = A[lo] for higuy <= i < loguy */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy-1] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - 1 - lo >= hi - loguy ) {
if (lo + width < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo + width < higuy) {
hi = higuy - width;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
/***
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays
*
*Purpose:
* sorts the sub-array of elements between lo and hi (inclusive)
* side effects: sorts in place
* assumes that lo < hi
*
*Entry:
* char *lo = pointer to low element to sort
* char *hi = pointer to high element to sort
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
* 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void shortsort (
char *lo,
char *hi,
unsigned width,
int ( *comp)(const void *, const void *)
)
{
char *p, *max;
/* Note: in assertions below, i and j are alway inside original bound of
array to sort. */
while (hi > lo) {
/* A[i] <= A[j] for i <= j, j > hi */
max = lo;
for (p = lo+width; p <= hi; p += width) {
/* A[i] <= A[max] for lo <= i < p */
if (comp(p, max) > 0) {
max = p;
}
/* A[i] <= A[max] for lo <= i <= p */
}
/* A[i] <= A[max] for lo <= i <= hi */
swap(max, hi, width);
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
hi -= width;
/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
}
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
so array is sorted */
}
/***
*swap(a, b, width) - swap two elements
*
*Purpose:
* swaps the two array elements of size width
*
*Entry:
* char *a, *b = pointer to two elements to swap
* unsigned width = width in bytes of each array element
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void swap (
char *a,
char *b,
unsigned width
)
{
char tmp;
if ( a != b )
/* Do the swap one character at a time to avoid potential alignment
problems. */
while ( width-- ) {
tmp = *a;
*a++ = *b;
*b++ = tmp;
}
}
#endif /* XP_MAC */
#ifdef XP_MAC
#include <OSUtils.h>
#include <time.h>
static void MyReadLocation(MachineLocation * loc)
{
static MachineLocation storedLoc; // InsideMac, OSUtilities, page 4-20
static Boolean didReadLocation = FALSE;
if (!didReadLocation)
{
ReadLocation(&storedLoc);
didReadLocation = TRUE;
}
*loc = storedLoc;
}
// current local time = GMTDelta() + GMT
// GMT = local time - GMTDelta()
static long GMTDelta()
{
MachineLocation loc;
long gmtDelta;
MyReadLocation(&loc);
gmtDelta = loc.u.gmtDelta & 0x00FFFFFF;
if ((gmtDelta & 0x00800000) != 0)
gmtDelta |= 0xFF000000;
return gmtDelta;
}
// This routine simulates stdclib time(), time in seconds since 1.1.1970
// The time is in GMT
time_t GetTimeMac()
{
unsigned long maclocal;
// Get Mac local time
GetDateTime(&maclocal);
// Get Mac GMT
maclocal -= GMTDelta();
// return unix GMT
return (maclocal - UNIXMINUSMACTIME);
}
// Returns the GMT times
time_t Mactime(time_t *timer)
{
time_t t = GetTimeMac();
if (timer != NULL)
*timer = t;
return t;
}
#endif /* XP_MAC */

4
modules/libimg/gifcom/gif.cpp
Просмотреть файл

@ -84,10 +84,6 @@ PRLogModuleInfo *il_log_module = NULL;
# define MAX(x, y) (((x) > (y)) ? (x) : (y))
#endif
PR_BEGIN_EXTERN_C
extern int MK_OUT_OF_MEMORY;
PR_END_EXTERN_C
/* List of possible parsing states */
typedef enum {
gif_gather,

4
modules/libimg/gifcom/makefile.win
Просмотреть файл

@ -86,9 +86,9 @@ MODULE=img
DEPTH=..\..\..
LINCS=-I$(DEPTH)/dist/public/xpcom -I. -I$(DEPTH)/dist/public/raptor
CPPSRCS= nsGIFModule.cpp nsGIFDecoder.cpp dllcompat.cpp gif.cpp
CPPSRCS= nsGIFModule.cpp nsGIFDecoder.cpp gif.cpp
CPP_OBJS= .\$(OBJDIR)\nsGIFModule.obj .\$(OBJDIR)\nsGIFDecoder.obj \
.\$(OBJDIR)\dllcompat.obj .\$(OBJDIR)\gif.obj
.\$(OBJDIR)\gif.obj
include <$(DEPTH)\config\rules.mak>

1
modules/libimg/jpgcom/Makefile.in
Просмотреть файл

@ -34,7 +34,6 @@ CPPSRCS = \
jpeg.cpp \
nsJPGDecoder.cpp \
nsJPGModule.cpp \
dllcompat.cpp \
$(NULL)
LOCAL_INCLUDES = -I$(srcdir)

395
modules/libimg/jpgcom/dllcompat.cpp
Просмотреть файл

@ -1,395 +0,0 @@
/* -*- 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):
*/
/*
* The purpose of this file is to help phase out XP_ library
* from the image library. In general, XP_ data structures and
* functions will be replaced with the PR_ or PL_ equivalents.
* In cases where the PR_ or PL_ equivalents don't yet exist,
* this file (and its header equivalent) will play the role
* of the XP_ library.
*/
/* This file has func's from
xpcompat that are needed by
the local dll. So far,
1> Mac stuff.
*/
#include "prtypes.h"
#include "prlog.h"
#include "prmem.h"
#include "nsCRT.h"
//#include "xp_mcom.h"
PR_BEGIN_EXTERN_C
int MK_UNABLE_TO_LOCATE_FILE = -1;
int MK_OUT_OF_MEMORY = -2;
PR_END_EXTERN_C
#if defined(XP_MAC)
#ifndef UNIXMINUSMACTIME
#define UNIXMINUSMACTIME 2082844800UL
#endif
/* prototypes for local routines */
static void shortsort(char *lo, char *hi, unsigned width,
int ( *comp)(const void *, const void *));
static void swap(char *p, char *q, unsigned int width);
/* this parameter defines the cutoff between using quick sort and
insertion sort for arrays; arrays with lengths shorter or equal to the
below value use insertion sort */
#define CUTOFF 8 /* testing shows that this is good value */
/***
*XP_QSORT(base, num, wid, comp) - quicksort function for sorting arrays
*
*Purpose:
* quicksort the array of elements
* side effects: sorts in place
*
*Entry:
* char *base = pointer to base of array
* unsigned num = number of elements in the array
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
* 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
/* sort the array between lo and hi (inclusive) */
void XP_QSORT (
void *base,
size_t num,
size_t width,
int ( *comp)(const void *, const void *)
)
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
unsigned size; /* size of the sub-array */
char *lostk[30], *histk[30];
int stkptr; /* stack for saving sub-array to be processed */
/* Note: the number of stack entries required is no more than
1 + log2(size), so 30 is sufficient for any array */
if (num < 2 || width == 0)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = (char*)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
prserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size <= CUTOFF) {
shortsort(lo, hi, width, comp);
}
else {
/* First we pick a partititioning element. The efficiency of the
algorithm demands that we find one that is approximately the
median of the values, but also that we select one fast. Using
the first one produces bad performace if the array is already
sorted, so we use the middle one, which would require a very
wierdly arranged array for worst case performance. Testing shows
that a median-of-three algorithm does not, in general, increase
performance. */
mid = lo + (size / 2) * width; /* find middle element */
swap(mid, lo, width); /* swap it to beginning of array */
/* We now wish to partition the array into three pieces, one
consisiting of elements <= partition element, one of elements
equal to the parition element, and one of element >= to it. This
is done below; comments indicate conditions established at every
step. */
loguy = lo;
higuy = hi + width;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo <= loguy < hi, lo < higuy <= hi + 1,
A[i] <= A[lo] for lo <= i <= loguy,
A[i] >= A[lo] for higuy <= i <= hi */
do {
loguy += width;
} while (loguy <= hi && comp(loguy, lo) <= 0);
/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
either loguy > hi or A[loguy] > A[lo] */
do {
higuy -= width;
} while (higuy > lo && comp(higuy, lo) >= 0);
/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
either higuy <= lo or A[higuy] < A[lo] */
if (higuy < loguy)
break;
/* if loguy > hi or higuy <= lo, then we would have exited, so
A[loguy] > A[lo], A[higuy] < A[lo],
loguy < hi, highy > lo */
swap(loguy, higuy, width);
/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
of loop is re-established */
}
/* A[i] >= A[lo] for higuy < i <= hi,
A[i] <= A[lo] for lo <= i < loguy,
higuy < loguy, lo <= higuy <= hi
implying:
A[i] >= A[lo] for loguy <= i <= hi,
A[i] <= A[lo] for lo <= i <= higuy,
A[i] = A[lo] for higuy < i < loguy */
swap(lo, higuy, width); /* put partition element in place */
/* OK, now we have the following:
A[i] >= A[higuy] for loguy <= i <= hi,
A[i] <= A[higuy] for lo <= i < higuy
A[i] = A[lo] for higuy <= i < loguy */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy-1] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - 1 - lo >= hi - loguy ) {
if (lo + width < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo + width < higuy) {
hi = higuy - width;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
/***
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays
*
*Purpose:
* sorts the sub-array of elements between lo and hi (inclusive)
* side effects: sorts in place
* assumes that lo < hi
*
*Entry:
* char *lo = pointer to low element to sort
* char *hi = pointer to high element to sort
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
* 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void shortsort (
char *lo,
char *hi,
unsigned width,
int ( *comp)(const void *, const void *)
)
{
char *p, *max;
/* Note: in assertions below, i and j are alway inside original bound of
array to sort. */
while (hi > lo) {
/* A[i] <= A[j] for i <= j, j > hi */
max = lo;
for (p = lo+width; p <= hi; p += width) {
/* A[i] <= A[max] for lo <= i < p */
if (comp(p, max) > 0) {
max = p;
}
/* A[i] <= A[max] for lo <= i <= p */
}
/* A[i] <= A[max] for lo <= i <= hi */
swap(max, hi, width);
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
hi -= width;
/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
}
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
so array is sorted */
}
/***
*swap(a, b, width) - swap two elements
*
*Purpose:
* swaps the two array elements of size width
*
*Entry:
* char *a, *b = pointer to two elements to swap
* unsigned width = width in bytes of each array element
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void swap (
char *a,
char *b,
unsigned width
)
{
char tmp;
if ( a != b )
/* Do the swap one character at a time to avoid potential alignment
problems. */
while ( width-- ) {
tmp = *a;
*a++ = *b;
*b++ = tmp;
}
}
#endif /* XP_MAC */
#ifdef XP_MAC
#include <OSUtils.h>
static void MyReadLocation(MachineLocation * loc)
{
static MachineLocation storedLoc; // InsideMac, OSUtilities, page 4-20
static Boolean didReadLocation = FALSE;
if (!didReadLocation)
{
ReadLocation(&storedLoc);
didReadLocation = TRUE;
}
*loc = storedLoc;
}
// current local time = GMTDelta() + GMT
// GMT = local time - GMTDelta()
static long GMTDelta()
{
MachineLocation loc;
long gmtDelta;
MyReadLocation(&loc);
gmtDelta = loc.u.gmtDelta & 0x00FFFFFF;
if ((gmtDelta & 0x00800000) != 0)
gmtDelta |= 0xFF000000;
return gmtDelta;
}
// This routine simulates stdclib time(), time in seconds since 1.1.1970
// The time is in GMT
time_t GetTimeMac()
{
unsigned long maclocal;
// Get Mac local time
GetDateTime(&maclocal);
// Get Mac GMT
maclocal -= GMTDelta();
// return unix GMT
return (maclocal - UNIXMINUSMACTIME);
}
// Returns the GMT times
time_t Mactime(time_t *timer)
{
time_t t = GetTimeMac();
if (timer != NULL)
*timer = t;
return t;
}
#endif /* XP_MAC */

4
modules/libimg/jpgcom/jpeg.cpp
Просмотреть файл

@ -22,7 +22,7 @@
/*
* jpeg.c --- Glue code to Independent JPEG Group decoder library
* $Id: jpeg.cpp,v 1.17 2000/05/26 07:48:21 shaver%mozilla.org Exp $
* $Id: jpeg.cpp,v 1.18 2000/08/07 22:08:29 pnunn%netscape.com Exp $
*/
@ -49,8 +49,6 @@
PR_BEGIN_EXTERN_C
#include "jpeglib.h"
#include "jerror.h"
extern int MK_OUT_OF_MEMORY;
PR_END_EXTERN_C
#ifdef XP_OS2

3
modules/libimg/jpgcom/makefile.win
Просмотреть файл

@ -87,11 +87,10 @@ MODULE=img
DEPTH=..\..\..
LINCS=-I$(DEPTH)/dist/public/xpcom -I. -I$(DEPTH)/dist/public/raptor -I$(DEPTH)/dist/public/jpeg
CPPSRCS= nsJPGDecoder.cpp nsJPGModule.cpp jpeg.cpp dllcompat.cpp
CPPSRCS= nsJPGDecoder.cpp nsJPGModule.cpp jpeg.cpp
CPP_OBJS= \
.\$(OBJDIR)\nsJPGDecoder.obj \
.\$(OBJDIR)\nsJPGModule.obj \
.\$(OBJDIR)\dllcompat.obj \
.\$(OBJDIR)\jpeg.obj \
$(NULL)

1
modules/libimg/pngcom/Makefile.in
Просмотреть файл

@ -34,7 +34,6 @@ CPPSRCS = \
ipng.cpp \
nsPNGDecoder.cpp \
nsPNGModule.cpp \
dllcompat.cpp \
$(NULL)
LOCAL_INCLUDES = -I$(srcdir)

395
modules/libimg/pngcom/dllcompat.cpp
Просмотреть файл

@ -1,395 +0,0 @@
/* -*- 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):
*/
/*
* The purpose of this file is to help phase out XP_ library
* from the image library. In general, XP_ data structures and
* functions will be replaced with the PR_ or PL_ equivalents.
* In cases where the PR_ or PL_ equivalents don't yet exist,
* this file (and its header equivalent) will play the role
* of the XP_ library.
*/
/* This file has func's from
xpcompat that are needed by
the local dll. So far,
1> Mac stuff.
*/
#include "prtypes.h"
#include "prlog.h"
#include "prmem.h"
#include "nsCRT.h"
//#include "xp_mcom.h"
PR_BEGIN_EXTERN_C
int MK_UNABLE_TO_LOCATE_FILE = -1;
int MK_OUT_OF_MEMORY = -2;
PR_END_EXTERN_C
#if defined(XP_MAC)
#ifndef UNIXMINUSMACTIME
#define UNIXMINUSMACTIME 2082844800UL
#endif
/* prototypes for local routines */
static void shortsort(char *lo, char *hi, unsigned width,
int ( *comp)(const void *, const void *));
static void swap(char *p, char *q, unsigned int width);
/* this parameter defines the cutoff between using quick sort and
insertion sort for arrays; arrays with lengths shorter or equal to the
below value use insertion sort */
#define CUTOFF 8 /* testing shows that this is good value */
/***
*XP_QSORT(base, num, wid, comp) - quicksort function for sorting arrays
*
*Purpose:
* quicksort the array of elements
* side effects: sorts in place
*
*Entry:
* char *base = pointer to base of array
* unsigned num = number of elements in the array
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
* 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
/* sort the array between lo and hi (inclusive) */
void XP_QSORT (
void *base,
size_t num,
size_t width,
int ( *comp)(const void *, const void *)
)
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
unsigned size; /* size of the sub-array */
char *lostk[30], *histk[30];
int stkptr; /* stack for saving sub-array to be processed */
/* Note: the number of stack entries required is no more than
1 + log2(size), so 30 is sufficient for any array */
if (num < 2 || width == 0)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = (char*)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
prserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size <= CUTOFF) {
shortsort(lo, hi, width, comp);
}
else {
/* First we pick a partititioning element. The efficiency of the
algorithm demands that we find one that is approximately the
median of the values, but also that we select one fast. Using
the first one produces bad performace if the array is already
sorted, so we use the middle one, which would require a very
wierdly arranged array for worst case performance. Testing shows
that a median-of-three algorithm does not, in general, increase
performance. */
mid = lo + (size / 2) * width; /* find middle element */
swap(mid, lo, width); /* swap it to beginning of array */
/* We now wish to partition the array into three pieces, one
consisiting of elements <= partition element, one of elements
equal to the parition element, and one of element >= to it. This
is done below; comments indicate conditions established at every
step. */
loguy = lo;
higuy = hi + width;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo <= loguy < hi, lo < higuy <= hi + 1,
A[i] <= A[lo] for lo <= i <= loguy,
A[i] >= A[lo] for higuy <= i <= hi */
do {
loguy += width;
} while (loguy <= hi && comp(loguy, lo) <= 0);
/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
either loguy > hi or A[loguy] > A[lo] */
do {
higuy -= width;
} while (higuy > lo && comp(higuy, lo) >= 0);
/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
either higuy <= lo or A[higuy] < A[lo] */
if (higuy < loguy)
break;
/* if loguy > hi or higuy <= lo, then we would have exited, so
A[loguy] > A[lo], A[higuy] < A[lo],
loguy < hi, highy > lo */
swap(loguy, higuy, width);
/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
of loop is re-established */
}
/* A[i] >= A[lo] for higuy < i <= hi,
A[i] <= A[lo] for lo <= i < loguy,
higuy < loguy, lo <= higuy <= hi
implying:
A[i] >= A[lo] for loguy <= i <= hi,
A[i] <= A[lo] for lo <= i <= higuy,
A[i] = A[lo] for higuy < i < loguy */
swap(lo, higuy, width); /* put partition element in place */
/* OK, now we have the following:
A[i] >= A[higuy] for loguy <= i <= hi,
A[i] <= A[higuy] for lo <= i < higuy
A[i] = A[lo] for higuy <= i < loguy */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy-1] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - 1 - lo >= hi - loguy ) {
if (lo + width < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo + width < higuy) {
hi = higuy - width;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
/***
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays
*
*Purpose:
* sorts the sub-array of elements between lo and hi (inclusive)
* side effects: sorts in place
* assumes that lo < hi
*
*Entry:
* char *lo = pointer to low element to sort
* char *hi = pointer to high element to sort
* unsigned width = width in bytes of each array element
* int (*comp)() = pointer to function returning analog of strcmp for
* strings, but supplied by user for comparing the array elements.
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
* 1=2, pos if 1>2.
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void shortsort (
char *lo,
char *hi,
unsigned width,
int ( *comp)(const void *, const void *)
)
{
char *p, *max;
/* Note: in assertions below, i and j are alway inside original bound of
array to sort. */
while (hi > lo) {
/* A[i] <= A[j] for i <= j, j > hi */
max = lo;
for (p = lo+width; p <= hi; p += width) {
/* A[i] <= A[max] for lo <= i < p */
if (comp(p, max) > 0) {
max = p;
}
/* A[i] <= A[max] for lo <= i <= p */
}
/* A[i] <= A[max] for lo <= i <= hi */
swap(max, hi, width);
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
hi -= width;
/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
}
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
so array is sorted */
}
/***
*swap(a, b, width) - swap two elements
*
*Purpose:
* swaps the two array elements of size width
*
*Entry:
* char *a, *b = pointer to two elements to swap
* unsigned width = width in bytes of each array element
*
*Exit:
* returns void
*
*Exceptions:
*
*******************************************************************************/
static void swap (
char *a,
char *b,
unsigned width
)
{
char tmp;
if ( a != b )
/* Do the swap one character at a time to avoid potential alignment
problems. */
while ( width-- ) {
tmp = *a;
*a++ = *b;
*b++ = tmp;
}
}
#endif /* XP_MAC */
#ifdef XP_MAC
#include <OSUtils.h>
static void MyReadLocation(MachineLocation * loc)
{
static MachineLocation storedLoc; // InsideMac, OSUtilities, page 4-20
static Boolean didReadLocation = FALSE;
if (!didReadLocation)
{
ReadLocation(&storedLoc);
didReadLocation = TRUE;
}
*loc = storedLoc;
}
// current local time = GMTDelta() + GMT
// GMT = local time - GMTDelta()
static long GMTDelta()
{
MachineLocation loc;
long gmtDelta;
MyReadLocation(&loc);
gmtDelta = loc.u.gmtDelta & 0x00FFFFFF;
if ((gmtDelta & 0x00800000) != 0)
gmtDelta |= 0xFF000000;
return gmtDelta;
}
// This routine simulates stdclib time(), time in seconds since 1.1.1970
// The time is in GMT
time_t GetTimeMac()
{
unsigned long maclocal;
// Get Mac local time
GetDateTime(&maclocal);
// Get Mac GMT
maclocal -= GMTDelta();
// return unix GMT
return (maclocal - UNIXMINUSMACTIME);
}
// Returns the GMT times
time_t Mactime(time_t *timer)
{
time_t t = GetTimeMac();
if (timer != NULL)
*timer = t;
return t;
}
#endif /* XP_MAC */

1
modules/libimg/pngcom/ipng.cpp
Просмотреть файл

@ -37,7 +37,6 @@
#include "nsIImgDecoder.h" // include if_struct.h Needs to be first
#include "ipng.h"
#include "dllcompat.h"
#include "pngdec.h"
#include "nsPNGDecoder.h"

3
modules/libimg/pngcom/makefile.win
Просмотреть файл

@ -90,11 +90,10 @@ DEPTH=..\..\..
LINCS=-I$(DEPTH)/dist/public/xpcom -I. -I$(DEPTH)/dist/public/raptor \
-I$(DEPTH)/dist/public/png -I$(DEPTH)/dist/public/zlib -I$(DEPTH)/dist/public/img
CPPSRCS= dllcompat.cpp nsPNGDecoder.cpp nsPNGCallback.cpp ipng.cpp
CPPSRCS= nsPNGDecoder.cpp nsPNGCallback.cpp ipng.cpp
CPP_OBJS= \
.\$(OBJDIR)\nsPNGDecoder.obj \
.\$(OBJDIR)\nsPNGModule.obj \
.\$(OBJDIR)\dllcompat.obj \
.\$(OBJDIR)\ipng.obj

25
modules/libimg/src/xpcompat.h → modules/libimg/public/xpcompat.h
Просмотреть файл

@ -73,6 +73,31 @@ NS_EXPORT void* IL_SetTimeout(TimeoutCallbackFunction func, void * closure, PRUi
NS_EXPORT void IL_ClearTimeout(void *timer_id);
#define MK_UNABLE_TO_LOCATE_FILE -1
#define MK_OUT_OF_MEMORY -2
#define XP_MSG_IMAGE_PIXELS -7
#define XP_MSG_IMAGE_NOT_FOUND -8
#define XP_MSG_XBIT_COLOR -9
#define XP_MSG_1BIT_MONO -10
#define XP_MSG_XBIT_GREYSCALE -11
#define XP_MSG_XBIT_RGB -12
#define XP_MSG_DECODED_SIZE -13
#define XP_MSG_WIDTH_HEIGHT -14
#define XP_MSG_SCALED_FROM -15
#define XP_MSG_IMAGE_DIM -16
#define XP_MSG_COLOR -17
#define XP_MSG_NB_COLORS -18
#define XP_MSG_NONE -19
#define XP_MSG_COLORMAP -20
#define XP_MSG_BCKDRP_VISIBLE -21
#define XP_MSG_SOLID_BKGND -22
#define XP_MSG_JUST_NO -23
#define XP_MSG_TRANSPARENCY -24
#define XP_MSG_COMMENT -25
#define XP_MSG_UNKNOWN -26
#define XP_MSG_COMPRESS_REMOVE -27
PR_END_EXTERN_C
#endif

1
modules/libimg/public_com/MANIFEST
Просмотреть файл

@ -2,7 +2,6 @@
# This is a list of local files which get copied to the mozilla:dist:libimg directory
#
dllcompat.h
if_struct.h
il.h
il_utilp.h

1
modules/libimg/public_com/Makefile.in
Просмотреть файл

@ -31,7 +31,6 @@ MODULE = img
# XXX nsImgDCallbk.h should go into libimg/src instead of being here
EXPORTS = \
il.h \
dllcompat.h \
if_struct.h \
il_utilp.h \
nsIImgDecoder.h \

42
modules/libimg/public_com/dllcompat.h
Просмотреть файл

@ -1,42 +0,0 @@
/* -*- 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):
*/
/*
* The purpose of this file is to help phase out XP_ library
* from the image library. In general, XP_ data structures and
* functions will be replaced with the PR_ or PL_ equivalents.
* In cases where the PR_ or PL_ equivalents don't yet exist,
* this file (and its source equivalent) will play the role
* of the XP_ library.
*/
#ifndef dllcompat_h___
#define dllcompat_h___
#include "platform.h"
#include "prtypes.h"
#include "nsCom.h"
typedef void
(*TimeoutCallbackFunction) (void * closure);
#endif

2
modules/libimg/public_com/makefile.win
Просмотреть файл

@ -43,7 +43,7 @@ LCFLAGS = $(LCFLAGS) /TP
MODULE=img
DEPTH=..\..\..
EXPORTS= if_struct.h dllcompat.h il.h il_utilp.h \
EXPORTS= if_struct.h il.h il_utilp.h \
nsIImgDecoder.h nsIImgDCallbk.h nsImgDCallbk.h
include <$(DEPTH)/config/rules.mak>

2
modules/libimg/public_com/nsIImgDCallbk.h
Просмотреть файл

@ -22,7 +22,7 @@
#ifndef nsIImgDCallbk_h___
#define nsIImgDCallbk_h___
#include "dllcompat.h" // for TimeoutCallbackFunction
#include "xpcompat.h" // for TimeoutCallbackFunction
#include "nsISupports.h"
/* d34a2f20-cd9f-11d2-802c-0060088f91a3 */

197
modules/libimg/src/if.cpp
Просмотреть файл

@ -42,12 +42,6 @@
#include "nsIServiceManager.h"
PR_BEGIN_EXTERN_C
extern int XP_MSG_IMAGE_PIXELS;
extern int MK_UNABLE_TO_LOCATE_FILE;
extern int MK_OUT_OF_MEMORY;
PR_END_EXTERN_C
#define HOWMANY(x, r) (((x) + ((r) - 1)) / (r))
#define ROUNDUP(x, r) (HOWMANY(x, r) * (r))
@ -1687,196 +1681,7 @@ il_hash(const char *ubuf)
}
return h;
}
#if 0
#define IL_LAST_ICON 62
/* Extra factor of 7 is to account for duplications between
mc-icons and ns-icons */
static PRUint32 il_icon_table[(IL_LAST_ICON + 7) * 2];
static void
il_setup_icon_table(void)
{
int inum = 0;
/* gopher/ftp icons */
il_icon_table[inum++] = il_hash("internal-gopher-text");
il_icon_table[inum++] = IL_GOPHER_TEXT;
il_icon_table[inum++] = il_hash("internal-gopher-image");
il_icon_table[inum++] = IL_GOPHER_IMAGE;
il_icon_table[inum++] = il_hash("internal-gopher-binary");
il_icon_table[inum++] = IL_GOPHER_BINARY;
il_icon_table[inum++] = il_hash("internal-gopher-sound");
il_icon_table[inum++] = IL_GOPHER_SOUND;
il_icon_table[inum++] = il_hash("internal-gopher-movie");
il_icon_table[inum++] = IL_GOPHER_MOVIE;
il_icon_table[inum++] = il_hash("internal-gopher-menu");
il_icon_table[inum++] = IL_GOPHER_FOLDER;
il_icon_table[inum++] = il_hash("internal-gopher-index");
il_icon_table[inum++] = IL_GOPHER_SEARCHABLE;
il_icon_table[inum++] = il_hash("internal-gopher-telnet");
il_icon_table[inum++] = IL_GOPHER_TELNET;
il_icon_table[inum++] = il_hash("internal-gopher-unknown");
il_icon_table[inum++] = IL_GOPHER_UNKNOWN;
/* news icons */
il_icon_table[inum++] = il_hash("internal-news-catchup-group");
il_icon_table[inum++] = IL_NEWS_CATCHUP;
il_icon_table[inum++] = il_hash("internal-news-catchup-thread");
il_icon_table[inum++] = IL_NEWS_CATCHUP_THREAD;
il_icon_table[inum++] = il_hash("internal-news-followup");
il_icon_table[inum++] = IL_NEWS_FOLLOWUP;
il_icon_table[inum++] = il_hash("internal-news-go-to-newsrc");
il_icon_table[inum++] = IL_NEWS_GOTO_NEWSRC;
il_icon_table[inum++] = il_hash("internal-news-next-article");
il_icon_table[inum++] = IL_NEWS_NEXT_ART;
il_icon_table[inum++] = il_hash("internal-news-next-article-gray");
il_icon_table[inum++] = IL_NEWS_NEXT_ART_GREY;
il_icon_table[inum++] = il_hash("internal-news-next-thread");
il_icon_table[inum++] = IL_NEWS_NEXT_THREAD;
il_icon_table[inum++] = il_hash("internal-news-next-thread-gray");
il_icon_table[inum++] = IL_NEWS_NEXT_THREAD_GREY;
il_icon_table[inum++] = il_hash("internal-news-post");
il_icon_table[inum++] = IL_NEWS_POST;
il_icon_table[inum++] = il_hash("internal-news-prev-article");
il_icon_table[inum++] = IL_NEWS_PREV_ART;
il_icon_table[inum++] = il_hash("internal-news-prev-article-gray");
il_icon_table[inum++] = IL_NEWS_PREV_ART_GREY;
il_icon_table[inum++] = il_hash("internal-news-prev-thread");
il_icon_table[inum++] = IL_NEWS_PREV_THREAD;
il_icon_table[inum++] = il_hash("internal-news-prev-thread-gray");
il_icon_table[inum++] = IL_NEWS_PREV_THREAD_GREY;
il_icon_table[inum++] = il_hash("internal-news-reply");
il_icon_table[inum++] = IL_NEWS_REPLY;
il_icon_table[inum++] = il_hash("internal-news-rtn-to-group");
il_icon_table[inum++] = IL_NEWS_RTN_TO_GROUP;
il_icon_table[inum++] = il_hash("internal-news-show-all-articles");
il_icon_table[inum++] = IL_NEWS_SHOW_ALL_ARTICLES;
il_icon_table[inum++] = il_hash("internal-news-show-unread-articles");
il_icon_table[inum++] = IL_NEWS_SHOW_UNREAD_ARTICLES;
il_icon_table[inum++] = il_hash("internal-news-subscribe");
il_icon_table[inum++] = IL_NEWS_SUBSCRIBE;
il_icon_table[inum++] = il_hash("internal-news-unsubscribe");
il_icon_table[inum++] = IL_NEWS_UNSUBSCRIBE;
il_icon_table[inum++] = il_hash("internal-news-newsgroup");
il_icon_table[inum++] = IL_NEWS_FILE;
il_icon_table[inum++] = il_hash("internal-news-newsgroups");
il_icon_table[inum++] = IL_NEWS_FOLDER;
/* httpd file icons */
il_icon_table[inum++] = il_hash("/mc-icons/menu.gif");
il_icon_table[inum++] = IL_GOPHER_FOLDER;
il_icon_table[inum++] = il_hash("/mc-icons/unknown.gif");
il_icon_table[inum++] = IL_GOPHER_UNKNOWN;
il_icon_table[inum++] = il_hash("/mc-icons/text.gif");
il_icon_table[inum++] = IL_GOPHER_TEXT;
il_icon_table[inum++] = il_hash("/mc-icons/image.gif");
il_icon_table[inum++] = IL_GOPHER_IMAGE;
il_icon_table[inum++] = il_hash("/mc-icons/sound.gif");
il_icon_table[inum++] = IL_GOPHER_SOUND;
il_icon_table[inum++] = il_hash("/mc-icons/movie.gif");
il_icon_table[inum++] = IL_GOPHER_MOVIE;
il_icon_table[inum++] = il_hash("/mc-icons/binary.gif");
il_icon_table[inum++] = IL_GOPHER_BINARY;
/* Duplicate httpd icons, but using new naming scheme. */
il_icon_table[inum++] = il_hash("/ns-icons/menu.gif");
il_icon_table[inum++] = IL_GOPHER_FOLDER;
il_icon_table[inum++] = il_hash("/ns-icons/unknown.gif");
il_icon_table[inum++] = IL_GOPHER_UNKNOWN;
il_icon_table[inum++] = il_hash("/ns-icons/text.gif");
il_icon_table[inum++] = IL_GOPHER_TEXT;
il_icon_table[inum++] = il_hash("/ns-icons/image.gif");
il_icon_table[inum++] = IL_GOPHER_IMAGE;
il_icon_table[inum++] = il_hash("/ns-icons/sound.gif");
il_icon_table[inum++] = IL_GOPHER_SOUND;
il_icon_table[inum++] = il_hash("/ns-icons/movie.gif");
il_icon_table[inum++] = IL_GOPHER_MOVIE;
il_icon_table[inum++] = il_hash("/ns-icons/binary.gif");
il_icon_table[inum++] = IL_GOPHER_BINARY;
/* ... and names for all the image icons */
il_icon_table[inum++] = il_hash("internal-icon-delayed");
il_icon_table[inum++] = IL_IMAGE_DELAYED;
il_icon_table[inum++] = il_hash("internal-icon-notfound");
il_icon_table[inum++] = IL_IMAGE_NOT_FOUND;
il_icon_table[inum++] = il_hash("internal-icon-baddata");
il_icon_table[inum++] = IL_IMAGE_BAD_DATA;
il_icon_table[inum++] = il_hash("internal-icon-insecure");
il_icon_table[inum++] = IL_IMAGE_INSECURE;
il_icon_table[inum++] = il_hash("internal-icon-embed");
il_icon_table[inum++] = IL_IMAGE_EMBED;
/* This belongs up in the `news icons' section */
il_icon_table[inum++] = il_hash("internal-news-followup-and-reply");
il_icon_table[inum++] = IL_NEWS_FOLLOWUP_AND_REPLY;
/* editor icons. */
il_icon_table[inum++] = il_hash("internal-edit-named-anchor");
il_icon_table[inum++] = IL_EDIT_NAMED_ANCHOR;
il_icon_table[inum++] = il_hash("internal-edit-form-element");
il_icon_table[inum++] = IL_EDIT_FORM_ELEMENT;
il_icon_table[inum++] = il_hash("internal-edit-unsupported-tag");
il_icon_table[inum++] = IL_EDIT_UNSUPPORTED_TAG;
il_icon_table[inum++] = il_hash("internal-edit-unsupported-end-tag");
il_icon_table[inum++] = IL_EDIT_UNSUPPORTED_END_TAG;
il_icon_table[inum++] = il_hash("internal-edit-java");
il_icon_table[inum++] = IL_EDIT_JAVA;
il_icon_table[inum++] = il_hash("internal-edit-PLUGIN");
il_icon_table[inum++] = IL_EDIT_PLUGIN;
/* Security Advisor and S/MIME icons */
il_icon_table[inum++] = il_hash("internal-sa-signed");
il_icon_table[inum++] = IL_SA_SIGNED;
il_icon_table[inum++] = il_hash("internal-sa-encrypted");
il_icon_table[inum++] = IL_SA_ENCRYPTED;
il_icon_table[inum++] = il_hash("internal-sa-nonencrypted");
il_icon_table[inum++] = IL_SA_NONENCRYPTED;
il_icon_table[inum++] = il_hash("internal-sa-signed-bad");
il_icon_table[inum++] = IL_SA_SIGNED_BAD;
il_icon_table[inum++] = il_hash("internal-sa-encrypted-bad");
il_icon_table[inum++] = IL_SA_ENCRYPTED_BAD;
il_icon_table[inum++] = il_hash("internal-smime-attached");
il_icon_table[inum++] = IL_SMIME_ATTACHED;
il_icon_table[inum++] = il_hash("internal-smime-signed");
il_icon_table[inum++] = IL_SMIME_SIGNED;
il_icon_table[inum++] = il_hash("internal-smime-encrypted");
il_icon_table[inum++] = IL_SMIME_ENCRYPTED;
il_icon_table[inum++] = il_hash("internal-smime-encrypted-signed");
il_icon_table[inum++] = IL_SMIME_ENC_SIGNED;
il_icon_table[inum++] = il_hash("internal-smime-signed-bad");
il_icon_table[inum++] = IL_SMIME_SIGNED_BAD;
il_icon_table[inum++] = il_hash("internal-smime-encrypted-bad");
il_icon_table[inum++] = IL_SMIME_ENCRYPTED_BAD;
il_icon_table[inum++] = il_hash("internal-smime-encrypted-signed-bad");
il_icon_table[inum++] = IL_SMIME_ENC_SIGNED_BAD;
/* LibMsg Attachment Icon */
il_icon_table[inum++] = il_hash("internal-attachment-icon");
il_icon_table[inum++] = IL_MSG_ATTACH;
PR_ASSERT(inum <= (int)(sizeof(il_icon_table) / sizeof(il_icon_table[0])));
}
static PRUint32
il_internal_image(const char *image_url)
{
int i;
PRUint32 hash = il_hash(image_url);
if (il_icon_table[0]==0)
il_setup_icon_table();
for (i=0; i < (int)(sizeof(il_icon_table) / sizeof(il_icon_table[0])); i++)
{
if (il_icon_table[i<<1] == hash)
{
return il_icon_table[(i<<1)+1];
}
}
return 0;
}
#endif
/* block certain hosts from loading images */
PRBool il_PermitLoad(const char * image_url, nsIImageRequestObserver * aObserver) {

30
modules/libimg/src/xpcompat.cpp
Просмотреть файл

@ -35,39 +35,9 @@
#include "plstr.h"
#include "ilISystemServices.h"
#include "nsCRT.h"
#if 0
#include "xp_mcom.h"
#endif
extern ilISystemServices *il_ss;
PR_BEGIN_EXTERN_C
int MK_UNABLE_TO_LOCATE_FILE = -1;
int MK_OUT_OF_MEMORY = -2;
int XP_MSG_IMAGE_PIXELS = -7;
int XP_MSG_IMAGE_NOT_FOUND = -8;
int XP_MSG_XBIT_COLOR = -9;
int XP_MSG_1BIT_MONO = -10;
int XP_MSG_XBIT_GREYSCALE = -11;
int XP_MSG_XBIT_RGB = -12;
int XP_MSG_DECODED_SIZE = -13;
int XP_MSG_WIDTH_HEIGHT = -14;
int XP_MSG_SCALED_FROM = -15;
int XP_MSG_IMAGE_DIM = -16;
int XP_MSG_COLOR = -17;
int XP_MSG_NB_COLORS = -18;
int XP_MSG_NONE = -19;
int XP_MSG_COLORMAP = -20;
int XP_MSG_BCKDRP_VISIBLE = -21;
int XP_MSG_SOLID_BKGND = -22;
int XP_MSG_JUST_NO = -23;
int XP_MSG_TRANSPARENCY = -24;
int XP_MSG_COMMENT = -25;
int XP_MSG_UNKNOWN = -26;
int XP_MSG_COMPRESS_REMOVE = -27;
PR_END_EXTERN_C
char *XP_GetString(int i)
{
return ("XP_GetString replacement needed");