src/tools/hmi_generator.rb

   1 # -*- coding: euc-jp -*-
   2 #
   3 # hmi_generator.rb
   4 #
   5 # Copyright (c) 2012-2015 project bchan
   6 #
   7 # This software is provided 'as-is', without any express or implied
   8 # warranty. In no event will the authors be held liable for any damages
   9 # arising from the use of this software.
  10 #
  11 # Permission is granted to anyone to use this software for any purpose,
  12 # including commercial applications, and to alter it and redistribute it
  13 # freely, subject to the following restrictions:
  14 #
  15 # 1. The origin of this software must not be misrepresented; you must not
  16 #    claim that you wrote the original software. If you use this software
  17 #    in a product, an acknowledgment in the product documentation would be
  18 #    appreciated but is not required.
  19 #
  20 # 2. Altered source versions must be plainly marked as such, and must not be
  21 #    misrepresented as being the original software.
  22 #
  23 # 3. This notice may not be removed or altered from any source
  24 #    distribution.
  25 #
  26
  27 require 'yaml'
  28 require 'erb'
  29
  30 def conv_euc_to_TCArray(str)
  31   ret = Array.new();
  32   str.encode("EUC-JP").each_char do |x|
  33     i = x.bytesize - 1;
  34     val = 0;
  35     x.each_byte do |ch|
  36       val += ch << (8 * i);
  37       i -= 1;
  38     end
  39     ret.push(val & 0x7f7f);
  40   end
  41   ret;
  42 end
  43
  44 def conv_TCArray_to_hex_definition(a)
  45   str = String.new();
  46   a.each do |x|
  47     str += "0x" + x.to_s(16) + ", "
  48   end
  49   str += "TNULL";
  50 end
  51
  52 def calc_euc_to_TCArray_length(str)
  53   str = conv_euc_to_TCArray(str);
  54   return str.length;
  55 end
  56
  57 class HMIParts
  58   attr_accessor :yaml
  59   def initialize(yaml)
  60     @yaml = yaml;
  61   end
  62   def type()
  63     @yaml["type"];
  64   end
  65   def name()
  66     @yaml["name"];
  67   end
  68   def text_length()
  69     @yaml["length"];
  70   end
  71   def rect_string()
  72     "{{" + @yaml["rect"]["left"].to_s + ", " + @yaml["rect"]["top"].to_s + ", " + @yaml["rect"]["right"].to_s + ", " + @yaml["rect"]["bottom"].to_s + "}}";
  73   end
  74   def rect_left()
  75     @yaml["rect"]["left"].to_s
  76   end
  77   def rect_top()
  78     @yaml["rect"]["top"].to_s
  79   end
  80   def rect_right()
  81     @yaml["rect"]["right"].to_s
  82   end
  83   def rect_bottom()
  84     @yaml["rect"]["bottom"].to_s
  85   end
  86   def text_array()
  87     conv_TCArray_to_hex_definition(conv_euc_to_TCArray(@yaml["text"]));
  88   end
  89   def text_array_length()
  90     calc_euc_to_TCArray_length(@yaml["text"]);
  91   end
  92   def is_attr_specified()
  93     @yaml["attr"] != nil
  94   end
  95   def get_attr_offset()
  96     if self.is_attr_specified()
  97       7
  98     else
  99       1
 100     end
 101   end
 102   def get_attrval_chcol()
 103     if @yaml["attr"]["chcol"] == nil
 104       return -1
 105     end
 106     @yaml["attr"]["chcol"]
 107   end
 108   def get_attrval_class()
 109     if @yaml["attr"]["class"] == nil
 110       return -1
 111     end
 112     @yaml["attr"]["class"]
 113   end
 114   def get_attrval_attr()
 115     if @yaml["attr"]["attr"] == nil
 116       return -1
 117     end
 118     @yaml["attr"]["attr"]
 119   end
 120   def get_attrval_csize_h()
 121     if @yaml["attr"]["csize"] == nil || @yaml["attr"]["csize"]["h"] == nil
 122       return 16
 123     end
 124     @yaml["attr"]["csize"]["h"]
 125   end
 126   def get_attrval_csize_v()
 127     if @yaml["attr"]["csize"] == nil || @yaml["attr"]["csize"]["v"] == nil
 128       return 16
 129     end
 130     @yaml["attr"]["csize"]["v"]
 131   end
 132   def is_need_eventbreak()
 133     return false
 134   end
 135   def get_databox_specify()
 136     return @yaml["databox"]["specify"]
 137   end
 138   def get_databox_number()
 139     return @yaml["databox"]["number"]
 140   end
 141   def is_databox_specify_argument()
 142     @yaml["databox"] != nil && @yaml["databox"]["specify"] == "argument"
 143   end
 144   def is_databox_use()
 145     @yaml["databox"] != nil && (@yaml["databox"]["specify"] != "direct" || @yaml["databox"]["specify"] != "argument")
 146   end
 147   def is_use_rect_in_open()
 148     !is_databox_use()
 149   end
 150
 151   def generate_header_eventtype_enumulate(main_name, window_name)
 152     script = <<-EOS
 153     EOS
 154
 155     erb = ERB.new(script, nil, '-');
 156     erb.result(binding)
 157   end
 158
 159   def generate_header_eventstruct_definition(main_name, window_name)
 160     script = <<-EOS
 161     EOS
 162
 163     erb = ERB.new(script, nil, '-');
 164     erb.result(binding)
 165   end
 166
 167   def generate_header_eventunion_member(main_name, window_name)
 168     script = <<-EOS
 169     EOS
 170
 171     erb = ERB.new(script, nil, '-');
 172     erb.result(binding)
 173   end
 174
 175   def generate_prototypes(window_name)
 176     script = <<-EOS
 177     EOS
 178
 179     erb = ERB.new(script, nil, '-');
 180     erb.result(binding)
 181   end
 182
 183   def generate_source_struct(window_name)
 184     script = <<-EOS
 185     EOS
 186
 187     erb = ERB.new(script, nil, '-');
 188     erb.result(binding)
 189   end
 190
 191   def generate_source_functions(main_name, window_name)
 192     script = <<-EOS
 193     EOS
 194
 195     erb = ERB.new(script, nil, '-');
 196     erb.result(binding)
 197   end
 198
 199   def generate_initialize_in_new()
 200     script = <<-EOS
 201         window-><%= self.name() %>.id = -1;
 202         <%- if self.is_databox_specify_argument() -%>
 203         window-><%= self.name() %>.dnum = dnum_<%= self.name() %>;
 204         <%- end -%>
 205     EOS
 206
 207     erb = ERB.new(script, nil, '-');
 208     erb.result(binding)
 209   end
 210
 211   def generate_create_systemcall_databox()
 212     case self.get_databox_specify()
 213     when "argument"
 214       script = "copn_par(wid, window-><%= self.name() %>.dnum, NULL)"
 215     when "specify"
 216       script = "copn_par(wid, <%= self.get_databox_number() %>, NULL)"
 217     end
 218
 219     erb = ERB.new(script, nil, '-');
 220     erb.result(binding)
 221   end
 222
 223   def generate_create_systemcall_direct()
 224     script = <<-EOS
 225     EOS
 226
 227     erb = ERB.new(script, nil, '-');
 228     erb.result(binding)
 229   end
 230
 231   def generate_create_systemcall()
 232     if self.is_databox_use()
 233       return self.generate_create_systemcall_databox()
 234     else
 235       return self.generate_create_systemcall_direct()
 236     end
 237   end
 238
 239   def generate_create_in_open()
 240     script = <<-EOS
 241         <%- if !self.is_databox_use() -%>
 242         r = (RECT)<%= self.rect_string() %>;
 243         <%- end -%>
 244         window-><%= self.name() %>.id = <%= self.generate_create_systemcall()%>;
 245         if (window-><%= self.name() %>.id < 0) {
 246                 DP_ER("ccre_xxx <%= self.name() %> error:", window-><%= self.name() %>.id);
 247         }
 248         <%- if self.is_databox_use() -%><%= self.generate_loadvalue_in_open() %><%- end -%>
 249     EOS
 250
 251     erb = ERB.new(script, nil, '-');
 252     erb.result(binding)
 253   end
 254
 255   def generate_loadvalue_in_open()
 256     script = <<-EOS
 257     EOS
 258
 259     erb = ERB.new(script, nil, '-');
 260     erb.result(binding)
 261   end
 262
 263   def generate_savevalue_in_close()
 264     script = <<-EOS
 265     EOS
 266
 267     erb = ERB.new(script, nil, '-');
 268     erb.result(binding)
 269   end
 270
 271   def generate_action_in_butdnwork(main_name, window_name)
 272     script = <<-EOS
 273     EOS
 274
 275     erb = ERB.new(script, nil, '-');
 276     erb.result(binding)
 277   end
 278
 279   def generate_draw_in_draw(main_name, window_name)
 280     script = <<-EOS
 281     EOS
 282
 283     erb = ERB.new(script, nil, '-');
 284     erb.result(binding)
 285   end
 286 end
 287
 288 class HMITextBoxParts < HMIParts
 289   def is_need_eventbreak()
 290     return true
 291   end
 292
 293   def generate_header_eventtype_enumulate(main_name, window_name)
 294     script = <<-EOS
 295         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_DETERMINE,
 296         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_COPY,
 297         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MOVE,
 298         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MENU,
 299         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_KEYMENU,
 300     EOS
 301
 302     erb = ERB.new(script, nil, '-');
 303     erb.result(binding)
 304   end
 305
 306   def generate_header_eventstruct_definition(main_name, window_name)
 307     script = <<-EOS
 308 struct <%= window_name %>_eventdata_<%= self.name() %>_determine_t_ {
 309         TC *value;
 310         W len;
 311 };
 312 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_determine_t_ <%= window_name %>_eventdata_<%= self.name() %>_determine_t;
 313
 314 struct <%= window_name %>_eventdata_<%= self.name() %>_copy_t_ {
 315         WID rel_wid;
 316         PNT pos;
 317 };
 318 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_copy_t_ <%= window_name %>_eventdata_<%= self.name() %>_copy_t;
 319
 320 struct <%= window_name %>_eventdata_<%= self.name() %>_move_t_ {
 321         WID rel_wid;
 322         PNT pos;
 323 };
 324 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_move_t_ <%= window_name %>_eventdata_<%= self.name() %>_move_t;
 325
 326 struct <%= window_name %>_eventdata_<%= self.name() %>_menu_t_ {
 327         PNT pos;
 328 };
 329 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_menu_t_ <%= window_name %>_eventdata_<%= self.name() %>_menu_t;
 330
 331 struct <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t_ {
 332         TC keycode;
 333 };
 334 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t_ <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t;
 335
 336     EOS
 337
 338     erb = ERB.new(script, nil, '-');
 339     erb.result(binding)
 340   end
 341
 342   def generate_header_eventunion_member(main_name, window_name)
 343     script = <<-EOS
 344                 <%= window_name %>_eventdata_<%= self.name() %>_determine_t <%= window_name %>_<%= self.name() %>_determine;
 345                 <%= window_name %>_eventdata_<%= self.name() %>_copy_t <%= window_name %>_<%= self.name() %>_copy;
 346                 <%= window_name %>_eventdata_<%= self.name() %>_move_t <%= window_name %>_<%= self.name() %>_move;
 347                 <%= window_name %>_eventdata_<%= self.name() %>_menu_t <%= window_name %>_<%= self.name() %>_menu;
 348                 <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t <%= window_name %>_<%= self.name() %>_keymenu;
 349     EOS
 350
 351     erb = ERB.new(script, nil, '-');
 352     erb.result(binding)
 353   end
 354
 355   def generate_prototypes(window_name)
 356     script = <<-EOS
 357 IMPORT W <%= window_name %>_set<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len);
 358 IMPORT W <%= window_name %>_get<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len);
 359 IMPORT W <%= window_name %>_cut<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len, Bool cut);
 360 IMPORT W <%= window_name %>_insert<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len);
 361     EOS
 362
 363     erb = ERB.new(script, nil, '-');
 364     erb.result(binding)
 365   end
 366
 367   def generate_source_struct(window_name)
 368     script = <<-EOS
 369         struct {
 370                 PAID id;
 371                 <% if self.is_databox_specify_argument() %>W dnum;<% end %>
 372                 TC buf[<%= self.text_length() %>+<%= self.get_attr_offset() %>+1];
 373                 W buf_written;
 374                 Bool appended;
 375                 Bool nextaction;
 376         } <%= self.name() %>;
 377     EOS
 378
 379     erb = ERB.new(script, nil, '-');
 380     erb.result(binding)
 381   end
 382
 383   def generate_source_functions(main_name, window_name)
 384     script = <<-EOS
 385 EXPORT W <%= window_name %>_set<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len)
 386 {
 387         W cp_len;
 388
 389         if (len < <%= self.text_length() %>) {
 390                 cp_len = len;
 391         } else {
 392                 cp_len = <%= self.text_length() %>;
 393         }
 394         memcpy(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>, str, cp_len * sizeof(TC));
 395         window-><%= self.name() %>.buf[<%= self.get_attr_offset() %> + cp_len] = TNULL;
 396         window-><%= self.name() %>.buf_written = cp_len;
 397         if (window->wid < 0) {
 398                 return 0;
 399         }
 400
 401         return cset_val(window-><%= self.name() %>.id, cp_len, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 402 }
 403
 404 EXPORT W <%= window_name %>_get<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len)
 405 {
 406         W err, cp_len;
 407
 408         if (window->wid > 0) {
 409                 err = cget_val(window-><%= self.name() %>.id, <%= self.text_length() %>, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 410                 if (err < 0) {
 411                         return err;
 412                 }
 413                 window-><%= self.name() %>.buf_written = err;
 414         }
 415
 416         if (len < window-><%= self.name() %>.buf_written) {
 417                 cp_len = len;
 418         } else {
 419                 cp_len = window-><%= self.name() %>.buf_written;
 420         }
 421         memcpy(str, window-><%= self.name() %>.buf + <%= self.get_attr_offset() %>, cp_len * sizeof(TC));
 422
 423         return cp_len;
 424 }
 425
 426 EXPORT W <%= window_name %>_cut<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len, Bool cut)
 427 {
 428         W err, len0;
 429
 430         len0 = ccut_txt(window-><%= self.name() %>.id, len, str, cut == False ? 0 : 1);
 431         if (len0 < 0) {
 432                 return len0;
 433         }
 434
 435         if (cut != False) {
 436                 err = cget_val(window-><%= self.name() %>.id, <%= self.text_length() %>, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 437                 if (err < 0) {
 438                         return err;
 439                 }
 440                 window-><%= self.name() %>.buf_written = err;
 441                 return len0;
 442         }
 443
 444         return len0;
 445 }
 446
 447 EXPORT W <%= window_name %>_insert<%= self.name() %>text(<%= window_name %>_t *window, TC *str, W len)
 448 {
 449         W err;
 450
 451         err = cins_txt(window-><%= self.name() %>.id, (PNT){0x8000, 0x8000}, str);
 452         if (err < 0) {
 453                 return err;
 454         }
 455
 456         err = cget_val(window-><%= self.name() %>.id, <%= self.text_length() %>, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 457         if (err < 0) {
 458                 return err;
 459         }
 460         window-><%= self.name() %>.buf_written = err;
 461
 462         return err;
 463 }
 464
 465 LOCAL VOID <%= window_name %>_action<%= self.name() %>(<%= window_name %>_t *window, WEVENT *wev, <%= main_name %>event_t *evt)
 466 {
 467         W i, len;
 468
 469         i = cact_par(window-><%= self.name() %>.id, wev);
 470         if (i & 0x2000) {
 471                 window-><%= self.name() %>.nextaction = True;
 472                 switch (i) {
 473                 case    P_MENU:
 474                         if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
 475                                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_KEYMENU;
 476                                 evt->data.<%= window_name %>_<%= self.name() %>_keymenu.keycode = wev->e.data.key.code;
 477                         } else {
 478                                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MENU;
 479                                 evt->data.<%= window_name %>_<%= self.name() %>_menu.pos = wev->s.pos;
 480                         }
 481                         <%= window_name %>_setflag(window, <%= window_name.upcase %>_FLAG_PARTS_NEXTACTION);
 482                         break;
 483                 default:
 484                         wugt_evt(wev);
 485                         <%= window_name %>_setflag(window, <%= window_name.upcase %>_FLAG_PARTS_OTHEREVENT);
 486                         break;
 487                 }
 488                 return;
 489         }
 490         window-><%= self.name() %>.nextaction = False;
 491         if (i & 0x1000) {
 492                 len = cget_val(window-><%= self.name() %>.id, <%= self.text_length() %>, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 493                 if (len > 0) {
 494                         window-><%= self.name() %>.buf_written = len;
 495                 }
 496         }
 497         switch (i & 7) {
 498         case    P_BUT:
 499                 cchg_par(window-><%= self.name() %>.id, P_INACT);
 500                 cchg_par(window-><%= self.name() %>.id, P_ACT);
 501                 wugt_evt(wev);
 502                 break;
 503         case    P_TAB:
 504                 break;
 505         case    P_NL:
 506         case    P_END:
 507                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_DETERMINE;
 508                 evt->data.<%= window_name %>_<%= self.name() %>_determine.value = window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>;
 509                 evt->data.<%= window_name %>_<%= self.name() %>_determine.len = window-><%= self.name() %>.buf_written;
 510                 break;
 511         case    P_MOVE:
 512                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MOVE;
 513                 evt->data.<%= window_name %>_<%= self.name() %>_move.rel_wid = wev->s.wid;
 514                 evt->data.<%= window_name %>_<%= self.name() %>_move.pos = wev->s.pos;
 515                 break;
 516         case    P_COPY:
 517                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_COPY;
 518                 evt->data.<%= window_name %>_<%= self.name() %>_copy.rel_wid = wev->s.wid;
 519                 evt->data.<%= window_name %>_<%= self.name() %>_copy.pos = wev->s.pos;
 520                 break;
 521         }
 522 }
 523
 524     EOS
 525
 526     erb = ERB.new(script, nil, '-');
 527     erb.result(binding)
 528   end
 529
 530   def generate_initialize_in_new()
 531     script = <<-EOS
 532         window-><%= self.name() %>.id = -1;
 533         <%- if self.is_databox_specify_argument() -%>
 534         window-><%= self.name() %>.dnum = dnum_<%= self.name() %>;
 535         <%- end -%>
 536         memset(window-><%= self.name() %>.buf, 0, sizeof(TC)*<%= self.text_length() %>);
 537         <%- if self.is_attr_specified() -%>
 538         window-><%= self.name() %>.buf[0] = MC_ATTR;
 539         *(COLOR*)(window-><%= self.name() %>.buf + 1) = <%= self.get_attrval_chcol() %>;
 540         window-><%= self.name() %>.buf[3] = <%= self.get_attrval_class() %>;
 541         window-><%= self.name() %>.buf[4] = <%= self.get_attrval_attr() %>;
 542         window-><%= self.name() %>.buf[5] = <%= self.get_attrval_csize_h() %>;
 543         window-><%= self.name() %>.buf[6] = <%= self.get_attrval_csize_v() %>;
 544         window-><%= self.name() %>.buf[7] = TNULL;
 545         <%- else -%>
 546         window-><%= self.name() %>.buf[0] = MC_STR;
 547         window-><%= self.name() %>.buf[1] = TNULL;
 548         <%- end -%>
 549         window-><%= self.name() %>.nextaction = False;
 550     EOS
 551
 552     erb = ERB.new(script, nil, '-');
 553     erb.result(binding)
 554   end
 555
 556   def generate_create_systemcall_direct()
 557     script = "ccre_tbx(wid, TB_PARTS|P_DISP, &r, <%= self.text_length() %>, window-><%= self.name() %>.buf, NULL)"
 558
 559     erb = ERB.new(script, nil, '-');
 560     erb.result(binding)
 561   end
 562
 563   def generate_loadvalue_in_open()
 564     script = <<-EOS
 565         cset_val(window-><%= self.name() %>.id, <%= self.text_length() %>, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 566     EOS
 567
 568     erb = ERB.new(script, nil, '-');
 569     erb.result(binding)
 570   end
 571
 572   def generate_savevalue_in_close()
 573     script = <<-EOS
 574         err = cget_val(window-><%= self.name() %>.id, <%= self.text_length() %>, (W*)(window-><%= self.name() %>.buf+<%= self.get_attr_offset() %>));
 575         if (err >= 0) {
 576                 window-><%= self.name() %>.buf_written = err;
 577         }
 578     EOS
 579
 580     erb = ERB.new(script, nil, '-');
 581     erb.result(binding)
 582   end
 583
 584   def generate_action_in_butdnwork(main_name, window_name)
 585     script = <<-EOS
 586         if (id == window-><%= self.name() %>.id) {
 587                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
 588                 <%= window_name %>_action<%= self.name() %>(window, wev, evt);
 589                 return;
 590         }
 591     EOS
 592
 593     erb = ERB.new(script, nil, '-');
 594     erb.result(binding)
 595   end
 596 end
 597
 598 class HMISecretTextBoxParts < HMITextBoxParts
 599   def generate_create_systemcall_direct()
 600     script = "ccre_xbx(wid, XB_PARTS|P_DISP, &r, <%= self.text_length() %>, window-><%= self.name() %>.buf, NULL);";
 601
 602     erb = ERB.new(script, nil, '-');
 603     erb.result(binding)
 604   end
 605 end
 606
 607 class HMINumberBoxParts < HMIParts
 608   def is_need_eventbreak()
 609     return true
 610   end
 611   def is_double()
 612     if @yaml["format"]["datatype"] == "double"
 613       return true
 614     end
 615     return false
 616   end
 617   def is_pointdisplay()
 618     ret = @yaml["format"]["pointdisplay"];
 619     if ret == nil
 620       return false
 621     end
 622     return ret
 623   end
 624   def is_hankaku()
 625     ret = @yaml["format"]["hankaku"];
 626     if ret == nil
 627       return false
 628     end
 629     return ret
 630   end
 631   def get_fontsize()
 632     sz = @yaml["format"]["fontsize"]
 633     if sz == nil
 634       return 16
 635     end
 636     if sz < 0
 637       return 16
 638     end
 639     if sz > 255
 640       return 255
 641     end
 642     return sz
 643   end
 644   def get_decimalplace()
 645     sz = @yaml["format"]["decimalplace"]
 646     if sz == nil
 647       return 0
 648     end
 649     if sz < 0
 650       return 0
 651     end
 652     if sz > 15
 653       return 15
 654     end
 655     return sz
 656   end
 657
 658   def generate_header_eventtype_enumulate(main_name, window_name)
 659     script = <<-EOS
 660         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_DETERMINE,
 661         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_COPY,
 662         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MOVE,
 663         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MENU,
 664         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_KEYMENU,
 665     EOS
 666
 667     erb = ERB.new(script, nil, '-');
 668     erb.result(binding)
 669   end
 670
 671   def generate_header_eventstruct_definition(main_name, window_name)
 672     script = <<-EOS
 673 struct <%= window_name %>_eventdata_<%= self.name() %>_determine_t_ {
 674         <% if self.is_double() %>DOUBLE<% else %>W<% end %> value;
 675 };
 676 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_determine_t_ <%= window_name %>_eventdata_<%= self.name() %>_determine_t;
 677
 678 struct <%= window_name %>_eventdata_<%= self.name() %>_copy_t_ {
 679         WID rel_wid;
 680         PNT pos;
 681 };
 682 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_copy_t_ <%= window_name %>_eventdata_<%= self.name() %>_copy_t;
 683
 684 struct <%= window_name %>_eventdata_<%= self.name() %>_move_t_ {
 685         WID rel_wid;
 686         PNT pos;
 687 };
 688 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_move_t_ <%= window_name %>_eventdata_<%= self.name() %>_move_t;
 689
 690 struct <%= window_name %>_eventdata_<%= self.name() %>_menu_t_ {
 691         PNT pos;
 692 };
 693 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_menu_t_ <%= window_name %>_eventdata_<%= self.name() %>_menu_t;
 694
 695 struct <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t_ {
 696         TC keycode;
 697 };
 698 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t_ <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t;
 699
 700     EOS
 701
 702     erb = ERB.new(script, nil, '-');
 703     erb.result(binding)
 704   end
 705
 706   def generate_header_eventunion_member(main_name, window_name)
 707     script = <<-EOS
 708                 <%= window_name %>_eventdata_<%= self.name() %>_determine_t <%= window_name %>_<%= self.name() %>_determine;
 709                 <%= window_name %>_eventdata_<%= self.name() %>_copy_t <%= window_name %>_<%= self.name() %>_copy;
 710                 <%= window_name %>_eventdata_<%= self.name() %>_move_t <%= window_name %>_<%= self.name() %>_move;
 711                 <%= window_name %>_eventdata_<%= self.name() %>_menu_t <%= window_name %>_<%= self.name() %>_menu;
 712                 <%= window_name %>_eventdata_<%= self.name() %>_keymenu_t <%= window_name %>_<%= self.name() %>_keymenu;
 713     EOS
 714
 715     erb = ERB.new(script, nil, '-');
 716     erb.result(binding)
 717   end
 718
 719   def generate_prototypes(window_name)
 720     script = <<-EOS
 721 IMPORT W <%= window_name %>_set<%= self.name() %>value(<%= window_name %>_t *window, <% if self.is_double() %>DOUBLE<% else %>W<% end %> value);
 722 IMPORT W <%= window_name %>_get<%= self.name() %>value(<%= window_name %>_t *window, <% if self.is_double() %>DOUBLE<% else %>W<% end %> *value);
 723     EOS
 724
 725     erb = ERB.new(script, nil, '-');
 726     erb.result(binding)
 727   end
 728
 729   def generate_source_struct(window_name)
 730     script = <<-EOS
 731         struct {
 732                 PAID id;
 733                 <% if self.is_databox_specify_argument() %>W dnum;<% end %>
 734                 UW format;
 735                 <% if self.is_double() %>DOUBLE<% else %>W<% end %> cv;
 736                 Bool nextaction;
 737         } <%= self.name() %>;
 738     EOS
 739
 740     erb = ERB.new(script, nil, '-');
 741     erb.result(binding)
 742   end
 743
 744   def generate_source_functions(main_name, window_name)
 745     script = <<-EOS
 746 EXPORT W <%= window_name %>_set<%= self.name() %>value(<%= window_name %>_t *window, <% if self.is_double() %>DOUBLE<% else %>W<% end %> value)
 747 {
 748         window-><%= self.name() %>.cv = value;
 749         if (window->wid < 0) {
 750                 return 0;
 751         }
 752
 753         return cset_val(window-><%= self.name() %>.id, <% if self.is_double() %>2<% else %>1<% end %>, (W*)(&window-><%= self.name() %>.cv));
 754 }
 755
 756 EXPORT W <%= window_name %>_get<%= self.name() %>value(<%= window_name %>_t *window, <% if self.is_double() %>DOUBLE<% else %>W<% end %> *value)
 757 {
 758         W err;
 759
 760         if (window->wid > 0) {
 761                 err = cget_val(window-><%= self.name() %>.id, <% if self.is_double() %>2<% else %>1<% end %>, (W*)(&window-><%= self.name() %>.cv));
 762                 if (err < 0) {
 763                         return err;
 764                 }
 765         }
 766
 767         *value = window-><%= self.name() %>.cv;
 768         return 0;
 769 }
 770
 771 LOCAL VOID <%= window_name %>_action<%= self.name() %>(<%= window_name %>_t *window, WEVENT *wev, <%= main_name %>event_t *evt)
 772 {
 773         W i;
 774
 775         i = cact_par(window-><%= self.name() %>.id, wev);
 776         if (i & 0x2000) {
 777                 window-><%= self.name() %>.nextaction = True;
 778                 <%= window_name %>_setflag(window, <%= window_name.upcase %>_FLAG_PARTS_OTHEREVENT);
 779                 wugt_evt(wev);
 780                 return;
 781         }
 782         window-><%= self.name() %>.nextaction = False;
 783         if (i & 0x1000) {
 784                 cget_val(window-><%= self.name() %>.id, <% if self.is_double() %>2<% else %>1<% end %>, (W*)(&window-><%= self.name() %>.cv));
 785         }
 786         switch (i & 7) {
 787         case    P_BUT:
 788                 wugt_evt(wev);
 789                 break;
 790         case    P_TAB:
 791                 break;
 792         case    P_NL:
 793         case    P_END:
 794                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_DETERMINE;
 795                 evt->data.<%= window_name %>_<%= self.name() %>_determine.value = window-><%= self.name() %>.cv;
 796                 break;
 797         case    P_MOVE:
 798                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MOVE;
 799                 evt->data.<%= window_name %>_<%= self.name() %>_move.rel_wid = wev->s.wid;
 800                 evt->data.<%= window_name %>_<%= self.name() %>_move.pos = wev->s.pos;
 801                 break;
 802         case    P_COPY:
 803                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_COPY;
 804                 evt->data.<%= window_name %>_<%= self.name() %>_copy.rel_wid = wev->s.wid;
 805                 evt->data.<%= window_name %>_<%= self.name() %>_copy.pos = wev->s.pos;
 806                 break;
 807         case    P_MENU:
 808                 if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
 809                         evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_KEYMENU;
 810                         evt->data.<%= window_name %>_<%= self.name() %>_keymenu.keycode = wev->e.data.key.code;
 811                 } else {
 812                         evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_MENU;
 813                         evt->data.<%= window_name %>_<%= self.name() %>_menu.pos = wev->s.pos;
 814                 }
 815                 window-><%= self.name() %>.nextaction = True;
 816                 <%= window_name %>_setflag(window, <%= window_name.upcase %>_FLAG_PARTS_NEXTACTION);
 817                 wugt_evt(wev);
 818                 break;
 819         }
 820 }
 821
 822     EOS
 823
 824     erb = ERB.new(script, nil, '-');
 825     erb.result(binding)
 826   end
 827
 828   def generate_initialize_in_new()
 829     script = <<-EOS
 830         window-><%= self.name() %>.id = -1;
 831         <%- if self.is_databox_specify_argument() -%>
 832         window-><%= self.name() %>.dnum = dnum_<%= self.name() %>;
 833         <%- end -%>
 834         window-><%= self.name() %>.format = (<%= self.get_fontsize() %> << 8)|<% if self.is_double() %>0xF0<% else %>0<% end %>|<% if self.is_hankaku() %>0x40<% else %>0<% end %>|<% if self.is_pointdisplay() %>0x10<% else %>0<% end %>|<%=  self.get_decimalplace() %>;
 835         window-><%= self.name() %>.cv = <% if self.is_double() %>0.0<% else %>0<% end %>;
 836         window-><%= self.name() %>.nextaction = False;
 837     EOS
 838
 839     erb = ERB.new(script, nil, '-');
 840     erb.result(binding)
 841   end
 842
 843   def generate_create_systemcall_direct()
 844     script = "ccre_nbx(wid, NB_PARTS|P_DISP, &r, window-><%= self.name() %>.format, (W*)&window-><%= self.name() %>.cv, NULL)"
 845
 846     erb = ERB.new(script, nil, '-');
 847     erb.result(binding)
 848   end
 849
 850   def generate_loadvalue_in_open()
 851     script = <<-EOS
 852         cset_val(window-><%= self.name() %>.id, <% if self.is_double() %>2<% else %>1<% end %>, (W*)(&window-><%= self.name() %>.cv));
 853     EOS
 854
 855     erb = ERB.new(script, nil, '-');
 856     erb.result(binding)
 857   end
 858
 859   def generate_savevalue_in_close()
 860     script = <<-EOS
 861         err = cget_val(window-><%= self.name() %>.id, <% if self.is_double() %>2<% else %>1<% end %>, (W*)(&window-><%= self.name() %>.cv));
 862     EOS
 863
 864     erb = ERB.new(script, nil, '-');
 865     erb.result(binding)
 866   end
 867
 868   def generate_action_in_butdnwork(main_name, window_name)
 869     script = <<-EOS
 870         if (id == window-><%= self.name() %>.id) {
 871                 <%= window_name %>_action<%= self.name() %>(window, wev, evt);
 872                 return;
 873         }
 874     EOS
 875
 876     erb = ERB.new(script, nil, '-');
 877     erb.result(binding)
 878   end
 879 end
 880
 881 class HMITextMomentallySwitchParts < HMIParts
 882   def generate_header_eventtype_enumulate(main_name, window_name)
 883     script = <<-EOS
 884         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_PUSH,
 885     EOS
 886
 887     erb = ERB.new(script, nil, '-');
 888     erb.result(binding)
 889   end
 890
 891   def generate_source_struct(window_name)
 892     script = <<-EOS
 893         struct {
 894                 PAID id;
 895                 <% if self.is_databox_specify_argument() %>W dnum;<% end %>
 896         } <%= self.name() %>;
 897     EOS
 898
 899     erb = ERB.new(script, nil, '-');
 900     erb.result(binding)
 901   end
 902
 903   def generate_create_systemcall_direct()
 904     script = "ccre_msw(wid, MS_PARTS|P_DISP, &r, (TC[]){MC_STR, <%= self.text_array() %>}, NULL)"
 905
 906     erb = ERB.new(script, nil, '-');
 907     erb.result(binding)
 908   end
 909
 910   def generate_action_in_butdnwork(main_name, window_name)
 911     script = <<-EOS
 912         if (id == window-><%= self.name() %>.id) {
 913                 ret = cact_par(window-><%= self.name() %>.id, wev);
 914                 if ((ret & 0x5000) != 0x5000) {
 915                         return;
 916                 }
 917                 evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_PUSH;
 918                 return;
 919         }
 920     EOS
 921
 922     erb = ERB.new(script, nil, '-');
 923     erb.result(binding)
 924   end
 925 end
 926
 927 class HMISerialBoxParts < HMIParts
 928   def calc_serialbox_formatlength()
 929     l = 0;
 930     @yaml["fields"].each { |field|
 931       case field["type"]
 932       when "number"
 933         l += 3; # specify, max, min
 934       when "items"
 935         l += 1; # specify
 936         field["items"].each { |item| # item text
 937           l+= 1 + calc_euc_to_TCArray_length(item["text"]);
 938         }
 939         l += 1; # TNULL
 940       when "fixed"
 941         l += calc_euc_to_TCArray_length(field["text"]);
 942       end
 943     }
 944     l += 1; # for last TNULL
 945     return l
 946   end
 947   def calc_serialbox_fieldsnumber()
 948     l = 0;
 949     @yaml["fields"].each { |field|
 950       case field["type"]
 951       when "number", "items"
 952         l += 1;
 953       when "fixed"
 954         # not variable field.
 955       end
 956     }
 957     return l
 958   end
 959   def is_need_eventbreak()
 960     return true
 961   end
 962
 963   def generate_header_eventtype_enumulate(main_name, window_name)
 964     script = <<-EOS
 965     EOS
 966
 967     erb = ERB.new(script, nil, '-');
 968     erb.result(binding)
 969   end
 970
 971   def generate_prototypes(window_name)
 972     script = <<-EOS
 973 struct <%= window_name %>_<%= self.name() %>value_t_ {
 974 <%- @yaml["fields"].each do |field| -%>
 975 <%- case field["type"] -%>
 976 <%- when "number" -%>
 977         W <%= field["name"] %>;
 978 <%- when "items" -%>
 979         enum {
 980         <%- field["items"].each do |item| -%>
 981                 <%= window_name.upcase %>_<%= self.name().upcase %>_<%= field["name"].upcase %>VALUE_<%= item["name"].upcase %>,
 982         <%- end -%>
 983         } <%= field["name"] %>;
 984 <%- end -%>
 985 <%- end -%>
 986 };
 987 typedef struct <%= window_name %>_<%= self.name() %>value_t_ <%= window_name %>_<%= self.name() %>value_t;
 988 IMPORT W <%= window_name %>_set<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name %>_<%= self.name() %>value_t *value);
 989 IMPORT W <%= window_name %>_get<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name %>_<%= self.name() %>value_t *value);
 990     EOS
 991
 992     erb = ERB.new(script, nil, '-');
 993     erb.result(binding)
 994   end
 995
 996   def generate_source_struct(window_name)
 997     script = <<-EOS
 998         struct {
 999                 PAID id;
1000                 <% if self.is_databox_specify_argument() %>W dnum;<% end %>
1001                 TC format[<%= self.calc_serialbox_formatlength() %>];
1002                 W cv[<%= self.calc_serialbox_fieldsnumber() %>];
1003                 Bool nextaction;
1004         } <%= self.name() %>;
1005     EOS
1006
1007     erb = ERB.new(script, nil, '-');
1008     erb.result(binding)
1009   end
1010
1011   def generate_source_functions(main_name, window_name)
1012     script = <<-EOS
1013 EXPORT W <%= window_name %>_set<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name %>_<%= self.name() %>value_t *value)
1014 {
1015         <%- j = 0 -%>
1016         <%- @yaml["fields"].each do |field| -%>
1017         <%- case field["type"] -%>
1018         <%- when "number" -%>
1019         if ((<%= field["min"] %> <= value-><%= field["name"] %>)&&(value-><%= field["name"] %> <= <%= field["max"] %>)) {
1020                 window-><%= self.name() %>.cv[<%= j %>] = value-><%= field["name"] %>;<%- j+=1 %>
1021         }
1022         <%- when "items" -%>
1023         if ((0 <= value-><%= field["name"] %>)&&(value-><%= field["name"] %> < <%= field["items"].length %>)) {
1024                 window-><%= self.name() %>.cv[<%= j %>] = value-><%= field["name"] %>;<%- j+=1 %>
1025         }
1026         <%- end -%>
1027         <%- end -%>
1028         if (window->wid < 0) {
1029                 return 0;
1030         }
1031
1032         return cset_val(window-><%= self.name() %>.id, <%= self.calc_serialbox_fieldsnumber() %>, (W*)(window-><%= self.name() %>.cv));
1033 }
1034
1035 EXPORT W <%= window_name %>_get<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name %>_<%= self.name() %>value_t *value)
1036 {
1037         W err;
1038
1039         if (window->wid > 0) {
1040                 err = cget_val(window-><%= self.name() %>.id, <%= self.calc_serialbox_fieldsnumber() %>, (W*)(window-><%= self.name() %>.cv));
1041                 if (err < 0) {
1042                         return err;
1043                 }
1044         }
1045
1046         <%- j = 0 -%>
1047         <%- @yaml["fields"].each do |field| -%>
1048         <%- case field["type"] -%>
1049         <%- when "number", "items" -%>
1050         value-><%= field["name"] %> = window-><%= self.name() %>.cv[<%= j %>];<%- j+=1 %>
1051         <%- end -%>
1052         <%- end -%>
1053
1054         return 0;
1055 }
1056
1057 LOCAL VOID <%= window_name %>_action<%= self.name() %>(<%= window_name %>_t *window, WEVENT *wev, <%= main_name %>event_t *evt)
1058 {
1059         W i;
1060
1061         i = cact_par(window-><%= self.name() %>.id, wev);
1062         if (i & 0x2000) {
1063                 window-><%= self.name() %>.nextaction = True;
1064                 <%= window_name %>_setflag(window, <%= window_name.upcase %>_FLAG_PARTS_OTHEREVENT);
1065                 wugt_evt(wev);
1066                 return;
1067         }
1068         window-><%= self.name() %>.nextaction = False;
1069         if (i & 0x1000) {
1070                 cget_val(window-><%= self.name() %>.id, <%= self.calc_serialbox_fieldsnumber() %>, (W*)(window-><%= self.name() %>.cv));
1071                 /* TODO: export event */
1072         }
1073         switch (i & 7) {
1074                 case    P_BUT:
1075                         wugt_evt(wev);
1076                         break;
1077                 case    P_TAB:
1078                 case    P_NL:
1079                 case    P_END:
1080                 case    P_MOVE:
1081                 case    P_COPY:
1082                         break;
1083         }
1084 }
1085
1086     EOS
1087
1088     erb = ERB.new(script, nil, '-');
1089     erb.result(binding)
1090   end
1091
1092   def generate_initialize_in_new()
1093     script = <<-EOS
1094         window-><%= self.name() %>.id = -1;
1095         <%- if self.is_databox_specify_argument() -%>
1096         window-><%= self.name() %>.dnum = dnum_<%= self.name() %>;
1097         <%- end -%>
1098         <%- l = 0 -%>
1099         <%- @yaml["fields"].each do |field| -%>
1100         <%- case field["type"] -%>
1101         <%- when "number" -%>
1102         window-><%= self.name() %>.format[<%= l %>] = 0x0e00 | <%= field["chars"] %>;<%- l+=1 %>
1103         window-><%= self.name() %>.format[<%= l %>] = <%= field["min"] %>;<%- l+=1 %>
1104         window-><%= self.name() %>.format[<%= l %>] = <%= field["max"] %>;<%- l+=1 %>
1105         <%- when "items" -%>
1106         window-><%= self.name() %>.format[<%= l %>] = 0x0800 | <%= field["chars"] %>;<%- l+=1 %>
1107           <%- field["items"].each do |item| -%>
1108         window-><%= self.name() %>.format[<%= l %>] = MC_STR;<%- l+=1 %>
1109             <%- conv_euc_to_TCArray(item["text"]).each do |ch| -%>
1110         window-><%= self.name() %>.format[<%= l %>] = 0x<%= ch.to_s(16) %>;<%- l+=1 %>
1111             <%- end -%>
1112           <%- end -%>
1113         window-><%= self.name() %>.format[<%= l %>] = TNULL;<%- l+=1 %>
1114         <%- when "fixed" -%>
1115           <%- conv_euc_to_TCArray(field["text"]).each do |ch| -%>
1116         window-><%= self.name() %>.format[<%= l %>] = 0x<%= ch.to_s(16) %>;<%- l+=1 %>
1117           <%- end -%>
1118         <%- end -%>
1119         <%- end -%>
1120         window-><%= self.name() %>.format[<%= l %>] = TNULL;<%- l+=1 %>
1121         <%- l = 0 -%>
1122         <%- @yaml["fields"].each do |field| -%>
1123         <%- case field["type"] -%>
1124         <%- when "number" -%>
1125         window-><%= self.name() %>.cv[<%= l %>] = <%= field["min"] %>;<%- l+=1 %>
1126         <%- when "items" -%>
1127         window-><%= self.name() %>.cv[<%= l %>] = 0;<%- l+=1 %>
1128         <%- end -%>
1129         <%- end -%>
1130         window-><%= self.name() %>.nextaction = False;
1131     EOS
1132
1133     erb = ERB.new(script, nil, '-');
1134     erb.result(binding)
1135   end
1136
1137   def generate_create_systemcall_direct()
1138     script = "ccre_sbx(wid, SB_PARTS|P_DISP, &r, window-><%= self.name() %>.format, <%= self.calc_serialbox_fieldsnumber() %>, window-><%= self.name() %>.cv, NULL)"
1139
1140     erb = ERB.new(script, nil, '-');
1141     erb.result(binding)
1142   end
1143
1144   def generate_loadvalue_in_open()
1145     script = <<-EOS
1146         cset_val(window-><%= self.name() %>.id, <%= self.calc_serialbox_fieldsnumber() %>, (W*)(window-><%= self.name() %>.cv));
1147     EOS
1148
1149     erb = ERB.new(script, nil, '-');
1150     erb.result(binding)
1151   end
1152
1153   def generate_savevalue_in_close()
1154     script = <<-EOS
1155         err = cget_val(window-><%= self.name() %>.id, <%= self.calc_serialbox_fieldsnumber() %>, (W*)(window-><%= self.name() %>.cv));
1156     EOS
1157
1158     erb = ERB.new(script, nil, '-');
1159     erb.result(binding)
1160   end
1161
1162   def generate_action_in_butdnwork(main_name, window_name)
1163     script = <<-EOS
1164         if (id == window-><%= self.name() %>.id) {
1165                 <%= window_name %>_action<%= self.name() %>(window, wev, evt);
1166                 return;
1167         }
1168     EOS
1169
1170     erb = ERB.new(script, nil, '-');
1171     erb.result(binding)
1172   end
1173 end
1174
1175 class HMISwitchSelectorParts < HMIParts
1176   def calc_formatlength()
1177     l = 0;
1178     @yaml["fields"].each { |field|
1179       l+= 1 + calc_euc_to_TCArray_length(field["text"]);
1180     }
1181     l += 1; # for last TNULL
1182     return l
1183   end
1184   def is_need_eventbreak()
1185     return false
1186   end
1187
1188   def generate_header_eventtype_enumulate(main_name, window_name)
1189     script = <<-EOS
1190         <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_CHANGE,
1191     EOS
1192
1193     erb = ERB.new(script, nil, '-');
1194     erb.result(binding)
1195   end
1196
1197   def generate_header_eventstruct_definition(main_name, window_name)
1198     script = <<-EOS
1199 struct <%= window_name %>_eventdata_<%= self.name() %>_change_t_ {
1200         <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T value;
1201 };
1202 typedef struct <%= window_name %>_eventdata_<%= self.name() %>_change_t_ <%= window_name %>_eventdata_<%= self.name() %>_change_t;
1203
1204     EOS
1205
1206     erb = ERB.new(script, nil, '-');
1207     erb.result(binding)
1208   end
1209
1210   def generate_header_eventunion_member(main_name, window_name)
1211     script = <<-EOS
1212                 <%= window_name %>_eventdata_<%= self.name() %>_change_t <%= window_name %>_<%= self.name() %>_change;
1213     EOS
1214
1215     erb = ERB.new(script, nil, '-');
1216     erb.result(binding)
1217   end
1218
1219   def generate_prototypes(window_name)
1220     script = <<-EOS
1221 enum <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T_ {
1222         <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_NOSEL = 0,
1223         <%- @yaml["fields"].each do |field| -%>
1224         <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_<%= field["name"].upcase %>,
1225         <%- end -%>
1226 };
1227 typedef enum <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T_ <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T;
1228 IMPORT W <%= window_name %>_set<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T value);
1229 IMPORT W <%= window_name %>_get<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T *value);
1230     EOS
1231
1232     erb = ERB.new(script, nil, '-');
1233     erb.result(binding)
1234   end
1235
1236   def generate_source_struct(window_name)
1237     script = <<-EOS
1238         struct {
1239                 PAID id;
1240                 <%- if self.is_databox_use() -%>
1241                 W dnum;
1242                 <%- else -%>
1243                 TC format[<%= self.calc_formatlength()%>];
1244                 <%- end -%>
1245                 <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T value;
1246         } <%= self.name() %>;
1247     EOS
1248
1249     erb = ERB.new(script, nil, '-');
1250     erb.result(binding)
1251   end
1252
1253   def generate_source_functions(main_name, window_name)
1254     script = <<-EOS
1255 EXPORT W <%= window_name %>_set<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T value)
1256 {
1257         W val;
1258
1259         val = window-><%= self.name() %>.value = value;
1260         if (window->wid < 0) {
1261                 return 0;
1262         }
1263
1264         return cset_val(window-><%= self.name() %>.id, 1, (W*)(&val));
1265 }
1266
1267 EXPORT W <%= window_name %>_get<%= self.name() %>value(<%= window_name %>_t *window, <%= window_name.upcase %>_<%= self.name().upcase %>VALUE_T *value)
1268 {
1269         W val,err;
1270
1271         if (window->wid > 0) {
1272                 err = cget_val(window-><%= self.name() %>.id, 1, (W*)(&val));
1273                 if (err < 0) {
1274                         return err;
1275                 }
1276         }
1277         *value = window-><%= self.name() %>.value = val;
1278
1279         return 0;
1280 }
1281
1282 LOCAL VOID <%= window_name %>_action<%= self.name() %>(<%= window_name %>_t *window, WEVENT *wev, <%= main_name %>event_t *evt)
1283 {
1284         W i;
1285
1286         i = cact_par(window-><%= self.name() %>.id, wev);
1287         if ((i & 0x5000) != 0x5000) {
1288                 return;
1289         }
1290         window-><%= self.name() %>.value = i & 0xfff;
1291         evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= window_name.upcase %>_PARTS_<%= self.name().upcase %>_CHANGE;
1292         evt->data.<%= window_name %>_<%= self.name() %>_change.value = window-><%= self.name() %>.value;
1293 }
1294
1295     EOS
1296
1297     erb = ERB.new(script, nil, '-');
1298     erb.result(binding)
1299   end
1300
1301   def generate_initialize_in_new()
1302     script = <<-EOS
1303         window-><%= self.name() %>.id = -1;
1304         <%- if self.is_databox_use() -%>
1305         window-><%= self.name() %>.dnum = dnum_<%= self.name() %>;
1306         <%- else -%>
1307           <%- l = 0 -%>
1308           <%- @yaml["fields"].each do |field| -%>
1309         window-><%= self.name() %>.format[<%= l %>] = MC_STR;<%- l+=1 %>
1310             <%- conv_euc_to_TCArray(field["text"]).each do |ch| -%>
1311         window-><%= self.name() %>.format[<%= l %>] = 0x<%= ch.to_s(16) %>;<%- l+=1 %>
1312             <%- end -%>
1313           <%- end -%>
1314         window-><%= self.name() %>.format[<%= l %>] = TNULL;<%- l+=1 %>
1315         <%- end -%>
1316         window-><%= self.name() %>.value = 0;
1317     EOS
1318
1319     erb = ERB.new(script, nil, '-');
1320     erb.result(binding)
1321   end
1322
1323   def generate_create_systemcall_direct()
1324     script = "ccre_sel(wid, WS_PARTS|P_DISP, &r, window-><%= self.name() %>.value, window-><%= self.name() %>.format, NULL)"
1325
1326     erb = ERB.new(script, nil, '-');
1327     erb.result(binding)
1328   end
1329
1330   def generate_loadvalue_in_open()
1331     script = <<-EOS
1332         cset_val(window-><%= self.name() %>.id, 1, (W*)(&window-><%= self.name() %>.value));
1333     EOS
1334
1335     erb = ERB.new(script, nil, '-');
1336     erb.result(binding)
1337   end
1338
1339   def generate_savevalue_in_close()
1340     script = <<-EOS
1341         err = cget_val(window-><%= self.name() %>.id, 1, (W*)(&window-><%= self.name() %>.value));
1342     EOS
1343
1344     erb = ERB.new(script, nil, '-');
1345     erb.result(binding)
1346   end
1347
1348   def generate_action_in_butdnwork(main_name, window_name)
1349     script = <<-EOS
1350         if (id == window-><%= self.name() %>.id) {
1351                 <%= window_name %>_action<%= self.name() %>(window, wev, evt);
1352                 return;
1353         }
1354     EOS
1355
1356     erb = ERB.new(script, nil, '-');
1357     erb.result(binding)
1358   end
1359 end
1360
1361 class HMIFixedTextParts < HMIParts
1362   def is_need_eventbreak()
1363     return false
1364   end
1365   def is_use_rect_in_open()
1366     return false
1367   end
1368
1369   def generate_initialize_in_new()
1370     return ""
1371   end
1372   def generate_create_in_open()
1373     return ""
1374   end
1375   def generate_draw_in_draw(main_name, window_name)
1376     script = <<-EOS
1377         gset_chc(window->gid, 0x10000000, -1);
1378         gdra_stp(window->gid, <%= self.rect_left() %>, <%= self.rect_bottom() %>, (TC[]){<%= self.text_array() %>}, <%= self.text_array_length() %>, G_STORE);
1379     EOS
1380
1381     erb = ERB.new(script, nil, '-');
1382     erb.result(binding)
1383   end
1384 end
1385
1386 def generate_parts(type, a)
1387   case type
1388   when "textbox"
1389     return HMITextBoxParts.new(a);
1390   when "secrettextbox"
1391     return HMISecretTextBoxParts.new(a);
1392   when "textmomentallyswitch"
1393     return HMITextMomentallySwitchParts.new(a);
1394   when "serialbox"
1395     return HMISerialBoxParts.new(a);
1396   when "numberbox"
1397     return HMINumberBoxParts.new(a);
1398   when "switchselector"
1399     return HMISwitchSelectorParts.new(a);
1400   when "fixedtext"
1401     return HMIFixedTextParts.new(a)
1402   end
1403 end
1404
1405 class HMIWindow
1406   attr_accessor :yaml, :parts
1407   def initialize(yaml)
1408     @yaml = yaml;
1409     @parts = Array.new();
1410     if yaml["parts"] != nil
1411       yaml["parts"].each { |a|
1412         w = generate_parts(a["type"], a)
1413         @parts.push(w);
1414       };
1415     end
1416   end
1417   def struct_name()
1418     @yaml["window_name"]
1419   end
1420   def is_attr_xxx(name)
1421     if @yaml["attributes"] == nil || @yaml["attributes"].empty?
1422       false
1423     else
1424       @yaml["attributes"].any? { |item|
1425         item == name;
1426       };
1427     end
1428   end
1429   def is_exportevent_xxx(name)
1430     if @yaml["export_events"] == nil || @yaml["export_events"].empty?
1431       false
1432     else
1433       @yaml["export_events"].any? { |item|
1434         item == name;
1435       };
1436     end
1437   end
1438   def is_attr_scrollable()
1439     self.is_attr_xxx("scrollable");
1440   end
1441   def is_attr_resizable()
1442     self.is_attr_xxx("resizable");
1443   end
1444   def is_attr_opencheckable()
1445     self.is_attr_xxx("opencheckable");
1446   end
1447   def is_attr_subwindow()
1448     self.is_attr_xxx("subwindow");
1449   end
1450   def is_attr_alwaysopen()
1451     self.is_attr_xxx("alwaysopen");
1452   end
1453   def is_exportevent_draw()
1454     self.is_exportevent_xxx("draw");
1455   end
1456   def is_exportevent_butdn()
1457     self.is_exportevent_xxx("butdn");
1458   end
1459   def is_exportevent_paste()
1460     self.is_exportevent_xxx("paste");
1461   end
1462   def is_exportevent_close()
1463     self.is_exportevent_xxx("close");
1464   end
1465   def is_exportevent_switch()
1466     self.is_exportevent_xxx("switch");
1467   end
1468   def is_exportevent_mousemove()
1469     self.is_exportevent_xxx("mousemove");
1470   end
1471   def is_exportevent_scroll()
1472     self.is_exportevent_xxx("scroll");
1473   end
1474   def is_exist_controllparts()
1475     @parts.length > 0;
1476   end
1477   def is_exist_use_rect_in_open()
1478     @parts.any? { |item|
1479       item.is_use_rect_in_open();
1480     };
1481   end
1482   def is_need_flag()
1483     true # tmp
1484   end
1485   def get_window_width()
1486     @yaml["size"]["h"]
1487   end
1488   def get_window_height()
1489     @yaml["size"]["v"]
1490   end
1491   def get_window_title()
1492     @yaml["title"]
1493   end
1494   def is_exist_eventbreak_parts()
1495       @parts.any? { |item|
1496         item.is_need_eventbreak();
1497       };
1498   end
1499   def get_window_parent()
1500     @yaml["parent"]
1501   end
1502   def get_window_title_max_length()
1503     len = @yaml["title_max_length"];
1504     if len == nil
1505       return 128
1506     end
1507     return len
1508   end
1509
1510   def generate_header_eventtype_enumulate(main_name)
1511     script = <<-EOS
1512         <%- if self.is_exportevent_draw() -%>
1513         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_DRAW,
1514         <%- end -%>
1515         <%- if self.is_attr_resizable() -%>
1516         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_RESIZE,
1517         <%- end -%>
1518         <%- if self.is_exportevent_close() -%>
1519         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_CLOSE,
1520         <%- end -%>
1521         <%- if self.is_exportevent_butdn() -%>
1522         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_BUTDN,
1523         <%- end -%>
1524         <%- if self.is_exportevent_paste() -%>
1525         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_PASTE,
1526         <%- end -%>
1527         <%- if self.is_exportevent_switch() -%>
1528         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_SWITCH,
1529         <%- end -%>
1530         <%- if self.is_exportevent_mousemove() -%>
1531         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_MOUSEMOVE,
1532         <%- end -%>
1533         <%- if self.is_exportevent_scroll() and self.is_attr_scrollable() -%>
1534         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_SCROLL,
1535         <%- end -%>
1536         <%- @parts.each do |p| -%><%= p.generate_header_eventtype_enumulate(main_name, self.struct_name()) %><%- end -%>
1537     EOS
1538
1539     erb = ERB.new(script, nil, '-');
1540     erb.result(binding)
1541   end
1542
1543   def generate_header_partsevent_struct(main_name)
1544     script = <<-EOS
1545         <%- @parts.each do |p| -%><%= p.generate_header_eventstruct_definition(main_name, self.struct_name()) %><%- end -%>
1546     EOS
1547
1548     erb = ERB.new(script, nil, '-');
1549     erb.result(binding)
1550   end
1551
1552   def generate_header_partsevent_unionmember(main_name)
1553     script = <<-EOS
1554         <%- @parts.each do |p| -%><%= p.generate_header_eventunion_member(main_name, self.struct_name()) %><%- end -%>
1555     EOS
1556
1557     erb = ERB.new(script, nil, '-');
1558     erb.result(binding)
1559   end
1560
1561   def generate_prototypes()
1562     script = <<-EOS
1563 typedef struct <%= self.struct_name() %>_t_ <%= self.struct_name() %>_t;
1564 <%- if self.is_attr_scrollable() -%>
1565 typedef VOID (*<%= self.struct_name() %>_scrollcalback)(VP arg, W dh, W dv);
1566 <%- end -%>
1567
1568 <%- if self.is_attr_scrollable() -%>
1569 IMPORT VOID <%= self.struct_name() %>_scrollbyvalue(<%= self.struct_name() %>_t *window, W dh, W dv);
1570 IMPORT W <%= self.struct_name() %>_setdrawrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b);
1571 IMPORT W <%= self.struct_name() %>_setworkrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b);
1572 IMPORT W <%= self.struct_name() %>_scrollworkarea(<%= self.struct_name() %>_t *window, W dh, W dv);
1573 IMPORT W <%= self.struct_name() %>_getworkrect(<%= self.struct_name() %>_t *window, RECT *r);
1574 <%- end -%>
1575 <%- if self.is_attr_opencheckable() -%>
1576 IMPORT Bool <%= self.struct_name() %>_isopen(<%= self.struct_name() %>_t *window);
1577 <%- end -%>
1578 <%- if self.is_exportevent_paste() -%>
1579 IMPORT VOID <%= self.struct_name() %>_responsepasterequest(<%= self.struct_name() %>_t *window, W nak, PNT *pos);
1580 <%- end -%>
1581 <%- if self.is_exportevent_draw() -%>
1582 IMPORT W <%= self.struct_name() %>_startredisp(<%= self.struct_name() %>_t *window, RECT *r);
1583 IMPORT W <%= self.struct_name() %>_endredisp(<%= self.struct_name() %>_t *window);
1584 IMPORT W <%= self.struct_name() %>_eraseworkarea(<%= self.struct_name() %>_t *window, RECT *r);
1585 <%- end -%>
1586 IMPORT W <%= self.struct_name() %>_requestredisp(<%= self.struct_name() %>_t *window);
1587 <%- if self.is_exportevent_butdn() -%>
1588 IMPORT GID <%= self.struct_name() %>_startdrag(<%= self.struct_name() %>_t *window);
1589 IMPORT W <%= self.struct_name() %>_getdrag(<%= self.struct_name() %>_t *window, PNT *pos, WID *wid, PNT *pos_butup);
1590 IMPORT VOID <%= self.struct_name() %>_enddrag(<%= self.struct_name() %>_t *window);
1591 <%- end -%>
1592 IMPORT GID <%= self.struct_name() %>_getGID(<%= self.struct_name() %>_t *window);
1593 IMPORT WID <%= self.struct_name() %>_getWID(<%= self.struct_name() %>_t *window);
1594 IMPORT W <%= self.struct_name() %>_settitle(<%= self.struct_name() %>_t *window, TC *title);
1595 IMPORT Bool <%= self.struct_name() %>_isactive(<%= self.struct_name() %>_t *window);
1596 <%- if !self.is_attr_alwaysopen() -%>
1597 IMPORT W <%= self.struct_name() %>_open(<%= self.struct_name() %>_t *window);
1598 IMPORT VOID <%= self.struct_name() %>_close(<%= self.struct_name() %>_t *window);
1599 <%- end -%>
1600 <%- @parts.each do |p| -%><%= p.generate_prototypes(self.struct_name()) %><%- end -%>
1601     EOS
1602
1603     erb = ERB.new(script, nil, '-');
1604     erb.result(binding)
1605   end
1606
1607   def generate_initialize_arguments()
1608     script = <<-EOS
1609 <%- if self.is_attr_resizable() -%>RECT *r<% else %>PNT *p<% end %>, <%- if self.is_attr_subwindow() -%><%= self.get_window_parent() %>_t *parent<%- else -%>WID parent<%- end -%>, TC *title, PAT *bgpat<%- @parts.each do |p| -%><% if p.is_databox_specify_argument() %>, W dnum_<%= p.name() %><% end %><%- end -%><%- -%>
1610     EOS
1611
1612     erb = ERB.new(script, nil, '-');
1613     erb.result(binding)
1614   end
1615
1616   def generate_initialize_arguments_values()
1617     script = <<-EOS
1618 <%- if self.is_attr_resizable() -%>r<% else %>p<% end %>, parent, title, bgpat<%- @parts.each do |p| -%><% if p.is_databox_specify_argument() %>, dnum_<%= p.name() %><% end %><%- end -%><%- -%>
1619     EOS
1620
1621     erb = ERB.new(script, nil, '-');
1622     erb.result(binding)
1623   end
1624
1625   def generate_source_struct()
1626     script = <<-EOS
1627 struct <%= self.struct_name() %>_t_ {
1628         <%- if self.is_need_flag() -%>
1629         UW flag;
1630         <%- end -%>
1631         WID wid;
1632         GID gid;
1633         <%- if self.is_attr_subwindow() -%>
1634         <%= self.get_window_parent() %>_t *parent;
1635         <%- else -%>
1636         WID parent;
1637         <%- end -%>
1638         RECT r;
1639         PAT bgpat;
1640         <%- if self.is_attr_scrollable() -%>
1641         hmi_windowscroll_t wscr;
1642         <%- end -%>
1643         <%- if !self.is_attr_alwaysopen() -%>
1644         TC title[<%= self.get_window_title_max_length() %>+1];
1645         <%- end -%>
1646         WEVENT savedwev;
1647         <%- @parts.each do |p| -%><%= p.generate_source_struct(self.struct_name()) %><%- end -%>
1648 };
1649
1650     EOS
1651
1652     erb = ERB.new(script, nil, '-');
1653     erb.result(binding)
1654   end
1655
1656   def generate_source_functions(main_name)
1657     script = <<-EOS
1658 <%- if self.is_need_flag() -%>
1659 #define <%= self.struct_name().upcase %>_FLAG_DRAWREQUEST 0x00000001
1660 <%- if self.is_attr_scrollable() -%>
1661 #define <%= self.struct_name().upcase %>_FLAG_RSCROLLING 0x00000002
1662 #define <%= self.struct_name().upcase %>_FLAG_BSCROLLING 0x00000004
1663 <%- end -%>
1664 <%- if self.is_exist_eventbreak_parts -%>
1665 #define <%= self.struct_name().upcase %>_FLAG_PARTS_OTHEREVENT 0x0000000f
1666 #define <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION 0x00000010
1667 <%- end -%>
1668
1669 #define <%= self.struct_name() %>_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
1670 #define <%= self.struct_name() %>_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
1671 #define <%= self.struct_name() %>_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
1672
1673 <%- end -%>
1674 <%- @parts.each do |p| -%><%= p.generate_source_functions(main_name, self.struct_name()) %><%- end -%>
1675 <%- if self.is_attr_scrollable() -%>
1676 EXPORT VOID <%= self.struct_name() %>_scrollbyvalue(<%= self.struct_name() %>_t *window, W dh, W dv)
1677 {
1678         hmi_windowscroll_scrollworkrect(&window->wscr, dh, dv);
1679 }
1680
1681 EXPORT W <%= self.struct_name() %>_setdrawrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b)
1682 {
1683         return hmi_windowscroll_setdrawrect(&window->wscr, l, t, r, b);
1684 }
1685
1686 EXPORT W <%= self.struct_name() %>_setworkrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b)
1687 {
1688         return hmi_windowscroll_setworkrect(&window->wscr, l, t, r, b);
1689 }
1690
1691 EXPORT W <%= self.struct_name() %>_scrollworkarea(<%= self.struct_name() %>_t *window, W dh, W dv)
1692 {
1693         W err;
1694         err = wscr_wnd(window->wid, NULL, dh, dv, W_MOVE|W_RDSET);
1695         if (err < 0) {
1696                 return err;
1697         }
1698         if ((err & W_RDSET) != 0) {
1699                 <%= self.struct_name() %>_setflag(window, <%= self.struct_name().upcase %>_FLAG_DRAWREQUEST);
1700         }
1701         return 0;
1702 }
1703
1704 EXPORT W <%= self.struct_name() %>_getworkrect(<%= self.struct_name() %>_t *window, RECT *r)
1705 {
1706         return wget_wrk(window->wid, r);
1707 }
1708
1709 <%- end -%>
1710 <%- if self.is_attr_opencheckable() -%>
1711 EXPORT Bool <%= self.struct_name() %>_isopen(<%= self.struct_name() %>_t *window)
1712 {
1713         if (window->wid < 0) {
1714                 return False;
1715         }
1716         return True;
1717 }
1718
1719 <%- end -%>
1720 <%- if self.is_exportevent_paste() -%>
1721 EXPORT VOID <%= self.struct_name() %>_responsepasterequest(<%= self.struct_name() %>_t *window, W nak, PNT *pos)
1722 {
1723         if (pos != NULL) {
1724                 window->savedwev.r.r.p.rightbot.x = pos->x;
1725                 window->savedwev.r.r.p.rightbot.y = pos->y;
1726         }
1727         wrsp_evt(&window->savedwev, nak);
1728 }
1729
1730 <%- end -%>
1731 <%- if self.is_exportevent_draw() -%>
1732 EXPORT W <%= self.struct_name() %>_startredisp(<%= self.struct_name() %>_t *window, RECT *r)
1733 {
1734         return wsta_dsp(window->wid, r, NULL);
1735 }
1736
1737 EXPORT W <%= self.struct_name() %>_endredisp(<%= self.struct_name() %>_t *window)
1738 {
1739         return wend_dsp(window->wid);
1740 }
1741
1742 EXPORT W <%= self.struct_name() %>_eraseworkarea(<%= self.struct_name() %>_t *window, RECT *r)
1743 {
1744         return wera_wnd(window->wid, r);
1745 }
1746
1747 <%- else -%>
1748 LOCAL VOID <%= self.struct_name() %>_draw(<%= self.struct_name() %>_t *window, RECT *r)
1749 {
1750         cdsp_pwd(window->wid, r, P_RDISP);
1751         <%- @parts.each do |p| -%><%= p.generate_draw_in_draw(main_name, self.struct_name()) %><%- end -%>
1752 }
1753
1754 LOCAL VOID <%= self.struct_name() %>_redisp(<%= self.struct_name() %>_t *window)
1755 {
1756         RECT r;
1757         do {
1758                 if (wsta_dsp(window->wid, &r, NULL) == 0) {
1759                         break;
1760                 }
1761                 wera_wnd(window->wid, &r);
1762                 <%= self.struct_name() %>_draw(window, &r);
1763         } while (wend_dsp(window->wid) > 0);
1764 }
1765
1766 <%- end -%>
1767 EXPORT W <%= self.struct_name() %>_requestredisp(<%= self.struct_name() %>_t *window)
1768 {
1769         return wreq_dsp(window->wid);
1770 }
1771
1772 <%- if self.is_exportevent_butdn() -%>
1773 EXPORT GID <%= self.struct_name() %>_startdrag(<%= self.struct_name() %>_t *window)
1774 {
1775         return wsta_drg(window->wid, 0);
1776 }
1777
1778 EXPORT W <%= self.struct_name() %>_getdrag(<%= self.struct_name() %>_t *window, PNT *pos, WID *wid, PNT *pos_butup)
1779 {
1780         W etype;
1781
1782         etype = wget_drg(pos, &window->savedwev);
1783         *wid = window->savedwev.s.wid;
1784         if (etype == EV_BUTUP) {
1785                 *pos_butup = window->savedwev.s.pos;
1786         }
1787
1788         return etype;
1789 }
1790
1791 EXPORT VOID <%= self.struct_name() %>_enddrag(<%= self.struct_name() %>_t *window)
1792 {
1793         wend_drg();
1794 }
1795
1796 <%- end -%>
1797 EXPORT GID <%= self.struct_name() %>_getGID(<%= self.struct_name() %>_t *window)
1798 {
1799         return wget_gid(window->wid);
1800 }
1801
1802 EXPORT WID <%= self.struct_name() %>_getWID(<%= self.struct_name() %>_t *window)
1803 {
1804         return window->wid;
1805 }
1806
1807 EXPORT W <%= self.struct_name() %>_settitle(<%= self.struct_name() %>_t *window, TC *title)
1808 {
1809         <%- if !self.is_attr_alwaysopen() -%>
1810         tc_strncpy(window->title, title, <%= self.get_window_title_max_length() %>);
1811         window->title[<%= self.get_window_title_max_length() %>] = TNULL;
1812         return wset_tit(window->wid, -1, window->title, 0);
1813         <%- else -%>
1814         return wset_tit(window->wid, -1, title, 0);
1815         <%- end -%>
1816 }
1817
1818 EXPORT Bool <%= self.struct_name() %>_isactive(<%= self.struct_name() %>_t *window)
1819 {
1820         WID wid;
1821         wid = wget_act(NULL);
1822         if (window->wid == wid) {
1823                 return True;
1824         }
1825         return False;
1826 }
1827
1828 LOCAL VOID <%= self.struct_name() %>_butdnwork(<%= self.struct_name() %>_t *window, WEVENT *wev, <%= main_name %>event_t *evt)
1829 {
1830         <%- if self.is_exist_controllparts() -%>
1831         PAID id;
1832         W ret;
1833
1834         ret = cfnd_par(window->wid, wev->s.pos, &id);
1835         if (ret <= 0) {
1836                 return;
1837         }
1838         <%- @parts.each do |p| -%><%= p.generate_action_in_butdnwork(main_name, self.struct_name()) %><%- end -%>
1839         <%- end -%>
1840         <%- if self.is_exportevent_butdn() -%>
1841         evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_BUTDN;
1842         evt->data.<%= self.struct_name() %>_butdn.type = wchk_dck(wev->s.time);
1843         evt->data.<%= self.struct_name() %>_butdn.pos = wev->s.pos;
1844         memcpy(&window->savedwev, wev, sizeof(WEVENT));
1845         <%- end -%>
1846 }
1847
1848 <%- if self.is_attr_resizable() -%>
1849 LOCAL VOID <%= self.struct_name() %>_resize(<%= self.struct_name() %>_t *window, SIZE *sz)
1850 {
1851         RECT work;
1852         Bool workchange = False;
1853
1854         wget_wrk(window->wid, &work);
1855         if (work.c.left != 0) {
1856                 work.c.left = 0;
1857                 workchange = True;
1858         }
1859         if (work.c.top != 0) {
1860                 work.c.top = 0;
1861                 workchange = True;
1862         }
1863         wset_wrk(window->wid, &work);
1864         gset_vis(window->gid, work);
1865
1866         if (workchange == True) {
1867                 wera_wnd(window->wid, NULL);
1868                 wreq_dsp(window->wid);
1869         }
1870
1871         sz->v = work.c.bottom - work.c.top;
1872         sz->h = work.c.right - work.c.left;
1873 }
1874
1875 <%- end -%>
1876 <% if self.is_attr_alwaysopen() %>LOCAL<% else %>EXPORT<% end %> W <%= self.struct_name() %>_open(<%= self.struct_name() %>_t *window<% if self.is_attr_alwaysopen() %>, TC *title<% end %>)
1877 {
1878         WID wid;
1879         <%- if self.is_exist_use_rect_in_open() -%>
1880         RECT r;
1881         <%- end -%>
1882
1883         if (window->wid > 0) {
1884                 return 0;
1885         }
1886
1887         wid = wopn_wnd(WA_STD<% if self.is_attr_subwindow() %>|WA_SUBW<% end %><% if self.is_attr_resizable() %>|WA_SIZE|WA_HHDL|WA_VHDL<% end %><% if self.is_attr_scrollable() %>|WA_BBAR|WA_RBAR<% end %>, <% if self.is_attr_subwindow() %>window->parent->wid<% else %>window->parent<% end %>, &(window->r), NULL, 2, <% if !self.is_attr_alwaysopen() %>window->title<%- else -%>title<%- end -%>, &window->bgpat, NULL);
1888         if (wid < 0) {
1889                 DP_ER("wopn_wnd: subjectoption error", wid);
1890                 return wid;
1891         }
1892         window->wid = wid;
1893         window->gid = wget_gid(wid);
1894         <%- if self.is_attr_scrollable() -%>
1895         hmi_windowscroll_settarget(&window->wscr, wid);
1896         <%- end -%>
1897
1898         <%- @parts.each do |p| -%><%= p.generate_create_in_open() %><%- end -%>
1899
1900         wreq_dsp(wid);
1901
1902         return 0;
1903 }
1904
1905 <%- if !self.is_attr_alwaysopen() -%>
1906 EXPORT VOID <%= self.struct_name() %>_close(<%= self.struct_name() %>_t *window)
1907 {
1908         WDSTAT stat;
1909         W err;
1910
1911         if (window->wid < 0) {
1912                 return;
1913         }
1914
1915         stat.attr = WA_STD;
1916         err = wget_sts(window->wid, &stat, NULL);
1917         if (err >= 0) {
1918                 window->r = stat.r;
1919         }
1920         <%- @parts.reverse_each do |p| -%><%= p.generate_savevalue_in_close() %><%- end -%>
1921         <%- if self.is_exist_controllparts() -%>
1922         cdel_pwd(window->wid, NOCLR);
1923         <%- end -%>
1924         wcls_wnd(window->wid, CLR);
1925         window->wid = -1;
1926         window->gid = -1;
1927 }
1928
1929 <%- end -%>
1930     EOS
1931
1932     erb = ERB.new(script, nil, '-');
1933     erb.result(binding)
1934   end
1935
1936   def generate_checkpartsflag_in_checkflag(main_name)
1937     script = <<-EOS
1938         <%- if self.is_exist_eventbreak_parts() -%>
1939         if (<%= self.struct_name() %>_issetflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_OTHEREVENT) == True) {
1940                 <%= self.struct_name() %>_clearflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_OTHEREVENT);
1941                 <%= self.struct_name() %>_setflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION);
1942                 return False;
1943         } else if (<%= self.struct_name() %>_issetflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION) == True) {
1944                 <%= self.struct_name() %>_clearflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION);
1945         <%- self.parts.each do |p| -%>
1946         <%- if p.is_need_eventbreak() -%>
1947                 if (hmi-><%= self.struct_name() %>-><%= p.name() %>.nextaction == True) {
1948                         hmi->wev.s.type = EV_NULL;
1949                         <%= self.struct_name() %>_action<%= p.name() %>(hmi-><%= self.struct_name() %>, &hmi->wev, &hmi->evt);
1950                         return True;
1951                 }
1952         <%- end -%>
1953         <%- end -%>
1954         }
1955         <%- end -%>
1956     EOS
1957
1958     erb = ERB.new(script, nil, '-');
1959     erb.result(binding)
1960   end
1961
1962   def generate_new_del_functions()
1963     script = <<-EOS
1964 EXPORT <%= self.struct_name() %>_t* <%= self.struct_name() %>_new(<%= self.generate_initialize_arguments() %>)
1965 {
1966         <%= self.struct_name() %>_t *window;
1967         <%- if self.is_attr_scrollable() -%>
1968         W err;
1969         <%- end -%>
1970
1971         window = (<%= self.struct_name() %>_t*)malloc(sizeof(<%= self.struct_name() %>_t));
1972         if (window == NULL) {
1973                 return NULL;
1974         }
1975         <%- if self.is_attr_scrollable() -%>
1976         window->flag = 0;
1977         <%- end -%>
1978         window->wid = -1;
1979         window->gid = -1;
1980         window->parent = parent;
1981         <%- if self.is_attr_resizable() -%>
1982         window->r = *r;
1983         <%- else -%>
1984         window->r.c.left = p->x;
1985         window->r.c.top = p->y;
1986         window->r.c.right = p->x + <%= self.get_window_width() %>;
1987         window->r.c.bottom = p->y + <%= self.get_window_height() %>;
1988         <%- end -%>
1989         if (bgpat != NULL) {
1990                 window->bgpat = *bgpat;
1991         } else {
1992                 window->bgpat = (PAT){{0, 16, 16, 0x10ffffff, 0, FILL100}};
1993         }
1994         <%- if self.is_attr_scrollable() -%>
1995         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
1996         if (err < 0) {
1997                 free(window);
1998                 return NULL;
1999         }
2000         <%- end -%>
2001         <%- if !self.is_attr_alwaysopen() -%>
2002         tc_strset(window->title, TNULL, <%= self.get_window_title_max_length() %>+1);
2003         if (title != 0) {
2004                 tc_strncpy(window->title, title, <%= self.get_window_title_max_length() %>);
2005         } else {
2006                 <%- l = 0 -%>
2007                 <%- conv_euc_to_TCArray(self.get_window_title()).each do |ch| -%>
2008                 window->title[<%= l %>] = 0x<%= ch.to_s(16) %>;<%- l+=1 %>
2009                 <%- end -%>
2010         }
2011         <%- end -%>
2012         <%- @parts.each do |p| -%><%= p.generate_initialize_in_new() %><%- end -%>
2013
2014         <%- if self.is_attr_alwaysopen() -%>
2015         err = <%= self.struct_name() %>_open(window, title);
2016         if (err < 0) {
2017                 <%- if self.is_attr_scrollable() -%>
2018                 hmi_windowscroll_finalize(&window->wscr);
2019                 <%- end -%>
2020                 free(window);
2021                 return NULL;
2022         }
2023         <%- end -%>
2024
2025         return window;
2026 }
2027
2028 LOCAL VOID <%= self.struct_name() %>_delete(<%= self.struct_name() %>_t *window)
2029 {
2030         if (window->wid > 0) {
2031                 <%- if self.is_exist_controllparts() -%>
2032                 cdel_pwd(window->wid, NOCLR);
2033                 <%- end -%>
2034                 wcls_wnd(window->wid, CLR);
2035         }
2036         <%- if self.is_attr_scrollable() -%>
2037         hmi_windowscroll_finalize(&window->wscr);
2038         <%- end -%>
2039         free(window);
2040 }
2041
2042     EOS
2043
2044     erb = ERB.new(script, nil, '-');
2045     erb.result(binding)
2046   end
2047 end
2048
2049 class HMIData
2050   attr_accessor :yaml, :win, :name
2051   def initialize(yaml)
2052     @yaml = yaml;
2053     @win = Array.new();
2054     yaml["windows"].each { |a|
2055       w = HMIWindow.new(a);
2056       @win.push(w);
2057     };
2058   end
2059   def main_name()
2060     @yaml["generator"]["name"]
2061   end
2062   def lisence_header()
2063     @yaml["generator"]["lisence_header"]
2064   end
2065   def lisence_source()
2066     @yaml["generator"]["lisence_source"]
2067   end
2068   def filename_header()
2069     @yaml["generator"]["output_header"]
2070   end
2071
2072   def generate_header_eventtype_enumulate()
2073     script = <<-EOS
2074 enum {
2075         <%= self.main_name().upcase %>EVENT_TYPE_NONE,
2076         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MOUSEMOVE,
2077         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_KEYDOWN,
2078         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MENU,
2079         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_TIMEOUT,
2080         <%- @win.each do |w| -%><%= w.generate_header_eventtype_enumulate(self.main_name()) %><%- end -%>
2081 };
2082     EOS
2083
2084     erb = ERB.new(script, nil, '-');
2085     erb.result(binding)
2086   end
2087   def generate_header_eventtype_struct()
2088     script = <<-EOS
2089 struct <%= self.main_name() %>_eventdata_mousemove_t_ {
2090         PNT pos;
2091 };
2092 typedef struct <%= self.main_name() %>_eventdata_mousemove_t_ <%= self.main_name() %>_eventdata_mousemove_t;
2093
2094 struct <%= self.main_name() %>_eventdata_keydown_t_ {
2095         TC keycode;
2096         UH keytop;
2097         UW stat;
2098 };
2099 typedef struct <%= self.main_name() %>_eventdata_keydown_t_ <%= self.main_name() %>_eventdata_keydown_t;
2100
2101 struct <%= self.main_name() %>_eventdata_menu_t_ {
2102         PNT pos;
2103 };
2104 typedef struct <%= self.main_name() %>_eventdata_menu_t_ <%= self.main_name() %>_eventdata_menu_t;
2105
2106 struct <%= self.main_name() %>_eventdata_timeout_t_ {
2107         W code;
2108 };
2109 typedef struct <%= self.main_name() %>_eventdata_timeout_t_ <%= self.main_name() %>_eventdata_timeout_t;
2110
2111 <%- @win.each do |w| -%>
2112 <%- if w.is_exportevent_draw() -%>
2113 struct <%= w.struct_name() %>_eventdata_draw_t_ {
2114 };
2115 typedef struct <%= w.struct_name() %>_eventdata_draw_t_ <%= w.struct_name() %>_eventdata_draw_t;
2116
2117 <%- end -%>
2118 <%- if w.is_attr_resizable() -%>
2119 struct <%= w.struct_name() %>_eventdata_resize_t_ {
2120         SIZE work_sz;
2121 };
2122 typedef struct <%= w.struct_name() %>_eventdata_resize_t_ <%= w.struct_name() %>_eventdata_resize_t;
2123
2124 <%- end -%>
2125 <%- if w.is_exportevent_close() -%>
2126 struct <%= w.struct_name() %>_eventdata_close_t_ {
2127         Bool save;
2128 };
2129 typedef struct <%= w.struct_name() %>_eventdata_close_t_ <%= w.struct_name() %>_eventdata_close_t;
2130
2131 <%- end -%>
2132 <%- if w.is_exportevent_butdn() -%>
2133 struct <%= w.struct_name() %>_eventdata_butdn_t_ {
2134         W type;
2135         PNT pos;
2136 };
2137 typedef struct <%= w.struct_name() %>_eventdata_butdn_t_ <%= w.struct_name() %>_eventdata_butdn_t;
2138
2139 <%- end -%>
2140 <%- if w.is_exportevent_paste() -%>
2141 struct <%= w.struct_name() %>_eventdata_paste_t_ {
2142 };
2143 typedef struct <%= w.struct_name() %>_eventdata_paste_t_ <%= w.struct_name() %>_eventdata_paste_t;
2144
2145 <%- end -%>
2146 <%- if w.is_exportevent_switch() -%>
2147 struct <%= w.struct_name() %>_eventdata_switch_t_ {
2148 };
2149 typedef struct <%= w.struct_name() %>_eventdata_switch_t_ <%= w.struct_name() %>_eventdata_switch_t;
2150
2151 <%- end -%>
2152 <%- if w.is_exportevent_mousemove() -%>
2153 struct <%= w.struct_name() %>_eventdata_mousemove_t_ {
2154         PNT pos;
2155         UW stat;
2156 };
2157 typedef struct <%= w.struct_name() %>_eventdata_mousemove_t_ <%= w.struct_name() %>_eventdata_mousemove_t;
2158
2159 <%- end -%>
2160 <%- if w.is_exportevent_scroll() and w.is_attr_scrollable() -%>
2161 struct <%= w.struct_name() %>_eventdata_scroll_t_ {
2162         W dh;
2163         W dv;
2164 };
2165 typedef struct <%= w.struct_name() %>_eventdata_scroll_t_ <%= w.struct_name() %>_eventdata_scroll_t;
2166
2167 <%- end -%>
2168 <%= w.generate_header_partsevent_struct(self.main_name()) %><%- -%>
2169 <%- end -%>
2170     EOS
2171
2172     erb = ERB.new(script, nil, '-');
2173     erb.result(binding)
2174   end
2175   def generate_header_eventtype_union()
2176     script = <<-EOS
2177 struct <%= self.main_name() %>event_t_ {
2178         W type;
2179         union  {
2180                 <%= self.main_name() %>_eventdata_mousemove_t common_mousemove;
2181                 <%= self.main_name() %>_eventdata_keydown_t common_keydown;
2182                 <%= self.main_name() %>_eventdata_menu_t common_menu;
2183                 <%= self.main_name() %>_eventdata_timeout_t common_timeout;
2184 <%- @win.each do |w| -%>
2185                 <%- if w.is_exportevent_draw() -%>
2186                 <%= w.struct_name() %>_eventdata_draw_t <%= w.struct_name() %>_draw;
2187                 <%- end -%>
2188                 <%- if w.is_attr_resizable() -%>
2189                 <%= w.struct_name() %>_eventdata_resize_t <%= w.struct_name() %>_resize;
2190                 <%- end -%>
2191                 <%- if w.is_exportevent_close() -%>
2192                 <%= w.struct_name() %>_eventdata_close_t <%= w.struct_name() %>_close;
2193                 <%- end -%>
2194                 <%- if w.is_exportevent_butdn() -%>
2195                 <%= w.struct_name() %>_eventdata_butdn_t <%= w.struct_name() %>_butdn;
2196                 <%- end -%>
2197                 <%- if w.is_exportevent_paste() -%>
2198                 <%= w.struct_name() %>_eventdata_paste_t <%= w.struct_name() %>_paste;
2199                 <%- end -%>
2200                 <%- if w.is_exportevent_switch() -%>
2201                 <%= w.struct_name() %>_eventdata_switch_t <%= w.struct_name() %>_switch;
2202                 <%- end -%>
2203                 <%- if w.is_exportevent_mousemove() -%>
2204                 <%= w.struct_name() %>_eventdata_mousemove_t <%= w.struct_name() %>_mousemove;
2205                 <%- end -%>
2206                 <%- if w.is_exportevent_scroll() and w.is_attr_scrollable() -%>
2207                 <%= w.struct_name() %>_eventdata_scroll_t <%= w.struct_name() %>_scroll;
2208                 <%- end -%>
2209                 <%- -%><%= w.generate_header_partsevent_unionmember(self.main_name()) %><%- -%>
2210 <%- end -%>
2211         } data;
2212 };
2213 typedef struct <%= self.main_name() %>event_t_ <%= self.main_name() %>event_t;
2214     EOS
2215
2216     erb = ERB.new(script, nil, '-');
2217     erb.result(binding)
2218   end
2219   def generate_header_main_prototypes()
2220     script = <<-EOS
2221 typedef struct <%= self.main_name() %>_t_ <%= self.main_name() %>_t;
2222
2223 IMPORT <%= self.main_name() %>_t* <%= self.main_name() %>_new();
2224 IMPORT VOID <%= self.main_name() %>_delete(<%= self.main_name() %>_t *hmi);
2225 IMPORT W <%= self.main_name() %>_getevent(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t **evt);
2226 <%- @win.each do |w| -%>
2227 IMPORT <%= w.struct_name() %>_t* <%= self.main_name() %>_new<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.generate_initialize_arguments() %>);
2228 <%- end -%>
2229 <%- @win.each do |w| -%>
2230 IMPORT VOID <%= self.main_name() %>_delete<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.struct_name() %>_t *window);
2231 <%- end -%>
2232     EOS
2233
2234     erb = ERB.new(script, nil, '-');
2235     erb.result(binding)
2236   end
2237
2238   def generate_header()
2239     str = String.new();
2240     @win.each { |w|
2241       str += w.generate_prototypes() + "\n";
2242     };
2243     str += self.generate_header_eventtype_enumulate() + "\n";
2244     str += self.generate_header_eventtype_struct();
2245     str += self.generate_header_eventtype_union() + "\n";
2246     str += self.generate_header_main_prototypes() + "\n";
2247     str;
2248   end
2249
2250   def generate_source_include_files()
2251     script = <<-EOS
2252 #include    "<%= self.filename_header() %>"
2253 #include    "hmi/hmi_windowscroll.h"
2254
2255 #include        <bstdio.h>
2256 #include        <bstdlib.h>
2257 #include        <tcode.h>
2258 #include        <tstring.h>
2259 #include        <btron/btron.h>
2260 #include        <btron/hmi.h>
2261 #include        <btron/vobj.h>
2262
2263 #if 1
2264 # define DP(arg) printf arg
2265 # define DP_ER(msg, err) printf("%s (%d/%x)\\n", msg, err>>16, err)
2266 #else
2267 # define DP(arg) /**/
2268 # define DP_ER(msg, err) /**/
2269 #endif
2270
2271     EOS
2272
2273     erb = ERB.new(script, nil, '-');
2274     erb.result(binding)
2275   end
2276
2277   def generate_source_mainloop_windowid_valuablelist()
2278     script = <<-EOS
2279 <%- @win.each_with_index do |w, idx| -%>
2280 <%= w.struct_name() %>_id<%- if idx != @win.length - 1 -%>, <%- end -%>
2281 <%- end -%>
2282     EOS
2283     erb = ERB.new(script, nil, '-');
2284     erb.result(binding)
2285   end
2286
2287   def generate_source_mainloop()
2288     script = <<-EOS
2289 LOCAL VOID <%= self.main_name() %>_setswitchbutdnflag(<%= self.main_name() %>_t *hmi)
2290 {
2291         hmi->flag = hmi->flag | <%= self.main_name().upcase %>_FLAG_SWITCHBUTDN;
2292 }
2293
2294 LOCAL VOID <%= self.main_name() %>_clearswitchbutdnflag(<%= self.main_name() %>_t *hmi)
2295 {
2296         hmi->flag = hmi->flag & ~<%= self.main_name().upcase %>_FLAG_SWITCHBUTDN;
2297 }
2298
2299 LOCAL Bool <%= self.main_name() %>_issetswitchbutdnflag(<%= self.main_name() %>_t *hmi)
2300 {
2301         if ((hmi->flag & <%= self.main_name().upcase %>_FLAG_SWITCHBUTDN) == 0) {
2302                 return False;
2303         }
2304         return True;
2305 }
2306
2307 <%- @win.each do |w| -%>
2308 LOCAL Bool <%= self.main_name() %>_is<%= w.struct_name() %>WID(<%= self.main_name() %>_t *hmi, WID wid)
2309 {
2310         if (hmi-><%= w.struct_name() %>->wid == wid) {
2311                 return True;
2312         }
2313         return False;
2314 }
2315
2316 <%- end -%>
2317 LOCAL VOID <%= self.main_name() %>_weventnull(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2318 {
2319         cidl_par(wev->s.wid, &wev->s.pos);
2320         if (wev->s.cmd != W_WORK)
2321                 return;         /*ºî¶ÈÎÎ°è³°*/
2322         if (wev->s.stat & ES_CMD)
2323                 return; /*Ì¿Îá¥¡¼¤¬²¡¤µ¤ì¤Æ¤¤¤ë*/
2324 <%- @win.each do |w| -%>
2325         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2326                 <%- if w.is_exist_controllparts() -%>
2327                 cidl_par(wev->s.wid, &wev->s.pos);
2328                 <%- end -%>
2329                 <%- if w.is_exportevent_mousemove() -%>
2330                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_MOUSEMOVE;
2331                 hmi->evt.data.<%= w.struct_name() %>_mousemove.pos = wev->s.pos;
2332                 hmi->evt.data.<%= w.struct_name() %>_mousemove.stat = wev->s.stat;
2333                 <%- elsif !w.is_exist_controllparts() -%>
2334                 gset_ptr(PS_SELECT, NULL, -1, -1);
2335                 <%- end -%>
2336                 return;
2337         }
2338 <%- end -%>
2339         /*¥¦¥£¥ó¥É¥¦³°*/
2340         hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MOUSEMOVE;
2341         hmi->evt.data.common_mousemove.pos = wev->s.pos;
2342 }
2343
2344 LOCAL VOID <%= self.main_name() %>_weventrequest(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2345 {
2346         switch (wev->g.cmd) {
2347         case    W_REDISP:       /*ºÆÉ½¼¨Í×µá*/
2348                 <%- @win.each do |w| -%>
2349                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2350                         <%- if w.is_exportevent_draw() -%>
2351                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2352                         <%- else -%>
2353                         <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2354                         <%- end -%>
2355                         break;
2356                 }
2357                 <%- end -%>
2358                 break;
2359         case    W_PASTE:        /*Å½¹þ¤ßÍ×µá*/
2360                 <%- @win.each do |w| -%>
2361                 <%- if w.is_exportevent_paste() -%>
2362                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2363                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_PASTE;
2364                         memcpy(&hmi-><%= w.struct_name() %>->savedwev, wev, sizeof(WEVENT));
2365                         break;
2366                 }
2367                 <%- end -%>
2368                 <%- end -%>
2369                 wrsp_evt(wev, 1); /*NACK*/
2370                 break;
2371         case    W_DELETE:       /*ÊÝÂ¸½ªÎ»*/
2372                 wrsp_evt(wev, 0);       /*ACK*/
2373                 <%- @win.each do |w| -%>
2374                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2375                         <%- if w.is_exportevent_close() -%>
2376                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_CLOSE;
2377                         evt->data.<%= w.struct_name() %>_close.save = True;
2378                         <%- else -%>
2379                         <%= w.struct_name() %>_close(hmi-><%= w.struct_name() %>);
2380                         <%- end -%>
2381                         break;
2382                 }
2383                 <%- end -%>
2384                 break;
2385         case    W_FINISH:       /*ÇÑ´þ½ªÎ»*/
2386                 wrsp_evt(wev, 0);       /*ACK*/
2387                 <%- @win.each do |w| -%>
2388                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2389                         <%- if w.is_exportevent_close() -%>
2390                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_CLOSE;
2391                         evt->data.<%= w.struct_name() %>_close.save = False;
2392                         <%- else -%>
2393                         <%= w.struct_name() %>_close(hmi-><%= w.struct_name() %>);
2394                         <%- end -%>
2395                         break;
2396                 }
2397                 <%- end -%>
2398                 break;
2399         }
2400 }
2401
2402 LOCAL VOID <%= self.main_name() %>_weventbutdn(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2403 {
2404         W i, err;
2405         W dh, dv; /* TODO: add check for exist scrollable window */
2406
2407         switch  (wev->s.cmd) {
2408         case    W_PICT:
2409                 switch (wchk_dck(wev->s.time)) {
2410                 case    W_DCLICK:
2411                         <%- @win.each do |w| -%>
2412                         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2413                                 <%- if w.is_exportevent_close() -%>
2414                                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_CLOSE;
2415                                 evt->data.<%= w.struct_name() %>_close.save = True; /* TODO: tmp value */
2416                                 <%- else -%>
2417                                 <%= w.struct_name() %>_close(hmi-><%= w.struct_name() %>);
2418                                 <%- end -%>
2419                                 return;
2420                         }
2421                         <%- end -%>
2422                         return;
2423                 case    W_PRESS:
2424                         break;
2425                 default:
2426                         return;
2427                 }
2428         case    W_FRAM:
2429         case    W_TITL:
2430                 if (wmov_drg(wev, NULL) > 0) {
2431                         <%- @win.each do |w| -%>
2432                         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2433                                 <%- if w.is_exportevent_draw() -%>
2434                                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2435                                 <%- else -%>
2436                                 <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2437                                 <%- end -%>
2438                                 return;
2439                         }
2440                         <%- end -%>
2441                 }
2442                 return;
2443         case    W_LTHD:
2444         case    W_RTHD:
2445         case    W_LBHD:
2446         case    W_RBHD:
2447                 switch (wchk_dck(wev->s.time)) {
2448                 case    W_DCLICK:
2449                         i = wchg_wnd(wev->s.wid, NULL, W_MOVE);
2450                         break;
2451                 case    W_PRESS:
2452                         i = wrsz_drg(wev, NULL, NULL);
2453                         break;
2454                 default:
2455                         return;
2456                 }
2457
2458                 <%- @win.each do |w| -%>
2459                 <%- if w.is_attr_resizable() -%>
2460                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2461                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_RESIZE;
2462                         <%= w.struct_name() %>_resize(hmi-><%= w.struct_name() %>, &evt->data.<%= w.struct_name() %>_resize.work_sz);
2463                         hmi_windowscroll_updatebar(&hmi-><%= w.struct_name() %>->wscr);
2464                         if (i > 0) {
2465                                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST);
2466                         }
2467                         return;
2468                 }
2469                 <%- end -%>
2470                 <%- end -%>
2471                 return;
2472         case    W_RBAR:
2473                 <%- @win.each do |w| -%>
2474                 <%- if w.is_attr_scrollable() -%>
2475                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2476                         err = hmi_windowscroll_weventrbar(&hmi-><%= w.struct_name() %>->wscr, wev, &dh, &dv);
2477                         if (err < 0) {
2478                                 return;
2479                         }
2480                         if (err == 0) {
2481                                 <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2482                         } else {
2483                                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2484                         }
2485                         <%- if w.is_exportevent_scroll() -%>
2486                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2487                         evt->data.<%= w.struct_name() %>_scroll.dh = dh;
2488                         evt->data.<%= w.struct_name() %>_scroll.dv = dv;
2489                         <%- end -%>
2490                         return;
2491                 }
2492                 <%- end -%>
2493                 <%- end -%>
2494                 return;
2495         case    W_BBAR:
2496                 <%- @win.each do |w| -%>
2497                 <%- if w.is_attr_scrollable() -%>
2498                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2499                         err = hmi_windowscroll_weventbbar(&hmi-><%= w.struct_name() %>->wscr, wev, &dh, &dv);
2500                         if (err < 0) {
2501                                 return;
2502                         }
2503                         if (err == 0) {
2504                                 <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2505                         } else {
2506                                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2507                         }
2508                         <%- if w.is_exportevent_scroll() -%>
2509                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2510                         evt->data.<%= w.struct_name() %>_scroll.dh = dh;
2511                         evt->data.<%= w.struct_name() %>_scroll.dv = dv;
2512                         <%- end -%>
2513                         return;
2514                 }
2515                 <%- end -%>
2516                 <%- end -%>
2517                 return;
2518         case    W_WORK:
2519                 <%- @win.each do |w| -%>
2520                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2521                         <%= w.struct_name() %>_butdnwork(hmi-><%= w.struct_name() %>, wev, evt);
2522                         return;
2523                 }
2524                 <%- end -%>
2525                 return;
2526         }
2527
2528         return;
2529 }
2530
2531 LOCAL VOID <%= self.main_name() %>_weventswitch(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2532 {
2533         <%= self.main_name() %>_setswitchbutdnflag(hmi);
2534         <%- @win.each do |w| -%>
2535         <%- if w.is_exportevent_switch() -%>
2536         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2537                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SWITCH;
2538                 return;
2539         }
2540         <%- end -%>
2541         <%- end -%>
2542 }
2543
2544 LOCAL VOID <%= self.main_name() %>_weventreswitch(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2545 {
2546         <%= self.main_name() %>_setswitchbutdnflag(hmi);
2547         <%- @win.each do |w| -%>
2548         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2549                 <%- if w.is_exportevent_switch() -%>
2550                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SWITCH;
2551                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST);
2552                 return;
2553                 <%- else -%>
2554                 <%- if w.is_exportevent_draw() -%>
2555                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2556                 <%- else -%>
2557                 <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2558                 return;
2559                 <%- end -%>
2560                 <%- end -%>
2561         }
2562         <%- end -%>
2563 }
2564
2565 LOCAL VOID <%= self.main_name() %>_receivemessage(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t *evt)
2566 {
2567         MESSAGE msg;
2568         W err;
2569
2570         err = rcv_msg(MM_ALL, &msg, sizeof(MESSAGE), WAIT|NOCLR);
2571         if (err >= 0) {
2572                 if (msg.msg_type == MS_TMOUT) { /* should be use other type? */
2573                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_TIMEOUT;
2574                         evt->data.common_timeout.code = msg.msg_body.TMOUT.code;
2575                 }
2576         }
2577         clr_msg(MM_ALL, MM_ALL);
2578 }
2579
2580 LOCAL Bool <%= self.main_name() %>_checkflag(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t **evt)
2581 {
2582         W err, dh, dv;
2583
2584         <%- @win.each do |w| -%>
2585         <%- if w.is_need_flag() and w.is_attr_scrollable() -%>
2586         if (<%= w.struct_name() %>_issetflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING) == True) {
2587                 err = hmi_windowscroll_weventrbar(&hmi-><%= w.struct_name() %>->wscr, &hmi->wev, &dh, &dv);
2588                 if (err < 0) {
2589                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2590                         return False;
2591                 }
2592                 if (err == 0) {
2593                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2594                 } else {
2595                         <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2596                 }
2597                 <%- if w.is_exportevent_scroll() -%>
2598                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2599                 hmi->evt.data.<%= w.struct_name() %>_scroll.dh = dh;
2600                 hmi->evt.data.<%= w.struct_name() %>_scroll.dv = dv;
2601                 <%- end -%>
2602                 return True;
2603         }
2604         if (<%= w.struct_name() %>_issetflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING) == True) {
2605                 err = hmi_windowscroll_weventbbar(&hmi-><%= w.struct_name() %>->wscr, &hmi->wev, &dh, &dv);
2606                 if (err < 0) {
2607                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2608                         return False;
2609                 }
2610                 if (err == 0) {
2611                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2612                 } else {
2613                         <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2614                 }
2615                 <%- if w.is_exportevent_scroll() -%>
2616                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2617                 hmi->evt.data.<%= w.struct_name() %>_scroll.dh = dh;
2618                 hmi->evt.data.<%= w.struct_name() %>_scroll.dv = dv;
2619                 <%- end -%>
2620                 return True;
2621         }
2622         <%- end -%>
2623         <%- end -%>
2624         <%- @win.each do |w| -%><%= w.generate_checkpartsflag_in_checkflag(self.main_name()) %><%- end -%>
2625
2626         return False;
2627 }
2628
2629 EXPORT W <%= self.main_name() %>_getevent(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t **evt)
2630 {
2631         WEVENT  *wev0;
2632         Bool ok;
2633
2634         hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_NONE;
2635         *evt = &hmi->evt;
2636         wev0 = &hmi->wev;
2637
2638         ok = <%= self.main_name() %>_issetswitchbutdnflag(hmi);
2639         if (ok == True) {
2640                 <%= self.main_name() %>_weventbutdn(hmi, wev0, &hmi->evt);
2641                 <%= self.main_name() %>_clearswitchbutdnflag(hmi);
2642                 return 0;
2643         }
2644
2645         <%- @win.each do |w| -%>
2646         <%- if w.is_need_flag() -%>
2647         if (<%= w.struct_name() %>_issetflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST) == True) {
2648                 <%- if w.is_exportevent_draw() -%>
2649                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2650                 <%- else -%>
2651                 <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2652                 <%- end -%>
2653                 <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST);
2654                 return 0;
2655         }
2656         <%- end -%>
2657         <%- end -%>
2658
2659         ok = <%= self.main_name() %>_checkflag(hmi, evt);
2660         if (ok == True) {
2661                 return 0;
2662         }
2663
2664         wget_evt(wev0, WAIT);
2665         switch (wev0->s.type) {
2666         case    EV_NULL:
2667                 <%= self.main_name() %>_weventnull(hmi, wev0, &hmi->evt);
2668                 break;
2669         case    EV_REQUEST:
2670                 <%= self.main_name() %>_weventrequest(hmi, wev0, &hmi->evt);
2671                 break;
2672         case    EV_RSWITCH:
2673                 <%= self.main_name() %>_weventreswitch(hmi, wev0, &hmi->evt);
2674                 break;
2675         case    EV_SWITCH:
2676                 <%= self.main_name() %>_weventswitch(hmi, wev0, &hmi->evt);
2677                 break;
2678         case    EV_BUTDWN:
2679                 <%= self.main_name() %>_weventbutdn(hmi, wev0, &hmi->evt);
2680                 break;
2681         case    EV_KEYDWN:
2682         case    EV_AUTKEY:
2683                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_KEYDOWN;
2684                 hmi->evt.data.common_keydown.keycode = wev0->e.data.key.code;
2685                 hmi->evt.data.common_keydown.keytop = wev0->e.data.key.keytop;
2686                 hmi->evt.data.common_keydown.stat = wev0->e.stat;
2687                 break;
2688         case    EV_INACT:
2689                 pdsp_msg(NULL);
2690                 break;
2691         case    EV_DEVICE:
2692                 oprc_dev(&wev0->e, NULL, 0);
2693                 break;
2694         case    EV_MSG:
2695                 <%= self.main_name() %>_receivemessage(hmi, &hmi->evt);
2696                 break;
2697         case    EV_MENU:
2698                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MENU;
2699                 hmi->evt.data.common_menu.pos = wev0->s.pos;
2700                 break;
2701         }
2702
2703         return 0;
2704 }
2705
2706     EOS
2707
2708     erb = ERB.new(script, nil, '-');
2709     erb.result(binding)
2710   end
2711
2712   def generate_struct()
2713     str = String.new();
2714     @win.each { |w|
2715       str += w.generate_source_struct();
2716     };
2717     script = <<-EOS
2718 #define <%= self.main_name().upcase %>_FLAG_SWITCHBUTDN 0x00000001
2719
2720 struct <%= self.main_name() %>_t_ {
2721         WEVENT wev;
2722         <%= self.main_name() %>event_t evt;
2723         UW flag;
2724         <%- @win.each do |w| -%>
2725         <%= w.struct_name() %>_t *<%= w.struct_name() %>;
2726         <%- end -%>
2727 };
2728
2729     EOS
2730     erb = ERB.new(script, nil, '-');
2731     str += erb.result(binding)
2732   end
2733
2734   def generate_windowfunctions()
2735     str = String.new();
2736     @win.each { |w|
2737       str += w.generate_source_functions(self.main_name());
2738     };
2739     str;
2740   end
2741
2742   def generate_source_new_del_wrappers()
2743     script = <<-EOS
2744 <%- @win.each do |w| -%>
2745 EXPORT <%= w.struct_name() %>_t* <%= self.main_name() %>_new<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.generate_initialize_arguments() %>)
2746 {
2747         <%- if w.is_attr_subwindow -%>
2748         if (parent == NULL) {
2749                 return NULL;
2750         }
2751         <%- end -%>
2752         if (hmi-><%= w.struct_name() %> != NULL) {
2753                 return NULL;
2754         }
2755         hmi-><%= w.struct_name() %> = <%= w.struct_name() %>_new(<%= w.generate_initialize_arguments_values() %>);
2756         return hmi-><%= w.struct_name() %>;
2757 }
2758
2759 EXPORT VOID <%= self.main_name() %>_delete<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.struct_name() %>_t *window)
2760 {
2761         <%= w.struct_name() %>_delete(hmi-><%= w.struct_name() %>);
2762         hmi-><%= w.struct_name() %> = NULL;
2763 }
2764
2765 <%- end -%>
2766
2767 EXPORT <%= self.main_name() %>_t* <%= self.main_name() %>_new()
2768 {
2769         <%= self.main_name() %>_t *hmi;
2770
2771         hmi = (<%= self.main_name() %>_t *)malloc(sizeof(<%= self.main_name() %>_t));
2772         if (hmi == NULL) {
2773                 return NULL;
2774         }
2775         hmi->flag = 0;
2776         <%- @win.each do |w| -%>
2777         hmi-><%= w.struct_name() %> = NULL;
2778         <%- end -%>
2779
2780         return hmi;
2781 }
2782
2783 EXPORT VOID <%= self.main_name() %>_delete(<%= self.main_name() %>_t *hmi)
2784 {
2785         <%- @win.each do |w| -%>
2786         if (hmi-><%= w.struct_name() %> != NULL) {
2787                 <%= w.struct_name() %>_delete(hmi-><%= w.struct_name() %>);
2788         }
2789         <%- end -%>
2790         free(hmi);
2791 }
2792     EOS
2793
2794     erb = ERB.new(script, nil, '-');
2795     erb.result(binding)
2796   end
2797
2798   def generate_source_mainfunctions()
2799     str = String.new();
2800     @win.each { |w|
2801       str += w.generate_new_del_functions();
2802     };
2803     str += self.generate_source_new_del_wrappers()
2804     str;
2805   end
2806
2807   def generate_source()
2808     str = String.new();
2809     str += self.generate_struct();
2810     str += self.generate_windowfunctions();
2811     str += self.generate_source_mainloop();
2812     str += self.generate_source_mainfunctions();
2813     str;
2814   end
2815 end
2816
2817 #
2818
2819 def generate_header(filename, data)
2820   fd = File.open(filename, "w");
2821   fd.puts data.lisence_header();
2822   fd.puts <<-EOS
2823
2824 /* This file is automatically generated. */
2825
2826 #include    <basic.h>
2827 #include        <btron/dp.h>
2828 #include        <btron/hmi.h>
2829
2830   EOS
2831   fd.puts "#ifndef __" + filename.upcase.gsub(/\./, '_') + "__";
2832   fd.puts "#define __" + filename.upcase.gsub(/\./, '_') + "__";
2833   fd.puts "\n";
2834   fd.puts data.generate_header();
2835   fd.puts "#endif\n"
2836 end
2837
2838 def generate_source(filename, data)
2839   fd = File.open(filename, "w");
2840   fd.puts data.lisence_source();
2841   fd.puts <<-EOS
2842
2843 /* This file is automatically generated. */
2844
2845   EOS
2846   fd.puts data.generate_source_include_files();
2847
2848   fd.puts data.generate_source();
2849
2850 end
2851
2852 yaml = YAML.load(File.read(ARGV[0], encoding: 'EUC-JP:UTF-8'));
2853 data = HMIData.new(yaml);
2854
2855 fname_header = yaml["generator"]["output_header"]
2856 fname_source = yaml["generator"]["output_source"]
2857
2858 generate_header(fname_header, data);
2859 generate_source(fname_source, data);