ImageRoll Class Reference

An ImageRoll is an image that can be expanded to an arbitrary size; it is made up of both fixed pieces and repeating pieces. More...

#include <ImageRoll.h>

Collaboration diagram for ImageRoll:

Public Types
enum	RollType {   Uninitialized , FixedImage , HorizontalRoll , VerticalRoll ,   Frame }

Public Member Functions
	ImageRoll ()
	ImageRoll (const wxImage &src)
	ImageRoll (RollType type, const wxImage &src, wxColour magicColor)
	ImageRoll (const ImageRoll &)
ImageRoll &	operator= (const ImageRoll &)
	~ImageRoll ()
bool	Ok () const
wxSize	GetMinSize () const
wxSize	GetMaxSize () const
void	Draw (wxDC &dc, wxRect rect, int logicalFunc)
void	Draw (wxDC &dc, wxRect rect)

Static Public Member Functions
static ImageArray	SplitH (const wxImage &src, wxColour magicColor)
static ImageArray	SplitV (const wxImage &src, wxColour magicColor)

Protected Member Functions
void	DrawBitmap (wxDC &dc, wxBitmap &bitmap, int x, int y, int logicalFunc)
void	Init (RollType type, const wxImage &src, wxColour magicColor)

Protected Attributes
RollType	mType
std::vector< wxBitmap >	mPieces
wxSize	mMinSize
wxSize	mMaxSize

Detailed Description

An ImageRoll is an image that can be expanded to an arbitrary size; it is made up of both fixed pieces and repeating pieces.

A typical ImageRoll might be made up of two fixed ends and a repeating middle part:

  /-----\                       /-----\
  |LEFT |--REPEATING--REPEATING-|RIGHT|
  \-----/                       \-----/

As you resize the image, it could look like this:

  /-----\ /-----\
  |LEFT |-|RIGHT|
  \-----/ \-----/

Or like this:

  /-----\                                  /-----\
  |LEFT |--REPEATING--REPEATING--REPEATING-|RIGHT|
  \-----/                                  \-----/

Note that an ImageRoll can have a center piece; in fact, its pieces always alternate fixed, repeating, fixed, repeating, etc. - although one of these pieces is allowed to be of size zero, making it skipped. Here's an example with a center piece:

  /-----\                /------\                /-----\
  |LEFT |-REPEAT--REPEAT-|CENTER|-repeat--repeat-|RIGHT|
  \-----/                \------/                \-----/

Note that the left and right repeating sections can be different. Of course, an ImageRoll can be oriented vertically as well. In the future, support for an ImageRoll that expands both horizontally and vertically at the same time will be supported.

An ImageRoll is initialized with a single wxImage that defines all of its pieces. This is done by way of a "magic color" which separates each piece in the image. If the magic colored pixel is denoted by "X", the above ImageRoll could be encoded like this:

  /-----\X        X/------\X        X/-----\
  |LEFT |X-REPEAT-X|CENTER|X-repeat-X|RIGHT|
  \-----/X        X\------/X        X\-----/

Putting two lines of magic color in a row will create a blank piece. For example, for an ImageRoll with a center piece but no left and right pieces:

  X        X/------\X        X
  X-REPEAT-X|CENTER|X-repeat-X
  X        X\------/X        X

Once again, the pieces are always assumed to alternate: fixed, repeating, fixed, repeating, etc. The magic color is specified when you construct the ImageRoll from a wxImage.

In the constructor, you also choose whether it is a horizontal or vertical ImageRoll (and later a "Frame" as well). You can also choose a "fixed" ImageRoll, which behaves just like a wxImage - this is handy so that you can use ImageRolls everywhere you were previously using wxImages.

Definition at line 27 of file ImageRoll.h.

Member Enumeration Documentation

RollType

enum ImageRoll::RollType

Enumerator
Uninitialized
FixedImage
HorizontalRoll
VerticalRoll
Frame

Definition at line 30 of file ImageRoll.h.

                 {
      Uninitialized,
      FixedImage,
      HorizontalRoll,
      VerticalRoll,
      Frame
   };

Constructor & Destructor Documentation

ImageRoll() [1/4]

ImageRoll::ImageRoll

(

)

Definition at line 282 of file ImageRoll.cpp.

{
   mType = Uninitialized;
}

References mType, and Uninitialized.

ImageRoll() [2/4]

ImageRoll::ImageRoll

(

const wxImage &

src

)

Definition at line 292 of file ImageRoll.cpp.

{
   Init(FixedImage, src, *wxWHITE);
}

References FixedImage, and Init().

Here is the call graph for this function:

ImageRoll() [3/4]

ImageRoll::ImageRoll	(	RollType	type,
		const wxImage &	src,
		wxColour	magicColor
	)

Definition at line 287 of file ImageRoll.cpp.

{
   Init(type, src, magicColor);
}

References Init().

Here is the call graph for this function:

ImageRoll() [4/4]

ImageRoll::ImageRoll ( const ImageRoll &  )

default

~ImageRoll()

ImageRoll::~ImageRoll ( )

default

Member Function Documentation

Draw() [1/2]

void ImageRoll::Draw	(	wxDC &	dc,
		wxRect	rect
	)

Definition at line 316 of file ImageRoll.cpp.

{
   Draw( dc, rect, wxCOPY );
}

References Draw().

Here is the call graph for this function:

Draw() [2/2]

void ImageRoll::Draw	(	wxDC &	dc,
		wxRect	rect,
		int	logicalFunc
	)

Referenced by Draw().

Here is the caller graph for this function:

DrawBitmap()

void ImageRoll::DrawBitmap ( wxDC &  dc, wxBitmap &  bitmap, int  x, int  y, int  logicalFunc  )

protected

Definition at line 302 of file ImageRoll.cpp.

{
   auto func = static_cast< wxRasterOperationMode >( logicalFunc );
   if (func == wxCOPY)
      dc.DrawBitmap(bitmap, x, y);
   else {
      wxMemoryDC memDC;
      memDC.SelectObject(bitmap);
      dc.Blit(x, y, bitmap.GetWidth(), bitmap.GetHeight(),
              &memDC, 0, 0, func);
   }
}

References wxRasterOperationMode.

GetMaxSize()

wxSize ImageRoll::GetMaxSize ( ) const

inline

Definition at line 48 of file ImageRoll.h.

{ return mMaxSize; }

GetMinSize()

wxSize ImageRoll::GetMinSize ( ) const

inline

Definition at line 47 of file ImageRoll.h.

{ return mMinSize; }

Init()

void ImageRoll::Init ( RollType  type, const wxImage &  src, wxColour  magicColor  )

protected

Definition at line 219 of file ImageRoll.cpp.

{
   ImageArray images;
   int i;
 
   mType = type;
 
   switch(mType) {
   case HorizontalRoll:
      images = SplitH(src, magicColor);
 
      mMinSize.x = 0;
      mMinSize.y = src.GetHeight();
      mMaxSize.x = 9999;
      mMaxSize.y = src.GetHeight();
 
      for(i = 0; i < (int)images.size(); i++) {
         if (images[i].Ok()) {
            mPieces.push_back(wxBitmap(images[i]));
            mMinSize.x += mPieces[i].GetWidth();
         }
         else
            mPieces.push_back(wxBitmap());
      }
      break;
 
   case VerticalRoll:
      images = SplitV(src, magicColor);
 
      mMinSize.x = src.GetWidth();
      mMinSize.y = 0;
      mMaxSize.x = src.GetWidth();
      mMaxSize.y = 9999;
 
      for(i = 0; i < (int)images.size(); i++) {
         if (images[i].Ok()) {
            mPieces.push_back(wxBitmap(images[i]));
            mMinSize.y += mPieces[i].GetHeight();
         }
         else
            mPieces.push_back(wxBitmap());
      }
      break;
 
   case FixedImage:
      mPieces.push_back(wxBitmap(src));
      mMinSize.x = src.GetWidth();
      mMinSize.y = src.GetHeight();
      mMaxSize.x = src.GetWidth();
      mMaxSize.y = src.GetHeight();
      break;
 
   /* Adding these shuts up some GCC warnings. It is functionally what was
    * implicit here before - Richard */
   case Uninitialized:
   break;
 
   case Frame:
   break;
 
   } // switch
}

References FixedImage, Frame, HorizontalRoll, mMaxSize, mMinSize, mPieces, mType, Ok(), SplitH(), SplitV(), Uninitialized, and VerticalRoll.

Referenced by ImageRoll().

Here is the call graph for this function:

Here is the caller graph for this function:

Ok()

bool ImageRoll::Ok

(

)

const

Definition at line 297 of file ImageRoll.cpp.

{
   return (mType != Uninitialized);
}

References mType, and Uninitialized.

Referenced by Init().

Here is the caller graph for this function:

operator=()

ImageRoll & ImageRoll::operator= ( const ImageRoll &  )

default

SplitH()

ImageArray ImageRoll::SplitH ( const wxImage &  src, wxColour  magicColor  )

static

Definition at line 109 of file ImageRoll.cpp.

{
   ImageArray result;
 
   int width = src.GetWidth();
   int height = src.GetHeight();
   unsigned char *data = src.GetData();
   unsigned char *ptr = data;
   unsigned char magicRed = magicColor.Red();
   unsigned char magicGreen = magicColor.Green();
   unsigned char magicBlue = magicColor.Blue();
   bool cur, prev;
   int i, j, start;
 
   // Sanity check...
   if (width<=0 || height<=0 || data==NULL)
      return result;
 
   prev = false;
   start = 0;
   for(i=0; i<width+1; i++) {
      if (i < width) {
         unsigned char *ptr2 = ptr;
         cur = true;
         for(j=0; j<height && cur; j++) {
            if (!(ptr2[0] == magicRed &&
                  ptr2[1] == magicGreen &&
                  ptr2[2] == magicBlue))
               cur = false;
            ptr2 += 3 * width;
         }
      }
      else
         cur = !prev;
 
      if ((cur && !prev)) {
         wxRect subRect(start, 0, i-start, height);
         wxImage subImage;
         if (subRect.width > 0)
            subImage = src.GetSubImage(subRect);
         else
            subImage = wxImage(subRect.width, subRect.height);
         result.push_back(subImage);
      }
      else if (!cur && prev) {
         start = i;
      }
 
      prev = cur;
      ptr += 3;
   }
 
   return result;
}

References wxImage().

Referenced by Init(), and ToolBarGrabber::ToolBarGrabber().

Here is the call graph for this function:

Here is the caller graph for this function:

SplitV()

ImageArray ImageRoll::SplitV ( const wxImage &  src, wxColour  magicColor  )

static

Definition at line 165 of file ImageRoll.cpp.

{
   ImageArray result;
   int width = src.GetWidth();
   int height = src.GetHeight();
   unsigned char *data = src.GetData();
   unsigned char *ptr = data;
   unsigned char magicRed = magicColor.Red();
   unsigned char magicGreen = magicColor.Green();
   unsigned char magicBlue = magicColor.Blue();
   bool cur, prev;
   int i, j, start;
 
   // Sanity check...
   if (width<=0 || height<=0 || data==NULL)
      return result;
 
   prev = false;
   start = 0;
   for(i=0; i<height+1; i++) {
      if (i < height) {
         unsigned char *ptr2 = ptr;
         cur = true;
         for(j=0; j<width && cur; j++) {
            if (!(ptr2[0] == magicRed &&
                  ptr2[1] == magicGreen &&
                  ptr2[2] == magicBlue))
               cur = false;
            ptr2 += 3;
         }
      }
      else
         cur = !prev;
 
      if ((cur && !prev)) {
         wxRect subRect(0, start, width, i-start);
         wxImage subImage;
         if (subRect.width > 0)
            subImage = src.GetSubImage(subRect);
         else
            subImage = wxImage(subRect.width, subRect.height);
         result.push_back(subImage);
      }
      else if (!cur && prev) {
         start = i;
      }
 
      prev = cur;
      ptr += 3*width;
   }
 
   return result;
}

References wxImage().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

mMaxSize

wxSize ImageRoll::mMaxSize

protected

Definition at line 69 of file ImageRoll.h.

Referenced by Init().

mMinSize

wxSize ImageRoll::mMinSize

protected

Definition at line 68 of file ImageRoll.h.

Referenced by Init().

mPieces

std::vector<wxBitmap> ImageRoll::mPieces

protected

Definition at line 67 of file ImageRoll.h.

Referenced by Init().

mType

RollType ImageRoll::mType

protected

Definition at line 65 of file ImageRoll.h.

Referenced by ImageRoll(), Init(), and Ok().

---

The documentation for this class was generated from the following files:

• ImageRoll.h
• ImageRoll.cpp