Esempio n. 1
0
IPv4Layer::IPv4Layer(const IPv4Address& srcIP, const IPv4Address& dstIP)
{
	initLayer();
	iphdr* ipHdr = getIPv4Header();
	ipHdr->ipSrc = srcIP.toInt();
	ipHdr->ipDst = dstIP.toInt();
}
Esempio n. 2
0
static void msContourLayerInfoInitialize(layerObj *layer)
{
  contourLayerInfo *clinfo = (contourLayerInfo *) layer->layerinfo;

  if (clinfo != NULL)
    return;

  clinfo = (contourLayerInfo *) msSmallCalloc(1,sizeof(contourLayerInfo));
  layer->layerinfo = clinfo;
  clinfo->hOrigDS = NULL;  
  clinfo->hDS = NULL;
  clinfo->extent.minx = -1.0;
  clinfo->extent.miny = -1.0;
  clinfo->extent.maxx = -1.0;
  clinfo->extent.maxy = -1.0;
  
  initLayer(&clinfo->ogrLayer, layer->map);
  clinfo->ogrLayer.type = layer->type;
  clinfo->ogrLayer.debug = layer->debug;
  clinfo->ogrLayer.connectiontype = MS_OGR;
  clinfo->ogrLayer.name = msStrdup(layer->name);
  clinfo->ogrLayer.connection = (char*)msSmallMalloc(strlen(clinfo->ogrLayer.name)+13);
  sprintf(clinfo->ogrLayer.connection, "__%s_CONTOUR__", clinfo->ogrLayer.name);
  clinfo->ogrLayer.units = layer->units;
}
Esempio n. 3
0
layerObj *layerObj_clone(layerObj *layer)
{
    layerObj *dstLayer;
    dstLayer = (layerObj *)malloc(sizeof(layerObj));
    initLayer(dstLayer, layer->map);
    msCopyLayer(dstLayer, layer);
}
Esempio n. 4
0
bool PVEFightResultLayer::init()
{
	bool bRet=false;
	do 
	{
		initLayer();
		bRet=true;
	} while (0);
	return bRet;
}
Esempio n. 5
0
/**********************************************************************
 * class extensions for layerObj, always within the context of a map
 **********************************************************************/
layerObj *layerObj_new(mapObj *map) {
    if(msGrowMapLayers(map) == NULL)
      return(NULL);

    if(initLayer((map->layers[map->numlayers]), map) == -1)
      return(NULL);

    map->layers[map->numlayers]->index = map->numlayers;
    //Update the layer order list with the layer's index.
    map->layerorder[map->numlayers] = map->numlayers;

    map->numlayers++;

    return (map->layers[map->numlayers-1]);
  }
bool PortRepairLayer::init()
{
    bool bRet=false;
    do
    {
        if (!Layer::init()) {
            break;
        }
        initLayer();
        initContainer();

        bRet=true;
    } while(0);
    return bRet;
}
Esempio n. 7
0
bool MainLayer::init()
{
	if (!Layer::init())
		return false;
	_angle = 0.0f;

	auto dispatcher = Director::getInstance()->getEventDispatcher();
	auto listener = EventListenerTouchOneByOne::create();
	listener->setSwallowTouches(true);
	listener->onTouchBegan = CC_CALLBACK_2(MainLayer::onTouchBegan, this);
	listener->onTouchMoved = CC_CALLBACK_2(MainLayer::onTouchMoved, this);
	listener->onTouchEnded = CC_CALLBACK_2(MainLayer::onTouchEnded, this);
	dispatcher->addEventListenerWithSceneGraphPriority(listener, this);
	initLayer();
	return true;
}
Esempio n. 8
0
int msEmbedScalebar(mapObj *map, imageObj *img)
{
    int l,index,s;
    pointObj point;
    imageObj *image = NULL;
    rendererVTableObj *renderer = MS_MAP_RENDERER(map);
    symbolObj *embededSymbol;

    if( ! renderer ) {
        msSetError(MS_MISCERR,"unsupported outputformat","msEmbedScalebar()");
        return MS_FAILURE;
    }
    index = msGetSymbolIndex(&(map->symbolset), "scalebar", MS_FALSE);
    if(index != -1)
        msRemoveSymbol(&(map->symbolset), index); /* remove cached symbol in case the function is called multiple
                      times with different zoom levels */

    if((embededSymbol=msGrowSymbolSet(&map->symbolset)) == NULL)
        return MS_FAILURE;
    s = map->symbolset.numsymbols;
    map->symbolset.numsymbols++;

    image = msDrawScalebar(map);
    if(!image) {
        return MS_FAILURE;
    }
    embededSymbol->pixmap_buffer = calloc(1,sizeof(rasterBufferObj));
    MS_CHECK_ALLOC(embededSymbol->pixmap_buffer, sizeof(rasterBufferObj), MS_FAILURE);

    if(MS_SUCCESS != renderer->getRasterBufferCopy(image,embededSymbol->pixmap_buffer)) {
        return MS_FAILURE;
    }

    embededSymbol->type = MS_SYMBOL_PIXMAP; /* intialize a few things */
    embededSymbol->name = msStrdup("scalebar");
    embededSymbol->sizex = embededSymbol->pixmap_buffer->width;
    embededSymbol->sizey = embededSymbol->pixmap_buffer->height;
    if(map->scalebar.transparent) {
        embededSymbol->transparent = MS_TRUE;
        embededSymbol->transparentcolor = 0;
    }

    switch(map->scalebar.position) {
    case(MS_LL):
        point.x = MS_NINT(embededSymbol->pixmap_buffer->width/2.0);
        point.y = map->height - MS_NINT(embededSymbol->pixmap_buffer->height/2.0);
        break;
    case(MS_LR):
        point.x = map->width - MS_NINT(embededSymbol->pixmap_buffer->width/2.0);
        point.y = map->height - MS_NINT(embededSymbol->pixmap_buffer->height/2.0);
        break;
    case(MS_LC):
        point.x = MS_NINT(map->width/2.0);
        point.y = map->height - MS_NINT(embededSymbol->pixmap_buffer->height/2.0);
        break;
    case(MS_UR):
        point.x = map->width - MS_NINT(embededSymbol->pixmap_buffer->width/2.0);
        point.y = MS_NINT(embededSymbol->pixmap_buffer->height/2.0);
        break;
    case(MS_UL):
        point.x = MS_NINT(embededSymbol->pixmap_buffer->width/2.0);
        point.y = MS_NINT(embededSymbol->pixmap_buffer->height/2.0);
        break;
    case(MS_UC):
        point.x = MS_NINT(map->width/2.0);
        point.y = MS_NINT(embededSymbol->pixmap_buffer->height/2.0);
        break;
    }

    l = msGetLayerIndex(map, "__embed__scalebar");
    if(l == -1) {
        if (msGrowMapLayers(map) == NULL)
            return(-1);
        l = map->numlayers;
        map->numlayers++;
        if(initLayer((GET_LAYER(map, l)), map) == -1) return(-1);
        GET_LAYER(map, l)->name = msStrdup("__embed__scalebar");
        GET_LAYER(map, l)->type = MS_LAYER_POINT;

        if (msGrowLayerClasses( GET_LAYER(map, l) ) == NULL)
            return(-1);

        if(initClass(GET_LAYER(map, l)->class[0]) == -1) return(-1);
        GET_LAYER(map, l)->numclasses = 1; /* so we make sure to free it */

        /* update the layer order list with the layer's index. */
        map->layerorder[l] = l;
    }

    GET_LAYER(map, l)->status = MS_ON;
    if(map->scalebar.postlabelcache) { /* add it directly to the image */
        if(msMaybeAllocateClassStyle(GET_LAYER(map, l)->class[0], 0)==MS_FAILURE) return MS_FAILURE;
        GET_LAYER(map, l)->class[0]->styles[0]->symbol = s;
        msDrawMarkerSymbol(&map->symbolset, img, &point, GET_LAYER(map, l)->class[0]->styles[0], 1.0);
    } else {
        if(!GET_LAYER(map, l)->class[0]->labels) {
Esempio n. 9
0
void NodeCom::initWithMap(rapidjson::Value& value)
{
    auto visibleSize=Director::getInstance()->getVisibleSize();
    
    node=cocos2d::Node::create();
    if (value.HasMember("contentSize")) {
        auto size=cocos2d::SizeFromString(value["contentSize"].GetString());
        if (size.width<0)
            size.width=visibleSize.width;
        
        if (size.height<0)
            size.height=visibleSize.height;
        
        node->setContentSize(size);
    }
    else {
        node->setContentSize(visibleSize);
    }
    
    if (value.HasMember("anchorPoint")) {
        node->setAnchorPoint(cocos2d::PointFromString(value["anchorPoint"].GetString()));
    }
        
    cocos2d::Point position=value.HasMember("position")?cocos2d::PointFromString(value["position"].GetString()):cocos2d::Point::ZERO;
    if (value.HasMember("anchor")) {
        node->setPosition(getRealPosition(cocos2d::Director::getInstance()->getVisibleSize(),
                                              position,
                                              cocos2d::PointFromString(value["anchor"].GetString())));
    }
    else if (value.HasMember("position")) {
        node->setPosition(cocos2d::PointFromString(value["position"].GetString()));
    }

    if (value.HasMember("Node")) {
        
        int count=value["Node"].Size();
        for (int i=0; i<count; i++) {
            rapidjson::Value& nodeValue=value["Node"][i];
            if (!nodeValue.IsNull()&&nodeValue.HasMember("type")) {
                const char* type=nodeValue["type"].GetString();
                cocos2d::Node* child=nullptr;
                
                if (strcmp("Label", type)==0) {
                    child=initLabel(nodeValue);
                }
                else if (strcmp("Sprite", type)==0) {
                    child=initSprite(nodeValue);
                }
                else if (strcmp("Layer", type)==0) {
                    child=initLayer(nodeValue);
                }
                else if (strcmp("Button", type)==0) {
                    child=initButton(nodeValue);
                }
                else if (strcmp("TableView", type)==0){
                    child=initTable(nodeValue);
                }
                else if (strcmp("ProgressTimer", type)==0){
                    child=initTimer(nodeValue);
                }
                    
                
                if (child!=nullptr) {
                    node->addChild(child);

                    if (nodeValue.HasMember("name")) {
                        const char* name= nodeValue["name"].GetString();
                        __nodeNames.insert(std::make_pair(name, child));
                    }
                    
                    if (nodeValue.HasMember("scale")) {
                        cocos2d::Point point=cocos2d::PointFromString(nodeValue["scale"].GetString());
                        child->setScale(point.x, point.y);
                    }

                    if (nodeValue.HasMember("position")) {
                        child->setPosition(cocos2d::PointFromString(nodeValue["position"].GetString()));
                    }
                    
                    if (nodeValue.HasMember("anchorPoint")) {
                        child->setAnchorPoint(cocos2d::PointFromString(nodeValue["anchorPoint"].GetString()));
                    }
                    
                    if (nodeValue.HasMember("localZOrder")) {
                        child->setLocalZOrder(nodeValue["localZOrder"].GetInt());
                    }
                    
                    if (nodeValue.HasMember("globalOrder")) {
                        child->setGlobalZOrder(nodeValue["globalOrder"].GetInt());
                    }
                    
                    if (nodeValue.HasMember("visible")) {
                        child->setVisible(nodeValue["visible"].GetBool());
                    }

                    if (nodeValue.HasMember("tag")) {
                        child->setTag(nodeValue["tag"].GetInt());
                    }
                    
                    //如果声明了anchor,则按照新的规则布局
                    cocos2d::Point position1=nodeValue.HasMember("position")? cocos2d::PointFromString(nodeValue["position"].GetString()):cocos2d::Point::ZERO;
                    if (nodeValue.HasMember("anchor")) {
                        child->setPosition(getRealPosition(node->getContentSize(), position1, cocos2d::PointFromString(nodeValue["anchor"].GetString())));
                    }
                    else if (nodeValue.HasMember("position")) {
                        child->setPosition(position1);
                    }
                }
            }
        }
    }
}
Esempio n. 10
0
IPv4Layer::IPv4Layer()
{
	initLayer();
}
Esempio n. 11
0
KisImportExportFilter::ConversionStatus KisXCFImport::loadFromDevice(QIODevice* device, KisDocument* doc)
{
    dbgFile << "Start decoding file";
    // Read the file into memory
    device->open(QIODevice::ReadOnly);
    QByteArray data = device->readAll();
    xcf_file = (uint8_t*)data.data();
    xcf_length = data.size();
    device->close();

    // Decode the data
    getBasicXcfInfo() ;
    initColormap();

    dbgFile << XCF.version << "width = " << XCF.width << "height = " << XCF.height << "layers = " << XCF.numLayers;

    // Create the image
    KisImageSP image = new KisImage(doc->createUndoStore(), XCF.width, XCF.height, KoColorSpaceRegistry::instance()->rgb8(), "built image");

    QVector<Layer> layers;
    uint maxDepth = 0;

    // Read layers
    for (int i = 0; i < XCF.numLayers; ++i) {

        Layer layer;

        xcfLayer& xcflayer = XCF.layers[i];
        dbgFile << i << " name = " << xcflayer.name << " opacity = " << xcflayer.opacity << "group:" << xcflayer.isGroup << xcflayer.pathLength;
        dbgFile << ppVar(xcflayer.dim.width) << ppVar(xcflayer.dim.height) << ppVar(xcflayer.dim.tilesx) << ppVar(xcflayer.dim.tilesy) << ppVar(xcflayer.dim.ntiles) << ppVar(xcflayer.dim.c.t) << ppVar(xcflayer.dim.c.l) << ppVar(xcflayer.dim.c.r) << ppVar(xcflayer.dim.c.b);

        maxDepth = qMax(maxDepth, xcflayer.pathLength);

        bool isRgbA = false;
        // Select the color space
        const KoColorSpace* colorSpace = 0;
        switch (xcflayer.type) {
        case GIMP_INDEXED_IMAGE:
        case GIMP_INDEXEDA_IMAGE:
        case GIMP_RGB_IMAGE:
        case GIMP_RGBA_IMAGE:
            colorSpace = KoColorSpaceRegistry::instance()->rgb8();
            isRgbA = true;
            break;
        case GIMP_GRAY_IMAGE:
        case GIMP_GRAYA_IMAGE:
            colorSpace = KoColorSpaceRegistry::instance()->colorSpace(GrayAColorModelID.id(), Integer8BitsColorDepthID.id(), "");
            isRgbA = false;
            break;
        }

        // Create the layer
        KisLayerSP kisLayer;
        if (xcflayer.isGroup) {
            kisLayer = new KisGroupLayer(image, QString::fromUtf8(xcflayer.name), xcflayer.opacity);
        }
        else {
            kisLayer = new KisPaintLayer(image, QString::fromUtf8(xcflayer.name), xcflayer.opacity, colorSpace);
        }

        // Set some properties
        kisLayer->setCompositeOpId(layerModeG2K(xcflayer.mode));
        kisLayer->setVisible(xcflayer.isVisible);
        kisLayer->disableAlphaChannel(xcflayer.mode != GIMP_NORMAL_MODE);

        layer.layer = kisLayer;
        layer.depth = xcflayer.pathLength;

        // Copy the data in the image
        initLayer(&xcflayer);

        int left = xcflayer.dim.c.l;
        int top = xcflayer.dim.c.t;

        if (!xcflayer.isGroup) {

            // Copy the data;
            for (unsigned int x = 0; x < xcflayer.dim.width; x += TILE_WIDTH) {
                for (unsigned int y = 0; y < xcflayer.dim.height; y += TILE_HEIGHT) {
                    rect want;
                    want.l = x + left;
                    want.t = y + top;
                    want.b = want.t + TILE_HEIGHT;
                    want.r = want.l + TILE_WIDTH;
                    Tile* tile = getMaskOrLayerTile(&xcflayer.dim, &xcflayer.pixels, want);
                    KisHLineIteratorSP it = kisLayer->paintDevice()->createHLineIteratorNG(x, y, TILE_WIDTH);
                    rgba* data = tile->pixels;
                    for (int v = 0; v < TILE_HEIGHT; ++v) {
                        if (isRgbA) {
                            // RGB image
                           do {
                                KoBgrTraits<quint8>::setRed(it->rawData(), GET_RED(*data));
                                KoBgrTraits<quint8>::setGreen(it->rawData(), GET_GREEN(*data));
                                KoBgrTraits<quint8>::setBlue(it->rawData(), GET_BLUE(*data));
                                KoBgrTraits<quint8>::setOpacity(it->rawData(), quint8(GET_ALPHA(*data)), 1);
                                ++data;
                            } while (it->nextPixel());
                        } else {
                            // Grayscale image
                            do {
                                it->rawData()[0] = GET_RED(*data);
                                it->rawData()[1] = GET_ALPHA(*data);
                                ++data;
                            } while (it->nextPixel());
                        }
                        it->nextRow();
                    }
                }
            }

            // Move the layer to its position
            kisLayer->paintDevice()->setX(left);
            kisLayer->paintDevice()->setY(top);
        }
        // Create the mask
        if (xcflayer.hasMask) {
            KisTransparencyMaskSP mask = new KisTransparencyMask();
            layer.mask = mask;

            mask->initSelection(kisLayer);
            for (unsigned int x = 0; x < xcflayer.dim.width; x += TILE_WIDTH) {
                for (unsigned int y = 0; y < xcflayer.dim.height; y += TILE_HEIGHT) {
                    rect want;
                    want.l = x + left;
                    want.t = y + top;
                    want.b = want.t + TILE_HEIGHT;
                    want.r = want.l + TILE_WIDTH;
                    Tile* tile = getMaskOrLayerTile(&xcflayer.dim, &xcflayer.mask, want);
                    KisHLineIteratorSP it = mask->paintDevice()->createHLineIteratorNG(x, y, TILE_WIDTH);
                    rgba* data = tile->pixels;
                    for (int v = 0; v < TILE_HEIGHT; ++v) {
                        do {
                            it->rawData()[0] = GET_ALPHA(*data);
                            ++data;
                        } while (it->nextPixel());
                        it->nextRow();
                    }

                }
            }
            mask->paintDevice()->setX(left);
            mask->paintDevice()->setY(top);
            image->addNode(mask, kisLayer);
        }

        dbgFile << xcflayer.pixels.tileptrs;
        layers.append(layer);
    }

    for (int i = 0; i <= maxDepth; ++i) {
        addLayers(layers, image, i);
    }

    doc->setCurrentImage(image);
    return KisImportExportFilter::OK;
}
void
complete_flatspec(struct FlattenSpec *spec, guesser guess_callback)
{
    unsigned i ;
    int anyPartial ;

    /* Find the layers to convert.
     */
    if( spec->numLayers == 0 ) {
        spec->layers = XCF.layers ;
        spec->numLayers = XCF.numLayers ;
    } else {
        for( i=0; i<spec->numLayers; i++ ) {
            GimpLayerModeEffects mode ;
            int opacity, hasMask ;
            unsigned j ;

            for( j=0; ; j++ ) {
                if( j == XCF.numLayers )
                    FatalGeneric(22,_("The image has no layer called '%s'"),
                                 spec->layers[i].name);
                if( strcmp(spec->layers[i].name,XCF.layers[j].name) == 0 )
                    break ;
            }
            mode = spec->layers[i].mode == (GimpLayerModeEffects)-1 ?
                   XCF.layers[j].mode : spec->layers[i].mode ;
            opacity = spec->layers[i].opacity == 9999 ?
                      XCF.layers[j].opacity : spec->layers[i].opacity ;
            hasMask = spec->layers[i].hasMask == -1 ?
                      XCF.layers[j].hasMask : spec->layers[i].hasMask ;
            if( hasMask && !XCF.layers[j].hasMask &&
                    XCF.layers[j].mask.hierarchy == 0 )
                FatalGeneric(22,_("Layer '%s' has no layer mask to enable"),
                             spec->layers[i].name);
            spec->layers[i] = XCF.layers[j] ;
            spec->layers[i].mode = mode ;
            spec->layers[i].opacity = opacity ;
            spec->layers[i].hasMask = hasMask ;
            spec->layers[i].isVisible = 1 ;
        }
    }

    /* Force the mode of the lowest visible layer to be Normal or Dissolve.
     * That may not be logical, but the Gimp does it
     */
    for( i=0; i < spec->numLayers; i++ ) {
        if( spec->layers[i].isVisible ) {
            if( spec->layers[i].mode != GIMP_DISSOLVE_MODE )
                spec->layers[i].mode = GIMP_NORMAL_MODE ;
            break ;
        }
    }

    /* Mimic the Gimp's behavior on indexed layers */
    if( XCF.type == GIMP_INDEXED && spec->gimpish_indexed ) {
        for( i=0; i<spec->numLayers; i++ )
            if( spec->layers[i].mode != GIMP_DISSOLVE_MODE )
                spec->layers[i].mode = GIMP_NORMAL_NOPARTIAL_MODE ;
    } else
        spec->gimpish_indexed = 0 ;

    /* compute dimensions of the window */
    if( spec->window_mode == AUTOCROP ) {
        int first = 1 ;
        for( i=0; i<spec->numLayers; i++ )
            if( spec->layers[i].isVisible ) {
                computeDimensions(&spec->layers[i].dim) ;
                if( first ) {
                    spec->dim = spec->layers[i].dim ;
                    first = 0 ;
                } else {
                    if( spec->dim.c.l < spec->layers[i].dim.c.l )
                        spec->dim.c.l = spec->layers[i].dim.c.l ;
                    if( spec->dim.c.r > spec->layers[i].dim.c.r )
                        spec->dim.c.r = spec->layers[i].dim.c.r ;
                    if( spec->dim.c.t < spec->layers[i].dim.c.t )
                        spec->dim.c.t = spec->layers[i].dim.c.t ;
                    if( spec->dim.c.b > spec->layers[i].dim.c.b )
                        spec->dim.c.b = spec->layers[i].dim.c.b ;
                }
            }
        if( first ) {
            spec->window_mode = USE_CANVAS ;
        } else {
            spec->dim.width = spec->dim.c.r - spec->dim.c.l ;
            spec->dim.height = spec->dim.c.b - spec->dim.c.t ;
        }
    }
    if( spec->window_mode != AUTOCROP ) {
        if( (spec->window_mode & MANUAL_OFFSET) == 0 )
            spec->dim.c.t = spec->dim.c.l = 0 ;
        if( (spec->window_mode & MANUAL_CROP) == 0 ) {
            spec->dim.height = XCF.height ;
            spec->dim.width = XCF.width ;
        }
    }
    computeDimensions(&spec->dim);

    /* We can't handle negative coordinates properly, so abort rather than
     * crash chaotically. See CVE-2009-217; Debian bug #533361.
     */
    if( spec->dim.c.t < 0 || spec->dim.c.l < 0 ) {
        FatalUnsupportedXCF("This version cannot extract pixels above or to the "
                            "left of the canvas");
    }

    /* Turn off layers that we don't hit at all */
    for( i=0; i<spec->numLayers; i++ )
        if( spec->layers[i].isVisible &&
                disjointRects(spec->dim.c,spec->layers[i].dim.c) )
            spec->layers[i].isVisible = 0 ;

    /* See if there is a completely covering layer somewhere in the stack */
    /* Also check if partial transparency is possible */
    anyPartial = 0 ;
    for( i=spec->numLayers; i-- ; ) {
        if( !spec->layers[i].isVisible )
            continue ;
        if( typeHasTransparency(spec->layers[i].type) ) {
            if( spec->layers[i].mode == GIMP_NORMAL_MODE )
                anyPartial = 1;
        } else if( isSubrect(spec->dim.c,spec->layers[i].dim.c) &&
                   (spec->layers[i].mode == GIMP_NORMAL_MODE ||
                    spec->layers[i].mode == GIMP_NORMAL_NOPARTIAL_MODE ||
                    spec->layers[i].mode == GIMP_DISSOLVE_MODE) ) {
            /* This layer fills out the entire image.
             * Turn off anly lower layers, and note that we cannot have
             * transparency at all.
             */
            while(i) spec->layers[--i].isVisible = 0 ;
            if( spec->default_pixel != FORCE_ALPHA_CHANNEL )
                spec->default_pixel = NEWALPHA(colormap[0],255);
            anyPartial = 0 ;
            break ;
        }
    }
    if( spec->partial_transparency_mode == ALLOW_PARTIAL_TRANSPARENCY &&
            (!anyPartial || ALPHA(spec->default_pixel) >= 128) )
        spec->partial_transparency_mode = PARTIAL_TRANSPARENCY_IMPOSSIBLE ;

    /* Initialize layers and print overview if we're verbose */
    for( i=spec->numLayers; i--; )
        if( spec->layers[i].isVisible ) {
            initLayer(&spec->layers[i]) ;
            if( verboseFlag ) {
                fprintf(stderr,"%dx%d%+d%+d %s %s",
                        spec->layers[i].dim.width, spec->layers[i].dim.height,
                        spec->layers[i].dim.c.l - spec->dim.c.l,
                        spec->layers[i].dim.c.t - spec->dim.c.t,
                        _(showGimpImageType(spec->layers[i].type)),
                        _(showGimpLayerModeEffects(spec->layers[i].mode)));
                if( spec->layers[i].opacity < 255 )
                    fprintf(stderr,"/%02d%%",spec->layers[i].opacity * 100 / 255);
                if( XCF.layers[i].hasMask )
                    fprintf(stderr,_("/mask"));
                fprintf(stderr," %s\n",spec->layers[i].name);
            }
        }

    /* Resolve color mode unless we wait until we have the entire image */
    if( spec->out_color_mode == COLOR_BY_CONTENTS &&
            !spec->process_in_memory ) {
        if( guess_callback )
            spec->out_color_mode = guess_callback(spec,NULL);
        if( spec->out_color_mode == COLOR_BY_CONTENTS )
            spec->out_color_mode = color_by_layers(spec) ;
    }
}