WhyCan Forum(哇酷开发者社区)

import (
	"fmt"

	"github.com/zlgopen/awtk-go/awtk"
)

func onCancel(ctx interface{}, e awtk.TEvent) awtk.TRet {
	fmt.Println("Cancel is clicked")
	return awtk.RET_OK
}

func appInit() {
	win := awtk.TWindowCreateDefault()

	ok := awtk.TButtonCreate(win, 10, 10, 80, 30)
	ok.SetPropStr(awtk.WIDGET_PROP_TEXT, "OK")
	ok.SetSelfLayout("default(x=c,y=m,w=80,h=40)")
	ok.On(awtk.EVT_CLICK, func(ctx interface{}, e awtk.TEvent) awtk.TRet {
		fmt.Println("OK is clicked")
		return awtk.RET_OK
	}, win)

	cancel := awtk.TButtonCreate(win, 10, 10, 80, 30)
	cancel.SetPropStr(awtk.WIDGET_PROP_TEXT, "Cancel")
	cancel.SetSelfLayout("default(x=c,y=m:-60,w=80,h=40)")
	cancel.On(awtk.EVT_CLICK, onCancel, win)

	quit := awtk.TButtonCreate(win, 10, 10, 80, 30)
	quit.SetPropStr(awtk.WIDGET_PROP_TEXT, "Quit")
	quit.SetSelfLayout("default(x=c,y=m:60,w=80,h=40)")
	quit.SetPropStr("on:click", "quit()")
}

func main() {
	awtk.Init(320, 480, awtk.APP_DESKTOP, "demo", "res")
	awtk.InitAssets()
	appInit()

	awtk.Run()
}

/**
 * @method event_recorder_player_start_record
 * 开始事件记录。
 * @annotation ["static"]
 * @param {const char*} filename 用于保存事件的文件名。
 *
 * @return {ret_t} 返回 RET_OK 表示成功，否则表示失败。
 */
ret_t event_recorder_player_start_record(const char* filename);

/**
 * @method event_recorder_player_start_play
 * 开始事件重放。
 * @annotation ["static"]
 * @param {const char*} filename 存放事件的文件名。
 * @param {uint32_t} times 循环播放的次数。
 *
 * @return {ret_t} 返回 RET_OK 表示成功，否则表示失败。
 */
ret_t event_recorder_player_start_play(const char* filename, uint32_t times);

/**
 * @method event_recorder_player_stop_record
 * 停止事件记录。
 * @annotation ["static"]
 *
 * @return {ret_t} 返回 RET_OK 表示成功，否则表示失败。
 */
ret_t event_recorder_player_stop_record(void);

/**
 * @method event_recorder_player_stop_play
 * 停止事件重放。
 * @annotation ["static"]
 *
 * @return {ret_t} 返回 RET_OK 表示成功，否则表示失败。
 */
ret_t event_recorder_player_stop_play(void);

#include "base/event_recorder_player.h"
...

static ret_t on_key_record_play_events(void* ctx, event_t* e) {
  key_event_t* evt = (key_event_t*)e;

#ifdef WITH_EVENT_RECORDER_PLAYER
  if (evt->key == TK_KEY_F5) {
    event_recorder_player_start_record("event_log.bin");
    return RET_STOP;
  } else if (evt->key == TK_KEY_F6) {
    event_recorder_player_stop_record();
    return RET_STOP;
  } else if (evt->key == TK_KEY_F7) {
    event_recorder_player_start_play("event_log.bin", 0xffff);
    return RET_STOP;
  } else if (evt->key == TK_KEY_F8) {
    event_recorder_player_stop_play();
    return RET_STOP;
  }
#endif /*WITH_EVENT_RECORDER_PLAYER*/

  return RET_OK;
}

...

widget_on(wm, EVT_KEY_UP, on_key_record_play_events, wm);

    vi.yoffset = i * fb_height(fb);
    if (ioctl(fb->fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
      perror("active fb swap failed");
    } 

static void* display_thread(void* ctx) {
  uint32_t i = 0;
  uint32_t index = 0;
  fb_info_t* fb = &s_fb;
  int fb_nr = fb_number(fb);
  uint32_t size = fb_size(fb);
  lcd_mem_t* lcd = (lcd_mem_t*)ctx;
  struct fb_var_screeninfo vi = (fb->var);

  log_info("display_thread start\n");
  while (!s_app_quited) {
    uint8_t* buff = fb->fbmem0 + size * i;
    uint32_t start = time_now_ms();

    vi.yoffset = i * fb_height(fb);
    pthread_mutex_lock(&s_mutex);
    memcpy(buff, lcd->offline_fb, size);
    pthread_mutex_unlock(&s_mutex);

    if (ioctl(fb->fd, FBIOPUT_VSCREENINFO, &vi) < 0) {
      perror("active fb swap failed");
    }   

    index++;
    i = index % fb_nr;
  }
  log_info("display_thread end\n");

  return NULL;

TencentOS/kernel/core/tos_event.c
TencentOS/kernel/core/tos_fifo.c
TencentOS/kernel/core/tos_global.c
TencentOS/kernel/core/tos_mmblk.c
TencentOS/kernel/core/tos_mmheap.c
TencentOS/kernel/core/tos_msg.c
TencentOS/kernel/core/tos_mutex.c
TencentOS/kernel/core/tos_pend.c
TencentOS/kernel/core/tos_queue.c
TencentOS/kernel/core/tos_robin.c
TencentOS/kernel/core/tos_sched.c
TencentOS/kernel/core/tos_sem.c
TencentOS/kernel/core/tos_sys.c
TencentOS/kernel/core/tos_task.c
TencentOS/kernel/core/tos_tick.c
TencentOS/kernel/core/tos_time.c
TencentOS/kernel/core/tos_timer.c
TencentOS/kernel/pm/tos_pm.c
TencentOS/kernel/pm/tos_tickless.c
TencentOS/arch/arm/arm-v7m/common/tos_cpu.c
TencentOS/arch/arm/arm-v7m/common/tos_fault.c
TencentOS/arch/arm/arm-v7m/cortex-m3/armcc/port_c.c
TencentOS/arch/arm/arm-v7m/cortex-m3/armcc/port_s.S

TencentOS/arch/arm/arm-v7m/common/include
TencentOS/arch/arm/arm-v7m/cortex-m3/armcc
TencentOS/kernel/core/include
TencentOS/kernel/hal/include
TencentOS/kernel/pm/include
TencentOS/TOS-CONFIG

src/platforms/tos/mutex.c
src/platforms/tos/semaphore.c
src/platforms/tos/thread.c
src/platforms/common/sys_tick.c

ret_t rtos_init(void) {
  tos_knl_init();
  tos_robin_config(TOS_ROBIN_STATE_ENABLED, (k_timeslice_t)500u);

  return RET_OK;
}

ret_t rtos_start(void) {
  tos_knl_start();

  return RET_OK;
}

void rtos_tick(void) {
  if (tos_knl_is_running()) {
    tos_knl_irq_enter();
    tos_tick_handler();
    tos_knl_irq_leave();
  }
}

void rtos_delay(uint32_t ms) {
  tos_task_delay(ms);
}

void* awtk_thread(void* args) {
  gui_app_start(320, 480);

  return NULL;
}

static ret_t awtk_start_ui_thread(void) {
  tk_thread_t* ui_thread = tk_thread_create(awtk_thread, NULL);
  return_value_if_fail(ui_thread != NULL, RET_BAD_PARAMS);

  tk_thread_set_priority(ui_thread, 3);
  tk_thread_set_name(ui_thread, "awtk");
  tk_thread_set_stack_size(ui_thread, 2048);

  return tk_thread_start(ui_thread);
}

int main() {
  hardware_prepare();
  platform_prepare();

  rtos_init();
  awtk_start_ui_thread();
  rtos_start();
	
	return 0;
}

static bool_t s_inited = FALSE;
static uint32_t s_heam_mem[4096];

ret_t platform_prepare(void) {
	if(!s_inited) {
		s_inited = TRUE;
    tk_mem_init(s_heam_mem, sizeof(s_heam_mem));
	}
  return RET_OK;
}

rtthread/
rtthread/bsp
rtthread/cortex-m3
rtthread/cortex-m3/context_gcc.S
rtthread/cortex-m3/context_iar.S
rtthread/cortex-m3/context_rvds.S
rtthread/cortex-m3/cpuport.c
rtthread/cortex-m3/SConscript
rtthread/include
rtthread/include/libc
rtthread/include/libc/libc_dirent.h
rtthread/include/libc/libc_errno.h
rtthread/include/libc/libc_fcntl.h
rtthread/include/libc/libc_fdset.h
rtthread/include/libc/libc_ioctl.h
rtthread/include/libc/libc_signal.h
rtthread/include/libc/libc_stat.h
rtthread/include/rtdbg.h
rtthread/include/rtdebug.h
rtthread/include/rtdef.h
rtthread/include/rthw.h
rtthread/include/rtlibc.h
rtthread/include/rtm.h
rtthread/include/rtservice.h
rtthread/include/rtthread.h
rtthread/rtconfig.h
rtthread/src
rtthread/src/clock.c
rtthread/src/components.c
rtthread/src/cpu.c
rtthread/src/device.c
rtthread/src/idle.c
rtthread/src/ipc.c
rtthread/src/irq.c
rtthread/src/Kconfig
rtthread/src/kservice.c
rtthread/src/mem.c
rtthread/src/memheap.c
rtthread/src/mempool.c
rtthread/src/object.c
rtthread/src/scheduler.c
rtthread/src/SConscript
rtthread/src/signal.c
rtthread/src/slab.c
rtthread/src/thread.c
rtthread/src/timer.c

rtthread
rtthread/include

src/platforms/rtt/mutex.c
src/platforms/rtt/semaphore.c
src/platforms/rtt/sys_tick.c
src/platforms/rtt/thread.c

static volatile uint64_t g_sys_tick;

void rtos_tick(void) {
  if (rtos_is_inited()) {
    rt_interrupt_enter();
    rt_tick_increase();
    rt_interrupt_leave();
  }
}

void SysTick_Handler(void) {
  g_sys_tick++;
  rtos_tick();
}

void* awtk_thread(void* args) {
  gui_app_start(320, 480);

  return NULL;
}

static ret_t awtk_start_ui_thread(void) {
  tk_thread_t* ui_thread = tk_thread_create(awtk_thread, NULL);
  return_value_if_fail(ui_thread != NULL, RET_BAD_PARAMS);

  tk_thread_set_priority(ui_thread, 3);
  tk_thread_set_name(ui_thread, "awtk");
  tk_thread_set_stack_size(ui_thread, 2048);

  return tk_thread_start(ui_thread);
}

static void hardware_prepare(void) {
  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
  systick_init();
  led_init();
  button_init();
  TFT_Init();
  TFT_ClearScreen(BLACK);
  FLASH_Init();
  TOUCH_Init();

  TIM3_Init(50, 7199);
  rtc_init();
}

int main() {
  hardware_prepare();
  platform_prepare();

  rtos_init();
  awtk_start_ui_thread();

  rtos_start();
}

static bool_t s_inited = FALSE;
static uint32_t s_heam_mem[4096];

ret_t platform_prepare(void) {
	if(!s_inited) {
		s_inited = TRUE;
    tk_mem_init(s_heam_mem, sizeof(s_heam_mem));
	}
  return RET_OK;
}

   static const char* fillFragShader =
      "#ifdef GL_ES\n"
      "#if defined(GL_FRAGMENT_PRECISION_HIGH) || defined(NANOVG_GL3)\n"
      " precision highp float;\n"
      "#else\n"
      " precision mediump float;\n"
      "#endif\n"
      "#endif\n"
      "#ifdef NANOVG_GL3\n"
      "#ifdef USE_UNIFORMBUFFER\n"
      "   layout(std140) uniform frag {\n"
      "      mat3 scissorMat;\n"
      "      mat3 paintMat;\n"
      "      vec4 innerCol;\n"
      "      vec4 outerCol;\n"
      "      vec2 scissorExt;\n"
      "      vec2 scissorScale;\n"
      "      vec2 extent;\n"
      "      float radius;\n"
      "      float feather;\n"
      "      float strokeMult;\n"
      "      float strokeThr;\n"
      "      int texType;\n"
      "      int type;\n"
      "   };\n"
      "#else\n" // NANOVG_GL3 && !USE_UNIFORMBUFFER
      "   uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
      "#endif\n"
      "   uniform sampler2D tex;\n"
      "   in vec2 ftcoord;\n"
      "   in vec2 fpos;\n"
      "   out vec4 outColor;\n"
      "#else\n" // !NANOVG_GL3
      "   uniform vec4 frag[UNIFORMARRAY_SIZE];\n"
      "   uniform sampler2D tex;\n"
      "   varying vec2 ftcoord;\n"
      "   varying vec2 fpos;\n"
      "#endif\n"
      "#ifndef USE_UNIFORMBUFFER\n"
      "   #define scissorMat mat3(frag[0].xyz, frag[1].xyz, frag[2].xyz)\n"
      "   #define paintMat mat3(frag[3].xyz, frag[4].xyz, frag[5].xyz)\n"
      "   #define innerCol frag[6]\n"
      "   #define outerCol frag[7]\n"
      "   #define scissorExt frag[8].xy\n"
      "   #define scissorScale frag[8].zw\n"
      "   #define extent frag[9].xy\n"
      "   #define radius frag[9].z\n"
      "   #define feather frag[9].w\n"
      "   #define strokeMult frag[10].x\n"
      "   #define strokeThr frag[10].y\n"
      "   #define texType int(frag[10].z)\n"
      "   #define type int(frag[10].w)\n"
      "#endif\n"
      "\n"
      "float sdroundrect(vec2 pt, vec2 ext, float rad) {\n"
      "   vec2 ext2 = ext - vec2(rad,rad);\n"
      "   vec2 d = abs(pt) - ext2;\n"
      "   return min(max(d.x,d.y),0.0) + length(max(d,0.0)) - rad;\n"
      "}\n"
      "\n"
      "// Scissoring\n"
      "float scissorMask(vec2 p) {\n"
      "   vec2 sc = (abs((scissorMat * vec3(p,1.0)).xy) - scissorExt);\n"
      "   sc = vec2(0.5,0.5) - sc * scissorScale;\n"
      "   return clamp(sc.x,0.0,1.0) * clamp(sc.y,0.0,1.0);\n"
      "}\n"
      "#ifdef EDGE_AA\n"
      "// Stroke - from [0..1] to clipped pyramid, where the slope is 1px.\n"
      "float strokeMask() {\n"
      "   return min(1.0, (1.0-abs(ftcoord.x*2.0-1.0))*strokeMult) * min(1.0, ftcoord.y);\n"
      "}\n"
      "#endif\n"
      "\n"
      "void main(void) {\n"
      "   vec4 result;\n"
      "   float scissor = scissorMask(fpos);\n"
      "#ifdef EDGE_AA\n"
      "   float strokeAlpha = strokeMask();\n"
      "   if (strokeAlpha < strokeThr) discard;\n"
      "#else\n"
      "   float strokeAlpha = 1.0;\n"
      "#endif\n"
      "   if (type == 0) {         // Gradient\n"
      "      // Calculate gradient color using box gradient\n"
      "      vec2 pt = (paintMat * vec3(fpos,1.0)).xy;\n"
      "      float d = clamp((sdroundrect(pt, extent, radius) + feather*0.5) / feather, 0.0, 1.0);\n"
      "      vec4 color = mix(innerCol,outerCol,d);\n"
      "      // Combine alpha\n"
      "      color *= strokeAlpha * scissor;\n"
      "      result = color;\n"
      "   } else if (type == 1) {      // Image\n"
      "      // Calculate color fron texture\n"
      "      vec2 pt = (paintMat * vec3(fpos,1.0)).xy / extent;\n"
      "#ifdef NANOVG_GL3\n"
      "      vec4 color = texture(tex, pt);\n"
      "#else\n"
      "      vec4 color = texture2D(tex, pt);\n"
      "#endif\n"
      "      if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
      "      if (texType == 2) color = vec4(color.x);"
      "      // Apply color tint and alpha.\n"
      "      color *= innerCol;\n"
      "      // Combine alpha\n"
      "      color *= strokeAlpha * scissor;\n"
      "      result = color;\n"
      "   } else if (type == 2) {      // Stencil fill\n"
      "      result = vec4(1,1,1,1);\n"
      "   } else if (type == 3) {      // Textured tris\n"
      "#ifdef NANOVG_GL3\n"
      "      vec4 color = texture(tex, ftcoord);\n"
      "#else\n"
      "      vec4 color = texture2D(tex, ftcoord);\n"
      "#endif\n"
      "      if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
      "      if (texType == 2) color = vec4(color.x);"
      "      color *= scissor;\n"
      "      result = color * innerCol;\n"
      "   }\n"
      "#ifdef NANOVG_GL3\n"
      "   outColor = result;\n"
      "#else\n"
      "   gl_FragColor = result;\n"
      "#endif\n"
      "}\n";

      "   if (type == 0) {         // Gradient\n"
      "      // Calculate gradient color using box gradient\n"
      "      vec2 pt = (paintMat * vec3(fpos,1.0)).xy;\n"
      "      float d = clamp((sdroundrect(pt, extent, radius) + feather*0.5) / feather, 0.0, 1.0);\n"
      "      vec4 color = mix(innerCol,outerCol,d);\n"
      "      // Combine alpha\n"
      "      color *= strokeAlpha * scissor;\n"
      "      result = color;\n"

      " if (type == 5) {    //fast fill color\n"
      "   result = innerCol;\n"

    " } else if(type == 7) {      // fill color\n"
      "   strokeAlpha = strokeMask();\n"
      "   if (strokeAlpha < strokeThr) discard;\n"
      "   float scissor = scissorMask(fpos);\n"
      "   vec4 color = innerCol;\n"
      "   color *= strokeAlpha * scissor;\n"
      "   result = color;\n"

      "   } else if (type == 3) {      // Textured tris\n"
      "#ifdef NANOVG_GL3\n"
      "      vec4 color = texture(tex, ftcoord);\n"
      "#else\n"
      "      vec4 color = texture2D(tex, ftcoord);\n"
      "#endif\n"
      "      if (texType == 1) color = vec4(color.xyz*color.w,color.w);"
      "      if (texType == 2) color = vec4(color.x);"
      "      color *= scissor;\n"
      "      result = color * innerCol;\n"
      "   }\n"

      " } else if (type == 3) {   // Textured tris\n"
      "#ifdef NANOVG_GL3\n"
      "   vec4 color = texture(tex, ftcoord);\n"
      "#else\n"
      "   vec4 color = texture2D(tex, ftcoord);\n"
      "#endif\n"
      "   if(color.x < 0.02) discard;\n"
      "   strokeAlpha = strokeMask();\n"
      "   if (strokeAlpha < strokeThr) discard;\n"
      "   float scissor = scissorMask(fpos);\n"
      "   color = vec4(color.x);"
      "   color *= scissor;\n"
      "   result = color * innerCol;\n"
      " }\n"

      "float strokeMask() {\n"
      "   return min(1.0, (1.0-abs(ftcoord.x*2.0-1.0))*strokeMult) * min(1.0, ftcoord.y);\n"
      "}\n"

      " if (type == 5) {    //fast fill color\n"
      "   result = innerCol;\n"

      "// Scissoring\n"
      "float scissorMask(vec2 p) {\n"
      "   vec2 sc = (abs((scissorMat * vec3(p,1.0)).xy) - scissorExt);\n"
      "   sc = vec2(0.5,0.5) - sc * scissorScale;\n"
      "   return clamp(sc.x,0.0,1.0) * clamp(sc.y,0.0,1.0);\n"
      "}\n"

static int glnvg__pathInScissor(const NVGpath* path, NVGscissor* scissor) {
  int32_t i = 0;
  float cx = scissor->xform[4];
  float cy = scissor->xform[5];
  float hw = scissor->extent[0];
  float hh = scissor->extent[1];

  float l = cx - hw;
  float t = cy - hh;
  float r = l + 2 * hw - 1;
  float b = t + 2 * hh - 1;

  const NVGvertex* verts = path->fill;
  for (i = 0; i < path->nfill; i++) {
    const NVGvertex* iter = verts + i;
    int x = iter->x;
    int y = iter->y;
    if (x < l || x > r || y < t || y > b) {
      return 0;
    }
  }

  return 1;
}

include(../awtk-iotjs/awtk-module/awtk.cmake)

git clone https://github.com/zlgopen/awtk-iotjs.git
cd awtk-iotjs
./build.sh

./run.sh demos/buttons.js

require('awtk').init(320, 480);

require('awtk').init(320, 480);

function applicationInit() {
  var win = TWindow.create(null, 0, 0, 0, 0); 
  var ok = TButton.create(win, 0, 0, 0, 0); 

  ok.setText("ok");
  ok.setSelfLayoutParams("center", "middle", "50%", "30");

  ok.on(TEventType.CLICK, function(evt) {
    var e = TPointerEvent.cast(evt);
    console.log("on click: " + e.x + " " + e.y);

    return TRet.OK;
  }); 
 
  win.layout();
}

applicationInit()