Attachment #492352 for bug #629708

View | Details | Raw Unified | Return to bug 629708 | Differences between
Collapse All | Expand All




{
    XRef *xref = doc->getXRef();
    Ref *pageref = doc->getCatalog()->getPageRef(page);
    Object streamrefobj;
    Object pageobj, contents;
    Object array;
    Ref r;

    Object pageobj = xref->fetch(pageref->num, pageref->gen);
    Object contents = pageobj.dictLookupNF("Contents");
    if (!pageobj.isDict() || contents.isNull()) {
        fprintf(stderr, "Error: malformed pdf (in pdf_prepend_stream neither pageobj is a dict nor were Contents found)\n");
        return;
    }

    if (contents.isRef())
        contents = xref->fetch(contents.getRefNum(), contents.getRefGen());

    Dict *dict = new Dict(xref);
    dict->set("Length", Object((int)len));
    MemStream *ms = new MemStream(buf, 0, len, Object(dict));
    Object stream = Object(static_cast<Stream*>(ms));

    r = xref->addIndirectObject(&stream);
    streamrefobj.initRef(r.num, r.gen);

    Array *array = new Array(xref);
    array->add(Object(r.num, r.gen));

    if (contents.isStream()) {
	// streams must be indirect, i.e. not fetch()-ed
        array->add(Object(pageobj.dictLookupNF("Contents")));
    }
    else if (contents.isArray()) {
        int i, len = contents.arrayGetLength();
        Object obj;
        for (i = 0; i < len; i++) {
            array->add(Object(contents.arrayGetNF(i)));
            array.arrayAdd(&obj);
        }
    }
    else
        fprintf(stderr, "Error: malformed pdf (not stream or array in pdf_prepend_stream)\n");

    pageobj.dictSet("Contents", Object(array));

    xref->setModifiedObject(&pageobj, *pageref);
//    pageobj.free();
}


static Object * name_object(const char *s)
{
    Object *o = new Object();
    o->initName((char *)s);
    return o;
}

/*
 * Create new PDF integer type object.
 */
static Object * int_object(int i)
{
    Object *o = new Object();
    o->initInt(i);
    return o;
}

static Object * get_resource_dict(XRef *xref,
                                  Dict *pagedict,
                                  Object *resdict,
                                  Ref *resref)
{
    Object res;

    /* TODO resource dict can also be inherited */
    Object res = pagedict->lookupNF("Resources");
        return NULL;

    if (res.isRef()) {
        *resref = res.getRef();
        *resdict = xref->fetch(resref->num, resref->gen);
    }
    else if (res.isDict()) {
        *resdict = res.copy();
        resref->num = 0;
    }
    else
        resdict = NULL;

//    res.free();
    return resdict;
}


{
    XRef *xref = doc->getXRef();
    Ref *pageref = doc->getCatalog()->getPageRef(page);
    Object pageobj, font, fonts;

    Object resdict;
    Ref resref;

    Object pageobj = xref->fetch(pageref->num, pageref->gen);
    if (!pageobj.isDict()) {
        fprintf(stderr, "Error: malformed pdf (not a dict in pdf_add_type1_font)\n");
        return;
    }

    if (!get_resource_dict(xref, pageobj.getDict(), &resdict, &resref)) {
        fprintf(stderr, "Error: malformed pdf (could not get resource dict in pdf_add_type1_font)\n");
//        pageobj.free();
        return;
    }

    Object font = Object(new Dict(xref));

    font.dictSet("Type", Object(objName,"Font"));
    font.dictSet("Subtype", Object(objName,"Type1"));
    font.dictSet("BaseFont", Object(objName,name));
    xref->addIndirectObject(&font);

    Object fonts = resdict.dictLookupNF("Font");
    if (fonts.isNull()) {
        /* Create new font dic obj in page's resources */
        resdict.dictSet("Font", Object(new Dict(xref)));
        resdict.dictSet("Font", &fonts);
    }

    Object *fonts_dic;

        fonts_dic = &fonts;
    } else if ( fonts.isRef() ) {
        /* "Font" resource is indirect reference object */
        dereferenced_obj = xref->fetch(fonts.getRefNum(), fonts.getRefGen());
        fonts_dic = &dereferenced_obj;
    }


    }

    /* Add new entry to "Font" resource */
//    TODO Malc - can't make this compile...
//    fonts_dic->dictSet("bannertopdf-font", &font);

    /* Notify poppler about changes */
    if ( fonts.isRef() ) {

    else
        xref->setModifiedObject(&resdict, resref);

//    pageobj.free();
}



                             const char *key,
                             float rect[4])
{
    Object o;
    Array *array;
    int i;

    Object o = dict->dictLookup(key);
        return false;

    if (!o.isArray()) {
        o.free();
        return false;
    }

    array = o.getArray();
    for (i = 0; i < 4; i++) {
        Object el = array->get(i);
        if (el.isNum())
            rect[i] = el.getNum();
        el.free();
    }

    o.free();
    return i == 4;
}


                          const char *key,
                          float rect[4])
{
    Object array;
    int i;
    Array *array = new Array(xref);
    array.initArray(xref);

    for (i = 0; i < 4; i++) {
        array->add(Object((double)rect[i]));
        el.initReal(rect[i]);
        array.arrayAdd(&el);
    }

    dict->dictSet(key, Object(array));
}



{
    XRef *xref = doc->getXRef();
    Ref *pageref = doc->getCatalog()->getPageRef(page);
    Object pageobj;
    float mediabox[4] = { 0.0, 0.0, width, length };
    float old_mediabox[4];

    Object pageobj = xref->fetch(pageref->num, pageref->gen);
    if (!pageobj.isDict()) {
        fprintf(stderr, "Error: malformed pdf\n");
        return;

    dict_set_rect (xref, &pageobj, "BleedBox", mediabox);

    xref->setModifiedObject(&pageobj, *pageref);
    pageobj.free();
}



{
    XRef *xref = doc->getXRef();
    Ref *pageref = doc->getCatalog()->getPageRef(pagenr);
    Object page, parentref, parent, kids, ref, countobj;
    int i;

    Object page = xref->fetch(pageref->num, pageref->gen);
    if (!page.isDict("Page")) {
        fprintf(stderr, "Error: malformed pdf (invalid Page object)\n");
        return;
    }

    Object parentref = page.dictLookupNF("Parent");
    Object parent = parentref.fetch(xref);
    if (!parent.isDict("Pages")) {
        fprintf(stderr, "Error: malformed pdf (Page.Parent must point to a "
                        "Pages object)\n");
        return;
    }

    Object kids = parent.dictLookup("Kids");
    if (!kids.isArray()) {
        fprintf(stderr, "Error: malformed pdf (Pages.Kids must be an array)\n");
        return;

    // object to the end of the array
    // Note: We must make a (shallow) copy of the page object to avoid loops in
    // the pages tree (not supported by major pdf implementations).
    Array *array = kids.getArray();

    for (i = 1; i < count; i++) {
        Ref r = xref->addIndirectObject(&page);
        array->add(Object(r.num,r.gen));
        kids.arrayAdd(&ref);
        ref.free();
    }

    parent.dictSet("Count", Object((int)count));
    parent.dictSet("Count", &countobj);
    countobj.free();

    xref->setModifiedObject(&parent, parentref.getRef());
}

        fprintf(stderr, "Can't get page from PDF tamplate file.\n");
        return 0;
    }
    Object pageobj;
    Ref pageref = page->getRef();
    Object pageobj =  xref->fetch(pageref.num, pageref.gen);

    const char *font_size = lookup_opt(opt, "banner-font-size");
    if ( ! font_size ) {

        appearance->append(" Tf");

        /* Modify field's appearance */
        field_obj->getDict()->set("DA", Object(appearance));
        appearance_obj.initString(appearance);
        field_obj->getDict()->set("DA", &appearance_obj);

        /*
         * Create /AP - entry stuff.

        appearance_stream->append("ET\n");
        appearance_stream->append("EMC\n");

        Dict *appearance_stream_dic = new Dict(xref);
        appearance_stream_dic.initDict(xref);

        /*
         * Appearance stream dic.
         * See: 4.9 Form XObjects
         * TABLE 4.41 Additional entries specific to a type 1 form dictionary
         */
        appearance_stream_dic->set("Type", Object(objName,"XObject"));
        appearance_stream_dic->set("Subtype", Object(objName,"Form"));
        appearance_stream_dic->set("FormType", Object((int)1));
        appearance_stream_dic->set("Resources", Object(resref.num, resref.gen));
        obj_ref_x.initRef(resref.num, resref.gen);
        appearance_stream_dic.dictSet("Resources", &obj_ref_x);

        /* BBox array: TODO. currently out of the head. */
	Array *array = new Array(xref);
        array->add(Object((double)0));
        array->add(Object((double)0));
        array->add(Object((double)237));
        array->add(Object((double)25));
        appearance_stream_dic->set("BBox", Object(array));
        appearance_stream_dic->set("Length", Object((int)appearance_stream->getLength()));
        el.initReal(237);
        array.arrayAdd(&el);
        el.initReal(25);
        array.arrayAdd(&el);
        appearance_stream_dic.dictSet("BBox", &array);
        appearance_stream_dic.dictSet("Length", int_object(appearance_stream->getLength()));

        MemStream *mem_stream = new MemStream(appearance_stream->getCString(),
                0, appearance_stream->getLength(), Object(appearance_stream_dic));

        /* Make obj stream */
        Object stream = Object(static_cast<Stream*>(mem_stream));
        stream.initStream(mem_stream);

        Ref r;
        r = xref->addIndirectObject(&stream);

        /* Update Xref table */
        Object obj_ref;
        obj_ref.initRef(r.num, r.gen);

        /* 
         * Fill Annotation's appearance streams dic /AP
         * See: 8.4.4 Appearance Streams
         */
        Dict *appearance_streams_dic = new Dict(xref);
        appearance_streams_dic->set("N", Object(r.num, r.gen));
        appearance_streams_dic.dictSet("N", &obj_ref);

        field_obj->getDict()->set("AP", Object(appearance_streams_dic));

        /* Notify poppler about changes */
        xref->setModifiedObject(field_obj, field_ref);

     * OpenOffice - by default sets it to 'true'.
     */
    Object *obj_form = catalog->getAcroForm();
    obj_form->dictSet("NeedAppearances", Object(gFalse));
    obj1.initBool(gFalse);
    obj_form->dictSet("NeedAppearances", &obj1);
    /* Add AccroForm as indirect obj */
    Ref ref_form = xref->addIndirectObject(obj_form);

    /*
     * So update Catalog object.
     */
    Object catObj = xref->getCatalog();
    catObj = xref->getCatalog(catObj);
    Ref catRef;
    catRef.gen = xref->getRootGen();
    catRef.num = xref->getRootNum();
    catObj.dictSet("AcroForm", Object(ref_form.num, ref_form.gen));
    xref->setModifiedObject(&catObj, catRef);
    catObj->dictSet("AcroForm", &obj2);
    xref->setModifiedObject(catObj, catRef);

    /* Success */
    return 1;

    XRef *xref = doc->getXRef();

    /* Font dictionary object for embeded font */
    Dict *f_dic = new Dict(xref);
    f_dic->set("Type", Object(objName,"Font"));
    f_dic.dictSet("Type", name_object("Font"));

    /* Stream lenght */
    f_dic->set("Length", Object((int)outlen));

    /* Lenght for EMB_FMT_TTF font type */
    if ( Font->outtype == EMB_FMT_TTF ) {
        f_dic->set("Length1", Object((int)outlen));
    }

    /* Add font subtype */
    const char *subtype = emb_pdf_get_fontfile_subtype(Font);
    if ( subtype ) {
        f_dic->set("Subtype", Object(objName,copyString(subtype)));
    }

    /* Create memory stream font. Add it to font dic. */
    MemStream *mem_stream = new MemStream(font_stream->getCString(),
            0, outlen, Object(f_dic));

    /* Make obj stream */
    Object stream = Object(static_cast<Stream*>(mem_stream));
    stream.initStream(mem_stream);

    Ref r;


    r = xref->addIndirectObject(&stream);

    /* Get page object */
    Object pageobj;
    Ref pageref = page->getRef();
    Object pageobj = xref->fetch(pageref.num, pageref.gen);
    if (!pageobj.isDict()) {
        fprintf(stderr, "Error: malformed pdf. (in pdf_embed_font pags is not a dict)\n");
        return 0;
    }


    Ref resref;
    Object *ret = get_resource_dict(xref, pageobj.getDict(), &resdict, &resref);
    if ( !ret ) {
        fprintf(stderr, "Error: malformed pdf. (in pdf_embed_font could not get resource dict\n");
        pageobj.free();
        return 0;
    }

    /* Dictionary for all fonts in page's resources */
    Object fonts = resdict.dictLookupNF("Font");

    resdict.dictLookupNF("Font", &fonts);
    if (fonts.isNull()) {
        /* Create new one, if doesn't exists */
	Dict* d = new Dict(xref);
        resdict.dictSet("Font", Object(d));
	fonts = Object(d);
        fprintf(stderr, "Create new font dict in page's resources.\n");
    }


    r = xref->addIndirectObject(cidfont_resource_dic);

    /* r - cid resource dic */
    Object font_res_obj_ref;
    font_res_obj_ref.initRef(r.num, r.gen);

    Object *fonts_dic;
    Object dereferenced_obj;

        fonts_dic = &fonts;
    } else if ( fonts.isRef() ) {
        /* "Font" resource is indirect reference object */
        dereferenced_obj = xref->fetch(fonts.getRefNum(), fonts.getRefGen());
        fonts_dic = &dereferenced_obj;
    }


    }

    /* Add to fonts dic new font */
    fonts_dic->dictSet("stanv_font", Object(r.num, r.gen));

    /* Notify poppler about changes in fonts dic */
    if ( fonts.isRef() ) {

    xref->setModifiedObject(&resdict, resref);
    fprintf(stderr, "Resource dict was changed.\n");

    pageobj.free();

    /* Success */
    return 1;
}

    XRef *xref = doc->getXRef();

    /* Font dictionary for embeded font */
    Object *dic = new Object( new Dict(xref));
    dic->initDict(xref);

    dic->dictSet("Type", Object(objName,"FontDescriptor"));
    dic->dictSet(
            "FontName",
            Object(objName,copyString(emb_pdf_escape_name(fdes->fontname,-1))));
    dic->dictSet("Flags", Object((int)fdes->flags));
    dic->dictSet("ItalicAngle", Object((int)fdes->italicAngle));
    dic->dictSet("Ascent", Object((int)fdes->ascent));
    dic->dictSet("Descent", Object((int)fdes->descent));
    dic->dictSet("CapHeight", Object((int)fdes->capHeight));
    dic->dictSet("StemV", Object((int)fdes->stemV));

    /* FontBox array */
    Array *array = new Array(xref);

    array->add(Object((double) fdes->bbxmin));
    array->add(Object((double) fdes->bbymin));
    array->add(Object((double) fdes->bbxmax));
    array->add(Object((double) fdes->bbymax));

    dic->dictSet("FontBBox", Object(array));
    el.initReal(fdes->bbymin);
    array.arrayAdd(&el);

    el.initReal(fdes->bbxmax);
    array.arrayAdd(&el);

    el.initReal(fdes->bbymax);
    array.arrayAdd(&el);

    dic->dictSet("FontBBox", &array);

    if (fdes->xHeight) {
        dic->dictSet("XHeight", Object((int)fdes->xHeight));
    }

    if (fdes->avgWidth) {
        dic->dictSet("AvgWidth", Object((int)fdes->avgWidth));
    }

    if (fdes->panose) {
        /* Font dictionary for embeded font */
        Dict *style_dic = new Dict(xref);
        style_dic.initDict(xref);

        Object panose;

        GooString *panose_str = new GooString(fdes->panose, 12);
        style_dic->set("Panose", Object(panose_str));
        style_dic.dictSet("Panose", &panose);

        dic->dictSet("Style", Object(style_dic));
    }

    dic->dictSet(emb_pdf_get_fontfile_key(emb), Object(fontfile_obj_ref.num, fontfile_obj_ref.gen));
    ref_obj.initRef(fontfile_obj_ref.num, fontfile_obj_ref.gen);
    dic->dictSet(emb_pdf_get_fontfile_key(emb), &ref_obj);

    return dic;
}

    /* Get XREF table */
    XRef *xref = doc->getXRef();

    Object *dic = new Object(new Dict(xref));
    dic->initDict(xref);

    dic->dictSet("Type", Object(objName,"Font"));
    dic->dictSet(
            "Subtype",
            Object(objName,copyString(emb_pdf_get_font_subtype(emb))));
    dic->dictSet(
            "BaseFont",
            Object(objName,copyString(emb_pdf_escape_name(fdes->fontname,-1))));

    dic->dictSet("FontDescriptor", Object(fontdescriptor_obj_ref.num, fontdescriptor_obj_ref.gen));
    ref_obj.initRef(fontdescriptor_obj_ref.num, fontdescriptor_obj_ref.gen);
    dic->dictSet("FontDescriptor", &ref_obj);

    if ( emb->plan & EMB_A_MULTIBYTE ) {
        assert(fwid->warray);

        Dict * CIDSystemInfo_dic = new Dict(xref);
        CIDSystemInfo_dic.initDict(xref);

        Object registry;
        Object ordering;

        GooString *str;

        str = new GooString(copyString(fdes->registry));
        CIDSystemInfo_dic->set("Registry", Object(str));
        CIDSystemInfo_dic.dictSet("Registry", &registry);

        str = new GooString(copyString(fdes->ordering));
        CIDSystemInfo_dic->set("Ordering", Object(str));

        CIDSystemInfo_dic->set("Supplement", Object((int)fdes->supplement));

        dic->dictSet("CIDSystemInfo", Object(CIDSystemInfo_dic));

        dic->dictSet("DW", Object((int)fwid->default_width));
        dic->dictSet("DW", int_object(fwid->default_width));
    }

    return dic;

    /* Get XREF table */
    XRef *xref = doc->getXRef();

    Object *dic = new Object(new Dict(xref));
    dic->initDict(xref);

    dic->dictSet("Type", Object(objName,("Font")));
    dic->dictSet("Subtype", Object(objName,("Type0")));


    GooString * basefont = new GooString();

    basefont->append((addenc[0])?encoding:"");

    dic->dictSet("BaseFont",
            Object(objName,(copyString(basefont->getCString()))));

    dic->dictSet("Encoding", Object(objName,(copyString(encoding))));


    Array *array = new Array(xref);
    array->add(Object(fontdescriptor_obj_ref.num, fontdescriptor_obj_ref.gen));

    dic->dictSet("DescendantFonts", Object(array));
    array.arrayAdd(&obj);

    dic->dictSet("DescendantFonts", &array);

    return dic;
}

Return to bug 629708