0a17b87286
Most tools used for compliance and SBOM generation use SPDX identifiers This change brings us a step closer to an easy SBOM generation. Signed-off-by: Alin Jerpelea <alin.jerpelea@sony.com>
829 lines
29 KiB
C
829 lines
29 KiB
C
/****************************************************************************
|
|
* graphics/nxbe/nxbe.h
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership. The
|
|
* ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
* "License"); you may not use this file except in compliance with the
|
|
* License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifndef __GRAPHICS_NXBE_NXBE_H
|
|
#define __GRAPHICS_NXBE_NXBE_H
|
|
|
|
/****************************************************************************
|
|
* Included Files
|
|
****************************************************************************/
|
|
|
|
#include <nuttx/config.h>
|
|
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
|
|
#include <nuttx/nx/nx.h>
|
|
#include <nuttx/nx/nxglib.h>
|
|
#include <nuttx/nx/nxcursor.h>
|
|
#include <nuttx/nx/nxbe.h>
|
|
|
|
/****************************************************************************
|
|
* Pre-processor Definitions
|
|
****************************************************************************/
|
|
|
|
/* These are the values for the clipping order provided to nx_clipper */
|
|
|
|
#define NX_CLIPORDER_TLRB (0) /* Top-left-right-bottom */
|
|
#define NX_CLIPORDER_TRLB (1) /* Top-right-left-bottom */
|
|
#define NX_CLIPORDER_BLRT (2) /* Bottom-left-right-top */
|
|
#define NX_CLIPORDER_BRLT (3) /* Bottom-right-left-top */
|
|
#define NX_CLIPORDER_DEFAULT NX_CLIPORDER_TLRB
|
|
|
|
/* Server flags and helper macros:
|
|
*
|
|
* NXBE_STATE_MODAL - One window is in a focused, modal state
|
|
*/
|
|
|
|
#define NXBE_STATE_MODAL (1 << 0) /* Bit 0: One window is in a focused,
|
|
* modal state */
|
|
|
|
/* Helpful flag macros */
|
|
|
|
#define NXBE_STATE_ISMODAL(nxbe) \
|
|
(((nxbe)->flags & NXBE_STATE_MODAL) != 0)
|
|
#define NXBE_STATE_SETMODAL(nxbe) \
|
|
do { (nxbe)->flags |= NXBE_STATE_MODAL; } while (0)
|
|
#define NXBE_STATE_CLRMODAL(nxbe) \
|
|
do { (nxbe)->flags &= ~NXBE_STATE_MODAL; } while (0)
|
|
|
|
/****************************************************************************
|
|
* Public Types
|
|
****************************************************************************/
|
|
|
|
/* Rasterization ************************************************************/
|
|
|
|
/* A vtable of raster operation function pointers. The types of the
|
|
* function points must match the device rasterizer types exported by nxglib.
|
|
*/
|
|
|
|
struct nxbe_dev_vtable_s
|
|
{
|
|
CODE void (*setpixel)(FAR NX_PLANEINFOTYPE *pinfo,
|
|
FAR const struct nxgl_point_s *pos,
|
|
nxgl_mxpixel_t color);
|
|
CODE void (*fillrectangle)(FAR NX_PLANEINFOTYPE *pinfo,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
nxgl_mxpixel_t color);
|
|
CODE void (*getrectangle)(FAR NX_PLANEINFOTYPE *pinfo,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
FAR void *dest, unsigned int deststride);
|
|
CODE void (*filltrapezoid)(FAR NX_PLANEINFOTYPE *pinfo,
|
|
FAR const struct nxgl_trapezoid_s *trap,
|
|
FAR const struct nxgl_rect_s *bounds,
|
|
nxgl_mxpixel_t color);
|
|
CODE void (*moverectangle)(FAR NX_PLANEINFOTYPE *pinfo,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
FAR struct nxgl_point_s *offset);
|
|
CODE void (*copyrectangle)(FAR NX_PLANEINFOTYPE *pinfo,
|
|
FAR const struct nxgl_rect_s *dest,
|
|
FAR const void *src,
|
|
FAR const struct nxgl_point_s *origin,
|
|
unsigned int srcstride);
|
|
};
|
|
|
|
#ifdef CONFIG_NX_RAMBACKED
|
|
/* A vtable of raster operation function pointers. The types of the
|
|
* function points must match the per-window framebuffer rasterizer types
|
|
* exported by nxglib.
|
|
*/
|
|
|
|
struct nxbe_pwfb_vtable_s
|
|
{
|
|
CODE void (*setpixel)(FAR struct nxbe_window_s *bwnd,
|
|
FAR const struct nxgl_point_s *pos,
|
|
nxgl_mxpixel_t color);
|
|
CODE void (*fillrectangle)(FAR struct nxbe_window_s *bwnd,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
nxgl_mxpixel_t color);
|
|
CODE void (*getrectangle)(FAR struct nxbe_window_s *bwnd,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
FAR void *dest, unsigned int deststride);
|
|
CODE void (*filltrapezoid)(FAR struct nxbe_window_s *bwnd,
|
|
FAR const struct nxgl_trapezoid_s *trap,
|
|
FAR const struct nxgl_rect_s *bounds,
|
|
nxgl_mxpixel_t color);
|
|
CODE void (*moverectangle)(FAR struct nxbe_window_s *bwnd,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
FAR struct nxgl_point_s *offset);
|
|
CODE void (*copyrectangle)(FAR struct nxbe_window_s *bwnd,
|
|
FAR const struct nxgl_rect_s *dest,
|
|
FAR const void *src,
|
|
FAR const struct nxgl_point_s *origin,
|
|
unsigned int srcstride);
|
|
};
|
|
#endif
|
|
|
|
#ifdef CONFIG_NX_SWCURSOR
|
|
/* A vtable of raster operation function pointers. The types of the
|
|
* function points must match the cursor rasterizer types exported by
|
|
* nxglib.
|
|
*/
|
|
|
|
struct nxbe_cursorops_s
|
|
{
|
|
CODE void (*draw)(FAR struct nxbe_state_s *be,
|
|
FAR const struct nxgl_rect_s *bounds,
|
|
int planeno);
|
|
CODE void (*erase)(FAR struct nxbe_state_s *be,
|
|
FAR const struct nxgl_rect_s *bounds,
|
|
int planeno);
|
|
CODE void (*backup)(FAR struct nxbe_state_s *be,
|
|
FAR const struct nxgl_rect_s *bounds,
|
|
int planeno);
|
|
};
|
|
#endif
|
|
|
|
/* Encapsulates everything needed support window rasterization commands. */
|
|
|
|
struct nxbe_plane_s
|
|
{
|
|
/* Raster device operations */
|
|
|
|
struct nxbe_dev_vtable_s dev;
|
|
|
|
#ifdef CONFIG_NX_RAMBACKED
|
|
/* Raster per-window framebuffer operations */
|
|
|
|
struct nxbe_pwfb_vtable_s pwfb;
|
|
#endif
|
|
|
|
#ifdef CONFIG_NX_SWCURSOR
|
|
/* Cursor device operations */
|
|
|
|
struct nxbe_cursorops_s cursor;
|
|
#endif
|
|
|
|
/* Framebuffer plane info describing destination video plane */
|
|
|
|
NX_DRIVERTYPE *driver;
|
|
NX_PLANEINFOTYPE pinfo;
|
|
};
|
|
|
|
/* Clipping *****************************************************************/
|
|
|
|
/* Clipping callback functions called nxbe_clipper for each visible and
|
|
* obscured region of a rectangle within a window.
|
|
*/
|
|
|
|
struct nxbe_clipops_s
|
|
{
|
|
CODE void (*visible)(FAR struct nxbe_clipops_s *cops,
|
|
FAR struct nxbe_plane_s *plane,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
|
|
CODE void (*obscured)(FAR struct nxbe_clipops_s *cops,
|
|
FAR struct nxbe_plane_s *plane,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
};
|
|
|
|
/* Cursor *******************************************************************/
|
|
|
|
/* Cursor state structure */
|
|
|
|
#if defined(CONFIG_NX_SWCURSOR)
|
|
struct nxbe_cursor_s
|
|
{
|
|
bool visible; /* True: the cursor is visible */
|
|
struct nxgl_rect_s bounds; /* Cursor image bounding box */
|
|
nxgl_mxpixel_t color1[CONFIG_NX_NPLANES]; /* Color1 is main color of the cursor */
|
|
nxgl_mxpixel_t color2[CONFIG_NX_NPLANES]; /* Color2 is color of any border */
|
|
nxgl_mxpixel_t color3[CONFIG_NX_NPLANES]; /* Color3 is the blended color */
|
|
size_t allocsize; /* Size of the background allocation */
|
|
FAR const uint8_t *image; /* Cursor image at 2-bits/pixel */
|
|
FAR nxgl_mxpixel_t *bkgd; /* Cursor background in device pixels */
|
|
};
|
|
#elif defined(CONFIG_NX_HWCURSOR)
|
|
struct nxbe_cursor_s
|
|
{
|
|
bool visible; /* True: the cursor is visible */
|
|
struct nxgl_point_s pos; /* The current cursor position */
|
|
};
|
|
#endif
|
|
|
|
/* Back-end state ***********************************************************/
|
|
|
|
/* This structure describes the overall back-end window state */
|
|
|
|
struct nxbe_state_s
|
|
{
|
|
uint8_t flags; /* NXBE_STATE_* flags */
|
|
|
|
#if defined(CONFIG_NX_SWCURSOR) || defined(CONFIG_NX_HWCURSOR)
|
|
/* Cursor support */
|
|
|
|
struct nxbe_cursor_s cursor; /* Cursor support */
|
|
#endif
|
|
|
|
/* The window list (with the background window always at the bottom) */
|
|
|
|
FAR struct nxbe_window_s *topwnd; /* The window at the top of the display */
|
|
struct nxbe_window_s bkgd; /* The background window is always at the bottom */
|
|
|
|
/* At present, only a solid colored background is supported for refills.
|
|
* The following provides the background color. It would be nice to
|
|
* support background bitmap images as well.
|
|
*/
|
|
|
|
nxgl_mxpixel_t bgcolor[CONFIG_NX_NPLANES];
|
|
|
|
/* vinfo describes the video controller and plane[n].pinfo describes color
|
|
* plane 'n' supported by the video controller. Most common color models
|
|
* fit in one plane, but this array provides future support for hardware
|
|
* with planar YUV types with 3 or 4 color planes.
|
|
*/
|
|
|
|
struct fb_videoinfo_s vinfo;
|
|
|
|
/* Rasterizing functions selected to match the BPP reported in pinfo[] */
|
|
|
|
struct nxbe_plane_s plane[CONFIG_NX_NPLANES];
|
|
};
|
|
|
|
/****************************************************************************
|
|
* Public Data
|
|
****************************************************************************/
|
|
|
|
#undef EXTERN
|
|
#if defined(__cplusplus)
|
|
#define EXTERN extern "C"
|
|
extern "C"
|
|
{
|
|
#else
|
|
#define EXTERN extern
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Public Function Prototypes
|
|
****************************************************************************/
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_colormap
|
|
*
|
|
* Description:
|
|
* Set the hardware color map to the palette expected by NX
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_FB_CMAP
|
|
int nxbe_colormap(FAR NX_DRIVERTYPE *dev);
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_notify_rectangle
|
|
*
|
|
* Description:
|
|
* When CONFIG_NX_UPDATE=y, then the graphics system will callout to
|
|
* inform some external module that the display has been updated. This
|
|
* would be useful in a couple for cases.
|
|
*
|
|
* - When a serial LCD is used, but a framebuffer is used to access the
|
|
* LCD. In this case, the update callout can be used to refresh the
|
|
* affected region of the display.
|
|
*
|
|
* - When VNC is enabled. This is case, this callout is necessary to
|
|
* update the remote frame buffer to match the local framebuffer.
|
|
*
|
|
* When this feature is enabled, some external logic must provide this
|
|
* interface. This is the function that will handle the notification. It
|
|
* receives the rectangular region that was updated on the provided plane.
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NX_UPDATE
|
|
void nxbe_notify_rectangle(FAR NX_DRIVERTYPE *dev,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: nx_configure
|
|
*
|
|
* Description:
|
|
* Configure the back end state structure based on information from the
|
|
* framebuffer or LCD driver
|
|
*
|
|
****************************************************************************/
|
|
|
|
int nxbe_configure(FAR NX_DRIVERTYPE *dev, FAR struct nxbe_state_s *be);
|
|
|
|
#if defined(CONFIG_NX_SWCURSOR) || defined(CONFIG_NX_HWCURSOR)
|
|
/****************************************************************************
|
|
* Name: nxbe_cursor_enable
|
|
*
|
|
* Description:
|
|
* Enable/disable presentation of the cursor
|
|
*
|
|
* Input Parameters:
|
|
* be - The back-end state structure instance
|
|
* enable - True: show the cursor, false: hide the cursor.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_cursor_enable(FAR struct nxbe_state_s *be, bool enable);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_cursor_setimage
|
|
*
|
|
* Description:
|
|
* Set the cursor image
|
|
*
|
|
* The image is provided a a 2-bits-per-pixel image. The two bit incoding
|
|
* is as following:
|
|
*
|
|
* 00 - The transparent background
|
|
* 01 - Color1: The main color of the cursor
|
|
* 10 - Color2: The color of any border
|
|
* 11 - Color3: A blend color for better imaging (fake anti-aliasing).
|
|
*
|
|
* Input Parameters:
|
|
* be - The back-end state structure instance
|
|
* image - Describes the cursor image in the expected format.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
#if defined(CONFIG_NX_HWCURSORIMAGE) || defined(CONFIG_NX_SWCURSOR)
|
|
void nxbe_cursor_setimage(FAR struct nxbe_state_s *be,
|
|
FAR struct nx_cursorimage_s *image);
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_cursor_setposition
|
|
*
|
|
* Description:
|
|
* Move the cursor to the specified position
|
|
*
|
|
* Input Parameters:
|
|
* be - The back-end state structure instance
|
|
* pos - The new cursor position
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_cursor_setposition(FAR struct nxbe_state_s *be,
|
|
FAR const struct nxgl_point_s *pos);
|
|
|
|
#endif /* CONFIG_NX_SWCURSOR || CONFIG_NX_HWCURSOR */
|
|
|
|
#ifdef CONFIG_NX_SWCURSOR
|
|
/****************************************************************************
|
|
* Name: nxbe_cursor_backupdraw and nxbe_cursor_backupdraw_dev
|
|
*
|
|
* Description:
|
|
* Called after any modification to the display (in window coordinate
|
|
* frame) to perform the backup-draw operation on one color plane.
|
|
*
|
|
* Input Parameters:
|
|
* be - The back-end state structure instance, or
|
|
* wnd - Window state structure
|
|
* rect - The modified region of the window. In windows coordinates for
|
|
* nxbe_cursor_backupdraw(); in graphics device coordinates for
|
|
* nxbe_cursor_backupdraw_dev().
|
|
* plane - The plane number to use.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_cursor_backupdraw(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect, int plane);
|
|
void nxbe_cursor_backupdraw_dev(FAR struct nxbe_state_s *be,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
int plane);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_cursor_backupdraw_all and nxbe_cursor_backupdraw_devall
|
|
*
|
|
* Description:
|
|
* Called after any modification to the display to perform the backup-draw
|
|
* operation on all color planes.
|
|
*
|
|
* Input Parameters:
|
|
* be - The back-end state structure instance, or
|
|
* wnd - Window state structure
|
|
* rect - The modified region of the window. In windows coordinates for
|
|
* nxbe_cursor_backupdraw(); in graphics device coordinates for
|
|
* nxbe_cursor_backupdraw_dev().
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_cursor_backupdraw_all(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
void nxbe_cursor_backupdraw_devall(FAR struct nxbe_state_s *be,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
#endif /* */
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_closewindow
|
|
*
|
|
* Description:
|
|
* Close an existing window
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window to be closed (and deallocated)
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_closewindow(struct nxbe_window_s *wnd);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_setposition
|
|
*
|
|
* Description:
|
|
* This function checks for intersections and redraws the display after
|
|
* a change in the position of a window.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_setposition(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_point_s *pos);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_setsize
|
|
*
|
|
* Description:
|
|
* This function checks for intersections and redraws the display after
|
|
* a change in the size of a window.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_setsize(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_size_s *size);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_raise
|
|
*
|
|
* Description:
|
|
* Bring the specified window to the top of the display.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_raise(FAR struct nxbe_window_s *wnd);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_lower
|
|
*
|
|
* Description:
|
|
* Lower the specified window to the bottom of the display.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_lower(FAR struct nxbe_window_s *wnd);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_modal
|
|
*
|
|
* Description:
|
|
* May be used to either (1) raise a window to the top of the display and
|
|
* select modal behavior, or (2) disable modal behavior.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_modal(FAR struct nxbe_window_s *wnd, bool enable);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_setvisibility
|
|
*
|
|
* Description:
|
|
* Select if the window is visible or hidden. A hidden window is still
|
|
* present will will update normally, but will be on the visible on the
|
|
* display until it is unhidden.
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window to be modified
|
|
* hide - True: Window will be hidden; false: Window will be visible
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_setvisibility(FAR struct nxbe_window_s *wnd, bool hide);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_setpixel
|
|
*
|
|
* Description:
|
|
* Set a single pixel in the window to the specified color. This is simply a
|
|
* degenerate case of nxbe_fill, but may be optimized in some architectures.
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window structure reference
|
|
* pos - The pixel location to be set
|
|
* col - The color to use in the set
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_setpixel(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_point_s *pos,
|
|
nxgl_mxpixel_t color[CONFIG_NX_NPLANES]);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_fill
|
|
*
|
|
* 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
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_fill(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
nxgl_mxpixel_t color[CONFIG_NX_NPLANES]);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_filltrapezoid
|
|
*
|
|
* Description:
|
|
* Fill the specified rectangle in the window with the specified color
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window structure reference
|
|
* clip - Clipping region (may be null)
|
|
* rect - The location to be filled
|
|
* col - The color to use in the fill
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_filltrapezoid(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *clip,
|
|
FAR const struct nxgl_trapezoid_s *trap,
|
|
nxgl_mxpixel_t color[CONFIG_NX_NPLANES]);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_getrectangle
|
|
*
|
|
* Description:
|
|
* Get the raw contents of graphic memory within a rectangular region. NOTE:
|
|
* Since raw graphic memory is returned, the returned memory content may be
|
|
* the memory of windows above this one and may not necessarily belong to
|
|
* this window unless you assure that this is the top window.
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window structure reference
|
|
* rect - The location to be copied
|
|
* plane - Specifies the color plane to get from.
|
|
* dest - The location to copy the memory region
|
|
* deststride - The width, in bytes, of the dest memory
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_getrectangle(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
unsigned int plane,
|
|
FAR uint8_t *dest, unsigned int deststride);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_move
|
|
*
|
|
* Description:
|
|
* Move a rectangular region within the window
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window within which the move is to be done
|
|
* rect - Describes the rectangular region to move
|
|
* offset - The offset to move the region
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_move(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect,
|
|
FAR const struct nxgl_point_s *offset);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_bitmap_dev
|
|
*
|
|
* Description:
|
|
* Copy a rectangular region of a larger image into the rectangle in the
|
|
* specified window. The graphics output is written to the graphics
|
|
* device unconditionally.
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window that will receive the bitmap image
|
|
* dest - Describes the rectangular region on the display that will
|
|
* receive the the bit map (window coordinate frame).
|
|
* src - The start of the source image.
|
|
* origin - The origin of the upper, left-most corner of the full bitmap.
|
|
* Both dest and origin are in window coordinates, however, origin
|
|
* may lie outside of the display.
|
|
* stride - The width of the full source image in pixels.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_bitmap_dev(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *dest,
|
|
FAR const void *src[CONFIG_NX_NPLANES],
|
|
FAR const struct nxgl_point_s *origin,
|
|
unsigned int stride);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_bitmap
|
|
*
|
|
* Description:
|
|
* Copy a rectangular region of a larger image into the rectangle in the
|
|
* specified window. This is a front end to nxbe_bitmap_dev() that is
|
|
* used only if CONFIG_NX_RAMBACKED=y. If the per-window frame buffer is
|
|
* selected, then the bit map will be written to both the graphics device
|
|
* and shadowed in the per-window framebuffer.
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window that will receive the bitmap image
|
|
* dest - Describes the rectangular region on the display that will
|
|
* receive the the bit map (window coordinate frame).
|
|
* src - The start of the source image.
|
|
* origin - The origin of the upper, left-most corner of the full bitmap.
|
|
* Both dest and origin are in window coordinates, however, origin
|
|
* may lie outside of the display.
|
|
* stride - The width of the full source image in bytes.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_bitmap(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *dest,
|
|
FAR const void *src[CONFIG_NX_NPLANES],
|
|
FAR const struct nxgl_point_s *origin,
|
|
unsigned int stride);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_flush
|
|
*
|
|
* Description:
|
|
* After per-window framebuffer has been updated, the modified region must
|
|
* be written to device graphics memory. That function is managed by this
|
|
* simple function. It does the following:
|
|
*
|
|
* 1) It calls nxbe_bitmap_dev() to copy the modified per-window
|
|
* framebuffer into device graphics memory.
|
|
* 2) If CONFIG_NX_SWCURSOR is enabled, it calls the cursor "draw"
|
|
* renderer to update re-draw the currsor image if any portion of
|
|
* graphics display update overwrote the cursor. Since these
|
|
* operations are performed back-to-back, any resulting flicker
|
|
* should be minimized.
|
|
*
|
|
* Input Parameters (same as for nxbe_bitmap_dev):
|
|
* wnd - The window that will receive the bitmap image
|
|
* dest - Describes the rectangular region in the window that will
|
|
* receive the the bit map (window coordinate frame).
|
|
* src - The start of the source image.
|
|
* origin - The origin of the upper, left-most corner of the full bitmap.
|
|
* Both dest and origin are in window coordinates, however,
|
|
* origin may lie outside of the display.
|
|
* stride - The width of the full source image in bytes.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
#ifdef CONFIG_NX_RAMBACKED
|
|
void nxbe_flush(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *dest,
|
|
FAR const void *src[CONFIG_NX_NPLANES],
|
|
FAR const struct nxgl_point_s *origin,
|
|
unsigned int stride);
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_redraw
|
|
*
|
|
* Description:
|
|
* Re-draw the visible portions of the rectangular region for the
|
|
* specified window
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_redraw(FAR struct nxbe_state_s *be,
|
|
FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_redrawbelow
|
|
*
|
|
* Description:
|
|
* Re-draw the visible portions of the rectangular region for all windows
|
|
* below (and including) the specified window. This function is called
|
|
* whenever a window is closed, moved, lowered or re-sized in order to
|
|
* expose newly visible portions of lower windows.
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_redrawbelow(FAR struct nxbe_state_s *be,
|
|
FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_isvisible
|
|
*
|
|
* Description:
|
|
* Return true if the point, pt, in window wnd is visible. pt is in
|
|
* absolute screen coordinates
|
|
*
|
|
****************************************************************************/
|
|
|
|
bool nxbe_isvisible(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_point_s *pos);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_clipper
|
|
*
|
|
* Description:
|
|
* Perform flexible clipping operations. Callbacks are executed for
|
|
* each obscured and visible portions of the window.
|
|
*
|
|
* Input Parameters:
|
|
* wnd - The window to be clipped.
|
|
* rect - The region of concern within the window
|
|
* order - Specifies the order to process the parts of the non-intersecting
|
|
* sub-rectangles.
|
|
* cops - The callbacks to handle obscured and visible parts of the
|
|
* sub-rectangles.
|
|
* plane - The raster operations to be used by the callback functions.
|
|
* These may vary with different color formats.
|
|
*
|
|
* Returned Value:
|
|
* None
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_clipper(FAR struct nxbe_window_s *wnd,
|
|
FAR const struct nxgl_rect_s *dest, uint8_t order,
|
|
FAR struct nxbe_clipops_s *cops,
|
|
FAR struct nxbe_plane_s *plane);
|
|
|
|
/****************************************************************************
|
|
* Name: nxbe_clipnull
|
|
*
|
|
* Description:
|
|
* The do-nothing clipping callback function
|
|
*
|
|
****************************************************************************/
|
|
|
|
void nxbe_clipnull(FAR struct nxbe_clipops_s *cops,
|
|
FAR struct nxbe_plane_s *plane,
|
|
FAR const struct nxgl_rect_s *rect);
|
|
|
|
#undef EXTERN
|
|
#if defined(__cplusplus)
|
|
}
|
|
#endif
|
|
|
|
#endif /* __GRAPHICS_NXBE_NXBE_H */
|