Re: commit: Infrastructure for tighly wrapped images.

On Thu, 2005-02-24 at 17:53 -0600, Ryan Pavlik wrote:
> This looks like it may be really slick! Is there a way to add support
> for "transparent=(pixelcolor==pagecolor)", since as much as we'd like,
> not a huge amount of people use Transparent PNG? This would permit JPG
> insertion perhaps, and while it wouldn't be perfect (compression
> artifacts), I think it might be worthwhile. I believe Word does this,
> but I'm not positive: I am allergic to Word's image handling, or vice
> versa perhaps.
>

Ah an interesting idea. The problem would be that the text which
encroaches into the rectangular area of the image would get overwritten
by the image.

This is a harder problem to solve. I won't do this right away.

There an excellent source of free clipart here:

http://www.openclipart.org/

I meant to give this link in my first email.

Actually I think we should give these guys a plug on our webpage in
return for a screenshot of their clipart in AbiWord.

Cheers

Martin

> Ryan
>
> msevior@physics.unimelb.edu.au wrote:
>
> >CVS: ----------------------------------------------------------------------
> >CVS: Enter Log. Lines beginning with `CVS:' are removed automatically
> >CVS:
> >CVS: Committing in .
> >CVS:
> >CVS: Modified Files:
> >CVS: src/af/gr/cocoa/gr_CocoaImage.h
> >CVS: src/af/gr/cocoa/gr_CocoaImage.mm
> >CVS: src/af/gr/unix/gr_UnixImage.cpp src/af/gr/unix/gr_UnixImage.h
> >CVS: src/af/gr/win/gr_Win32Image.cpp src/af/gr/win/gr_Win32Image.h
> >CVS: src/af/gr/xp/gr_Image.cpp src/af/gr/xp/gr_Image.h
> >CVS: src/af/gr/xp/gr_VectorImage.cpp src/af/gr/xp/gr_VectorImage.h
> >CVS: src/af/xap/unix/xap_UnixPSGraphics.cpp
> >CVS: src/af/xap/unix/xap_UnixPSImage.cpp
> >CVS: src/af/xap/unix/xap_UnixPSImage.h
> >CVS: ----------------------------------------------------------------------
> >Some infrastructure for tight wrapped images.
> >
> >This commit provides a lot of the infrastructure needed for tight text
> >wrapping around images and objects.
> >
> >This is where the text encroaches into the rectangular box which encloses
> >images with large areas of transparency such as are often found in clip
> >art collections and in particular in the open clip art collect at:
> >
> >I must admit part of my reason for working on this code is because I want
> >abiword screenshots to be featured along side OOo shots on that site. I
> >also remember being really impressed when I first saw this feature in MS
> >Word 97 and wondered how they did it. So here we go :-)
> >
> >The way I intend to implement this is to increase the length of the lines
> >placed around wrapped images to reflect the transparency of the object.
> >
> >So we need to work out if an image has transparency and where the first
> >non-transparent pixel is on each row of the image.
> >
> >To do this we need two additional platform-specific methods for the
> >GR_Image class. These are:
> >
> >virtual bool isTransparentAt(UT_sint32 x, UT_sint32 y) =0;
> >virtual bool hasAlpha (void) const = 0;
> >
> >These are pure virtual in the GR_Image base class. I've implemented these
> >for the Unix framework and have placed code that asserts in the Win32 and
> >Cocoa builds. I haven't tested these. So once again, my apologies if these
> >break those builds - it should be easy to fix though.
> >
> >The method "hasAlpha" simply returns true if there is any transparency in
> >the image. If there isn't all the rest of the code is shorted circuited.
> >
> >The method "isTransparentAt(x,y)" returns true if the pixel at the device
> >location (x,y) is pure transparent. This is a simple method that just
> >calculates the the location of the pixel at (x,y) and determines if it's
> >totally transparent.
> >
> >With these platform-specific methods we can now implement the XP methods
> >in GR_Image. These are:
> > void GenerateOutline(void);
> > void DestroyOutline(void);
> > UT_sint32 GetOffsetFromLeft(GR_Graphics * pG, UT_sint32 pad, UT_sint32
> >yTop, UT_sint32 height);
> > UT_sint32 GetOffsetFromRight(GR_Graphics * pG, UT_sint32 pad, UT_sint32
> >yTop, UT_sint32 height);
> >
> > bool isOutLinePresent(void) const
> > { return (m_vecOutLine.getItemCount() > 0);}
> >
> >The GenerateOutline method scans the image from the left and right sides
> >for the first non-transparent pixel at each row of the image. As it finds
> >this pixel it records it's location in the simple little class
> >
> >class ABI_EXPORT GR_Image_Point
> >{
> >public:
> > GR_Image_Point(void) : m_iX(0),m_iY(0)
> > {}
> > UT_sint32 m_iX;
> > UT_sint32 m_iY;
> >};
> >
> >then saves each point in the vector
> >
> > UT_GenericVector<GR_Image_Point *> m_vecOutLine;
> >
> >This vector contains the outline of the non-transparent portions of the
> >image. The "DestroyOutline(void)" method simply clears out this vector.
> >
> >The methods:
> >
> >UT_sint32 GetOffsetFromLeft(GR_Graphics * pG, UT_sint32 pad, UT_sint32
> >yTop, UT_sint32 height);
> > UT_sint32 GetOffsetFromRight(GR_Graphics * pG, UT_sint32 pad, UT_sint32
> >yTop, UT_sint32 height);
> >
> >Are what will be actually used to implement the tight wrapping feature. I
> >will implement these by intelligently scanning the the outline and
> >determining the closest approach of each pixel to the line segment given.
> >I've worked out the maths for this but it's not implemented yet.
> >
> >I'll send another post with this info.
> >
> >Cheers
> >
> >Martin
> >
> >
> >
> >
>
>
Received on Fri Feb 25 06:04:57 2005