Add support for trapezoidal fills

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@1323 42af7a65-404d-4744-a932-0658087f49c3

9 files changed, 400 insertions, 31 deletions

diff --git a/nuttx/graphics/nxbe/Make.defs b/nuttx/graphics/nxbe/Make.defs
index 034aa8824..647b074c4 100644
--- a/nuttx/graphics/nxbe/Make.defs
+++ b/nuttx/graphics/nxbe/Make.defs
@@ -37,5 +37,5 @@ NXBE_ASRCS	=
 NXBE_CSRCS	= nxbe_fbconfigure.c nxbe_colormap.c nxbe_clipper.c \
 		  nxbe_closewindow.c \
 		  nxbe_setposition.c nxbe_setsize.c nxbe_raise.c nxbe_lower.c \
-		  nxbe_fill.c nxbe_move.c nxbe_bitmap.c \
+		  nxbe_fill.c nxbe_filltrapezoid.c nxbe_move.c nxbe_bitmap.c \
 		  nxbe_redraw.c nxbe_redrawbelow.c
diff --git a/nuttx/graphics/nxbe/nxbe.h b/nuttx/graphics/nxbe/nxbe.h
index f6825a969..958ea9f35 100644
--- a/nuttx/graphics/nxbe/nxbe.h
+++ b/nuttx/graphics/nxbe/nxbe.h
@@ -55,13 +55,6 @@
 #  define CONFIG_NX_NPLANES      1  /* Max number of color planes supported */
 #endif
 
-/* Mnemonics for indices */
-
-#define NX_TOP_NDX           (0)
-#define NX_LEFT_NDX          (1)
-#define NX_RIGHT_NDX         (2)
-#define NX_BOTTOM_NDX        (3)
-
 /* These are the values for the clipping order provided to nx_clipper */
 
 #define NX_CLIPORDER_TLRB    (0)   /* Top-left-right-bottom */
@@ -87,6 +80,10 @@ struct nxbe_plane_s
   void (*fillrectangle)(FAR struct fb_planeinfo_s *pinfo,
                         FAR const struct nxgl_rect_s *rect,
                         nxgl_mxpixel_t color);
+  void (*filltrapezoid)(FAR struct fb_planeinfo_s *pinfo,
+                        FAR const struct nxgl_trapezoid_s *trap,
+                        FAR const struct nxgl_rect_s *bounds,
+                        nxgl_mxpixel_t color);
   void (*moverectangle)(FAR struct fb_planeinfo_s *pinfo,
                         FAR const struct nxgl_rect_s *rect,
                         FAR struct nxgl_point_s *offset);
diff --git a/nuttx/graphics/nxbe/nxbe_fbconfigure.c b/nuttx/graphics/nxbe/nxbe_fbconfigure.c
index 2e98d4463..0cf41cd27 100644
--- a/nuttx/graphics/nxbe/nxbe_fbconfigure.c
+++ b/nuttx/graphics/nxbe/nxbe_fbconfigure.c
@@ -128,6 +128,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 1)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_1bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_1bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_1bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_1bpp;
         }
@@ -137,6 +138,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 2)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_2bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_2bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_2bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_2bpp;
         }
@@ -146,6 +148,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 4)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_4bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_4bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_4bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_4bpp;
         }
@@ -155,6 +158,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 8)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_8bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_8bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_8bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_8bpp;
         }
@@ -164,6 +168,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 16)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_16bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_16bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_16bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_16bpp;
         }
@@ -173,6 +178,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 24)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_24bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_24bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_24bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_24bpp;
         }
@@ -182,6 +188,7 @@ int nxbe_fbconfigure(FAR struct fb_vtable_s *fb, FAR struct nxbe_state_s *be)
       if (be->plane[i].pinfo.bpp == 32)
         {
           be->plane[i].fillrectangle = nxgl_fillrectangle_32bpp;
+          be->plane[i].filltrapezoid = nxgl_filltrapezoid_32bpp;
           be->plane[i].moverectangle = nxgl_moverectangle_32bpp;
           be->plane[i].copyrectangle = nxgl_copyrectangle_32bpp;
         }
diff --git a/nuttx/graphics/nxbe/nxbe_fill.c b/nuttx/graphics/nxbe/nxbe_fill.c
index e92b21b10..d175d64fc 100644
--- a/nuttx/graphics/nxbe/nxbe_fill.c
+++ b/nuttx/graphics/nxbe/nxbe_fill.c
@@ -121,15 +121,23 @@ void nxbe_fill(FAR struct nxbe_window_s *wnd,
     }
 #endif
 
-  /* Offset the rectangle by the window origin to convert it into a bounding box */
+  /* Offset the rectangle by the window origin to convert it into a
+   * bounding box
+   */
 
   nxgl_rectoffset(&remaining, rect, wnd->origin.x, wnd->origin.y);
 
-  /* Clip to the limits of the window and of the background screen */
+  /* Clip to the bounding box to the limits of the window and of the
+   * background screen
+   */
 
   nxgl_rectintersect(&remaining, &remaining, &wnd->bounds);
   nxgl_rectintersect(&remaining, &remaining, &wnd->be->bkgd.bounds);
 
+  /* Then clip the bounding box due to other windows above this one.
+   * Render the portions of the trapezoid exposed in visible regions.
+   */
+
   if (!nxgl_nullrect(&remaining))
     {
 #if CONFIG_NX_NPLANES > 1
@@ -143,7 +151,7 @@ void nxbe_fill(FAR struct nxbe_window_s *wnd,
           info.color         = color[i];
 
           nxbe_clipper(wnd->above, &remaining, NX_CLIPORDER_DEFAULT,
-                       &info.cops, &wnd->be->plane[0]);
+                       &info.cops, &wnd->be->plane[i]);
         }
     }
 }
diff --git a/nuttx/graphics/nxbe/nxbe_filltrapezoid.c b/nuttx/graphics/nxbe/nxbe_filltrapezoid.c
new file mode 100644
index 000000000..78445e7f9
--- /dev/null
+++ b/nuttx/graphics/nxbe/nxbe_filltrapezoid.c
@@ -0,0 +1,162 @@
+/****************************************************************************
+ * graphics/nxbe/nxbe_filltrapezoid.c
+ *
+ *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <fixedmath.h>
+#include <nuttx/nxglib.h>
+
+#include "nxbe.h"
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+struct nxbe_filltrap_s
+{
+  struct nxbe_clipops_s cops;
+  struct nxgl_trapezoid_s trap;
+  nxgl_mxpixel_t color;
+};
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: nxbe_clipfilltrapezoid
+ *
+ * Description:
+ *  Called from nxbe_clipper() to performed the fill operation on visible portions
+ *  of the rectangle.
+ *
+ ****************************************************************************/
+
+static void nxbe_clipfilltrapezoid(FAR struct nxbe_clipops_s *cops,
+                                   FAR struct nxbe_plane_s *plane,
+                                   FAR const struct nxgl_rect_s *rect)
+{
+  struct nxbe_filltrap_s *fillinfo = (struct nxbe_filltrap_s *)cops;
+  plane->filltrapezoid(&plane->pinfo, &fillinfo->trap, rect, fillinfo->color);
+}
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: nxbe_filltrapezoid
+ *
+ * Description:
+ *  Fill the specified rectangle in the window with the specified color
+ *
+ * Input Parameters:
+ *   wnd  - The window structure reference
+ *   rect - The location to be filled
+ *   col  - The color to use in the fill
+ *
+ * Return:
+ *   None
+ *
+ ****************************************************************************/
+
+void nxbe_filltrapezoid(FAR struct nxbe_window_s *wnd,
+                        FAR const struct nxgl_trapezoid_s *trap,
+                        nxgl_mxpixel_t color[CONFIG_NX_NPLANES])
+{
+  struct nxbe_filltrap_s info;
+  struct nxgl_rect_s bounds;
+  struct nxgl_rect_s remaining;
+  int i;
+
+#ifdef CONFIG_DEBUG
+  if (!wnd || !trap)
+    {
+      return;
+    }
+#endif
+
+  /* Offset the trapezoid by the window origin to position it within
+   * the framebuffer region
+   */
+
+  nxgl_trapoffset(&info.trap, trap, wnd->origin.x, wnd->origin.y);
+
+  /* Now create a bounding box that contains the trapezoid */
+
+  bounds.pt1.x = b16toi(ngl_min(info.trap.top.x1, info.trap.bot.x1));
+  bounds.pt1.y = b16toi(info.trap.top.y);
+  bounds.pt2.x = b16toi(ngl_max(info.trap.top.x2, info.trap.bot.x2));
+  bounds.pt2.y = b16toi(info.trap.bot.y);
+
+  /* Clip to the limits of the window and of the background screen */
+
+  nxgl_rectintersect(&remaining, &bounds, &wnd->bounds);
+  nxgl_rectintersect(&remaining, &remaining, &wnd->be->bkgd.bounds);
+
+  if (!nxgl_nullrect(&remaining))
+    {
+#if CONFIG_NX_NPLANES > 1
+      for (i = 0; i < wnd->be->vinfo.nplanes; i++)
+#else
+      i = 0;
+#endif
+        {
+          info.cops.visible  = nxbe_clipfilltrapezoid;
+          info.cops.obscured = nxbe_clipnull;
+          info.color         = color[i];
+
+          nxbe_clipper(wnd->above, &remaining, NX_CLIPORDER_DEFAULT,
+                       &info.cops, &wnd->be->plane[i]);
+        }
+    }
+}
diff --git a/nuttx/graphics/nxglib/Make.defs b/nuttx/graphics/nxglib/Make.defs
index ab0427e8b..82ce3bdd9 100644
--- a/nuttx/graphics/nxglib/Make.defs
+++ b/nuttx/graphics/nxglib/Make.defs
@@ -51,10 +51,12 @@ RMOVE2_CSRCS	= nxglib_moverectangle_8bpp.c nxglib_moverectangle_16bpp.c \
 #		  nxglib_copyrectangle_4bpp.c
 RCOPY2_CSRCS	= nxglib_copyrectangle_8bpp.c nxglib_copyrectangle_16bpp.c \
 		  nxglib_copyrectangle_24bpp.c nxglib_copyrectangle_32bpp.c
-RECT_CRCS	= nxglib_rectcopy.c nxglib_rectoffset.c nxglib_vectoradd.c \
+RECT_CSRCS	= nxglib_rectcopy.c nxglib_rectoffset.c nxglib_vectoradd.c \
 		  nxglib_rectintersect.c nxglib_nonintersecting.c \
 		  nxglib_rectoverlap.c nxglib_nullrect.c
+TRAP_CSRCS	= nxglib_runoffset.c nxglib_trapoffset.c
 NXGLIB_CSRCS	= nxglib_rgb2yuv.c nxglib_yuv2rgb.c \
 		  $(RFILL1_CSRCS) $(RFILL2_CSRCS) $(TFILL1_CSRCS) $(TFILL2_CSRCS) \
-		  $(RMOVE1_CSRCS) $(RMOVE2_CSRCS) $(RCOPY1_CSRCS) $(RCOPY2_CSRCS)
+		  $(RMOVE1_CSRCS) $(RMOVE2_CSRCS) $(RCOPY1_CSRCS) $(RCOPY2_CSRCS) \
+		  $(RECT_CSRCS) $(TRAP_CSRCS)
 
diff --git a/nuttx/graphics/nxglib/nxglib_filltrapezoid.c b/nuttx/graphics/nxglib/nxglib_filltrapezoid.c
index 2343a4680..a4ea25e51 100644
--- a/nuttx/graphics/nxglib/nxglib_filltrapezoid.c
+++ b/nuttx/graphics/nxglib/nxglib_filltrapezoid.c
@@ -79,20 +79,24 @@
  *
  * Descripton:
  *   Fill a trapezoidal region in the framebuffer memory with a fixed color.
- *   This is useful for drawing complex shape -- (most) complex shapes can be
- *   broken into a set of trapezoids.
+ *   Clip the trapezoid to lie within a boundng box.  This is useful for
+ *   drawing complex shapes that can be broken into a set of trapezoids.
  *
  ****************************************************************************/
 
-void NXGL_FUNCNAME(nxglib_filltrapezoid,NXGLIB_SUFFIX)
-(FAR struct fb_videoinfo_s *vinfo, FAR struct fb_planeinfo_s *pinfo,
- FAR const struct nxgl_trapezoid_s *trap, nxgl_mxpixel_t color)
+void NXGL_FUNCNAME(nxgl_filltrapezoid,NXGLIB_SUFFIX)(
+  FAR struct fb_planeinfo_s *pinfo,
+  FAR const struct nxgl_trapezoid_s *trap,
+  FAR const struct nxgl_rect_s *bounds,
+  nxgl_mxpixel_t color)
 {
   unsigned int stride;
   ubyte *line;
   int nrows;
   b16_t x1;
   b16_t x2;
+  nxgl_coord_t y1;
+  nxgl_coord_t y2;
   b16_t dx1dy;
   b16_t dx2dy;
 
@@ -102,18 +106,38 @@ void NXGL_FUNCNAME(nxglib_filltrapezoid,NXGLIB_SUFFIX)
 
   /* Get the top run position and the number of rows to draw */
 
-  x1     = trap->top.x1;
-  x2     = trap->top.x2;
-  nrows  = trap->bot.y - trap->top.y + 1;
+  x1 = trap->top.x1;
+  x2 = trap->top.x2;
 
-  /* Get the address of the first byte on the first line */
+  /* Calculate the slope of the left and right side of the trapezoid */
 
-  line   = pinfo->fbmem + trap->top.y * stride ;
+  dx1dy = b16divi((trap->bot.x1 - x1), nrows);
+  dx2dy = b16divi((trap->bot.x2 - x2), nrows);
 
-  /* Calculate the slope of the left and right side of the trapezoid */
+  /* Perform vertical clipping */
+
+  y1 = trap->top.y;
+  if (y1 < bounds->pt1.y)
+    {
+      int dy = bounds->pt1.y - y1;
+      x1    += dy * dx1dy;
+      x2    += dy * dx2dy;
+      y1     = bounds->pt1.y;
+    }
+
+  y2 = trap->bot.y;
+  if (y2 > bounds->pt2.y)
+    {
+      y2 = bounds->pt2.y;
+    }
+
+  /* Then calculate the number of rows to render */
+
+  nrows  = y2 - y1 + 1;
+
+  /* Get the address of the first byte on the first line */
 
-  dx1dy  = b16divi((trap->bot.x1 - x1), nrows);
-  dx2dy  = b16divi((trap->bot.x2 - x2), nrows);
+  line   = pinfo->fbmem + y1 * stride ;
 
   /* Then fill the trapezoid line-by-line */
 
@@ -140,17 +164,17 @@ void NXGL_FUNCNAME(nxglib_filltrapezoid,NXGLIB_SUFFIX)
        * always draw at least one pixel.
        */
 
-      if (x1 > x2 || ix2 < 0 || ix1 > vinfo->yres)
+      if (x1 > x2 || ix2 < bounds->pt1.x || ix1 > bounds->pt2.x)
         {
-          /* Get a clipped copies of the startingand ending X positions.  This
+          /* Get a clipped copies of the starting and ending X positions.  This
            * clipped truncates "down" and gives the quantized pixel holding the
            * fractional X position
            */
 
-          ix1 = ngl_clipl(ix1, 0);
-          ix2 = ngl_clipr(ix2, vinfo->yres);
+          ix1 = ngl_clipl(ix1, bounds->pt1.x);
+          ix2 = ngl_clipr(ix2, bounds->pt2.x);
 
-          /* Then draw the run from (line + clipx1) to (line + clipx2) */
+          /* Then draw the run from (line + ix1) to (line + ix2) */
 
           NXGL_MEMSET(line + NXGL_SCALEX(ix1), (NXGL_PIXEL_T)color, ix2 - ix1 + 1);
         }
diff --git a/nuttx/graphics/nxglib/nxglib_runoffset.c b/nuttx/graphics/nxglib/nxglib_runoffset.c
new file mode 100644
index 000000000..02aaab894
--- /dev/null
+++ b/nuttx/graphics/nxglib/nxglib_runoffset.c
@@ -0,0 +1,86 @@
+/****************************************************************************
+ * graphics/nxglib/nxsglib_runoffset.c
+ *
+ *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <fixedmath.h>
+#include <nuttx/nxglib.h>
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: nxgl_runoffset
+ *
+ * Description:
+ *   Offset the run position by the specified dx, dy values.
+ *
+ ****************************************************************************/
+
+void nxgl_runoffset(FAR struct nxgl_run_s *dest,
+                    FAR const struct nxgl_run_s *src,
+                    nxgl_coord_t dx, nxgl_coord_t dy)
+{
+  b16_t b16dx = itob16(dx);
+  dest->x1  += b16dx;
+  dest->x2  += b16dx;
+  dest->y   += dy;
+}
diff --git a/nuttx/graphics/nxglib/nxglib_trapoffset.c b/nuttx/graphics/nxglib/nxglib_trapoffset.c
new file mode 100644
index 000000000..4c6f1cffa
--- /dev/null
+++ b/nuttx/graphics/nxglib/nxglib_trapoffset.c
@@ -0,0 +1,83 @@
+/****************************************************************************
+ * graphics/nxglib/nxsglib_trapoffset.c
+ *
+ *   Copyright (C) 2008 Gregory Nutt. All rights reserved.
+ *   Author: Gregory Nutt <spudmonkey@racsa.co.cr>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ * 3. Neither the name NuttX nor the names of its contributors may be
+ *    used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ *
+ ****************************************************************************/
+
+/****************************************************************************
+ * Included Files
+ ****************************************************************************/
+
+#include <nuttx/config.h>
+
+#include <sys/types.h>
+#include <nuttx/nxglib.h>
+
+/****************************************************************************
+ * Pre-Processor Definitions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Types
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Data
+ ****************************************************************************/
+
+/****************************************************************************
+ * Private Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Public Functions
+ ****************************************************************************/
+
+/****************************************************************************
+ * Name: nxgl_trapoffset
+ *
+ * Description:
+ *   Offset the trapezoid position by the specified dx, dy values.
+ *
+ ****************************************************************************/
+
+void nxgl_trapoffset(FAR struct nxgl_trapezoid_s *dest,
+                     FAR const struct nxgl_trapezoid_s *src,
+                     nxgl_coord_t dx, nxgl_coord_t dy)
+{
+  nxgl_runoffset(&dest->top, &src->top, dx, dy);
+  nxgl_runoffset(&dest->bot, &src->bot, dx, dy);
+}