AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

ucgui在windows上的移植，及为go语言打造简易跨平台GUI的想法

2023-06-21 150
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： ucgui在windows上的移植，及为go语言打造简易跨平台GUI的想法

go语言缺乏官方GUI的支持，这点有时候很不方便。


虽然网上有很多开源的实现，但都不太满意，不太好用。


网上开源的有哪些？参见《2019，Go GUI项目爆发的一年？》https://studygolang.com/articles/21525?fr=sidebar


近来出现了很多跨平台的Go GUI项目。


虽说用井喷之势形容有些过了，但是的确有加速的迹象。难道Go语言将要开辟出另一大块疆土？


忙中偷闲，整理了一份目前GUI/图形/图像相关的Go项目列表。见下。欢迎补充。


原生GUI绑定

dlgs是一个跨平台的显示对话框和输入框的Go代码库。


glfw是一个GLFW3绑定库。


go-mobile支持移动平台应用开发（Android和iOS）。（其中包含OpenGL ES 2.0和ES 3.0绑定库。）


go-sdl2是一个SDL2绑定库。


go-gtk是一个GTK2绑定库。


gotk3是一个GTK+3绑定库。


GXUI，Google员工出品，但已经停止维护很久了。


。。。。。。


突然想起来曾经很火的嵌入式GUI，UCGUI多么的小巧灵活，且是使用100%的标准C代码编写的，跨平台当然很好移植和使用。


官方还有模拟器  emWin(UCGUI)模拟器。在电脑上有模拟器啊，这是不是很赞。


且图形界面可以在电脑上拖拽设计，这点儿更赞。



为什么网上没有go语言的ucgui的绑定？于是就萌生了用go语言封装ucgui的想法。



那么既然是为go语言打造的简易GUI,跨平台是必须的吧，至少Windows,linux和嵌入式linux都要支持的吧。


这不，以下先让ucgui在windows上的移植跑起来，是第一步。


ucgui在linux上的移植，参见博文：https://blog.csdn.net/yyz_1987/article/details/78380007


后续计划，ucgui的go语言封装



UCGUI简介：

UCGUI是一种嵌入式应用中的图形支持系统。


它设计用于为任何使用LCD图形显示的应用提供高效的独立于处理器及LCD控制器的图形用户接口。


它适用单任务或是多任务系统环境， 并适用于任意LCD控制器和CPU下任何尺寸的真实显示或虚拟显示。


它的设计架构是模块化的，由不同的模块中的不同层组成，由一个LCD驱动层来包含所有对LCD的具体图形操作。


UCGUI可以在任何的CPU上运行，因为它是100%的标准C代码编写的。


UCGUI能够适应大多数的使用黑白或彩色LCD的应用，它提供非常好的允许处理灰度的颜色管理。


还提供一个可扩展的2D图形库及占用极少RAM的窗口管理体系。


在Windows上的移植：，移植好的demo放在的我的github上了，


地址：https://github.com/yongzhena


https://github.com/yongzhena/ucgui-windows.git



使用方法:  

首先，windows上必须有GCC的环境。  


推荐安装mingwgcc  


我安装的是x86_64-810gcc-posix-seh-npMingw64v75.7z这个压缩包，直接解压。再配置环境变量即可。  


跟移植相关的，都在ucgui/GUI_X文件夹中。  


在ucgui/GUI文件夹中，有写好的makefile文件，直接make即可编译出libucgui.a库。  


然后需要把这个库放到GUIDemo_windows文件夹里。  


同时，里面有几个windows上需要依赖的库在里面。libGDI32.LIB,libWINMM.lib,  


同时多了两个文件MainTask.c和WinMain.c,其中windows程序的入口在WinMain.c中。  


这个里面也有一个makefile文件，可执行make命令，直接就生成了demo，test.exe可执行程序。    


//LCDSIM.c
#include <windows.h>
#include <memory.h>
#include <math.h>
#include "LCD.h"
#include "GUI.h"
#include "LCDConf.h"
unsigned int LCD_Buffer[LCD_YSIZE][LCD_XSIZE];
BITMAPINFO bmp; 
void LCDSIM_Init(void) 
{
  //初始化位图结构 
  ZeroMemory(&bmp,   sizeof(BITMAPINFO));  
  bmp.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
  bmp.bmiHeader.biWidth = LCD_XSIZE;   //位图宽度
  bmp.bmiHeader.biHeight = -LCD_YSIZE;  //位图高度  //当图像是倒立显示的时候，把biHeight改为对应的负值
  bmp.bmiHeader.biPlanes   =   1;   
  bmp.bmiHeader.biBitCount   =   32;   //一个像素32Bit
  bmp.bmiHeader.biCompression   =   BI_RGB; 
}
void UpdataShow(HDC _hdc)
{
  SetDIBitsToDevice(_hdc,
                0, 0,  //在屏幕中的起始坐标
                LCD_XSIZE, LCD_YSIZE,  //显示的屏幕的宽,高
                0 , 0,   //位图左下角的坐标
                0,  //DIB中的起始扫描线
                LCD_YSIZE,  // DIB扫描线数目
                (BYTE*)LCD_Buffer,  //位图数据区起始指针,是BYTE*类型
                &bmp,  //位图的BITMAPINFO指针
                DIB_RGB_COLORS);  //颜色使用类型
}
void LCDSIM_SetPixelIndex(int x, int y, int Index, int LayerIndex)  
{
#if 0
  int R = (Index & 0xF800) >> 11;
  int G = (Index & 0x07E0) >> 5;
  int B = Index & 0x001F;
  LCD_Buffer[y][x] = R << 3 << 16 | G << 2 << 8 | B << 3;
#endif
#if (LCD_BITSPERPIXEL == 8)
  unsigned char R = 1.164 * (Index - 16);
  LCD_Buffer[y][x] = R << 16 | R << 8 | R ;
#elif (LCD_BITSPERPIXEL == 16) && (LCD_FIXEDPALETTE == 565)
  LCD_Buffer[y][x] = ((Index & 0xF800) << 3 >> 11 << 16) | ((Index & 0x07E0) << 2 >> 5 << 8) | (Index & 0x1F)<<3;
#else if (LCD_BITSPERPIXEL == 1)
  if (Index == 0)
  {
    LCD_Buffer[y][x] = 0x00000000;
  }
  else
  {
    LCD_Buffer[y][x] = 0x00FFFFFF;
  }
#endif
}
void LCDSIM_FillRect(int x0, int y0, int x1, int y1, int Index, int LayerIndex)
{
}
int LCDSIM_GetPixelIndex(int x, int y, int LayerIndex)
{
  return LCD_Buffer[y][x];
}
void LCDSIM_SetLUTEntry(U8 Pos, LCD_COLOR color, int LayerIndex) 
{
}
GUI_PID_STATE Touch_Status;
void Touch_Pressed(int x, int y)  //触摸按下  x,y 为按下是的鼠标在窗体中的坐标
{
  Touch_Status.Pressed = 1;
  Touch_Status.x = x;
  Touch_Status.y = y;
  GUI_TOUCH_StoreStateEx(&Touch_Status);
}
void Touch_Release(void)  //触摸释放
{
  Touch_Status.Pressed = 0;
  Touch_Status.x = -1;
  Touch_Status.y = -1;
  GUI_TOUCH_StoreStateEx(&Touch_Status);
}



//LCD_Win.c
#if defined(_WIN32) || defined(WIN32) || defined(WIN64)
#include <windows.h>
#endif
#include "LCD.h"
#include "LCD_Private.h"              /* include LCDConf.h */
#include "LCDSIM.h"
#include "GUI_Private.h"
#include "memory.h"
/*********************************************************************
*
*       Defines
*
**********************************************************************
*/
#if LCD_BITSPERPIXEL <= 8
  #define PIXELINDEX U8
#else
  #define PIXELINDEX WORD
#endif
#ifdef WIN32
  #ifndef ASSERT
    #define ASSERT(Val) \
    if (!(Val)) \
      MessageBox(NULL,"...in file "__FILE__,"Assertion failed...",MB_OK);
  #endif
#endif
#ifdef LCD_ASSERT
  #undef LCD_ASSERT
#endif
#define LCD_ASSERT(v) ASSERT(v)
#ifndef LCD_DISPLAY_INDEX
  #define LCD_DISPLAY_INDEX 0
#endif
/*********************************************************************
*
*       Macros for internal use
*/
#if 0
static int _CheckBound(unsigned int c) {
  unsigned int NumColors = LCD_BITSPERPIXEL > 8 ? (LCD_BITSPERPIXEL > 16) ? 0xffffffff : 0xffff : (1 << LCD_BITSPERPIXEL) - 1;
  if (c > NumColors) {
    GUI_DEBUG_ERROROUT("LCDWin::SETPIXEL: parameters out of bounds");
    return 1;
  }
  return 0;
}
  #define SETPIXEL(x, y, c) \
    if (!_CheckBound(c)) { \
      LCDSIM_SetPixelIndex(x, y, c, LCD_DISPLAY_INDEX); \
    }
#else
  #define SETPIXEL(x, y, c) LCDSIM_SetPixelIndex(x, y, c, LCD_DISPLAY_INDEX)
#endif
#define XORPIXEL(x, y)    _XorPixel(x,y)
/*********************************************************************
*
*       Static code
*
**********************************************************************
*/
/*********************************************************************
*
*       _XorPixel
*/
static void _XorPixel(int x, int y) 
{
  unsigned int Index = LCD_L0_GetPixelIndex(x,y);
  LCDSIM_SetPixelIndex(x, y, LCD_NUM_COLORS-1-Index, LCD_DISPLAY_INDEX);
}
/*********************************************************************
*
*       _DrawBitLine1BPP
*/
static void _DrawBitLine1BPP(int x, int y, U8 const*p, int Diff, int xsize, const LCD_PIXELINDEX*pTrans) {
  LCD_PIXELINDEX Index0, Index1;
  #if (GUI_USE_MEMDEV_1BPP_FOR_SCREEN == 1)
    const LCD_PIXELINDEX aTrans[2] = {0, 1};
    if (!pTrans) {
      pTrans = aTrans;
    }
  #endif
  Index0 = *(pTrans + 0);
  Index1 = *(pTrans + 1);
  x+=Diff;
  switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS|LCD_DRAWMODE_XOR)) {
  case 0:    /* Write mode */
    do {
      LCDSIM_SetPixelIndex(x++,y, (*p & (0x80>>Diff)) ? Index1 : Index0, LCD_DISPLAY_INDEX);
      if (++Diff==8) {
        Diff=0;
        p++;
      }
    } while (--xsize);
    break;
  case LCD_DRAWMODE_TRANS:
    do {
      if (*p & (0x80>>Diff))
        LCDSIM_SetPixelIndex(x,y, Index1, LCD_DISPLAY_INDEX);
      x++;
      if (++Diff==8) {
        Diff=0;
        p++;
      }
    } while (--xsize);
    break;
  case LCD_DRAWMODE_XOR | LCD_DRAWMODE_TRANS:
  case LCD_DRAWMODE_XOR:
    do {
      if (*p & (0x80>>Diff)) {
        int Pixel = LCDSIM_GetPixelIndex(x,y, LCD_DISPLAY_INDEX);
        LCDSIM_SetPixelIndex(x,y, LCD_NUM_COLORS-1-Pixel, LCD_DISPLAY_INDEX);
      }
      x++;
      if (++Diff==8) {
        Diff=0;
        p++;
      }
    } while (--xsize);
    break;
  }
}
/*********************************************************************
*
*       _DrawBitLine2BPP
*/
#if (LCD_MAX_LOG_COLORS > 2)
static void _DrawBitLine2BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  LCD_PIXELINDEX Pixels = *p;
  int CurrentPixel = Diff;
  x += Diff;
  switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
    case 0:
      if (pTrans) {
        do {
          int Shift = (3 - CurrentPixel) << 1;
          int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
          LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
          SETPIXEL(x++, y, PixelIndex);
          if (++CurrentPixel == 4) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      } else {
        do {
          int Shift = (3 - CurrentPixel) << 1;
          int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
          SETPIXEL(x++, y, Index);
          if (++CurrentPixel == 4) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      }
      break;
    case LCD_DRAWMODE_TRANS:
      if (pTrans) {
        do {
          int Shift = (3 - CurrentPixel) << 1;
          int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
          if (Index) {
            LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
            SETPIXEL(x, y, PixelIndex);
          }
          x++;
          if (++CurrentPixel == 4) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      } else {
        do {
          int Shift = (3 - CurrentPixel) << 1;
          int Index = (Pixels & (0xC0 >> (6 - Shift))) >> Shift;
          if (Index) {
            SETPIXEL(x, y, Index);
          }
          x++;
          if (++CurrentPixel == 4) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      }
      break;
  }
}
#endif
/*********************************************************************
*
*       _DrawBitLine4BPP
*/
#if (LCD_MAX_LOG_COLORS > 4)
static void _DrawBitLine4BPP(int x, int y, U8 const * p, int Diff, int xsize, const LCD_PIXELINDEX * pTrans) {
  LCD_PIXELINDEX Pixels = *p;
  int CurrentPixel = Diff;
  x += Diff;
  switch (GUI_Context.DrawMode & (LCD_DRAWMODE_TRANS | LCD_DRAWMODE_XOR)) {
    case 0:
      if (pTrans) {
        do {
          int Shift = (1 - CurrentPixel) << 2;
          int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
          LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
          SETPIXEL(x++, y, PixelIndex);
          if (++CurrentPixel == 2) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      } else {
        do {
          int Shift = (1 - CurrentPixel) << 2;
          int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
          SETPIXEL(x++, y, Index);
          if (++CurrentPixel == 2) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      }
      break;
    case LCD_DRAWMODE_TRANS:
      if (pTrans) {
        do {
          int Shift = (1 - CurrentPixel) << 2;
          int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
          if (Index) {
            LCD_PIXELINDEX PixelIndex = *(pTrans + Index);
            SETPIXEL(x, y, PixelIndex);
          }
          x++;
          if (++CurrentPixel == 2) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      } else {
        do {
          int Shift = (1 - CurrentPixel) << 2;
          int Index = (Pixels & (0xF0 >> (4 - Shift))) >> Shift;
          if (Index) {
            SETPIXEL(x, y, Index);
          }
          x++;
          if (++CurrentPixel == 2) {
            CurrentPixel = 0;
            Pixels = *(++p);
          }
        } while (--xsize);
      }
      break;
  }
}
#endif
/*********************************************************************
*
*       _DrawBitLine8BPP
*/
#if (LCD_MAX_LOG_COLORS > 16)
static void _DrawBitLine8BPP(int x, int y, U8 const*p, int xsize, const LCD_PIXELINDEX*pTrans) {
  LCD_PIXELINDEX pixel;
  if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS)==0) {
    if (pTrans) {
      for (;xsize > 0; xsize--,x++,p++) {
        pixel = *p;
        SETPIXEL(x, y, *(pTrans+pixel));
      }
    } else {
      for (;xsize > 0; xsize--,x++,p++) {
        SETPIXEL(x, y, *p);
      }
    }
  } else {   /* Handle transparent bitmap */
    if (pTrans) {
      for (; xsize > 0; xsize--, x++, p++) {
        pixel = *p;
        if (pixel) {
          SETPIXEL(x+0, y, *(pTrans+pixel));
        }
      }
    } else {
      for (; xsize > 0; xsize--, x++, p++) {
        pixel = *p;
        if (pixel) {
          SETPIXEL(x+0, y, pixel);
        }
      }
    }
  }
}
#endif
/*********************************************************************
*
*       _DrawBitLine16BPP
*/
#if (LCD_BITSPERPIXEL > 8)
static void _DrawBitLine16BPP(int x, int y, U16 const * p, int xsize) {
  LCD_PIXELINDEX pixel;
  if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) == 0) {
    for (;xsize > 0; xsize--,x++,p++) {
      SETPIXEL(x, y, *p);
    }
  } else {   /* Handle transparent bitmap */
    for (; xsize > 0; xsize--, x++, p++) {
      pixel = *p;
      if (pixel) {
        SETPIXEL(x + 0, y, pixel);
      }
    }
  }
}
#endif
/*********************************************************************
*
*       _DrawBitLine24BPP
*/
#if (LCD_BITSPERPIXEL > 16)
static void _DrawBitLine24BPP(int x, int y, U32 const * p, int xsize) {
  LCD_PIXELINDEX pixel;
  if ((GUI_Context.DrawMode & LCD_DRAWMODE_TRANS) == 0) {
    for (;xsize > 0; xsize--, x++, p++) {
      SETPIXEL(x, y, *p);
    }
  } else {   /* Handle transparent bitmap */
    for (; xsize > 0; xsize--, x++, p++) {
      pixel = *p;
      if (pixel) {
        SETPIXEL(x+0, y, pixel);
      }
    }
  }
}
#endif
/*********************************************************************
*
*       Exported code
*
**********************************************************************
*/
/*********************************************************************
*
*       LCD_L0_DrawPixel
*
*  Purpose:  Writes 1 pixel into the display.
*/
void LCD_L0_DrawPixel(int x, int y) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    XORPIXEL(x, y);
  } else {
    SETPIXEL(x, y, LCD_COLORINDEX);
  }
}
/*********************************************************************
*
*       LCD_L0_DrawHLine
*/
void LCD_L0_DrawHLine(int x0, int y,  int x1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    for (;x0 <= x1; x0++) {
      XORPIXEL(x0, y);
    }
  } else {
    for (;x0 <= x1; x0++) {
      SETPIXEL(x0, y, LCD_COLORINDEX);
    }
  }
}
/*********************************************************************
*
*       LCD_L0_DrawVLine
*/
void LCD_L0_DrawVLine(int x, int y0,  int y1) {
  if (GUI_Context.DrawMode & LCD_DRAWMODE_XOR) {
    while (y0 <= y1) {
      XORPIXEL(x, y0);
      y0++;
    }
  } else {
    while (y0 <= y1) {
      SETPIXEL(x, y0, LCD_COLORINDEX);
      y0++;
    }
  }
}
/*********************************************************************
*
*       LCD_L0_FillRect
*/
void LCD_L0_FillRect(int x0, int y0, int x1, int y1) {
  for (; y0 <= y1; y0++) {
    LCD_L0_DrawHLine(x0,y0, x1);
  }
}
/*********************************************************************
*
*       LCD_L0_DrawBitmap
*/
void LCD_L0_DrawBitmap(int x0, int y0,
                       int xsize, int ysize,
                       int BitsPerPixel, 
                       int BytesPerLine,
                       const U8* pData, int Diff,
                       const LCD_PIXELINDEX* pTrans)
{
  int i;
  /*
     Use DrawBitLineXBPP
  */
  for (i=0; i<ysize; i++) {
    switch (BitsPerPixel) {
    case 1:
      _DrawBitLine1BPP(x0, i + y0, pData, Diff, xsize, pTrans);
      break;
    #if (LCD_MAX_LOG_COLORS > 2)
      case 2:
        _DrawBitLine2BPP(x0, i + y0, pData, Diff, xsize, pTrans);
        break;
    #endif
    #if (LCD_MAX_LOG_COLORS > 4)
      case 4:
        _DrawBitLine4BPP(x0, i + y0, pData, Diff, xsize, pTrans);
        break;
    #endif
    #if (LCD_MAX_LOG_COLORS > 16)
      case 8:
        _DrawBitLine8BPP(x0, i + y0, pData, xsize, pTrans);
        break;
    #endif
    #if (LCD_BITSPERPIXEL > 8)
      case 16:
        _DrawBitLine16BPP(x0, i + y0, (const U16 *)pData, xsize);
        break;
    #endif
    #if (LCD_BITSPERPIXEL > 16)
      case 24:
        _DrawBitLine24BPP(x0, i + y0, (const U32 *)pData, xsize);
        break;
    #endif
    }
    pData += BytesPerLine;
  }
}
/*********************************************************************
*
*       LCD_L0_SetOrg
*
*  Purpose:
*    Sets the original position of the virtual display.
*    Has no function at this point with the PC-driver.
*/
void LCD_L0_SetOrg(int x, int y) {
  //LCDSIM_SetOrg(x, y, LCD_DISPLAY_INDEX);
}
/*********************************************************************
*
*       Support for verification
*
*  Purpose:
*    The following routines are implemented, but have no functionility
*    at this point. The reason is that these functions are supposed
*    to supervise the hardware, which for obvious reasons can not be
*    done in a simulation.
*/
#if LCD_VERIFY
int  LCD_GetErrStat(void) {
  return 0;
}
void LCD_ClrErrStat(void) {
}
int  LCD_GetErrCnt (void) {
  return 0;
}
#endif  
/*********************************************************************
*
*       LCD_On
*       LCD_Off
*
*  (Not supported in Simulation)
*/
void LCD_Off          (void) {}
void LCD_On           (void) {}
/*********************************************************************
*
*       LCD_L0_SetLUTEntry
*/
void LCD_L0_SetLUTEntry(U8 Pos, LCD_COLOR color) {
  LCDSIM_SetLUTEntry(Pos, color, LCD_DISPLAY_INDEX);
}
/*********************************************************************
*
*       LCD_L0_Init
*/
int  LCD_L0_Init(void) {
  LCDSIM_Init();  //初始化LCDSIM
  return 0;
}
int  LCD_L0_CheckInit(void) {
  return 0;
} 
/*********************************************************************
*
*       LCD_L0_ReInit
*
*  Purpose:
*    This routine is supplied for compatibility and interchangability of
*    "C"-sources with embedded versions of the driver. It has no real
*    effect in the PC-version as there is simply no need to re-initialize
*    the LCD since it is just simulated anyhow.
*/
void LCD_L0_ReInit       (void) {}
unsigned LCD_L0_GetPixelIndex(int x, int y)  {
  return LCDSIM_GetPixelIndex(x,y, LCD_DISPLAY_INDEX);
}
/*********************************************************************
*
*       LCD_L0_XorPixel
*
*  Purpose:
*    Inverts 1 pixel of the display.
*/
void LCD_L0_XorPixel(int x, int y) {
  XORPIXEL(x, y);
}
/*********************************************************************
*
*       LCD_L0_SetPixelIndex
*
*  Purpose:
*    Writes 1 pixel into the display.
*/
void LCD_L0_SetPixelIndex(int x, int y, int ColorIndex) {
  SETPIXEL(x, y, ColorIndex);
}
/*********************************************************************
*
*       LCD_L0_GetDevFunc
*/
void * LCD_L0_GetDevFunc(int Index) {
  GUI_USE_PARA(Index);
  return NULL;
}
  void LCDWin_c(void);
  void LCDWin_c(void) { } /* avoid empty object files */



//GUI_X_Win.c
#include "GUI_X.h"
#include <windows.h>
/*********************************************************************
*
*       GUI_X_Init()
*/
void GUI_X_Init(void)
{
}
/*********************************************************************
*
*       GUI_X_ExecIdle()
*/
void GUI_X_ExecIdle(void)
{
  Sleep(1);
};
/*********************************************************************
*
*      Timing:
*                 GUI_GetTime()
*                 GUI_Delay(int)
Some timing dependent routines of uC/GUI require a GetTime
and delay funtion. Default time unit (tick), normally is
1 ms.
*/
int StartTime;  //程序开始运行时的时间 该时间为从系统开启算起所经过的时间 单位为毫秒
int GUI_X_GetTime(void) 
{
  return (timeGetTime() - StartTime);
}
void GUI_X_Delay(int Period) 
{
  Sleep(Period);
}
/*********************************************************************
*
*      Multitask interface for Win32
*
*  The folling section consisting of 4 routines is used to make
*  the GUI software thread safe with WIN32
*/
static HANDLE hMutex;
static int _EntranceCnt;   // For debugging only ... Not required
void GUI_X_InitOS(void) 
{
  StartTime = timeGetTime();  //需要添加winmm.lib库
  //创建一个互斥量对象
  hMutex = CreateMutex(NULL, 0, "GUI Simulation - Mutex");
}
U32 GUI_X_GetTaskId(void)
{
  return GetCurrentThreadId();
}
void GUI_X_Lock(void) 
{
  WaitForSingleObject(hMutex, INFINITE);
  if (++_EntranceCnt > 1)
  {
    //SIM_ErrorOut("Error in GUITASK.c module ...");
  }
}
void GUI_X_Unlock(void)
{
  _EntranceCnt--;
  ReleaseMutex(hMutex);
}
/*********************************************************************
*
*      Text output for Logging, warnings and errors
Logging - required only for higher debug levels
*/
void GUI_X_Log     (const char *s)     { /*SIM_Log(s); */}
void GUI_X_Warn    (const char *s)     { /*SIM_Warn(s); */}
void GUI_X_ErrorOut(const char *s)     { /*SIM_ErrorOut(s);*/ }


文章标签：
C语言
Go
iOS开发
Android开发
Linux
Windows
关键词：
Go语言
Windows跨平台
Go语言跨平台
Go跨平台
Windows Go
特立独行的猫a
目录
相关文章
陌陌谣
|
1月前
|
存储 监控 算法
员工上网行为监控中的Go语言算法：布隆过滤器的应用
在信息化高速发展的时代，企业上网行为监管至关重要。布隆过滤器作为一种高效、节省空间的概率性数据结构，适用于大规模URL查询与匹配，是实现精准上网行为管理的理想选择。本文探讨了布隆过滤器的原理及其优缺点，并展示了如何使用Go语言实现该算法，以提升企业网络管理效率和安全性。尽管存在误报等局限性，但合理配置下，布隆过滤器为企业提供了经济有效的解决方案。
陌陌谣
84 8
员工上网行为监控中的Go语言算法：布隆过滤器的应用
听风de歌
|
1月前
|
存储 Go 索引
go语言中的数组（Array）
go语言中的数组（Array）
听风de歌
117 67
陌陌谣
|
6天前
|
存储 监控 算法
内网监控系统之 Go 语言布隆过滤器算法深度剖析
在数字化时代，内网监控系统对企业和组织的信息安全至关重要。布隆过滤器（Bloom Filter）作为一种高效的数据结构，能够快速判断元素是否存在于集合中，适用于内网监控中的恶意IP和违规域名筛选。本文介绍其原理、优势及Go语言实现，提升系统性能与响应速度，保障信息安全。
陌陌谣
22 5
智物科技库
|
16天前
|
算法 安全 Go
Go语言中的加密和解密是如何实现的？
Go语言通过标准库中的`crypto`包提供丰富的加密和解密功能，包括对称加密（如AES）、非对称加密（如RSA、ECDSA）及散列函数（如SHA256）。`encoding/base64`包则用于Base64编码与解码。开发者可根据需求选择合适的算法和密钥，使用这些包进行加密操作。示例代码展示了如何使用`crypto/aes`包实现对称加密。加密和解密操作涉及敏感数据处理，需格外注意安全性。
智物科技库
38 14
运营研究坊
|
16天前
|
Go 数据库
Go语言中的包（package）是如何组织的？
在Go语言中，包是代码组织和管理的基本单元，用于集合相关函数、类型和变量，便于复用和维护。包通过目录结构、文件命名、初始化函数（`init`）及导出规则来管理命名空间和依赖关系。合理的包组织能提高代码的可读性、可维护性和可复用性，减少耦合度。例如，`stringutils`包提供字符串处理函数，主程序导入使用这些函数，使代码结构清晰易懂。
运营研究坊
63 11
2G冲浪词条
|
16天前
|
存储 安全 Go
Go语言中的map数据结构是如何实现的？
Go 语言中的 `map` 是基于哈希表实现的键值对数据结构，支持快速查找、插入和删除操作。其原理涉及哈希函数、桶（Bucket）、动态扩容和哈希冲突处理等关键机制，平均时间复杂度为 O(1)。为了确保线程安全，Go 提供了 `sync.Map` 类型，通过分段锁实现并发访问的安全性。示例代码展示了如何使用自定义结构体和切片模拟 `map` 功能，以及如何使用 `sync.Map` 进行线程安全的操作。
2G冲浪词条
39 9
陌陌谣
|
20天前
|
监控 安全 算法
深度剖析核心科技：Go 语言赋能局域网管理监控软件进阶之旅
在局域网管理监控中，跳表作为一种高效的数据结构，能显著提升流量索引和查询效率。基于Go语言的跳表实现，通过随机化索引层生成、插入和搜索功能，在高并发场景下展现卓越性能。跳表将查询时间复杂度优化至O(log n)，助力实时监控异常流量，保障网络安全与稳定。示例代码展示了其在实际应用中的精妙之处。
陌陌谣
38 9
tech1024
|
30天前
|
算法 安全 Go
Go 语言中实现 RSA 加解密、签名验证算法
随着互联网的发展，安全需求日益增长。非对称加密算法RSA成为密码学中的重要代表。本文介绍如何使用Go语言和[forgoer/openssl](https://github.com/forgoer/openssl)库简化RSA加解密操作，包括秘钥生成、加解密及签名验证。该库还支持AES、DES等常用算法，安装简便，代码示例清晰易懂。
tech1024
60 12
追逐时光者
|
1月前
|
Linux C# iOS开发
开源GTKSystem.Windows.Forms框架让C# Winform支持跨平台运行
开源GTKSystem.Windows.Forms框架让C# Winform支持跨平台运行
追逐时光者
59 12
陌陌谣
|
1月前
|
监控 算法 安全
解锁企业计算机监控的关键：基于 Go 语言的精准洞察算法
企业计算机监控在数字化浪潮下至关重要，旨在保障信息资产安全与高效运营。利用Go语言的并发编程和系统交互能力，通过进程监控、网络行为分析及应用程序使用记录等手段，实时掌握计算机运行状态。具体实现包括获取进程信息、解析网络数据包、记录应用使用时长等，确保企业信息安全合规，提升工作效率。本文转载自：[VIPShare](https://www.vipshare.com)。
陌陌谣
33 1

热门文章

最新文章

  • 1
    windows server2016搭建AD域服务器
  • 2
    Windows下Minio的安装以及基本使用
  • 3
    2025年1月9日更新Windows操作系统个人使用-禁用掉一下一些不必要的服务-关闭占用资源的进程-禁用服务提升系统运行速度-让电脑不再卡顿-优雅草央千澈-长期更新
  • 4
    AI Dev Gallery：微软开源 Windows AI 模型本地运行工具包和示例库，助理开发者快速集成 AI 功能
  • 5
    如何修复 Android 和 Windows 不支持视频编解码器的问题？
  • 6
    网安快速入门之Windows命令
  • 7
    Go 语言中实现 RSA 加解密、签名验证算法
  • 8
    Go语言中的包（package）是如何组织的？
  • 9
    Go语言中的map数据结构是如何实现的？
  • 10
    深度剖析核心科技：Go 语言赋能局域网管理监控软件进阶之旅
  • 1
    快速入门：利用Go语言下载Amazon商品信息的步骤详解
    87
  • 2
    Go语言学习12-数据的使用
    100
  • 3
    一文带你速通go语言指针
    96
  • 4
    来聊聊go语言的hashMap
    70
  • 5
    聊聊Go程序是如何运行的
    85
  • 6
    Go语言学习11-数据初始化
    79
  • 7
    速通Go语言编译过程
    68
  • 8
    一文带你速通Go语言基础语法
    106
  • 9
    Go语言的入门学习
    83
  • 10
    3137. K 周期字符串需要的最少操作次数[go语言中map学习]
    66

    • 相关课程

    更多
  • Go语言核心编程 - 数据结构和算法
  • Go语言核心编程 - 基础语法、数组、切片、Map
  • Go语言核心编程 - 面向对象、文件、单元测试、反射、TCP编程
  • Go语言完全自学手册图文教程
  • Linux Shell 编程入门与实战
  • Linux Shell 编程

    • 相关电子书

    更多
  • Go语言路上踩过的坑
  • gohbase ：HBase go客户端
  • Go构建日请求千亿级微服务实践

    • 相关实验场景

    更多
  • 快速配置Windows云服务器
  • Python网络通信程序典型应用
  • 手动搭建FTP站点（Windows）
    • 下一篇
    DataWorks售前咨询