Ejemplo n.º 1
0
/* setcolor */
int
gs_setcolor(gs_state * pgs, const gs_client_color * pcc)
{
    gs_color_space *    pcs = pgs->color[0].color_space;
    gs_client_color     cc_old = *pgs->color[0].ccolor;
    gx_device_color *dev_color = pgs->color[0].dev_color;
    bool do_unset  = true;

    if (pgs->in_cachedevice)
        return_error(gs_error_undefined); /* PLRM3 page 215. */
    if (dev_color->ccolor_valid && gx_dc_is_pure(dev_color)) {      /* change of colorspace will set type to _none */
        int i;
        int ncomps = cs_num_components(pcs);

        for(i=0; i < ncomps; i++)
            if (dev_color->ccolor.paint.values[i] != pcc->paint.values[i])
                break;
        do_unset = i < ncomps;      /* if i == ncomps, color unchanged, optimized */
    }
    if (do_unset)
        gx_unset_dev_color(pgs);
    (*pcs->type->adjust_color_count)(pcc, pcs, 1);
    *pgs->color[0].ccolor = *pcc;
    (*pcs->type->restrict_color)(pgs->color[0].ccolor, pcs);
    (*pcs->type->adjust_color_count)(&cc_old, pcs, -1);

    return 0;
}
Ejemplo n.º 2
0
static gx_color_index
svg_get_color(gx_device_svg *svg, const gx_drawing_color *pdc)
{

    gx_color_index color = gx_no_color_index;

    if (gx_dc_is_pure(pdc))
	color = gx_dc_pure_color(pdc);
    return color;
}
Ejemplo n.º 3
0
static char *
svg_make_color(gx_device_svg *svg, const gx_drawing_color *pdc)
{
    char *paint = (char *)gs_alloc_string(svg->memory, 8, "svg_make_color");

    if (!paint) {
        gs_throw(gs_error_VMerror, "string allocation failed");
        return NULL;
    }

    if (gx_dc_is_pure(pdc)) {
        gx_color_index color = gx_dc_pure_color(pdc);
        sprintf(paint, "#%06x", (int)(color & 0xffffffL));
    } else if (gx_dc_is_null(pdc)) {
        sprintf(paint, "None");
    } else {
        gs_free_string(svg->memory, (byte *)paint, 8, "svg_make_color");
        gs_throw(gs_error_rangecheck, "unknown color type");
        return NULL;
    }

    return paint;
}
Ejemplo n.º 4
0
/*
 * Compare two saved colors to check if match.
 * This routine used to be a simple memcmp(), but
 * that is insufficient, the checks must be explicit.
 */
bool gx_hld_saved_color_equal(const gx_hl_saved_color * psc1,
                           const gx_hl_saved_color * psc2)
{

    int i;

    if (psc1->saved_dev_color.type != psc2->saved_dev_color.type
     || psc1->color_space_id != psc2->color_space_id
     || psc1->pattern_id != psc2->pattern_id
     || psc1->ccolor_valid != psc2->ccolor_valid
     || psc1->ccolor.pattern != psc2->ccolor.pattern
     || psc1->saved_dev_color.phase.x != psc2->saved_dev_color.phase.x
     || psc1->saved_dev_color.phase.y != psc2->saved_dev_color.phase.y) {

        return(false);
    }

    for (i = 0; i < GX_DEVICE_COLOR_MAX_COMPONENTS; i++) {
        if (psc1->ccolor.paint.values[i] != psc2->ccolor.paint.values[i]) {
            return(false);
        }
    }
    /* NAFF: only gx_dc_pure_masked doesn't have a type checker */
    if (gx_dc_is_pure(&psc1->saved_dev_color) || psc1->saved_dev_color.type == &gx_dc_pure_masked) {
        if (psc1->saved_dev_color.colors.pure != psc2->saved_dev_color.colors.pure) {
            return(false);
        }
    }
    else if (gx_dc_is_binary_halftone(&psc1->saved_dev_color)) {

        if ((psc1->saved_dev_color.colors.binary.b_color[0] != psc2->saved_dev_color.colors.binary.b_color[0])
             || (psc1->saved_dev_color.colors.binary.b_color[1] != psc2->saved_dev_color.colors.binary.b_color[1])
             || (psc1->saved_dev_color.colors.binary.b_level != psc2->saved_dev_color.colors.binary.b_level)
             || (psc1->saved_dev_color.colors.binary.b_index != psc2->saved_dev_color.colors.binary.b_index)) {

            return(false);
        }
    }
    else if (gx_dc_is_colored_halftone(&psc1->saved_dev_color)) {

        for (i = 0; i < GX_DEVICE_COLOR_MAX_COMPONENTS; i++) {
            if (psc1->saved_dev_color.colors.colored.c_base[i] != psc2->saved_dev_color.colors.colored.c_base[i]
              || psc1->saved_dev_color.colors.colored.c_level[i] != psc2->saved_dev_color.colors.colored.c_level[i]) {

                return(false);
            }
        }
    }
    else if (gx_dc_is_devn(&psc1->saved_dev_color)) {

        for (i = 0; i < GX_DEVICE_COLOR_MAX_COMPONENTS; i++) {
             if (psc1->saved_dev_color.colors.devn.values[i] != psc2->saved_dev_color.colors.devn.values[i]) {

                 return(false);
             }
        }
    }
    else if (gx_dc_is_pattern1_color((gx_device_color *)(&psc1->saved_dev_color.type))) {

        if (psc1->saved_dev_color.colors.pattern.id != psc2->saved_dev_color.colors.pattern.id
         || psc1->saved_dev_color.colors.pattern.phase.x != psc2->saved_dev_color.colors.pattern.phase.x
         || psc1->saved_dev_color.colors.pattern.phase.y != psc2->saved_dev_color.colors.pattern.phase.y) {

            return(false);
        }
    }
    else if (gx_dc_is_pattern2_color((gx_device_color *)(&psc1->saved_dev_color.type))) {
        if (psc1->saved_dev_color.colors.pattern2.id != psc2->saved_dev_color.colors.pattern2.id
         || psc1->saved_dev_color.colors.pattern2.shfill != psc2->saved_dev_color.colors.pattern2.shfill) {

            return(false);
        }
    }

    return (true);
}