Embedded/guix
1
0
Fork 0
mirror of https://github.com/azure-rtos/guix.git synced 2025-01-28 07:03:11 +08:00
Code Issues Releases Wiki Activity
guix/guix_studio/studiox_screen_driver.c
Bo Chen (from Dev Box) db360a10fa Update copyright.
2024-01-29 14:12:20 +08:00

856 lines
28 KiB
C
Raw Permalink Blame History

/***************************************************************************
* Copyright (c) 2024 Microsoft Corporation
*
* This program and the accompanying materials are made available under the
* terms of the MIT License which is available at
* https://opensource.org/licenses/MIT.
*
* SPDX-License-Identifier: MIT
**************************************************************************/
/**************************************************************************/
/**************************************************************************/
/** */
/** GUIX Component */
/** */
/** Win32 Display Management (Display) */
/** */
/**************************************************************************/
#define GX_SOURCE_CODE
#include "tx_api.h"
/*#include "tx_thread.h"*/
#include "gx_api.h"
#include "gx_system.h"
#include "gx_widget.h"
#include "gx_window.h"
#include "gx_utility.h"
#include "gx_display.h"
#include "gx_canvas.h"
#include "windows.h"
#include "gx_win32_studio_display_driver.h"
#include "gx_dave2d_simulation_display_driver.h"
#include "studiox_constants.h"
#include "studiox_screen_driver.h"
#ifdef _DEBUG
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif
GX_DISPLAY target_win_display;
GX_CANVAS target_win_canvas;
GX_WINDOW_ROOT target_win_root_window;
void *target_win_canvas_memory = NULL;
HWND target_win_handle;
extern HPALETTE gx_palette_handle;
UINT win32_graphics_driver_setup_24xrgb(GX_DISPLAY *graphic);
VOID win32_graphics_driver_cleanup_24xrgb(GX_DISPLAY *graphic);
UINT win32_graphics_driver_setup_565rgb(GX_DISPLAY *graphic);
VOID win32_graphics_driver_cleanup_565rgb(GX_DISPLAY *graphic);
UINT win32_graphics_driver_setup_4444argb(GX_DISPLAY *display);
VOID win32_graphics_driver_cleanup_4444argb(GX_DISPLAY *graphic);
UINT win32_graphics_driver_setup_565bgr(GX_DISPLAY *graphic);
VOID win32_graphics_driver_cleanup_565bgr(GX_DISPLAY *graphic);
UINT win32_graphics_driver_setup_1555xrgb(GX_DISPLAY *display);
VOID win32_graphics_driver_cleanup_1555xrgb(GX_DISPLAY *display);
UINT win32_graphics_driver_setup_8bit_palette(GX_DISPLAY *graphic);
VOID win32_graphics_driver_cleanup_8bit_palette(GX_DISPLAY *graphic);
UINT win32_graphics_driver_setup_332rgb(GX_DISPLAY *display);
VOID win32_graphics_driver_cleanup_332rgb(GX_DISPLAY *display);
UINT win32_graphics_driver_setup_4bpp_grayscale(GX_DISPLAY *display);
VOID win32_graphics_driver_cleanup_4bpp_grayscale(GX_DISPLAY *display);
UINT win32_graphics_driver_setup_monochrome(GX_DISPLAY *graphic);
VOID win32_graphics_driver_cleanup_monochrome(GX_DISPLAY *graphic);
UINT win32_dave2d_graphics_driver_setup_8bit_palette(GX_DISPLAY *display);
UINT win32_dave2d_graphics_driver_setup_565rgb(GX_DISPLAY *display);
UINT win32_dave2d_graphics_driver_setup_24xrgb(GX_DISPLAY *display);
UINT win32_chromeart_graphics_driver_setup_565rgb(GX_DISPLAY *display);
BOOL guix_configure_canvas(int xres, int yres, int colorformat, int cpu_type, int IsSynergyD2D, GX_COLOR *palette, int pal_size);
UINT gx_system_focus_claim_standard(GX_WIDGET *widget);
HWND GetGuixWinHandle(void);
/*LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);*/
/**************************************************************************/
VOID gx_studio_buffer_toggle_stub(GX_CANVAS *canvas, GX_RECTANGLE *dirty)
{
}
/**************************************************************************/
VOID guix_canvas_flush(HDC win_device, int xpos, int ypos,
GX_CANVAS *canvas, GX_RECTANGLE *dirty, int scale, GRID_SNAP_INFO *gsi)
{
INT Top;
INT Left;
INT Height;
INT Width;
//HPALETTE old_palette;
GX_DISPLAY *display;
GX_RECTANGLE Limit;
GX_RECTANGLE Copy;
GX_WIN32_DISPLAY_DRIVER_DATA *driver_instance;
VOID *memptr;
HDC hdcMem;
HBITMAP hbmMem;
HANDLE hOld;
INT copy_width;
INT copy_height;
INT canvas_width;
INT canvas_height;
INT row;
INT col;
display = canvas -> gx_canvas_display;
driver_instance = (GX_WIN32_DISPLAY_DRIVER_DATA *)(display -> gx_display_driver_data);
_gx_utility_rectangle_define(&Limit, 0, 0,
canvas -> gx_canvas_x_resolution - 1,
canvas -> gx_canvas_y_resolution - 1);
if (dirty)
{
if (!_gx_utility_rectangle_overlap_detect(&Limit, dirty, &Copy))
{
return;
}
}
else
{
Copy = Limit;
}
SetMapMode(win_device, MM_TEXT);
Top = Copy.gx_rectangle_top;
Left = Copy.gx_rectangle_left;
Width = Copy.gx_rectangle_right - Copy.gx_rectangle_left + 1;
Height = Copy.gx_rectangle_bottom - Copy.gx_rectangle_top + 1;
memptr = _win32_canvas_memory_prepare(canvas, &Copy);
copy_width = Width * scale / 100;
copy_height = Height * scale / 100;
Left = Left * scale / 100;
Top = Top * scale / 100;
xpos = xpos * scale / 100;
ypos = ypos * scale / 100;
int grid_space = gsi->grid_space;
if (grid_space || gsi->crosshair_enabled || gsi->snap_line_count)
{
canvas_width = canvas->gx_canvas_x_resolution * scale / 100;
canvas_height = canvas->gx_canvas_y_resolution * scale / 100;
/* Create an off-screen DC for double-buffering */
hdcMem = CreateCompatibleDC(win_device);
hbmMem = CreateCompatibleBitmap(win_device, canvas_width, canvas_height);
hOld = SelectObject(hdcMem, hbmMem);
/* Flush canvas memory to off-screen DC. */
StretchDIBits(hdcMem, Left + xpos, Top + ypos, copy_width, copy_height,
Copy.gx_rectangle_left,
Copy.gx_rectangle_top + Height + 1,
Width, -Height, memptr,
(BITMAPINFO*)&(driver_instance->win32_driver_bmpinfo),
DIB_RGB_COLORS,
SRCCOPY);
if (grid_space)
{
grid_space *= scale / 100;
/* Draw grid. */
for (col = grid_space; col < canvas_height; col += grid_space)
{
for (row = grid_space; row < canvas_width; row += grid_space)
{
SetPixel(hdcMem, row, col, RGB(128, 128, 128));
}
}
}
if (gsi->crosshair_enabled)
{
// Draw crosshair
SelectObject(hdcMem, GetStockObject(DC_PEN));
SetDCPenColor(hdcMem, RGB(128, 128, 128));
col = (gsi->crosshair_cx - gsi->crosshair_size) * scale / 100;
row = gsi->crosshair_cy * scale / 100;
MoveToEx(hdcMem, col, row, NULL);
col = (gsi->crosshair_cx + gsi->crosshair_size + 1) * scale / 100;
LineTo(hdcMem, col, row);
col = gsi->crosshair_cx * scale / 100;
row = (gsi->crosshair_cy - gsi->crosshair_size) * scale / 100;
MoveToEx(hdcMem, col, row, NULL);
row = (gsi->crosshair_cy + gsi->crosshair_size + 1) * scale / 100;
LineTo(hdcMem, col, row);
}
if (gsi->snap_line_count)
{
// Draw snap lines;
SelectObject(hdcMem, GetStockObject(DC_PEN));
SetDCPenColor(hdcMem, RGB(255, 0, 0));
SNAPLINE_INFO *snapline;
for (int index = 0; index < gsi->snap_line_count; index++)
{
snapline = &gsi->snap_lines[index];
if (snapline->direction == SNAP_LINE_DIRECTION_VERTICAL)
{
// Draw vertical line
col = snapline->target_x_y * scale / 100;
row = snapline->target_top_left * scale / 100;
MoveToEx(hdcMem, col, row, NULL);
row = (snapline->target_bottom_right + 1) * scale / 100;
LineTo(hdcMem, col, row);
}
else
{
// Draw horizontal line
col = snapline->target_top_left * scale / 100;
row = snapline->target_x_y * scale / 100;
MoveToEx(hdcMem, col, row, NULL);
col = (snapline->target_bottom_right + 1) * scale / 100;
LineTo(hdcMem, col, row);
}
}
}
/* Transfer the off-screen DC to the screen. */
BitBlt(win_device, Left + xpos, Top + ypos, copy_width, copy_height, hdcMem, Left + xpos, Top + ypos, SRCCOPY);
/* Free-up the off-screen DC. */
SelectObject(hdcMem, hOld);
DeleteObject(hbmMem);
DeleteDC(hdcMem);
}
else
{
/* Flush canvas memory to the screen. */
StretchDIBits(win_device, Left + xpos, Top + ypos, copy_width, copy_height,
Copy.gx_rectangle_left,
Copy.gx_rectangle_top + Height + 1,
Width, -Height, memptr,
(BITMAPINFO *)&(driver_instance->win32_driver_bmpinfo),
DIB_RGB_COLORS,
SRCCOPY);
}
}
/**************************************************************************/
void guix_bitmap_flush(HDC win_device, int xpos, int ypos, int Width,
VOID *memptr, GX_BMP_INFO *bmpinfo)
{
INT Height;
SetMapMode(win_device, MM_TEXT);
Height = bmpinfo -> gx_bmp_header.biHeight;
StretchDIBits(win_device, xpos, ypos, Width, Height,
0, Height + 1, Width, -Height, memptr,
(BITMAPINFO *)bmpinfo,
DIB_RGB_COLORS,
SRCCOPY);
}
/**************************************************************************/
void guix_canvas_paint(HDC dc, GX_RECTANGLE dirty, int scale, GRID_SNAP_INFO *gsi)
{
GX_CANVAS *canvas;
canvas = &target_win_canvas;
/* Call the driver buffer toggle function for this canvas. */
#if 0
_gx_utility_rectangle_define(&dirty, 0, 0,
canvas -> gx_canvas_x_resolution - 1,
canvas -> gx_canvas_y_resolution - 1);
#else
//dirty = canvas ->gx_canvas_dirty_area;
#endif
guix_canvas_flush(dc, 0, 0, canvas, &dirty, scale, gsi);
}
/**************************************************************************/
VOID *guix_memory_allocate(ULONG size)
{
VOID *pointer;
pointer = malloc(size);
return pointer;
}
/**************************************************************************/
VOID guix_memory_free(VOID *mem)
{
free(mem);
}
/**************************************************************************/
HWND GetGuixWinHandle(void)
{
return target_win_handle;
}
/**************************************************************************/
void initialize_guix(HWND target_win)
{
target_win_handle = target_win;
_gx_system_initialize();
_gx_system_memory_allocator_set(guix_memory_allocate, guix_memory_free);
}
int gx_main(int argc, char ** argv)
{
return(0);
}
/**************************************************************************/
INT RunGuixDisplaySetupFunction(GX_DISPLAY *display, char *name, int xres, int yres,
int colorformat, int target_cpu, int IsRenesasDave2D, int IsDave2DFontFormat,
GX_COLOR *palette, int palsize, int aliased_font_palsize)
{
UINT (*setup_func)(GX_DISPLAY *);
INT memsize = xres * yres;
setup_func = GX_NULL;
/* figure out which setup function to run */
switch (colorformat)
{
case GX_COLOR_FORMAT_MONOCHROME:
case GX_COLOR_FORMAT_MONOCHROME_INVERTED:
setup_func = win32_graphics_driver_setup_monochrome;
memsize = ((xres + 7) >> 3) * yres;
break;
case GX_COLOR_FORMAT_2BIT_GRAY:
case GX_COLOR_FORMAT_2BIT_GRAY_INVERTED:
case GX_COLOR_FORMAT_4BIT_GRAY_INVERTED:
case GX_COLOR_FORMAT_4BIT_VGA:
case GX_COLOR_FORMAT_8BIT_GRAY:
case GX_COLOR_FORMAT_8BIT_GRAY_INVERTED:
/* FIXME: These formats are not done yet */
break;
case GX_COLOR_FORMAT_4BIT_GRAY:
setup_func = win32_graphics_driver_setup_4bpp_grayscale;
memsize = ((xres + 1) >> 1) * yres;
break;
case GX_COLOR_FORMAT_8BIT_PALETTE:
if (IsDave2DFontFormat)
{
setup_func = win32_dave2d_graphics_driver_setup_8bit_palette;
}
else
{
setup_func = win32_graphics_driver_setup_8bit_palette;
}
break;
case GX_COLOR_FORMAT_8BIT_PACKED_PIXEL:
setup_func = win32_graphics_driver_setup_332rgb;
break;
case GX_COLOR_FORMAT_5551BGRX:
case GX_COLOR_FORMAT_1555XRGB:
if (!IsRenesasDave2D)
{
setup_func = win32_graphics_driver_setup_1555xrgb;
}
memsize *= 2;
break;
case GX_COLOR_FORMAT_565RGB:
switch(target_cpu)
{
case CPU_SYNERGY:
case CPU_RA:
case CPU_RX:
if (IsRenesasDave2D)
{
setup_func = win32_dave2d_graphics_driver_setup_565rgb;
}
else
{
setup_func = win32_graphics_driver_setup_565rgb;
}
break;
case CPU_ST_CHROMEART:
setup_func = win32_chromeart_graphics_driver_setup_565rgb;
break;
default:
setup_func = win32_graphics_driver_setup_565rgb;
break;
}
memsize *= 2;
break;
case GX_COLOR_FORMAT_4444ARGB:
case GX_COLOR_FORMAT_4444BGRA:
setup_func = win32_graphics_driver_setup_4444argb;
memsize *= 2;
break;
case GX_COLOR_FORMAT_565BGR:
setup_func = win32_graphics_driver_setup_565bgr;
memsize *= 2;
break;
case GX_COLOR_FORMAT_24RGB:
case GX_COLOR_FORMAT_24BGR:
case GX_COLOR_FORMAT_24XRGB:
case GX_COLOR_FORMAT_24BGRX:
case GX_COLOR_FORMAT_32ARGB:
case GX_COLOR_FORMAT_32BGRA:
/* counts go in the aux data array: */
if (IsRenesasDave2D)
{
setup_func = win32_dave2d_graphics_driver_setup_24xrgb;
}
else
{
setup_func = win32_graphics_driver_setup_24xrgb;
}
memsize *= 4;
break;
}
if (setup_func)
{
if (_gx_display_create(display, name, setup_func, xres, yres) == GX_SUCCESS)
{
if (colorformat == GX_COLOR_FORMAT_8BIT_PALETTE)
{
if (!IsDave2DFontFormat)
{
if (aliased_font_palsize == 8)
{
display->gx_display_driver_4bit_glyph_draw = _gx_display_driver_8bpp_glyph_3bit_draw;
}
else
{
display->gx_display_driver_4bit_glyph_draw = _gx_display_driver_8bpp_glyph_4bit_draw;
}
}
}
return memsize;
}
}
return 0;
}
/**************************************************************************/
INT guix_create_app_display(GX_DISPLAY *display, char *name,
int xres, int yres, int colorformat,
int target_cpu, int IsRenesasDave2D, int IsDave2DFontFormat,
GX_COLOR *palette, int palsize, int aliased_font_palsize)
{
INT memsize;
memsize = RunGuixDisplaySetupFunction(display, name, xres, yres,
colorformat, target_cpu, IsRenesasDave2D, IsDave2DFontFormat,
palette, palsize, aliased_font_palsize);
if (memsize)
{
if (colorformat <= GX_COLOR_FORMAT_8BIT_PALETTE)
{
if (display -> gx_display_driver_palette_set && palette)
{
display -> gx_display_driver_palette_set(display, palette, palsize);
}
}
}
return memsize;
}
/**************************************************************************/
INT guix_studio_create_display(GX_DISPLAY *display, char *name,
int xres, int yres, int colorformat,
int target_cpu, int IsRenesasDave2D, int IsDave2DFontFormat,
GX_COLOR *palette, int palsize, int aliased_font_palsize)
{
INT memsize;
memsize = RunGuixDisplaySetupFunction(display, name, xres, yres,
colorformat, target_cpu, IsRenesasDave2D, IsDave2DFontFormat,
palette, palsize, aliased_font_palsize);
if (memsize)
{
// Dummy out the display toggle function, Studio uses it's own canvas_flush function
// to draw the canvas to the visible window
display->gx_display_driver_buffer_toggle = gx_studio_buffer_toggle_stub;
if (colorformat <= GX_COLOR_FORMAT_8BIT_PALETTE)
{
if (display -> gx_display_driver_palette_set && palette)
{
display -> gx_display_driver_palette_set(display, palette, palsize);
}
}
}
return memsize;
}
void guix_studio_delete_display(GX_DISPLAY *display)
{
void (*cleanup_func)(GX_DISPLAY *);
cleanup_func = NULL;
/* figure out which cleanup function to run if
this is not first time */
switch (display -> gx_display_color_format)
{
case GX_COLOR_FORMAT_MONOCHROME:
case GX_COLOR_FORMAT_MONOCHROME_INVERTED:
cleanup_func = win32_graphics_driver_cleanup;
break;
case GX_COLOR_FORMAT_2BIT_GRAY:
case GX_COLOR_FORMAT_2BIT_GRAY_INVERTED:
case GX_COLOR_FORMAT_4BIT_GRAY_INVERTED:
case GX_COLOR_FORMAT_4BIT_VGA:
case GX_COLOR_FORMAT_8BIT_GRAY:
case GX_COLOR_FORMAT_8BIT_GRAY_INVERTED:
break;
case GX_COLOR_FORMAT_4BIT_GRAY:
case GX_COLOR_FORMAT_8BIT_PALETTE:
case GX_COLOR_FORMAT_8BIT_PACKED_PIXEL:
case GX_COLOR_FORMAT_5551BGRX:
case GX_COLOR_FORMAT_1555XRGB:
case GX_COLOR_FORMAT_565RGB:
case GX_COLOR_FORMAT_4444ARGB:
case GX_COLOR_FORMAT_4444BGRA:
case GX_COLOR_FORMAT_565BGR:
case GX_COLOR_FORMAT_24RGB:
case GX_COLOR_FORMAT_24BGR:
case GX_COLOR_FORMAT_24BGRX:
case GX_COLOR_FORMAT_24XRGB:
case GX_COLOR_FORMAT_32ARGB:
case GX_COLOR_FORMAT_32BGRA:
/* counts go in the aux data array: */
cleanup_func = win32_graphics_driver_cleanup;
break;
}
if (cleanup_func)
{
_gx_display_delete(display, cleanup_func);
}
}
/**************************************************************************/
VOID guix_cleanup_target_win_canvas(VOID)
{
if (target_win_canvas_memory != NULL)
{
free(target_win_canvas_memory);
target_win_canvas_memory = NULL;
guix_studio_delete_display(&target_win_display);
_gx_canvas_delete(&target_win_canvas);
_gx_window_root_delete(&target_win_root_window);
}
}
/**************************************************************************/
BOOL guix_configure_target_win_canvas(int xres,
int yres,
int colorformat,
int target_cpu,
int IsSynergyD2D,
int IsSynergyFontFormat,
GX_COLOR *palette,
int palsize,
int aliased_font_palsize)
{
GX_RECTANGLE size;
int memsize;
if (target_win_canvas_memory != NULL)
{
_gx_widget_hide((GX_WIDGET *)&target_win_root_window);
free(target_win_canvas_memory);
target_win_canvas_memory = NULL;
guix_studio_delete_display(&target_win_display);
_gx_canvas_delete(&target_win_canvas);
_gx_window_root_delete(&target_win_root_window);
}
memsize = guix_studio_create_display(&target_win_display, "StudioX Main Display",
xres, yres, colorformat, target_cpu, IsSynergyD2D, IsSynergyFontFormat, palette, palsize, aliased_font_palsize);
if (memsize)
{
gx_win32_set_win_handle(target_win_display.gx_display_driver_data, GetGuixWinHandle());
gx_win32_set_thread_id(target_win_display.gx_display_driver_data, GetCurrentThreadId());
target_win_canvas_memory = malloc(memsize);
//_gx_canvas_create(&target_win_canvas, "StudioX Canvas",
// &target_win_display, GX_CANVAS_MANAGED | GX_CANVAS_VISIBLE,
// xres, yres, target_win_canvas_memory, memsize);
_gx_canvas_create(&target_win_canvas, "StudioX Canvas",
&target_win_display, GX_CANVAS_VISIBLE,
xres, yres, target_win_canvas_memory, memsize);
/* Create a background root window and attach to the background canvas. */
_gx_utility_rectangle_define(&size, 0, 0, xres - 1, yres - 1);
_gx_window_root_create(&target_win_root_window, "GUIX root window", &target_win_canvas,
GX_STYLE_BORDER_NONE, GX_ID_NONE, &size);
return TRUE;
}
return FALSE;
}
/**************************************************************************/
GX_WINDOW_ROOT *get_root_window(void)
{
GX_WINDOW_ROOT *root = _gx_system_root_window_created_list;
return &target_win_root_window;
}
/**************************************************************************/
GX_DISPLAY *get_target_view_display(void)
{
return &target_win_display;
}
/**************************************************************************/
GX_CANVAS *get_target_win_canvas(void)
{
return &target_win_canvas;
}
/**************************************************************************/
HWND get_target_win_handle()
{
return target_win_handle;
}
/**************************************************************************/
/* kgm- replace the standard implementation of this function (remove the
file gx_system_dirty_partial_add from GUIX library build for studiox.
This replacement sends an event to studioX target window when the
root canvas is marked dirty */
UINT _gx_system_dirty_partial_add(GX_WIDGET *widget, GX_RECTANGLE *dirty_area)
{
UINT index;
GX_DIRTY_AREA *dirty_entry;
GX_WIDGET *test;
GX_WINDOW_ROOT *root;
GX_CANVAS *canvas;
GX_DIRTY_AREA *empty_dirty_entry = GX_NULL;
if (!widget)
{
return GX_PTR_ERROR;
}
if (!(widget -> gx_widget_status & GX_STATUS_VISIBLE))
{
return GX_PTR_ERROR;
}
/* if a widget is transparent, we actually need to mark it's
first non-transparent parent as being dirty
*/
while ((widget -> gx_widget_status & GX_STATUS_TRANSPARENT) &&
(widget -> gx_widget_parent))
{
widget = widget -> gx_widget_parent;
}
/* walk up to find root window */
test = widget;
while (test -> gx_widget_parent)
{
test = test -> gx_widget_parent;
}
if (test -> gx_widget_type != GX_TYPE_ROOT_WINDOW)
{
return GX_PTR_ERROR;
}
root = (GX_WINDOW_ROOT *)test;
/* pick up pointer to canvas */
canvas = root -> gx_window_root_canvas;
/***************************************
THIS IS THE ADDED CODE FOR STUDIOX
***************************************/
if (canvas == &target_win_canvas)
{
WPARAM wparam = MAKEWPARAM(dirty_area->gx_rectangle_left, dirty_area->gx_rectangle_top);
LPARAM lparam = MAKELPARAM(dirty_area->gx_rectangle_right, dirty_area->gx_rectangle_bottom);
PostMessage(target_win_handle, GUIX_DIRTY, wparam, lparam);
// When marking widgets dirty for the target win, just always mark the top-level
// window dirty to fix any drawing issues caused by Studio intercepting the
// target widget drawing, or a transparent target widget not being given
// transparent style. We want the drawing inside Studio to look right.
if (widget != (GX_WIDGET *) root)
{
widget = (GX_WIDGET *) root->gx_widget_first_child;
}
}
/***************************************
END OF THE ADDED CODE
***************************************/
/* Setup pointer to dirty list. */
dirty_entry = canvas -> gx_canvas_dirty_list;
/* Check to see if widget already has an entry. */
for (index = 0; index < canvas -> gx_canvas_dirty_count; index++)
{
/* Is the same widget is present. */
if (dirty_entry -> gx_dirty_area_widget == widget)
{
/* if rectangles overlap, combine them rather
than adding another entry
*/
if (_gx_utility_rectangle_overlap_detect(&dirty_entry -> gx_dirty_area_rectangle,
dirty_area, GX_NULL))
{
/* Combine the dirty rectangles. */
_gx_utility_rectangle_combine(&dirty_entry -> gx_dirty_area_rectangle, dirty_area);
/* Return success. */
return(GX_SUCCESS);
}
}
else if ((empty_dirty_entry == GX_NULL) && (dirty_entry -> gx_dirty_area_widget == GX_NULL))
{
empty_dirty_entry = dirty_entry;
}
/* Move to next dirty entry. */
dirty_entry++;
}
if (empty_dirty_entry)
{
/* Reuse the invalid dirty entry. */
empty_dirty_entry -> gx_dirty_area_widget = widget;
empty_dirty_entry -> gx_dirty_area_rectangle = *dirty_area;
return(GX_SUCCESS);
}
/* If we get here, we didn't find an entry for this caller. Add a new entry. */
/* Are there more dirty entries? */
if (canvas -> gx_canvas_dirty_count < GX_MAX_DIRTY_AREAS)
{
/* Yes, more dirty entries, add this one! */
dirty_entry = &canvas -> gx_canvas_dirty_list[canvas -> gx_canvas_dirty_count];
canvas -> gx_canvas_dirty_count++;
dirty_entry -> gx_dirty_area_widget = widget;
dirty_entry -> gx_dirty_area_rectangle = *dirty_area;
}
/* Return success. */
return(GX_SUCCESS);
}
/**************************************************************************/
/* replace the standard implementation of this function (remove the
file gx_scroll_wheeel_selected_set from GUIX library build for studiox.)
This replacement can be removed when timer issue in studio get fix. */
UINT _gx_scroll_wheel_selected_set(GX_SCROLL_WHEEL *wheel, INT row)
{
if ((row < 0) || wheel->gx_scroll_wheel_total_rows <= 0)
{
row = 0;
}
else if (row > wheel->gx_scroll_wheel_total_rows - 1)
{
row = wheel->gx_scroll_wheel_total_rows - 1;
}
wheel->gx_scroll_wheel_selected_row = row;
if (wheel->gx_widget_style & GX_STATUS_VISIBLE)
{
_gx_system_dirty_mark((GX_WIDGET *)wheel);
}
return GX_SUCCESS;
}
/**************************************************************************/
/* replace the standard implementation of this function
(guix focus is not need in studio edit mode) */
UINT _gx_system_focus_claim(GX_WIDGET *widget)
{
GX_WINDOW_ROOT *root = get_root_window();
GX_BOOL child_detect;
if (root)
{
_gx_widget_child_detect((GX_WIDGET *)root, widget, &child_detect);
if (child_detect)
{
/* GUIX edit mode. */
return 0;
}
else
{
/* GUIX running mode. */
return gx_system_focus_claim_standard(widget);
}
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink