graphics.cxx

windows mobile phone source code

  PPixelDataPtr pixel = GetRasterDataPtr(y) + x*4;
  return (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
}


PPixelDataPtr PPixelBase::CalculateRaster(PORDINATE x, PORDINATE y,
                                                     PDIMENSION & lastX) const
{
  PAssert(x >= 0 && (PDIMENSION)x < Width(), "Pixel out of bounds");
  lastX += (PDIMENSION)x;
  if (lastX > Width())
    lastX = Width();
  return GetRasterDataPtr(y) + x*GetDepth()/8;
}


void PPixelBase::SetRaster(PORDINATE x, PORDINATE y,
                                  const PBYTEArray & raster, PDIMENSION width)
{
  if (width > (PDIMENSION)raster.GetSize())
    width = (PDIMENSION)raster.GetSize();
  SetRasterValues(x, y, raster, width);
}
  

void PPixelBase::GetRaster(PORDINATE x, PORDINATE y,
                                  PBYTEArray & raster, PDIMENSION width) const
{
  if (width > Width())
    width = Width();
  GetRasterValues(x, y, raster.GetPointer(width), width);
}
  

void PPixelBase::SetRasterColours(PORDINATE x, PORDINATE y,
                                const PColourArray & raster, PDIMENSION width)
{
  if (width > (PDIMENSION)raster.GetSize())
    width = (PDIMENSION)raster.GetSize();
  while ((PDIMENSION)x < width) {
    SetPixel(x, y, (BYTE)palette.GetIndex(raster[x]));
    x++;
  }
}


void PPixels24::SetRasterColours(PORDINATE x, PORDINATE y,
                                const PColourArray & raster, PDIMENSION width)
{
  if (width > (PDIMENSION)raster.GetSize())
    width = (PDIMENSION)raster.GetSize();
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  while ((PDIMENSION)x < width) {
    *pixel++ = raster[x].GetRed();
    *pixel++ = raster[x].GetGreen();
    *pixel++ = raster[x++].GetBlue();
  }
}


void PPixels32::SetRasterColours(PORDINATE x, PORDINATE y,
                                const PColourArray & raster, PDIMENSION width)
{
  if (width > (PDIMENSION)raster.GetSize())
    width = (PDIMENSION)raster.GetSize();
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  while ((PDIMENSION)x < width) {
    *pixel++ = raster[x].GetRed();
    *pixel++ = raster[x].GetGreen();
    *pixel++ = raster[x].GetBlue();
    *pixel++ = raster[x++].GetAlpha();
  }
}


void PPixels1::SetRasterValues(PORDINATE x, PORDINATE y,
                                        const BYTE * raster, PDIMENSION width)
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  BYTE mask = (BYTE)(0x80 >> (x&7));
  *pixel = 0;
  while ((PDIMENSION)x < width) {
    if (*raster++ != 0)
      *pixel |= mask;
    mask >>= 1;
    if (mask == 0) {
      *++pixel = 0;
      mask = 0x80;
    }
    x++;
  }
}


void PPixels2::SetRasterValues(PORDINATE x, PORDINATE y,
                                        const BYTE * raster, PDIMENSION width)
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  while ((PDIMENSION)(x += 4) <= width) {
    *pixel++ = (BYTE)((raster[0] << 6)|(raster[1] << 4)|
                      (raster[2] << 2)| raster[3]);
    raster += 4;
  }
  switch (x&3) {
    case 1 :
      *pixel = (BYTE)((raster[0] << 6)|(raster[1] << 4)|
                        (raster[2] << 2));
      break;
    case 2 :
      *pixel = (BYTE)((raster[0] << 6)|(raster[1] << 4));
      break;
    case 3 :
      *pixel = (BYTE)(raster[0] << 6);
      break;
  }
}


void PPixels4::SetRasterValues(PORDINATE x, PORDINATE y,
                                        const BYTE * raster, PDIMENSION width)
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  while ((PDIMENSION)(x += 2) <= width) {
    *pixel++ = (BYTE)((raster[0] << 4)|raster[1]);
    raster += 2;
  }
  if ((x&1) != 0)
    *pixel = (BYTE)(*raster << 4);
}


void PPixels8::SetRasterValues(PORDINATE x, PORDINATE y,
                                        const BYTE * raster, PDIMENSION width)
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  memcpy(pixel, raster, width);
}


void PPixels24::SetRasterValues(PORDINATE x, PORDINATE y,
                                        const BYTE * raster, PDIMENSION width)
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  while ((PDIMENSION)x < width) {
    *pixel++ = *raster;
    *pixel++ = *raster;
    *pixel++ = *raster;
    raster++;
    x++;
  }
}


void PPixels32::SetRasterValues(PORDINATE x, PORDINATE y,
                                        const BYTE * raster, PDIMENSION width)
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  SetDirtyArea(x, y, width);
  while ((PDIMENSION)x < width) {
    *pixel++ = *raster;
    *pixel++ = *raster;
    *pixel++ = *raster;
    *pixel++ = 0;
    raster++;
    x++;
  }
}


void PPixelBase::GetRasterColours(PORDINATE x, PORDINATE y,
                                PColourArray & raster, PDIMENSION width) const
{
  CalculateRaster(x, y, width);
  raster.SetMinSize(width);
  while ((PDIMENSION)x < width) {
    raster[x] = palette.GetColour(GetPixel(x, y));
    x++;
  }
}


void PPixels24::GetRasterColours(PORDINATE x, PORDINATE y,
                                PColourArray & raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  raster.SetMinSize(width);
  while ((PDIMENSION)x < width) {
    raster[x++] = PColour(pixel[0], pixel[1], pixel[2]);
    pixel += 3;
  }
}


void PPixels32::GetRasterColours(PORDINATE x, PORDINATE y,
                                PColourArray & raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  raster.SetMinSize(width);
  while ((PDIMENSION)x < width) {
    raster[x++] = PColour(pixel[0], pixel[1], pixel[2], pixel[3]);
    pixel += 4;
  }
}


void PPixels1::GetRasterValues(PORDINATE x, PORDINATE y,
                                        BYTE * raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  int mask = 0x80 >> (x&7);
  *pixel = 0;
  while ((PDIMENSION)x < width) {
    *raster++ = (BYTE)((*pixel & mask) != 0);
    mask >>= 1;
    if (mask == 0) {
      *++pixel = 0;
      mask = 0x80;
    }
    x++;
  }
}


void PPixels2::GetRasterValues(PORDINATE x, PORDINATE y,
                                        BYTE * raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  while ((PDIMENSION)x < width) {
    *raster++ = (BYTE)(*pixel >> 6);
    if ((PDIMENSION)++x < width) {
      *raster++ = (BYTE)((*pixel >> 4)&3);
      if ((PDIMENSION)++x < width) {
        *raster++ = (BYTE)((*pixel >> 2)&3);
        if ((PDIMENSION)++x < width)
          *raster++ = (BYTE)(*pixel&3);
      }
    }
    pixel++;
  }
}


void PPixels4::GetRasterValues(PORDINATE x, PORDINATE y,
                                        BYTE * raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  while ((PDIMENSION)x < width) {
    *raster++ = (BYTE)(*pixel >> 4);
    if ((PDIMENSION)++x < width)
      *raster++ = (BYTE)(*pixel&0xf);
    pixel++;
  }
}


void PPixels8::GetRasterValues(PORDINATE x, PORDINATE y,
                                        BYTE * raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  memcpy(raster, pixel, width);
}


void PPixels24::GetRasterValues(PORDINATE x, PORDINATE y,
                                        BYTE * raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  while ((PDIMENSION)x < width) {
    *raster++ = (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
    pixel += 3;
    x++;
  }
}


void PPixels32::GetRasterValues(PORDINATE x, PORDINATE y,
                                        BYTE * raster, PDIMENSION width) const
{
  PPixelDataPtr pixel = CalculateRaster(x, y, width);
  while ((PDIMENSION)x < width) {
    *raster++ = (BYTE)((pixel[0]*30 + pixel[1]*59 + pixel[2]*11)/100);
    pixel += 4;
    x++;
  }
}


PPixelImage PPixelBase::ExtractPixels(PORDINATE x, PORDINATE y,
                                   PDIMENSION width, PDIMENSION height) const
{
  PAssert(x >= 0 && (PDIMENSION)x < Width() &&
          y >= 0 && (PDIMENSION)y < Height(), "Pixel out of bounds");
  if (width > Width() - x)
    width = Width() - x;
  if (height > Height() - y)
    height = Height() - y;

  PPixelImage pix(width, height, GetDepth());

  if (GetDepth() >= 8 || x%(8/GetDepth()) == 0) {
    for (PDIMENSION py = 0; py < height; py++)
      memcpy(pix->GetRasterDataPtr(py),
                 GetRasterDataPtr(y++) + x*GetDepth()/8, pix->pixelLineBytes);
  }
  else {
    PBYTEArray raster(width);
    for (PDIMENSION py = 0; py < height; py++) {
      GetRaster(x, y++, raster, width);
      pix->SetRaster(py, raster, width);
    }
  }
  return pix;
}


//////////////////////////////////////////////////////////////////////////////
// PCanvasState

#if defined(_PCANVASSTATE)

PCanvasState::PCanvasState()
  : penStyle(PCanvas::Solid),
    penWidth(0),
    penMode(PCanvas::SrcCopy),
    penFgColour(PColour::Black),
    penBkColour(PColour::White),
    fillFgColour(PColour::Clear),
    fillBkColour(PColour::Clear),
    fillMode(PCanvas::SrcCopy),
    font("System", 10),
    textFgColour(PColour::Black),
    textBkColour(PColour::White),
    palette(),
    polyFillMode(PCanvas::Winding),
    viewport(0, 0, 100, 100), 
    map(0, 0, 100, 100)
{
}


PCanvasState::PCanvasState(const PCanvasState & s)
  : penStyle(s.penStyle),
    penWidth(s.penWidth),
    penMode(s.penMode),
    penFgColour(s.penFgColour),
    penBkColour(s.penBkColour),
    fillFgColour(s.fillFgColour),
    fillBkColour(s.fillBkColour),
    fillPattern(s.fillPattern),
    fillMode(s.fillMode),
    font(s.font),
    textFgColour(s.textFgColour),
    textBkColour(s.textBkColour),
    palette(s.palette),
    polyFillMode(s.polyFillMode),
    viewport(s.viewport), 
    map(s.map)
{
}


BOOL PCanvasState::SetPenStyle(PenStyles style)
{
  if (penStyle == style)
    return FALSE;
  penStyle = style;
  return TRUE;
}


BOOL PCanvasState::SetPenWidth(int width)
{
  if (penWidth == width)
    return FALSE;
  penWidth = width;
  return TRUE;
}


BOOL PCanvasState::SetPenMode(DrawingModes mode)
{
  if (penMode == mode)
    return FALSE;
  penMode = mode;
  return TRUE;
}


BOOL PCanvasState::SetPenFgColour(const PColour & colour)
{
  if (colour == penFgColour)
    return FALSE;
  penFgColour = colour;
  return TRUE;
}


BOOL PCanvasState::SetPenBkColour(const PColour & colour)
{
  if (colour == penBkColour)
    return FALSE;
  penBkColour = colour;
  return TRUE;
}


BOOL PCanvasState::SetFillPattern(const PPattern & pattern)
{
  if (fillPattern == pattern)
    return FALSE;
  fillPattern = pattern;
  return TRUE;
}


BOOL PCanvasState::SetPatternOrigin(const PPoint & pt)
{
  if (patternOrigin == pt)
    return FALSE;
  patternOrigin = pt;
  return TRUE;
}


BOOL PCanvasState::SetFillMode(DrawingModes mode)
{
  if (fillMode == mode)
    return FALSE;
  fillMode = mode;
  return TRUE;
}


BOOL PCanvasState::SetFillFgColour(const PColour & colour)
{
  if (colour == fillFgColour)
    return FALSE;
  fillFgColour = colour;
  return TRUE;
}


BOOL PCanvasState::SetFillBkColour(const PColour & colour)
{
  if (colour == fillBkColour)
    return FALSE;
  fillBkColour = colour;
  return TRUE;
}


BOOL PCanvasState::SetFont(const PFont & newFont)
{
  if (font == newFont)
    return FALSE;
  font = newFont;
  return TRUE;
}


BOOL PCanvasState::SetTextFgColour(const PColour & colour)
{
  if (colour == textFgColour)
    return FALSE;
  textFgColour = colour;
  return TRUE;
}


BOOL PCanvasState::SetTextBkColour(const PColour & colour)
{
  if (colour == textBkColour)
    return FALSE;
  textBkColour = colour;
  return TRUE;
}


BOOL PCanvasState::SetPalette(const PPalette & newPal)
{
  if (palette == newPal)
    return FALSE;
  palette = newPal;
  return TRUE;
}


BOOL PCanvasState::SetPolyFillMode(PolyFillMode newMode)
{
  if (polyFillMode == newMode)
    return FALSE;
  polyFillMode = newMode;
  return TRUE;
}


BOOL PCanvasState::SetViewportRect(const PRect & rect)
{
  if (viewport == rect)
    return FALSE;
  viewport = rect;
  return TRUE;
}


BOOL PCanvasState::SetMappingRect(const PRect & rect)
{
  if (map == rect)
    return FALSE;
  map = rect;
  return TRUE;
}