Tools/WinSN5.0Ver.iso/NETSCAP.50/WIN1998.ZIP/ns/modules/libfont/src/f.cpp

C/C++ Source or Header | 1998-04-08 | 9.9 KB | 431 lines

/* -*- 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.
 */
/*
 * f.cpp (FontObject.cpp)
 *
 * C++ implementation of the (f) FontObject
 *
 * dp Suresh <[e-mail]>
 */


#include "f.h"
#include "nf.h"


FontObject::
FontObject(struct nff *f, struct nfrc *irc, const char *url)
           : self(f), inGC(0), wfList(free_fh_store), iswebfont(0), state(NF_FONT_COMPLETE), shared(1)
{
    m_rcMajorType = nfrc_GetMajorType(irc, NULL);
    m_rcMinorType = nfrc_GetMinorType(irc, NULL);
    urlOfFont = CopyString(url);
    if (urlOfFont && *urlOfFont)
    {
        // Webfont
        iswebfont = 1;
        state = NF_FONT_INCOMPLETE;
    }
}

FontObject::
~FontObject()
{
    if (urlOfFont) delete (char *)urlOfFont;
}


jdouble * FontObject::
EnumerateSizes(struct nfrc *rc)
{
    wfListElement *tmp = head;
    jdouble *ret = NULL;
    int max_ret_len = 0;

    for (; tmp; tmp = tmp->next)
      {
        struct fh_store *ele = (struct fh_store *)tmp->item;

        computeSizes(rc, ele);
        jdouble *sizes = ele->sizesList.getSizes();
        if (sizes)
        {
            MergeSizes(ret, max_ret_len, sizes);
        }
    }
    return (ret);
}

/*ARGSUSED*/
struct nfrf * FontObject::
GetRenderableFont(struct nfrc *rc, jdouble pointsize)
{
    struct nfrf * rf = NULL;
    wfListElement *tmp = head;
    int onlyOne = (head == tail);

    if (!onlyOne)
    {
        WF_TRACEMSG(("NF: More than one displayer handling font 0x%x.", self));
    }

    // Sanity check to make sure that the rc is of the same type
    if (!nfrc_IsEquivalent(rc, m_rcMajorType, m_rcMinorType, NULL))
    {
        // Invalid rc.
        return NULL;
    }

    for (; tmp; tmp = tmp->next)
    {
        struct fh_store *ele = (struct fh_store *)tmp->item;

        // Get any cached rf.
        rf = ele->sizesList.getRf(pointsize);
        if (rf)
        {
            // Increment the refcount of the cached rf.
            WF_TRACEMSG(("NF: Found rf %x (f = 0x%x, pointsize = %6.2f) in cache.",
                rf, self, pointsize));
            nfrf_addRef(rf, NULL);
            break;
        }

        // Try to get a new rf.
        // The right way to do this is to check with the list of enumerated
        // sizes to see if the displayer does support this size. We will
        // however, ask the displayer anyway if there was only one
        // displayer that handled this font.
        if (!onlyOne)
        {
            computeSizes(rc, ele);
            if (!ele->sizesList.supportsSize(pointsize))
            {
                // point size not supported by this displayer. Try next....
                continue;
            }
        }
        rf = ele->fppeer->CreateRenderableFont(rc, ele->fh, pointsize);
        if (!rf)
        {
            // That displayer lied about the sizes it can handle.
            // Remove the size from the sizes list.
            ele->sizesList.removeSize(pointsize);
        }
        else
        {
            WF_TRACEMSG(("NF: Created new rf %x (f = 0x%x, pointsize = %6.2f) from displayer %s.",
                rf, self, pointsize, ele->fppeer->name()));

            // Cache this rf.
            int ret = ele->sizesList.addRf(rf);
            //
            // if ret < 0, then we ran out of memory
            // This is very bad because we are now having the
            // fh refcount the nff. And the fh would need to know
            // exactly how many rf's were created with it. If an
            // rf was created but not added to the sizesList, then
            // the fh will be deleted one too soon causing access of
            // deleted object when the final RfDone() happens.
            break;
        }
    }
    return(rf);
}
struct nffmi *
FontObject::GetMatchInfo(struct nfrc *rc, jdouble pointsize)
{
    struct nffmi *fmi = NULL;
    wfListElement *tmp = head;

    for (; tmp; tmp = tmp->next)
      {
        struct fh_store *ele = (struct fh_store *)tmp->item;
        computeSizes(rc, ele);

        if (ele->sizesList.supportsSize(pointsize))
          {
            // Get the fh corresponding to this fontdisplayer
            fmi = ele->fppeer->GetMatchInfo(ele->fh);

            if (!fmi)
              {
                // That displayer lied about the sizes it can handle.
                // Remove the size from the sizes list.
                ele->sizesList.removeSize(pointsize);
              }
            else
              {
                break;
              }
          }
      }
    return (fmi);
}

jint
FontObject::GetRcMajorType()
{
    return (m_rcMajorType);
}

jint
FontObject::GetRcMinorType()
{
    return (m_rcMinorType);
}


int
FontObject::isShared(void)
{
    return (shared);
}

int
FontObject::setShared(int sharedState)
{
    shared = sharedState;
    return (0);
}


//
// FontBroker specific
//

int FontObject::
addFontHandle(FontDisplayerPeerObject *fppeer, void *fh)
{
    struct fh_store *ele = new fh_store;
    if (!ele) {
        // No memory.
        return (-1);
    }
    ele->fppeer = fppeer;
    ele->fh = fh;
    add((void *)ele);

    // Tell wffpPeer that we created a fh
    fppeer->FontHandleCreated(fh);

    //
    // We will have the fonthandle refcount the Font too.
    // A font should not be deleted until all its fonthandles
    // are deleted.
    //
    nff_addRef(self, NULL);

    // If the displayer is a non-native displayer
    // (The correct condition is if this is webfont)
    // then disable shared
    if (!fppeer->isNative())
    {
        setShared(0);
    }

    return (0);
}


int FontObject::
isRfExist(struct nfrf *rf)
{
    wfListElement *tmp = head;
    int nrf;

    for (; tmp; tmp = tmp->next)
      {
        struct fh_store *ele = (struct fh_store *)tmp->item;
        nrf = ele->sizesList.isRfExist(rf);
        if (nrf > 0)
          {
            break;
          }
      }
    return (nrf);
}

int
FontObject::releaseRf(struct nfrf *rf)
{
    wfListElement *tmp = head;
    int ret = 0;

    for (; tmp; tmp = tmp->next)
      {
        struct fh_store *ele = (struct fh_store *)tmp->item;
        ret += ele->sizesList.removeRf(rf);
      }

    return (ret);
}

int
FontObject::isWebFont()
{
    return (iswebfont);
}

const char *
FontObject::url()
{
    return (urlOfFont);
}


int
FontObject::GetState()
{
    return (state);
}


int
FontObject::setState(int completion_state)
{
    int old_state = state;
    state = completion_state;
    return (old_state);
}



#include "Pcf.h"
//
// The Font garbage Collector.
//
// A FontHandle can be released when there are no consumers using this
// FontObject and there are no rf's active. This is given by the expression
//        [referenceCount(FONT) - fonthandleCount(FONT)]
//                + rfcount(FONT.sizesList)                == 0
// referenceCount(FONT) is got from looking into the nff* jmc object
// fonthandleCount(FONT) is got by count()
//
// A FontObject can be destroyed only when there are no fonthandles
// in the FontObject. This is given by the expression:
//        fonthandleCount(FONT) == 0
//
// This will return ZERO, if the Font can be deleted. If not, it
// will return NONZERO.
//
int FontObject::
GC()
{
    // Prevent the GC from calling itself. This will happen when fonthandles
    // are removed. Since each of the list element refcounts the Font, everytime
    // an element it removed, its freeItem() will Font::release().
    // The below will prevent the GC from stepping over itself.
    if (inGC)
    {
        return(-1);
    }
    inGC++;

    wfListElement *tmp = head;

    cfImplHeader* impl = (cfImplHeader*)cf2cfImpl(self);
    int nconsumers = impl->refcount - count();

    // At this point, we will increment the refcount by 1. This is because
    // removing an fh could cause the refcount to goto zero and that would
    // cause the FontObject that we are working with to be deleted from
    // underneath us. To prevent this, **AFTER COMPUTING nconsumers** we
    // increment the refcount.
    impl->refcount++;

    while(tmp)
    {
        struct fh_store *ele = (struct fh_store *)tmp->item;
        //
        // WARNING: we could be possibly removing this element.
        // Store the next element we should visit ahead of time.
        //
        tmp = tmp->next;

        if (nconsumers + ele->sizesList.getRfCount() == 0)
        {
            // This fonthandle is a candidate for deletion.
            remove(ele);
        }
    }

    // Undo the dummy incrementing of refcount we did to protect ourself.
    // NOTE: we cannot use nff_release() as that would go and delete the
    // object. Callers of the GC are smart enough to check the return value
    // of GC or look at the refcount and delete the object.
    impl->refcount--;

    inGC --;
    return (impl->refcount);
}

//
// Private method implementations.
//

void FontObject::
computeSizes(struct nfrc *rc, struct fh_store *ele)
{
#if defined(XP_WIN) && !defined(WIN32) && !defined(XP_OS2)
    /* Win 16 core dumps on  enumerating. HACK HACK HACK */
    return;
#else
    if (!ele->sizesList.initialized())
      {
        // Sizes was never computed for this
        WF_TRACEMSG(("NF: Computing sizes supported by font 0x%x by displayer %s.\n",
            self, ele->fppeer->name()));
        jdouble *sizes = ele->fppeer->EnumerateSizes(rc, ele->fh);
        ele->sizesList.addSizes(sizes);
      }
#endif
}

//
// Other functions
//
void
free_fh_store(wfList *object, void *item)
{
    // We know that the wfList is actually a FontObject
    // because FontObject is the superclass and wfList is the
    // base class.
    //
    // Hence this is ok.
    FontObject *fob = (FontObject *)object;
    struct fh_store *ele = (struct fh_store *)item;

    // Tell the wffpPeer that we are done with the the fonthandle
    // The wffpPeer will take decisions of unloading the displayer
    // DLM on this call.
    ele->fppeer->FontHandleDone(ele->fh);


    delete(ele);

    //
    // We will have the fonthandle refcount the Font too. So
    // deletion of a fontHandle will decrement the refcount of Font.
    // A font should not be deleted until all its fonthandles
    // are deleted.
    //
    nff_release(fob->self, NULL);
}