예제 #1
0
파일: p_gstate.c 프로젝트: xharbour/core
void
pdf_setdashpattern_internal(PDF *p, pdc_scalar *darray, int length,
                            pdc_scalar phase)
{
    pdf_gstate *gs = &p->curr_ppt->gstate[p->curr_ppt->sl];

    /* length == 0 or 1 means solid line */
    if (length < 2)
    {
        if (gs->dashed || PDF_FORCE_OUTPUT())
        {
            pdc_puts(p->out, "[] 0 d\n");
            gs->dashed = pdc_false;
        }
    }
    else
    {
        int i;

	pdc_begin_array(p->out);
        for (i = 0; i < length; i++)
        {
            pdc_printf(p->out, "%f ", darray[i]);
        }
	pdc_end_array_c(p->out);
        pdc_printf(p->out, "%f d\n", phase);
        gs->dashed = pdc_true;
    }
}
예제 #2
0
파일: p_color.c 프로젝트: LuaDist/cd
void
pdf_write_colorspace(PDF *p, int slot, pdc_bool direct)
{
    static const char *fn = "pdf_write_colorspace";

    pdf_colorspace *cs;
    int base;

    if (slot < 0 || slot >= p->colorspaces_number)
	pdc_error(p->pdc, PDF_E_INT_BADCS, fn,
            pdc_errprintf(p->pdc, "%d", slot),
            "(unknown)", 0);

    cs = &p->colorspaces[slot];

    /* we always write simple colorspaces directly */
    if (PDF_SIMPLE_COLORSPACE(cs))
	direct = pdc_true;

    if (!direct) {
	pdc_objref_c(p->out, cs->obj_id);
	return;
    }

    switch (cs->type) {
	case DeviceGray:
	pdc_printf(p->out, "/DeviceGray");
	break;

	case DeviceRGB:
	pdc_printf(p->out, "/DeviceRGB");
	break;

	case DeviceCMYK:
	pdc_printf(p->out, "/DeviceCMYK");
	break;


	case Indexed:
	base = cs->val.indexed.base;

	pdc_begin_array(p->out);
	pdc_puts(p->out, "/Indexed");

	pdf_write_colorspace(p, base, pdc_false);

	pdc_printf(p->out, " %d", cs->val.indexed.palette_size - 1);
	pdc_objref_c(p->out, cs->val.indexed.colormap_id);
	pdc_end_array_c(p->out);
	break;

	case PatternCS:
	pdc_begin_array(p->out);
	pdc_printf(p->out, "/Pattern");
	pdf_write_colorspace(p, cs->val.pattern.base, pdc_false);
	pdc_end_array(p->out);
	break;

	default:
	pdc_error(p->pdc, PDF_E_INT_BADCS, fn,
	    pdc_errprintf(p->pdc, "%d", slot),
	    pdc_errprintf(p->pdc, "%d", cs->type), 0);
    }
} /* pdf_write_colorspace */
예제 #3
0
void
pdf_write_doc_extgstates(PDF *p)
{
    int i, j;

    pdf_extgstateresource *gs;

    for (i = 0; i < p->extgstates_number; i++)
    {
	gs = &p->extgstates[i];

	pdc_begin_obj(p->out, gs->obj_id);		/* ExtGState resource */
	pdc_begin_dict(p->out);

	pdc_puts(p->out, "/Type/ExtGState\n");

	if (gs->font_obj != PDC_NEW_ID)
	{
	    pdc_puts(p->out, "/Font");
	    pdc_begin_array(p->out);
	    pdc_objref(p->out, "", gs->font_obj);
	    pdc_printf(p->out, "%f", gs->font_size);
	    pdc_end_array(p->out);
	}

        if (gs->line_width != pdc_undef)
	    pdc_printf(p->out, "/LW %f\n", gs->line_width);

        if (gs->line_cap != pdc_undef)
	    pdc_printf(p->out, "/LC %d\n", gs->line_cap);

        if (gs->line_join != pdc_undef)
	    pdc_printf(p->out, "/LJ %d\n", gs->line_join);

        if (gs->miter_limit != pdc_undef)
	    pdc_printf(p->out, "/ML %f\n", gs->miter_limit);

	if (gs->dash_count > 0)
	{
	    pdc_printf(p->out, "/D");
	    pdc_begin_array(p->out);
	    pdc_begin_array(p->out);

	    for (j = 0; j < gs->dash_count; ++j)
		pdc_printf(p->out, "%f ", gs->dash_array[j]);

	    pdc_end_array_c(p->out);
            pdc_printf(p->out, "%f", gs->dash_phase);
	    pdc_end_array(p->out);
            /* but see page 157 of PDF Reference: integer */
	}

	if (gs->ri != AutoIntent)
            pdc_printf(p->out, "/RI/%s\n",
                pdc_get_keyword((long) gs->ri, pdf_renderingintent_pdfkeylist));

        if (gs->stroke_adjust != pdc_undef)
	    pdc_printf(p->out, "/SA %s\n", PDC_BOOLSTR(gs->stroke_adjust));

        if (gs->overprint_stroke != pdc_undef)
            pdc_printf(p->out, "/OP %s\n", PDC_BOOLSTR(gs->overprint_stroke));

        if (gs->overprint_fill != pdc_undef)
            pdc_printf(p->out, "/op %s\n", PDC_BOOLSTR(gs->overprint_fill));
        else if (gs->overprint_stroke == pdc_true)
            pdc_puts(p->out, "/op false\n");

        if (gs->overprint_mode != pdc_undef)
	    pdc_printf(p->out, "/OPM %d\n", gs->overprint_mode);

        if (gs->flatness != pdc_undef)
	    pdc_printf(p->out, "/FL %f\n", gs->flatness);

        if (gs->smoothness != pdc_undef)
	    pdc_printf(p->out, "/SM %f\n", gs->smoothness);

        if (gs->opacity_fill != pdc_undef)
	    pdc_printf(p->out, "/ca %f\n", gs->opacity_fill);

	if (gs->blendmode != BM_None) {
            const char *modename;
	    int modecount=0;

	    for (j = 0; ; j++) {
                if (!pdf_blendmode_pdfkeylist[j].word)
		    break;
                if (gs->blendmode & pdf_blendmode_pdfkeylist[j].code)
                    modecount++;
            }

	    pdc_printf(p->out, "/BM");

	    /*
	     * ACROBUG: Acrobat 7 doesn't like Blend mode arrays with a
	     * singly entry under some circumstances (many entries? images
	     * involved?) so we avoid the array if we have only one entry.
	     */
	    if (modecount > 1)
		pdc_begin_array(p->out);

	    for (j = 0; ; j++) {
                modename = pdf_blendmode_pdfkeylist[j].word;
                if (!modename) break;
                if (gs->blendmode & pdf_blendmode_pdfkeylist[j].code)
                    pdc_printf(p->out, "/%s", modename);
            }

	    if (modecount > 1)
		pdc_end_array(p->out);
	}

        if (gs->opacity_stroke != pdc_undef)
	    pdc_printf(p->out, "/CA %f\n", gs->opacity_stroke);

        if (gs->alpha_is_shape != pdc_undef)
	    pdc_printf(p->out, "/AIS %s\n", PDC_BOOLSTR(gs->alpha_is_shape));

        if (gs->text_knockout != pdc_undef)
	    pdc_printf(p->out, "/TK %s\n", PDC_BOOLSTR(gs->text_knockout));

	pdc_end_dict(p->out);
	pdc_end_obj(p->out);			/* ExtGState resource */
    }
}