Move fx_agg_driver files up one level

core/src/fxge/agg/fx_agg_driver.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#include "core/src/fxge/agg/include/fx_agg_driver.h"
+#include "core/src/fxge/agg/fx_agg_driver.h"
 
 #include <algorithm>
 
 #include "core/include/fxcodec/fx_codec.h"
 #include "core/include/fxge/fx_ge.h"
 #include "core/src/fxge/dib/dib_int.h"
 #include "core/src/fxge/ge/fx_text_int.h"
 #include "third_party/agg23/agg_conv_dash.h"
 #include "third_party/agg23/agg_conv_stroke.h"
 #include "third_party/agg23/agg_curves.h"
@@ skipping 158 matching lines @@
     rasterizer.add_path_transformed(stroke, pObject2Device);
   } else {
     agg::conv_stroke<agg::path_storage> stroke(path_data);
     stroke.line_join(join);
     stroke.line_cap(cap);
     stroke.miter_limit(pGraphState->m_MiterLimit);
     stroke.width(width);
     rasterizer.add_path_transformed(stroke, pObject2Device);
   }
 }
+
 IFX_RenderDeviceDriver* IFX_RenderDeviceDriver::CreateFxgeDriver(
     CFX_DIBitmap* pBitmap,
     FX_BOOL bRgbByteOrder,
     CFX_DIBitmap* pOriDevice,
     FX_BOOL bGroupKnockout) {
   return new CFX_AggDeviceDriver(pBitmap, 0, bRgbByteOrder, pOriDevice,
                                  bGroupKnockout);
 }
+
 CFX_AggDeviceDriver::CFX_AggDeviceDriver(CFX_DIBitmap* pBitmap,
                                          int dither_bits,
                                          FX_BOOL bRgbByteOrder,
                                          CFX_DIBitmap* pOriDevice,
                                          FX_BOOL bGroupKnockout) {
   m_pBitmap = pBitmap;
   m_DitherBits = dither_bits;
   m_pClipRgn = NULL;
   m_pPlatformBitmap = NULL;
   m_pPlatformGraphics = NULL;
   m_pDwRenderTartget = NULL;
   m_bRgbByteOrder = bRgbByteOrder;
   m_pOriDevice = pOriDevice;
   m_bGroupKnockout = bGroupKnockout;
   m_FillFlags = 0;
   InitPlatform();
 }
+
 CFX_AggDeviceDriver::~CFX_AggDeviceDriver() {
   delete m_pClipRgn;
   for (int i = 0; i < m_StateStack.GetSize(); i++)
     delete m_StateStack[i];
   DestroyPlatform();
 }
+
+uint8_t* CFX_AggDeviceDriver::GetBuffer() const {
+  return m_pBitmap->GetBuffer();
+}
+
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
 void CFX_AggDeviceDriver::InitPlatform() {}
+
 void CFX_AggDeviceDriver::DestroyPlatform() {}
+
 FX_BOOL CFX_AggDeviceDriver::DrawDeviceText(int nChars,
                                             const FXTEXT_CHARPOS* pCharPos,
                                             CFX_Font* pFont,
                                             CFX_FontCache* pCache,
                                             const CFX_Matrix* pObject2Device,
                                             FX_FLOAT font_size,
                                             FX_DWORD color,
                                             int alpha_flag,
                                             void* pIccTransform) {
   return FALSE;
-}
+}  // _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
 #endif
+
 int CFX_AggDeviceDriver::GetDeviceCaps(int caps_id) {
   switch (caps_id) {
     case FXDC_DEVICE_CLASS:
       return FXDC_DISPLAY;
     case FXDC_PIXEL_WIDTH:
       return m_pBitmap->GetWidth();
     case FXDC_PIXEL_HEIGHT:
       return m_pBitmap->GetHeight();
     case FXDC_BITS_PIXEL:
       return m_pBitmap->GetBPP();
@@ skipping 15 matching lines @@
       if (m_pBitmap->IsCmykImage()) {
         flags |= FXRC_CMYK_OUTPUT;
       }
       return flags;
     }
     case FXDC_DITHER_BITS:
       return m_DitherBits;
   }
   return 0;
 }
+
 void CFX_AggDeviceDriver::SaveState() {
   CFX_ClipRgn* pClip = NULL;
   if (m_pClipRgn) {
     pClip = new CFX_ClipRgn(*m_pClipRgn);
   }
   m_StateStack.Add(pClip);
 }
+
 void CFX_AggDeviceDriver::RestoreState(FX_BOOL bKeepSaved) {
   if (m_StateStack.GetSize() == 0) {
     delete m_pClipRgn;
     m_pClipRgn = NULL;
     return;
   }
   CFX_ClipRgn* pSavedClip = m_StateStack[m_StateStack.GetSize() - 1];
   delete m_pClipRgn;
   m_pClipRgn = NULL;
   if (bKeepSaved) {
     if (pSavedClip) {
       m_pClipRgn = new CFX_ClipRgn(*pSavedClip);
     }
   } else {
     m_StateStack.RemoveAt(m_StateStack.GetSize() - 1);
     m_pClipRgn = pSavedClip;
   }
 }
+
 void CFX_AggDeviceDriver::SetClipMask(agg::rasterizer_scanline_aa& rasterizer) {
   FX_RECT path_rect(rasterizer.min_x(), rasterizer.min_y(),
                     rasterizer.max_x() + 1, rasterizer.max_y() + 1);
   path_rect.Intersect(m_pClipRgn->GetBox());
   CFX_DIBitmapRef mask;
   CFX_DIBitmap* pThisLayer = mask.New();
   if (!pThisLayer) {
     return;
   }
   pThisLayer->Create(path_rect.Width(), path_rect.Height(), FXDIB_8bppMask);
   pThisLayer->Clear(0);
   agg::rendering_buffer raw_buf(pThisLayer->GetBuffer(), pThisLayer->GetWidth(),
                                 pThisLayer->GetHeight(),
                                 pThisLayer->GetPitch());
   agg::pixfmt_gray8 pixel_buf(raw_buf);
   agg::renderer_base<agg::pixfmt_gray8> base_buf(pixel_buf);
   agg::renderer_scanline_aa_offset<agg::renderer_base<agg::pixfmt_gray8> >
       final_render(base_buf, path_rect.left, path_rect.top);
   final_render.color(agg::gray8(255));
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, final_render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   m_pClipRgn->IntersectMaskF(path_rect.left, path_rect.top, mask);
 }
+
 FX_BOOL CFX_AggDeviceDriver::SetClip_PathFill(const CFX_PathData* pPathData,
                                               const CFX_Matrix* pObject2Device,
                                               int fill_mode) {
   m_FillFlags = fill_mode;
   if (!m_pClipRgn) {
     m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH),
                                  GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   }
   if (pPathData->GetPointCount() == 5 || pPathData->GetPointCount() == 4) {
     CFX_FloatRect rectf;
@@ skipping 12 matching lines @@
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   rasterizer.add_path(path_data.m_PathData);
   rasterizer.filling_rule((fill_mode & 3) == FXFILL_WINDING
                               ? agg::fill_non_zero
                               : agg::fill_even_odd);
   SetClipMask(rasterizer);
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::SetClip_PathStroke(
     const CFX_PathData* pPathData,
     const CFX_Matrix* pObject2Device,
     const CFX_GraphStateData* pGraphState) {
   if (!m_pClipRgn) {
     m_pClipRgn = new CFX_ClipRgn(GetDeviceCaps(FXDC_PIXEL_WIDTH),
                                  GetDeviceCaps(FXDC_PIXEL_HEIGHT));
   }
   CAgg_PathData path_data;
   path_data.BuildPath(pPathData, NULL);
   agg::rasterizer_scanline_aa rasterizer;
   rasterizer.clip_box(0.0f, 0.0f, (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_WIDTH)),
                       (FX_FLOAT)(GetDeviceCaps(FXDC_PIXEL_HEIGHT)));
   RasterizeStroke(rasterizer, path_data.m_PathData, pObject2Device,
                   pGraphState);
   rasterizer.filling_rule(agg::fill_non_zero);
   SetClipMask(rasterizer);
   return TRUE;
 }
+
 class CFX_Renderer {
  private:
   int m_Alpha, m_Red, m_Green, m_Blue, m_Gray;
   FX_DWORD m_Color;
   FX_BOOL m_bFullCover;
   FX_BOOL m_bRgbByteOrder;
   CFX_DIBitmap* m_pOriDevice;
   FX_RECT m_ClipBox;
   const CFX_DIBitmap* m_pClipMask;
   CFX_DIBitmap* m_pDevice;
   const CFX_ClipRgn* m_pClipRgn;
   void (CFX_Renderer::*composite_span)(uint8_t*,
                                        int,
                                        int,
                                        int,
                                        uint8_t*,
                                        int,
                                        int,
                                        uint8_t*,
                                        uint8_t*);
 
  public:
   void prepare(unsigned) {}
+
   void CompositeSpan(uint8_t* dest_scan,
                      uint8_t* ori_scan,
                      int Bpp,
                      FX_BOOL bDestAlpha,
                      int span_left,
                      int span_len,
                      uint8_t* cover_scan,
                      int clip_left,
                      int clip_right,
                      uint8_t* clip_scan) {
@@ skipping 175 matching lines @@
           if (!index) {
             *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
           } else {
             *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
           }
         }
         dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
       }
     }
   }
+
   void CompositeSpan1bpp(uint8_t* dest_scan,
                          int Bpp,
                          int span_left,
                          int span_len,
                          uint8_t* cover_scan,
                          int clip_left,
                          int clip_right,
                          uint8_t* clip_scan,
                          uint8_t* dest_extra_alpha_scan) {
     ASSERT(!m_bRgbByteOrder);
@@ skipping 24 matching lines @@
       if (src_alpha) {
         if (!index) {
           *dest_scan1 &= ~(1 << (7 - (col + span_left) % 8));
         } else {
           *dest_scan1 |= 1 << (7 - (col + span_left) % 8);
         }
       }
       dest_scan1 = dest_scan + (span_left % 8 + col - col_start + 1) / 8;
     }
   }
+
   void CompositeSpanGray(uint8_t* dest_scan,
                          int Bpp,
                          int span_left,
                          int span_len,
                          uint8_t* cover_scan,
                          int clip_left,
                          int clip_right,
                          uint8_t* clip_scan,
                          uint8_t* dest_extra_alpha_scan) {
     ASSERT(!m_bRgbByteOrder);
@@ skipping 47 matching lines @@
           if (src_alpha == 255) {
             *dest_scan = m_Gray;
           } else {
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
           }
         }
         dest_scan++;
       }
     }
   }
+
   void CompositeSpanARGB(uint8_t* dest_scan,
                          int Bpp,
                          int span_left,
                          int span_len,
                          uint8_t* cover_scan,
                          int clip_left,
                          int clip_right,
                          uint8_t* clip_scan,
                          uint8_t* dest_extra_alpha_scan) {
     int col_start = span_left < clip_left ? clip_left - span_left : 0;
@@ skipping 74 matching lines @@
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Green, alpha_ratio);
           dest_scan++;
           *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, alpha_ratio);
           dest_scan += 2;
           continue;
         }
       }
       dest_scan += Bpp;
     }
   }
+
   void CompositeSpanRGB(uint8_t* dest_scan,
                         int Bpp,
                         int span_left,
                         int span_len,
                         uint8_t* cover_scan,
                         int clip_left,
                         int clip_right,
                         uint8_t* clip_scan,
                         uint8_t* dest_extra_alpha_scan) {
     int col_start = span_left < clip_left ? clip_left - span_left : 0;
@@ skipping 106 matching lines @@
             dest_scan++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Red, src_alpha);
             dest_scan += Bpp - 2;
             continue;
           }
         }
         dest_scan += Bpp;
       }
     }
   }
+
   void CompositeSpanCMYK(uint8_t* dest_scan,
                          int Bpp,
                          int span_left,
                          int span_len,
                          uint8_t* cover_scan,
                          int clip_left,
                          int clip_right,
                          uint8_t* clip_scan,
                          uint8_t* dest_extra_alpha_scan) {
     ASSERT(!m_bRgbByteOrder);
@@ skipping 61 matching lines @@
             dest_scan++;
             *dest_scan = FXDIB_ALPHA_MERGE(*dest_scan, m_Gray, src_alpha);
             dest_scan++;
             continue;
           }
         }
         dest_scan += 4;
       }
     }
   }
+
   template <class Scanline>
   void render(const Scanline& sl) {
     if (!m_pOriDevice && !composite_span) {
       return;
     }
     int y = sl.y();
     if (y < m_ClipBox.top || y >= m_ClipBox.bottom) {
       return;
     }
     uint8_t* dest_scan = m_pDevice->GetBuffer() + m_pDevice->GetPitch() * y;
@@ skipping 170 matching lines @@
           ArgbDecode(color, m_Alpha, m_Red, m_Green, m_Blue);
         }
       }
     }
     if (m_pDevice->GetBPP() == 1) {
       composite_span = &CFX_Renderer::CompositeSpan1bpp;
     }
     return TRUE;
   }
 };
+
 FX_BOOL CFX_AggDeviceDriver::RenderRasterizer(
     agg::rasterizer_scanline_aa& rasterizer,
     FX_DWORD color,
     FX_BOOL bFullCover,
     FX_BOOL bGroupKnockout,
     int alpha_flag,
     void* pIccTransform) {
   CFX_DIBitmap* pt = bGroupKnockout ? m_pOriDevice : NULL;
   CFX_Renderer render;
   if (!render.Init(m_pBitmap, pt, m_pClipRgn, color, bFullCover,
                    m_bRgbByteOrder, alpha_flag, pIccTransform)) {
     return FALSE;
   }
   agg::scanline_u8 scanline;
   agg::render_scanlines(rasterizer, scanline, render,
                         (m_FillFlags & FXFILL_NOPATHSMOOTH) != 0);
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::DrawPath(const CFX_PathData* pPathData,
                                       const CFX_Matrix* pObject2Device,
                                       const CFX_GraphStateData* pGraphState,
                                       FX_DWORD fill_color,
                                       FX_DWORD stroke_color,
                                       int fill_mode,
                                       int alpha_flag,
                                       void* pIccTransform,
                                       int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
@@ skipping 63 matching lines @@
     int fill_flag = FXGETFLAG_COLORTYPE(alpha_flag) << 8 |
                     FXGETFLAG_ALPHA_STROKE(alpha_flag);
     if (!RenderRasterizer(rasterizer, stroke_color,
                           fill_mode & FXFILL_FULLCOVER, m_bGroupKnockout,
                           fill_flag, pIccTransform)) {
       return FALSE;
     }
   }
   return TRUE;
 }
+
 void RgbByteOrderSetPixel(CFX_DIBitmap* pBitmap, int x, int y, FX_DWORD argb) {
   if (x < 0 || x >= pBitmap->GetWidth() || y < 0 || y >= pBitmap->GetHeight()) {
     return;
   }
   uint8_t* pos = (uint8_t*)pBitmap->GetBuffer() + y * pBitmap->GetPitch() +
                  x * pBitmap->GetBPP() / 8;
   if (pBitmap->GetFormat() == FXDIB_Argb) {
     FXARGB_SETRGBORDERDIB(pos, ArgbGamma(argb));
   } else {
     int alpha = FXARGB_A(argb);
     pos[0] = (FXARGB_R(argb) * alpha + pos[0] * (255 - alpha)) / 255;
     pos[1] = (FXARGB_G(argb) * alpha + pos[1] * (255 - alpha)) / 255;
     pos[2] = (FXARGB_B(argb) * alpha + pos[2] * (255 - alpha)) / 255;
   }
 }
+
 void RgbByteOrderCompositeRect(CFX_DIBitmap* pBitmap,
                                int left,
                                int top,
                                int width,
                                int height,
                                FX_ARGB argb) {
   int src_alpha = FXARGB_A(argb);
   if (src_alpha == 0) {
     return;
   }
@@ skipping 60 matching lines @@
         *dest_scan = FX_GAMMA_INVERSE(
             FXDIB_ALPHA_MERGE(FX_GAMMA(*dest_scan), src_b, src_alpha));
         dest_scan++;
         if (Bpp == 4) {
           dest_scan++;
         }
       }
     }
   }
 }
+
 void RgbByteOrderTransferBitmap(CFX_DIBitmap* pBitmap,
                                 int dest_left,
                                 int dest_top,
                                 int width,
                                 int height,
                                 const CFX_DIBSource* pSrcBitmap,
                                 int src_left,
                                 int src_top) {
   if (!pBitmap) {
     return;
@@ skipping 83 matching lines @@
                                                src_scan[2]));
           src_scan += 4;
           dest_scan += 4;
         }
       }
     }
   } else {
     ASSERT(FALSE);
   }
 }
+
 FX_ARGB _DefaultCMYK2ARGB(FX_CMYK cmyk, uint8_t alpha) {
   uint8_t r, g, b;
   AdobeCMYK_to_sRGB1(FXSYS_GetCValue(cmyk), FXSYS_GetMValue(cmyk),
                      FXSYS_GetYValue(cmyk), FXSYS_GetKValue(cmyk), r, g, b);
   return ArgbEncode(alpha, r, g, b);
 }
+
 FX_BOOL _DibSetPixel(CFX_DIBitmap* pDevice,
                      int x,
                      int y,
                      FX_DWORD color,
                      int alpha_flag,
                      void* pIccTransform) {
   FX_BOOL bObjCMYK = FXGETFLAG_COLORTYPE(alpha_flag);
   int alpha = bObjCMYK ? FXGETFLAG_ALPHA_FILL(alpha_flag) : FXARGB_A(color);
   if (pIccTransform) {
     ICodec_IccModule* pIccModule =
@@ skipping 15 matching lines @@
         color = _DefaultCMYK2ARGB(color, alpha);
       }
     }
   }
   pDevice->SetPixel(x, y, color);
   if (pDevice->m_pAlphaMask) {
     pDevice->m_pAlphaMask->SetPixel(x, y, alpha << 24);
   }
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::SetPixel(int x,
                                       int y,
                                       FX_DWORD color,
                                       int alpha_flag,
                                       void* pIccTransform) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (!CFX_GEModule::Get()->GetCodecModule() ||
       !CFX_GEModule::Get()->GetCodecModule()->GetIccModule()) {
@@ skipping 26 matching lines @@
       if (bCMYK) {
         FXSETFLAG_ALPHA_FILL(alpha_flag, new_alpha);
       } else {
         color = (color & 0xffffff) | (new_alpha << 24);
       }
       return _DibSetPixel(m_pBitmap, x, y, color, alpha_flag, pIccTransform);
     }
   }
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::FillRect(const FX_RECT* pRect,
                                       FX_DWORD fill_color,
                                       int alpha_flag,
                                       void* pIccTransform,
                                       int blend_type) {
   if (blend_type != FXDIB_BLEND_NORMAL) {
     return FALSE;
   }
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
@@ skipping 19 matching lines @@
     }
     return TRUE;
   }
   m_pBitmap->CompositeMask(
       draw_rect.left, draw_rect.top, draw_rect.Width(), draw_rect.Height(),
       (const CFX_DIBitmap*)m_pClipRgn->GetMask(), fill_color,
       draw_rect.left - clip_rect.left, draw_rect.top - clip_rect.top,
       FXDIB_BLEND_NORMAL, NULL, m_bRgbByteOrder, alpha_flag, pIccTransform);
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::GetClipBox(FX_RECT* pRect) {
   if (!m_pClipRgn) {
     pRect->left = pRect->top = 0;
     pRect->right = GetDeviceCaps(FXDC_PIXEL_WIDTH);
     pRect->bottom = GetDeviceCaps(FXDC_PIXEL_HEIGHT);
     return TRUE;
   }
   *pRect = m_pClipRgn->GetBox();
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::GetDIBits(CFX_DIBitmap* pBitmap,
                                        int left,
                                        int top,
                                        void* pIccTransform,
                                        FX_BOOL bDEdge) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (bDEdge) {
     if (m_bRgbByteOrder) {
@@ skipping 28 matching lines @@
   if (m_bRgbByteOrder) {
     RgbByteOrderTransferBitmap(pBitmap, 0, 0, rect.Width(), rect.Height(),
                                pBack, left, top);
   } else {
     bRet = pBitmap->TransferBitmap(0, 0, rect.Width(), rect.Height(), pBack,
                                    left, top, pIccTransform);
   }
   delete pBack;
   return bRet;
 }
+
 FX_BOOL CFX_AggDeviceDriver::SetDIBits(const CFX_DIBSource* pBitmap,
                                        FX_DWORD argb,
                                        const FX_RECT* pSrcRect,
                                        int left,
                                        int top,
                                        int blend_type,
                                        int alpha_flag,
                                        void* pIccTransform) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   if (pBitmap->IsAlphaMask())
     return m_pBitmap->CompositeMask(
         left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, argb,
         pSrcRect->left, pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder,
         alpha_flag, pIccTransform);
   return m_pBitmap->CompositeBitmap(
       left, top, pSrcRect->Width(), pSrcRect->Height(), pBitmap, pSrcRect->left,
       pSrcRect->top, blend_type, m_pClipRgn, m_bRgbByteOrder, pIccTransform);
 }
+
 FX_BOOL CFX_AggDeviceDriver::StretchDIBits(const CFX_DIBSource* pSource,
                                            FX_DWORD argb,
                                            int dest_left,
                                            int dest_top,
                                            int dest_width,
                                            int dest_height,
                                            const FX_RECT* pClipRect,
                                            FX_DWORD flags,
                                            int alpha_flag,
                                            void* pIccTransform,
@@ skipping 17 matching lines @@
                    FALSE, m_bRgbByteOrder, alpha_flag, pIccTransform,
                    blend_type);
   dest_clip.Offset(-dest_rect.left, -dest_rect.top);
   CFX_ImageStretcher stretcher;
   if (stretcher.Start(&composer, pSource, dest_width, dest_height, dest_clip,
                       flags)) {
     stretcher.Continue(NULL);
   }
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::StartDIBits(const CFX_DIBSource* pSource,
                                          int bitmap_alpha,
                                          FX_DWORD argb,
                                          const CFX_Matrix* pMatrix,
                                          FX_DWORD render_flags,
                                          void*& handle,
                                          int alpha_flag,
                                          void* pIccTransform,
                                          int blend_type) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   CFX_ImageRenderer* pRenderer = new CFX_ImageRenderer;
   pRenderer->Start(m_pBitmap, m_pClipRgn, pSource, bitmap_alpha, argb, pMatrix,
                    render_flags, m_bRgbByteOrder, alpha_flag, pIccTransform);
   handle = pRenderer;
   return TRUE;
 }
+
 FX_BOOL CFX_AggDeviceDriver::ContinueDIBits(void* pHandle, IFX_Pause* pPause) {
   if (!m_pBitmap->GetBuffer()) {
     return TRUE;
   }
   return ((CFX_ImageRenderer*)pHandle)->Continue(pPause);
 }
+
 void CFX_AggDeviceDriver::CancelDIBits(void* pHandle) {
   if (!m_pBitmap->GetBuffer()) {
     return;
   }
   delete (CFX_ImageRenderer*)pHandle;
 }
+
 CFX_FxgeDevice::CFX_FxgeDevice() {
   m_bOwnedBitmap = FALSE;
 }
+
 FX_BOOL CFX_FxgeDevice::Attach(CFX_DIBitmap* pBitmap,
                                int dither_bits,
                                FX_BOOL bRgbByteOrder,
                                CFX_DIBitmap* pOriDevice,
                                FX_BOOL bGroupKnockout) {
   if (!pBitmap) {
     return FALSE;
   }
   SetBitmap(pBitmap);
   IFX_RenderDeviceDriver* pDriver = new CFX_AggDeviceDriver(
       pBitmap, dither_bits, bRgbByteOrder, pOriDevice, bGroupKnockout);
   SetDeviceDriver(pDriver);
   return TRUE;
 }
+
 FX_BOOL CFX_FxgeDevice::Create(int width,
                                int height,
                                FXDIB_Format format,
                                int dither_bits,
                                CFX_DIBitmap* pOriDevice) {
   m_bOwnedBitmap = TRUE;
   CFX_DIBitmap* pBitmap = new CFX_DIBitmap;
   if (!pBitmap->Create(width, height, format)) {
     delete pBitmap;
     return FALSE;
   }
   SetBitmap(pBitmap);
   IFX_RenderDeviceDriver* pDriver =
       new CFX_AggDeviceDriver(pBitmap, dither_bits, FALSE, pOriDevice, FALSE);
   SetDeviceDriver(pDriver);
   return TRUE;
 }
+
 CFX_FxgeDevice::~CFX_FxgeDevice() {
   if (m_bOwnedBitmap) {
     delete GetBitmap();
   }
 }