Attachment #255 for bug #353

By default, Bugzilla does not search the list of RESOLVED bugs.
You can force it to do so by putting the upper-case word ALL in front of your search query, e.g.: ALL tdelibs
We recommend searching for bugs this way, as you may discover that your bug has already been resolved and fixed in a later release. View | Details | Raw Unified | Return to bug 353
Collapse All | Expand All




            image -> addAnnotation(annotation);
        }
#if 0
        for(int i = 0; i < src->generic_profiles; i++)
        {
            TQByteArray rawdata;

            image -> addAnnotation(annotation);
        }
#endif
        const ImageAttribute* imgAttr = GetImageAttribute(src, NULL);
        while(imgAttr)

            TQ_UINT8 opacity = OPACITY_OPAQUE;
            const ImageAttribute * attr = GetImageAttribute(image, "[layer-opacity]");
            if (attr != 0) {
                opacity = TQ_UINT8_MAX - ScaleQuantumToChar(TQString(attr->value).toInt());
            }
            KisPaintLayerSP layer = 0;

                        while (!hiter.isDone())
                        {
                            TQ_UINT8 *ptr= hiter.rawData();
                            *(ptr++) = ScaleQuantumToChar(pp->red); // cyan
                            *(ptr++) = ScaleQuantumToChar(pp->green); // magenta
                            *(ptr++) = ScaleQuantumToChar(pp->blue); // yellow
                            *(ptr++) = ScaleQuantumToChar(indexes[x]); // Black
// XXX: Warning! This ifdef messes up the paren matching big-time!
#ifdef HAVE_MAGICK6
                            if (image->matte != MagickFalse) {
#else
                            if (image->matte == true) {
#endif
                                *(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
                            }
                            else {
                                *(ptr++) = OPACITY_OPAQUE;

                            {
                                TQ_UINT8 *ptr= hiter.rawData();
                                // XXX: not colorstrategy and bitdepth independent
                                *(ptr++) = ScaleQuantumToChar(pp->blue);
                                *(ptr++) = ScaleQuantumToChar(pp->green);
                                *(ptr++) = ScaleQuantumToChar(pp->red);
                                *(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
                                pp++;
                                ++hiter;

                            {
                                TQ_UINT8 *ptr= hiter.rawData();
                                // XXX: not colorstrategy and bitdepth independent
                                *(ptr++) = ScaleQuantumToChar(pp->blue);
                                *(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
                                pp++;
                                ++hiter;

                    while (!it.isDone()) {
                        TQ_UINT8 * d = it.rawData();
                        pp -> red = ScaleCharToQuantum(d[PIXEL_CYAN]);
                        pp -> green = ScaleCharToQuantum(d[PIXEL_MAGENTA]);
                        pp -> blue = ScaleCharToQuantum(d[PIXEL_YELLOW]);
                        if (alpha)
                            pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_CMYK_ALPHA]);
                        indexes[x]= ScaleCharToQuantum(d[PIXEL_BLACK]);
                        x++;
                        pp++;

                    while (!it.isDone()) {
                        TQ_UINT8 * d = it.rawData();
                        pp -> red = ScaleCharToQuantum(d[PIXEL_RED]);
                        pp -> green = ScaleCharToQuantum(d[PIXEL_GREEN]);
                        pp -> blue = ScaleCharToQuantum(d[PIXEL_BLUE]);
                        if (alpha)
                            pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_ALPHA]);
                        pp++;
                        ++it;

                else {
                    while (!it.isDone()) {
                        TQ_UINT8 * d = it.rawData();
                        pp -> red = ScaleCharToQuantum(d[PIXEL_GRAY]);
                        pp -> green = ScaleCharToQuantum(d[PIXEL_GRAY]);
                        pp -> blue = ScaleCharToQuantum(d[PIXEL_GRAY]);
                        if (alpha)
                            pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_GRAY_ALPHA]);
                        pp++;
                        ++it;

Return to bug 353

Lines 182-187 Link Here

(-)koffice-1.6.3/filters/chalk/gmagick/kis_image_magick_converter.cc (-25 / +27 lines)
182	image -> addAnnotation(annotation);	182	image -> addAnnotation(annotation);
183	}	183	}
		184	#if 0
184	for(int i = 0; i < src->generic_profiles; i++)	185	for(int i = 0; i < src->generic_profiles; i++)
185	{	186	{
186	TQByteArray rawdata;	187	TQByteArray rawdata;
Lines 193-198 Link Here
193	image -> addAnnotation(annotation);	194	image -> addAnnotation(annotation);
194	}	195	}
		196	#endif
195	const ImageAttribute* imgAttr = GetImageAttribute(src, NULL);	197	const ImageAttribute* imgAttr = GetImageAttribute(src, NULL);
196	while(imgAttr)	198	while(imgAttr)
Lines 480-486 Link Here
480	TQ_UINT8 opacity = OPACITY_OPAQUE;	482	TQ_UINT8 opacity = OPACITY_OPAQUE;
481	const ImageAttribute * attr = GetImageAttribute(image, "[layer-opacity]");	483	const ImageAttribute * attr = GetImageAttribute(image, "[layer-opacity]");
482	if (attr != 0) {	484	if (attr != 0) {
483	opacity = TQ_UINT8_MAX - Downscale(TQString(attr->value).toInt());	485	opacity = TQ_UINT8_MAX - ScaleQuantumToChar(TQString(attr->value).toInt());
484	}	486	}
485	KisPaintLayerSP layer = 0;	487	KisPaintLayerSP layer = 0;
Lines 534-550 Link Here
534	while (!hiter.isDone())	536	while (!hiter.isDone())
535	{	537	{
536	TQ_UINT8 *ptr= hiter.rawData();	538	TQ_UINT8 *ptr= hiter.rawData();
537	*(ptr++) = Downscale(pp->red); // cyan	539	*(ptr++) = ScaleQuantumToChar(pp->red); // cyan
538	*(ptr++) = Downscale(pp->green); // magenta	540	*(ptr++) = ScaleQuantumToChar(pp->green); // magenta
539	*(ptr++) = Downscale(pp->blue); // yellow	541	*(ptr++) = ScaleQuantumToChar(pp->blue); // yellow
540	*(ptr++) = Downscale(indexes[x]); // Black	542	*(ptr++) = ScaleQuantumToChar(indexes[x]); // Black
541	// XXX: Warning! This ifdef messes up the paren matching big-time!	543	// XXX: Warning! This ifdef messes up the paren matching big-time!
542	#ifdef HAVE_MAGICK6	544	#ifdef HAVE_MAGICK6
543	if (image->matte != MagickFalse) {	545	if (image->matte != MagickFalse) {
544	#else	546	#else
545	if (image->matte == true) {	547	if (image->matte == true) {
546	#endif	548	#endif
547	*(ptr++) = OPACITY_OPAQUE - Downscale(pp->opacity);	549	*(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
548	}	550	}
549	else {	551	else {
550	*(ptr++) = OPACITY_OPAQUE;	552	*(ptr++) = OPACITY_OPAQUE;
Lines 578-587 Link Here
578	{	580	{
579	TQ_UINT8 *ptr= hiter.rawData();	581	TQ_UINT8 *ptr= hiter.rawData();
580	// XXX: not colorstrategy and bitdepth independent	582	// XXX: not colorstrategy and bitdepth independent
581	*(ptr++) = Downscale(pp->blue);	583	*(ptr++) = ScaleQuantumToChar(pp->blue);
582	*(ptr++) = Downscale(pp->green);	584	*(ptr++) = ScaleQuantumToChar(pp->green);
583	*(ptr++) = Downscale(pp->red);	585	*(ptr++) = ScaleQuantumToChar(pp->red);
584	*(ptr++) = OPACITY_OPAQUE - Downscale(pp->opacity);	586	*(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
585	pp++;	587	pp++;
586	++hiter;	588	++hiter;
Lines 608-615 Link Here
608	{	610	{
609	TQ_UINT8 *ptr= hiter.rawData();	611	TQ_UINT8 *ptr= hiter.rawData();
610	// XXX: not colorstrategy and bitdepth independent	612	// XXX: not colorstrategy and bitdepth independent
611	*(ptr++) = Downscale(pp->blue);	613	*(ptr++) = ScaleQuantumToChar(pp->blue);
612	*(ptr++) = OPACITY_OPAQUE - Downscale(pp->opacity);	614	*(ptr++) = OPACITY_OPAQUE - ScaleQuantumToChar(pp->opacity);
613	pp++;	615	pp++;
614	++hiter;	616	++hiter;
Lines 812-824 Link Here
812	while (!it.isDone()) {	814	while (!it.isDone()) {
813	TQ_UINT8 * d = it.rawData();	815	TQ_UINT8 * d = it.rawData();
814	pp -> red = Upscale(d[PIXEL_CYAN]);	816	pp -> red = ScaleCharToQuantum(d[PIXEL_CYAN]);
815	pp -> green = Upscale(d[PIXEL_MAGENTA]);	817	pp -> green = ScaleCharToQuantum(d[PIXEL_MAGENTA]);
816	pp -> blue = Upscale(d[PIXEL_YELLOW]);	818	pp -> blue = ScaleCharToQuantum(d[PIXEL_YELLOW]);
817	if (alpha)	819	if (alpha)
818	pp -> opacity = Upscale(OPACITY_OPAQUE - d[PIXEL_CMYK_ALPHA]);	820	pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_CMYK_ALPHA]);
819	indexes[x]= Upscale(d[PIXEL_BLACK]);	821	indexes[x]= ScaleCharToQuantum(d[PIXEL_BLACK]);
820	x++;	822	x++;
821	pp++;	823	pp++;
Lines 848-858 Link Here
848	while (!it.isDone()) {	850	while (!it.isDone()) {
849	TQ_UINT8 * d = it.rawData();	851	TQ_UINT8 * d = it.rawData();
850	pp -> red = Upscale(d[PIXEL_RED]);	852	pp -> red = ScaleCharToQuantum(d[PIXEL_RED]);
851	pp -> green = Upscale(d[PIXEL_GREEN]);	853	pp -> green = ScaleCharToQuantum(d[PIXEL_GREEN]);
852	pp -> blue = Upscale(d[PIXEL_BLUE]);	854	pp -> blue = ScaleCharToQuantum(d[PIXEL_BLUE]);
853	if (alpha)	855	if (alpha)
854	pp -> opacity = Upscale(OPACITY_OPAQUE - d[PIXEL_ALPHA]);	856	pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_ALPHA]);
855	pp++;	857	pp++;
856	++it;	858	++it;
Lines 879-889 Link Here
879	else {	881	else {
880	while (!it.isDone()) {	882	while (!it.isDone()) {
881	TQ_UINT8 * d = it.rawData();	883	TQ_UINT8 * d = it.rawData();
882	pp -> red = Upscale(d[PIXEL_GRAY]);	884	pp -> red = ScaleCharToQuantum(d[PIXEL_GRAY]);
883	pp -> green = Upscale(d[PIXEL_GRAY]);	885	pp -> green = ScaleCharToQuantum(d[PIXEL_GRAY]);
884	pp -> blue = Upscale(d[PIXEL_GRAY]);	886	pp -> blue = ScaleCharToQuantum(d[PIXEL_GRAY]);
885	if (alpha)	887	if (alpha)
886	pp -> opacity = Upscale(OPACITY_OPAQUE - d[PIXEL_GRAY_ALPHA]);	888	pp -> opacity = ScaleCharToQuantum(OPACITY_OPAQUE - d[PIXEL_GRAY_ALPHA]);
887	pp++;	889	pp++;
888	++it;	890	++it;