src/tools/hmi_generator.rb

   1 #
   2 # hmi_generator.rb
   3 #
   4 # Copyright (c) 2012 project bchan
   5 #
   6 # This software is provided 'as-is', without any express or implied
   7 # warranty. In no event will the authors be held liable for any damages
   8 # arising from the use of this software.
   9 #
  10 # Permission is granted to anyone to use this software for any purpose,
  11 # including commercial applications, and to alter it and redistribute it
  12 # freely, subject to the following restrictions:
  13 #
  14 # 1. The origin of this software must not be misrepresented; you must not
  15 #    claim that you wrote the original software. If you use this software
  16 #    in a product, an acknowledgment in the product documentation would be
  17 #    appreciated but is not required.
  18 #
  19 # 2. Altered source versions must be plainly marked as such, and must not be
  20 #    misrepresented as being the original software.
  21 #
  22 # 3. This notice may not be removed or altered from any source
  23 #    distribution.
  24 #
  25
  26 require 'yaml'
  27 require 'erb'
  28 require 'jcode'
  29
  30 def conv_euc_to_TCArray(str)
  31   ret = Array.new();
  32   str.each_char do |x|
  33     i = x.length - 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         gdra_stp(window->gid, <%= self.rect_left() %>, <%= self.rect_bottom() %>, (TC[]){<%= self.text_array() %>}, <%= self.text_array_length() %>, G_STORE);
1378     EOS
1379
1380     erb = ERB.new(script, nil, '-');
1381     erb.result(binding)
1382   end
1383 end
1384
1385 def generate_parts(type, a)
1386   case type
1387   when "textbox"
1388     return HMITextBoxParts.new(a);
1389   when "secrettextbox"
1390     return HMISecretTextBoxParts.new(a);
1391   when "textmomentallyswitch"
1392     return HMITextMomentallySwitchParts.new(a);
1393   when "serialbox"
1394     return HMISerialBoxParts.new(a);
1395   when "numberbox"
1396     return HMINumberBoxParts.new(a);
1397   when "switchselector"
1398     return HMISwitchSelectorParts.new(a);
1399   when "fixedtext"
1400     return HMIFixedTextParts.new(a)
1401   end
1402 end
1403
1404 class HMIWindow
1405   attr_accessor :yaml, :parts
1406   def initialize(yaml)
1407     @yaml = yaml;
1408     @parts = Array.new();
1409     if yaml["parts"] != nil
1410       yaml["parts"].each { |a|
1411         w = generate_parts(a["type"], a)
1412         @parts.push(w);
1413       };
1414     end
1415   end
1416   def struct_name()
1417     @yaml["window_name"]
1418   end
1419   def is_attr_xxx(name)
1420     if @yaml["attributes"] == nil || @yaml["attributes"].empty?
1421       false
1422     else
1423       @yaml["attributes"].any? { |item|
1424         item == name;
1425       };
1426     end
1427   end
1428   def is_exportevent_xxx(name)
1429     if @yaml["export_events"] == nil || @yaml["export_events"].empty?
1430       false
1431     else
1432       @yaml["export_events"].any? { |item|
1433         item == name;
1434       };
1435     end
1436   end
1437   def is_attr_scrollable()
1438     self.is_attr_xxx("scrollable");
1439   end
1440   def is_attr_resizable()
1441     self.is_attr_xxx("resizable");
1442   end
1443   def is_attr_opencheckable()
1444     self.is_attr_xxx("opencheckable");
1445   end
1446   def is_attr_subwindow()
1447     self.is_attr_xxx("subwindow");
1448   end
1449   def is_attr_alwaysopen()
1450     self.is_attr_xxx("alwaysopen");
1451   end
1452   def is_exportevent_draw()
1453     self.is_exportevent_xxx("draw");
1454   end
1455   def is_exportevent_butdn()
1456     self.is_exportevent_xxx("butdn");
1457   end
1458   def is_exportevent_paste()
1459     self.is_exportevent_xxx("paste");
1460   end
1461   def is_exportevent_close()
1462     self.is_exportevent_xxx("close");
1463   end
1464   def is_exportevent_switch()
1465     self.is_exportevent_xxx("switch");
1466   end
1467   def is_exportevent_mousemove()
1468     self.is_exportevent_xxx("mousemove");
1469   end
1470   def is_exportevent_scroll()
1471     self.is_exportevent_xxx("scroll");
1472   end
1473   def is_exist_controllparts()
1474     @parts.length > 0;
1475   end
1476   def is_exist_use_rect_in_open()
1477     @parts.any? { |item|
1478       item.is_use_rect_in_open();
1479     };
1480   end
1481   def is_need_flag()
1482     true # tmp
1483   end
1484   def get_window_width()
1485     @yaml["size"]["h"]
1486   end
1487   def get_window_height()
1488     @yaml["size"]["v"]
1489   end
1490   def get_window_title()
1491     @yaml["title"]
1492   end
1493   def is_exist_eventbreak_parts()
1494       @parts.any? { |item|
1495         item.is_need_eventbreak();
1496       };
1497   end
1498   def get_window_parent()
1499     @yaml["parent"]
1500   end
1501   def get_window_title_max_length()
1502     len = @yaml["title_max_length"];
1503     if len == nil
1504       return 128
1505     end
1506     return len
1507   end
1508
1509   def generate_header_eventtype_enumulate(main_name)
1510     script = <<-EOS
1511         <%- if self.is_exportevent_draw() -%>
1512         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_DRAW,
1513         <%- end -%>
1514         <%- if self.is_attr_resizable() -%>
1515         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_RESIZE,
1516         <%- end -%>
1517         <%- if self.is_exportevent_close() -%>
1518         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_CLOSE,
1519         <%- end -%>
1520         <%- if self.is_exportevent_butdn() -%>
1521         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_BUTDN,
1522         <%- end -%>
1523         <%- if self.is_exportevent_paste() -%>
1524         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_PASTE,
1525         <%- end -%>
1526         <%- if self.is_exportevent_switch() -%>
1527         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_SWITCH,
1528         <%- end -%>
1529         <%- if self.is_exportevent_mousemove() -%>
1530         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_MOUSEMOVE,
1531         <%- end -%>
1532         <%- if self.is_exportevent_scroll() and self.is_attr_scrollable() -%>
1533         <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_SCROLL,
1534         <%- end -%>
1535         <%- @parts.each do |p| -%><%= p.generate_header_eventtype_enumulate(main_name, self.struct_name()) %><%- end -%>
1536     EOS
1537
1538     erb = ERB.new(script, nil, '-');
1539     erb.result(binding)
1540   end
1541
1542   def generate_header_partsevent_struct(main_name)
1543     script = <<-EOS
1544         <%- @parts.each do |p| -%><%= p.generate_header_eventstruct_definition(main_name, self.struct_name()) %><%- end -%>
1545     EOS
1546
1547     erb = ERB.new(script, nil, '-');
1548     erb.result(binding)
1549   end
1550
1551   def generate_header_partsevent_unionmember(main_name)
1552     script = <<-EOS
1553         <%- @parts.each do |p| -%><%= p.generate_header_eventunion_member(main_name, self.struct_name()) %><%- end -%>
1554     EOS
1555
1556     erb = ERB.new(script, nil, '-');
1557     erb.result(binding)
1558   end
1559
1560   def generate_prototypes()
1561     script = <<-EOS
1562 typedef struct <%= self.struct_name() %>_t_ <%= self.struct_name() %>_t;
1563 <%- if self.is_attr_scrollable() -%>
1564 typedef VOID (*<%= self.struct_name() %>_scrollcalback)(VP arg, W dh, W dv);
1565 <%- end -%>
1566
1567 <%- if self.is_attr_scrollable() -%>
1568 IMPORT VOID <%= self.struct_name() %>_scrollbyvalue(<%= self.struct_name() %>_t *window, W dh, W dv);
1569 IMPORT W <%= self.struct_name() %>_setdrawrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b);
1570 IMPORT W <%= self.struct_name() %>_setworkrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b);
1571 IMPORT W <%= self.struct_name() %>_scrollworkarea(<%= self.struct_name() %>_t *window, W dh, W dv);
1572 IMPORT W <%= self.struct_name() %>_getworkrect(<%= self.struct_name() %>_t *window, RECT *r);
1573 <%- end -%>
1574 <%- if self.is_attr_opencheckable() -%>
1575 IMPORT Bool <%= self.struct_name() %>_isopen(<%= self.struct_name() %>_t *window);
1576 <%- end -%>
1577 <%- if self.is_exportevent_paste() -%>
1578 IMPORT VOID <%= self.struct_name() %>_responsepasterequest(<%= self.struct_name() %>_t *window, W nak, PNT *pos);
1579 <%- end -%>
1580 <%- if self.is_exportevent_draw() -%>
1581 IMPORT W <%= self.struct_name() %>_startredisp(<%= self.struct_name() %>_t *window, RECT *r);
1582 IMPORT W <%= self.struct_name() %>_endredisp(<%= self.struct_name() %>_t *window);
1583 IMPORT W <%= self.struct_name() %>_eraseworkarea(<%= self.struct_name() %>_t *window, RECT *r);
1584 <%- end -%>
1585 IMPORT W <%= self.struct_name() %>_requestredisp(<%= self.struct_name() %>_t *window);
1586 <%- if self.is_exportevent_butdn() -%>
1587 IMPORT GID <%= self.struct_name() %>_startdrag(<%= self.struct_name() %>_t *window);
1588 IMPORT W <%= self.struct_name() %>_getdrag(<%= self.struct_name() %>_t *window, PNT *pos, WID *wid, PNT *pos_butup);
1589 IMPORT VOID <%= self.struct_name() %>_enddrag(<%= self.struct_name() %>_t *window);
1590 <%- end -%>
1591 IMPORT GID <%= self.struct_name() %>_getGID(<%= self.struct_name() %>_t *window);
1592 IMPORT WID <%= self.struct_name() %>_getWID(<%= self.struct_name() %>_t *window);
1593 IMPORT W <%= self.struct_name() %>_settitle(<%= self.struct_name() %>_t *window, TC *title);
1594 IMPORT Bool <%= self.struct_name() %>_isactive(<%= self.struct_name() %>_t *window);
1595 <%- if !self.is_attr_alwaysopen() -%>
1596 IMPORT W <%= self.struct_name() %>_open(<%= self.struct_name() %>_t *window);
1597 IMPORT VOID <%= self.struct_name() %>_close(<%= self.struct_name() %>_t *window);
1598 <%- end -%>
1599 <%- @parts.each do |p| -%><%= p.generate_prototypes(self.struct_name()) %><%- end -%>
1600     EOS
1601
1602     erb = ERB.new(script, nil, '-');
1603     erb.result(binding)
1604   end
1605
1606   def generate_initialize_arguments()
1607     script = <<-EOS
1608 <%- 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 -%><%- -%>
1609     EOS
1610
1611     erb = ERB.new(script, nil, '-');
1612     erb.result(binding)
1613   end
1614
1615   def generate_initialize_arguments_values()
1616     script = <<-EOS
1617 <%- 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 -%><%- -%>
1618     EOS
1619
1620     erb = ERB.new(script, nil, '-');
1621     erb.result(binding)
1622   end
1623
1624   def generate_source_struct()
1625     script = <<-EOS
1626 struct <%= self.struct_name() %>_t_ {
1627         <%- if self.is_need_flag() -%>
1628         UW flag;
1629         <%- end -%>
1630         WID wid;
1631         GID gid;
1632         <%- if self.is_attr_subwindow() -%>
1633         <%= self.get_window_parent() %>_t *parent;
1634         <%- else -%>
1635         WID parent;
1636         <%- end -%>
1637         RECT r;
1638         PAT bgpat;
1639         <%- if self.is_attr_scrollable() -%>
1640         hmi_windowscroll_t wscr;
1641         <%- end -%>
1642         <%- if !self.is_attr_alwaysopen() -%>
1643         TC title[<%= self.get_window_title_max_length() %>+1];
1644         <%- end -%>
1645         WEVENT savedwev;
1646         <%- @parts.each do |p| -%><%= p.generate_source_struct(self.struct_name()) %><%- end -%>
1647 };
1648
1649     EOS
1650
1651     erb = ERB.new(script, nil, '-');
1652     erb.result(binding)
1653   end
1654
1655   def generate_source_functions(main_name)
1656     script = <<-EOS
1657 <%- if self.is_need_flag() -%>
1658 #define <%= self.struct_name().upcase %>_FLAG_DRAWREQUEST 0x00000001
1659 <%- if self.is_attr_scrollable() -%>
1660 #define <%= self.struct_name().upcase %>_FLAG_RSCROLLING 0x00000002
1661 #define <%= self.struct_name().upcase %>_FLAG_BSCROLLING 0x00000004
1662 <%- end -%>
1663 <%- if self.is_exist_eventbreak_parts -%>
1664 #define <%= self.struct_name().upcase %>_FLAG_PARTS_OTHEREVENT 0x0000000f
1665 #define <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION 0x00000010
1666 <%- end -%>
1667
1668 #define <%= self.struct_name() %>_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
1669 #define <%= self.struct_name() %>_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
1670 #define <%= self.struct_name() %>_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
1671
1672 <%- end -%>
1673 <%- @parts.each do |p| -%><%= p.generate_source_functions(main_name, self.struct_name()) %><%- end -%>
1674 <%- if self.is_attr_scrollable() -%>
1675 EXPORT VOID <%= self.struct_name() %>_scrollbyvalue(<%= self.struct_name() %>_t *window, W dh, W dv)
1676 {
1677         hmi_windowscroll_scrollworkrect(&window->wscr, dh, dv);
1678 }
1679
1680 EXPORT W <%= self.struct_name() %>_setdrawrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b)
1681 {
1682         return hmi_windowscroll_setdrawrect(&window->wscr, l, t, r, b);
1683 }
1684
1685 EXPORT W <%= self.struct_name() %>_setworkrect(<%= self.struct_name() %>_t *window, W l, W t, W r, W b)
1686 {
1687         return hmi_windowscroll_setworkrect(&window->wscr, l, t, r, b);
1688 }
1689
1690 EXPORT W <%= self.struct_name() %>_scrollworkarea(<%= self.struct_name() %>_t *window, W dh, W dv)
1691 {
1692         W err;
1693         err = wscr_wnd(window->wid, NULL, dh, dv, W_MOVE|W_RDSET);
1694         if (err < 0) {
1695                 return err;
1696         }
1697         if ((err & W_RDSET) != 0) {
1698                 <%= self.struct_name() %>_setflag(window, <%= self.struct_name().upcase %>_FLAG_DRAWREQUEST);
1699         }
1700         return 0;
1701 }
1702
1703 EXPORT W <%= self.struct_name() %>_getworkrect(<%= self.struct_name() %>_t *window, RECT *r)
1704 {
1705         return wget_wrk(window->wid, r);
1706 }
1707
1708 <%- end -%>
1709 <%- if self.is_attr_opencheckable() -%>
1710 EXPORT Bool <%= self.struct_name() %>_isopen(<%= self.struct_name() %>_t *window)
1711 {
1712         if (window->wid < 0) {
1713                 return False;
1714         }
1715         return True;
1716 }
1717
1718 <%- end -%>
1719 <%- if self.is_exportevent_paste() -%>
1720 EXPORT VOID <%= self.struct_name() %>_responsepasterequest(<%= self.struct_name() %>_t *window, W nak, PNT *pos)
1721 {
1722         if (pos != NULL) {
1723                 window->savedwev.r.r.p.rightbot.x = pos->x;
1724                 window->savedwev.r.r.p.rightbot.y = pos->y;
1725         }
1726         wrsp_evt(&window->savedwev, nak);
1727 }
1728
1729 <%- end -%>
1730 <%- if self.is_exportevent_draw() -%>
1731 EXPORT W <%= self.struct_name() %>_startredisp(<%= self.struct_name() %>_t *window, RECT *r)
1732 {
1733         return wsta_dsp(window->wid, r, NULL);
1734 }
1735
1736 EXPORT W <%= self.struct_name() %>_endredisp(<%= self.struct_name() %>_t *window)
1737 {
1738         return wend_dsp(window->wid);
1739 }
1740
1741 EXPORT W <%= self.struct_name() %>_eraseworkarea(<%= self.struct_name() %>_t *window, RECT *r)
1742 {
1743         return wera_wnd(window->wid, r);
1744 }
1745
1746 <%- else -%>
1747 LOCAL VOID <%= self.struct_name() %>_draw(<%= self.struct_name() %>_t *window, RECT *r)
1748 {
1749         cdsp_pwd(window->wid, r, P_RDISP);
1750         <%- @parts.each do |p| -%><%= p.generate_draw_in_draw(main_name, self.struct_name()) %><%- end -%>
1751 }
1752
1753 LOCAL VOID <%= self.struct_name() %>_redisp(<%= self.struct_name() %>_t *window)
1754 {
1755         RECT r;
1756         do {
1757                 if (wsta_dsp(window->wid, &r, NULL) == 0) {
1758                         break;
1759                 }
1760                 wera_wnd(window->wid, &r);
1761                 <%= self.struct_name() %>_draw(window, &r);
1762         } while (wend_dsp(window->wid) > 0);
1763 }
1764
1765 <%- end -%>
1766 EXPORT W <%= self.struct_name() %>_requestredisp(<%= self.struct_name() %>_t *window)
1767 {
1768         return wreq_dsp(window->wid);
1769 }
1770
1771 <%- if self.is_exportevent_butdn() -%>
1772 EXPORT GID <%= self.struct_name() %>_startdrag(<%= self.struct_name() %>_t *window)
1773 {
1774         return wsta_drg(window->wid, 0);
1775 }
1776
1777 EXPORT W <%= self.struct_name() %>_getdrag(<%= self.struct_name() %>_t *window, PNT *pos, WID *wid, PNT *pos_butup)
1778 {
1779         W etype;
1780
1781         etype = wget_drg(pos, &window->savedwev);
1782         *wid = window->savedwev.s.wid;
1783         if (etype == EV_BUTUP) {
1784                 *pos_butup = window->savedwev.s.pos;
1785         }
1786
1787         return etype;
1788 }
1789
1790 EXPORT VOID <%= self.struct_name() %>_enddrag(<%= self.struct_name() %>_t *window)
1791 {
1792         wend_drg();
1793 }
1794
1795 <%- end -%>
1796 EXPORT GID <%= self.struct_name() %>_getGID(<%= self.struct_name() %>_t *window)
1797 {
1798         return wget_gid(window->wid);
1799 }
1800
1801 EXPORT WID <%= self.struct_name() %>_getWID(<%= self.struct_name() %>_t *window)
1802 {
1803         return window->wid;
1804 }
1805
1806 EXPORT W <%= self.struct_name() %>_settitle(<%= self.struct_name() %>_t *window, TC *title)
1807 {
1808         <%- if !self.is_attr_alwaysopen() -%>
1809         tc_strncpy(window->title, title, <%= self.get_window_title_max_length() %>);
1810         window->title[<%= self.get_window_title_max_length() %>] = TNULL;
1811         return wset_tit(window->wid, -1, window->title, 0);
1812         <%- else -%>
1813         return wset_tit(window->wid, -1, title, 0);
1814         <%- end -%>
1815 }
1816
1817 EXPORT Bool <%= self.struct_name() %>_isactive(<%= self.struct_name() %>_t *window)
1818 {
1819         WID wid;
1820         wid = wget_act(NULL);
1821         if (window->wid == wid) {
1822                 return True;
1823         }
1824         return False;
1825 }
1826
1827 LOCAL VOID <%= self.struct_name() %>_butdnwork(<%= self.struct_name() %>_t *window, WEVENT *wev, <%= main_name %>event_t *evt)
1828 {
1829         <%- if self.is_exist_controllparts() -%>
1830         PAID id;
1831         W ret;
1832
1833         ret = cfnd_par(window->wid, wev->s.pos, &id);
1834         if (ret <= 0) {
1835                 return;
1836         }
1837         <%- @parts.each do |p| -%><%= p.generate_action_in_butdnwork(main_name, self.struct_name()) %><%- end -%>
1838         <%- end -%>
1839         <%- if self.is_exportevent_butdn() -%>
1840         evt->type = <%= main_name.upcase %>EVENT_TYPE_<%= self.struct_name().upcase %>_BUTDN;
1841         evt->data.<%= self.struct_name() %>_butdn.type = wchk_dck(wev->s.time);
1842         evt->data.<%= self.struct_name() %>_butdn.pos = wev->s.pos;
1843         memcpy(&window->savedwev, wev, sizeof(WEVENT));
1844         <%- end -%>
1845 }
1846
1847 <%- if self.is_attr_resizable() -%>
1848 LOCAL VOID <%= self.struct_name() %>_resize(<%= self.struct_name() %>_t *window, SIZE *sz)
1849 {
1850         RECT work;
1851         Bool workchange = False;
1852
1853         wget_wrk(window->wid, &work);
1854         if (work.c.left != 0) {
1855                 work.c.left = 0;
1856                 workchange = True;
1857         }
1858         if (work.c.top != 0) {
1859                 work.c.top = 0;
1860                 workchange = True;
1861         }
1862         wset_wrk(window->wid, &work);
1863         gset_vis(window->gid, work);
1864
1865         if (workchange == True) {
1866                 wera_wnd(window->wid, NULL);
1867                 wreq_dsp(window->wid);
1868         }
1869
1870         sz->v = work.c.bottom - work.c.top;
1871         sz->h = work.c.right - work.c.left;
1872 }
1873
1874 <%- end -%>
1875 <% 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 %>)
1876 {
1877         WID wid;
1878         <%- if self.is_exist_use_rect_in_open() -%>
1879         RECT r;
1880         <%- end -%>
1881
1882         if (window->wid > 0) {
1883                 return 0;
1884         }
1885
1886         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);
1887         if (wid < 0) {
1888                 DP_ER("wopn_wnd: subjectoption error", wid);
1889                 return wid;
1890         }
1891         window->wid = wid;
1892         window->gid = wget_gid(wid);
1893         <%- if self.is_attr_scrollable() -%>
1894         hmi_windowscroll_settarget(&window->wscr, wid);
1895         <%- end -%>
1896
1897         <%- @parts.each do |p| -%><%= p.generate_create_in_open() %><%- end -%>
1898
1899         wreq_dsp(wid);
1900
1901         return 0;
1902 }
1903
1904 <%- if !self.is_attr_alwaysopen() -%>
1905 EXPORT VOID <%= self.struct_name() %>_close(<%= self.struct_name() %>_t *window)
1906 {
1907         WDSTAT stat;
1908         W err;
1909
1910         if (window->wid < 0) {
1911                 return;
1912         }
1913
1914         stat.attr = WA_STD;
1915         err = wget_sts(window->wid, &stat, NULL);
1916         if (err >= 0) {
1917                 window->r = stat.r;
1918         }
1919         <%- @parts.reverse_each do |p| -%><%= p.generate_savevalue_in_close() %><%- end -%>
1920         <%- if self.is_exist_controllparts() -%>
1921         cdel_pwd(window->wid, NOCLR);
1922         <%- end -%>
1923         wcls_wnd(window->wid, CLR);
1924         window->wid = -1;
1925         window->gid = -1;
1926 }
1927
1928 <%- end -%>
1929     EOS
1930
1931     erb = ERB.new(script, nil, '-');
1932     erb.result(binding)
1933   end
1934
1935   def generate_checkpartsflag_in_checkflag(main_name)
1936     script = <<-EOS
1937         <%- if self.is_exist_eventbreak_parts() -%>
1938         if (<%= self.struct_name() %>_issetflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_OTHEREVENT) == True) {
1939                 <%= self.struct_name() %>_clearflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_OTHEREVENT);
1940                 <%= self.struct_name() %>_setflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION);
1941                 return False;
1942         } else if (<%= self.struct_name() %>_issetflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION) == True) {
1943                 <%= self.struct_name() %>_clearflag(hmi-><%= self.struct_name() %>, <%= self.struct_name().upcase %>_FLAG_PARTS_NEXTACTION);
1944         <%- self.parts.each do |p| -%>
1945         <%- if p.is_need_eventbreak() -%>
1946                 if (hmi-><%= self.struct_name() %>-><%= p.name() %>.nextaction == True) {
1947                         hmi->wev.s.type = EV_NULL;
1948                         <%= self.struct_name() %>_action<%= p.name() %>(hmi-><%= self.struct_name() %>, &hmi->wev, &hmi->evt);
1949                         return True;
1950                 }
1951         <%- end -%>
1952         <%- end -%>
1953         }
1954         <%- end -%>
1955     EOS
1956
1957     erb = ERB.new(script, nil, '-');
1958     erb.result(binding)
1959   end
1960
1961   def generate_new_del_functions()
1962     script = <<-EOS
1963 EXPORT <%= self.struct_name() %>_t* <%= self.struct_name() %>_new(<%= self.generate_initialize_arguments() %>)
1964 {
1965         <%= self.struct_name() %>_t *window;
1966         <%- if self.is_attr_scrollable() -%>
1967         W err;
1968         <%- end -%>
1969
1970         window = (<%= self.struct_name() %>_t*)malloc(sizeof(<%= self.struct_name() %>_t));
1971         if (window == NULL) {
1972                 return NULL;
1973         }
1974         <%- if self.is_attr_scrollable() -%>
1975         window->flag = 0;
1976         <%- end -%>
1977         window->wid = -1;
1978         window->gid = -1;
1979         window->parent = parent;
1980         <%- if self.is_attr_resizable() -%>
1981         window->r = *r;
1982         <%- else -%>
1983         window->r.c.left = p->x;
1984         window->r.c.top = p->y;
1985         window->r.c.right = p->x + <%= self.get_window_width() %>;
1986         window->r.c.bottom = p->y + <%= self.get_window_height() %>;
1987         <%- end -%>
1988         <%- if self.is_attr_scrollable() -%>
1989         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
1990         if (err < 0) {
1991                 free(window);
1992                 return NULL;
1993         }
1994         <%- end -%>
1995         <%- if !self.is_attr_alwaysopen() -%>
1996         tc_strset(window->title, TNULL, <%= self.get_window_title_max_length() %>+1);
1997         if (title != 0) {
1998                 tc_strncpy(window->title, title, <%= self.get_window_title_max_length() %>);
1999         } else {
2000                 <%- l = 0 -%>
2001                 <%- conv_euc_to_TCArray(self.get_window_title()).each do |ch| -%>
2002                 window->title[<%= l %>] = 0x<%= ch.to_s(16) %>;<%- l+=1 %>
2003                 <%- end -%>
2004         }
2005         <%- end -%>
2006         <%- @parts.each do |p| -%><%= p.generate_initialize_in_new() %><%- end -%>
2007
2008         <%- if self.is_attr_alwaysopen() -%>
2009         err = <%= self.struct_name() %>_open(window, title);
2010         if (err < 0) {
2011                 <%- if self.is_attr_scrollable() -%>
2012                 hmi_windowscroll_finalize(&window->wscr);
2013                 <%- end -%>
2014                 free(window);
2015                 return NULL;
2016         }
2017         <%- end -%>
2018
2019         return window;
2020 }
2021
2022 LOCAL VOID <%= self.struct_name() %>_delete(<%= self.struct_name() %>_t *window)
2023 {
2024         if (window->wid > 0) {
2025                 <%- if self.is_exist_controllparts() -%>
2026                 cdel_pwd(window->wid, NOCLR);
2027                 <%- end -%>
2028                 wcls_wnd(window->wid, CLR);
2029         }
2030         <%- if self.is_attr_scrollable() -%>
2031         hmi_windowscroll_finalize(&window->wscr);
2032         <%- end -%>
2033         free(window);
2034 }
2035
2036     EOS
2037
2038     erb = ERB.new(script, nil, '-');
2039     erb.result(binding)
2040   end
2041 end
2042
2043 class HMIData
2044   attr_accessor :yaml, :win, :name
2045   def initialize(yaml)
2046     @yaml = yaml;
2047     @win = Array.new();
2048     yaml["windows"].each { |a|
2049       w = HMIWindow.new(a);
2050       @win.push(w);
2051     };
2052   end
2053   def main_name()
2054     @yaml["generator"]["name"]
2055   end
2056   def lisence_header()
2057     @yaml["generator"]["lisence_header"]
2058   end
2059   def lisence_source()
2060     @yaml["generator"]["lisence_source"]
2061   end
2062   def filename_header()
2063     @yaml["generator"]["output_header"]
2064   end
2065
2066   def generate_header_eventtype_enumulate()
2067     script = <<-EOS
2068 enum {
2069         <%= self.main_name().upcase %>EVENT_TYPE_NONE,
2070         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MOUSEMOVE,
2071         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_KEYDOWN,
2072         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MENU,
2073         <%= self.main_name().upcase %>EVENT_TYPE_COMMON_TIMEOUT,
2074         <%- @win.each do |w| -%><%= w.generate_header_eventtype_enumulate(self.main_name()) %><%- end -%>
2075 };
2076     EOS
2077
2078     erb = ERB.new(script, nil, '-');
2079     erb.result(binding)
2080   end
2081   def generate_header_eventtype_struct()
2082     script = <<-EOS
2083 struct <%= self.main_name() %>_eventdata_mousemove_t_ {
2084         PNT pos;
2085 };
2086 typedef struct <%= self.main_name() %>_eventdata_mousemove_t_ <%= self.main_name() %>_eventdata_mousemove_t;
2087
2088 struct <%= self.main_name() %>_eventdata_keydown_t_ {
2089         TC keycode;
2090         UH keytop;
2091         UW stat;
2092 };
2093 typedef struct <%= self.main_name() %>_eventdata_keydown_t_ <%= self.main_name() %>_eventdata_keydown_t;
2094
2095 struct <%= self.main_name() %>_eventdata_menu_t_ {
2096         PNT pos;
2097 };
2098 typedef struct <%= self.main_name() %>_eventdata_menu_t_ <%= self.main_name() %>_eventdata_menu_t;
2099
2100 struct <%= self.main_name() %>_eventdata_timeout_t_ {
2101         W code;
2102 };
2103 typedef struct <%= self.main_name() %>_eventdata_timeout_t_ <%= self.main_name() %>_eventdata_timeout_t;
2104
2105 <%- @win.each do |w| -%>
2106 <%- if w.is_exportevent_draw() -%>
2107 struct <%= w.struct_name() %>_eventdata_draw_t_ {
2108 };
2109 typedef struct <%= w.struct_name() %>_eventdata_draw_t_ <%= w.struct_name() %>_eventdata_draw_t;
2110
2111 <%- end -%>
2112 <%- if w.is_attr_resizable() -%>
2113 struct <%= w.struct_name() %>_eventdata_resize_t_ {
2114         SIZE work_sz;
2115 };
2116 typedef struct <%= w.struct_name() %>_eventdata_resize_t_ <%= w.struct_name() %>_eventdata_resize_t;
2117
2118 <%- end -%>
2119 <%- if w.is_exportevent_close() -%>
2120 struct <%= w.struct_name() %>_eventdata_close_t_ {
2121         Bool save;
2122 };
2123 typedef struct <%= w.struct_name() %>_eventdata_close_t_ <%= w.struct_name() %>_eventdata_close_t;
2124
2125 <%- end -%>
2126 <%- if w.is_exportevent_butdn() -%>
2127 struct <%= w.struct_name() %>_eventdata_butdn_t_ {
2128         W type;
2129         PNT pos;
2130 };
2131 typedef struct <%= w.struct_name() %>_eventdata_butdn_t_ <%= w.struct_name() %>_eventdata_butdn_t;
2132
2133 <%- end -%>
2134 <%- if w.is_exportevent_paste() -%>
2135 struct <%= w.struct_name() %>_eventdata_paste_t_ {
2136 };
2137 typedef struct <%= w.struct_name() %>_eventdata_paste_t_ <%= w.struct_name() %>_eventdata_paste_t;
2138
2139 <%- end -%>
2140 <%- if w.is_exportevent_switch() -%>
2141 struct <%= w.struct_name() %>_eventdata_switch_t_ {
2142 };
2143 typedef struct <%= w.struct_name() %>_eventdata_switch_t_ <%= w.struct_name() %>_eventdata_switch_t;
2144
2145 <%- end -%>
2146 <%- if w.is_exportevent_mousemove() -%>
2147 struct <%= w.struct_name() %>_eventdata_mousemove_t_ {
2148         PNT pos;
2149         UW stat;
2150 };
2151 typedef struct <%= w.struct_name() %>_eventdata_mousemove_t_ <%= w.struct_name() %>_eventdata_mousemove_t;
2152
2153 <%- end -%>
2154 <%- if w.is_exportevent_scroll() and w.is_attr_scrollable() -%>
2155 struct <%= w.struct_name() %>_eventdata_scroll_t_ {
2156         W dh;
2157         W dv;
2158 };
2159 typedef struct <%= w.struct_name() %>_eventdata_scroll_t_ <%= w.struct_name() %>_eventdata_scroll_t;
2160
2161 <%- end -%>
2162 <%= w.generate_header_partsevent_struct(self.main_name()) %><%- -%>
2163 <%- end -%>
2164     EOS
2165
2166     erb = ERB.new(script, nil, '-');
2167     erb.result(binding)
2168   end
2169   def generate_header_eventtype_union()
2170     script = <<-EOS
2171 struct <%= self.main_name() %>event_t_ {
2172         W type;
2173         union  {
2174                 <%= self.main_name() %>_eventdata_mousemove_t common_mousemove;
2175                 <%= self.main_name() %>_eventdata_keydown_t common_keydown;
2176                 <%= self.main_name() %>_eventdata_menu_t common_menu;
2177                 <%= self.main_name() %>_eventdata_timeout_t common_timeout;
2178 <%- @win.each do |w| -%>
2179                 <%- if w.is_exportevent_draw() -%>
2180                 <%= w.struct_name() %>_eventdata_draw_t <%= w.struct_name() %>_draw;
2181                 <%- end -%>
2182                 <%- if w.is_attr_resizable() -%>
2183                 <%= w.struct_name() %>_eventdata_resize_t <%= w.struct_name() %>_resize;
2184                 <%- end -%>
2185                 <%- if w.is_exportevent_close() -%>
2186                 <%= w.struct_name() %>_eventdata_close_t <%= w.struct_name() %>_close;
2187                 <%- end -%>
2188                 <%- if w.is_exportevent_butdn() -%>
2189                 <%= w.struct_name() %>_eventdata_butdn_t <%= w.struct_name() %>_butdn;
2190                 <%- end -%>
2191                 <%- if w.is_exportevent_paste() -%>
2192                 <%= w.struct_name() %>_eventdata_paste_t <%= w.struct_name() %>_paste;
2193                 <%- end -%>
2194                 <%- if w.is_exportevent_switch() -%>
2195                 <%= w.struct_name() %>_eventdata_switch_t <%= w.struct_name() %>_switch;
2196                 <%- end -%>
2197                 <%- if w.is_exportevent_mousemove() -%>
2198                 <%= w.struct_name() %>_eventdata_mousemove_t <%= w.struct_name() %>_mousemove;
2199                 <%- end -%>
2200                 <%- if w.is_exportevent_scroll() and w.is_attr_scrollable() -%>
2201                 <%= w.struct_name() %>_eventdata_scroll_t <%= w.struct_name() %>_scroll;
2202                 <%- end -%>
2203                 <%- -%><%= w.generate_header_partsevent_unionmember(self.main_name()) %><%- -%>
2204 <%- end -%>
2205         } data;
2206 };
2207 typedef struct <%= self.main_name() %>event_t_ <%= self.main_name() %>event_t;
2208     EOS
2209
2210     erb = ERB.new(script, nil, '-');
2211     erb.result(binding)
2212   end
2213   def generate_header_main_prototypes()
2214     script = <<-EOS
2215 typedef struct <%= self.main_name() %>_t_ <%= self.main_name() %>_t;
2216
2217 IMPORT <%= self.main_name() %>_t* <%= self.main_name() %>_new();
2218 IMPORT VOID <%= self.main_name() %>_delete(<%= self.main_name() %>_t *hmi);
2219 IMPORT W <%= self.main_name() %>_getevent(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t **evt);
2220 <%- @win.each do |w| -%>
2221 IMPORT <%= w.struct_name() %>_t* <%= self.main_name() %>_new<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.generate_initialize_arguments() %>);
2222 <%- end -%>
2223 <%- @win.each do |w| -%>
2224 IMPORT VOID <%= self.main_name() %>_delete<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.struct_name() %>_t *window);
2225 <%- end -%>
2226     EOS
2227
2228     erb = ERB.new(script, nil, '-');
2229     erb.result(binding)
2230   end
2231
2232   def generate_header()
2233     str = String.new();
2234     @win.each { |w|
2235       str += w.generate_prototypes() + "\n";
2236     };
2237     str += self.generate_header_eventtype_enumulate() + "\n";
2238     str += self.generate_header_eventtype_struct();
2239     str += self.generate_header_eventtype_union() + "\n";
2240     str += self.generate_header_main_prototypes() + "\n";
2241     str;
2242   end
2243
2244   def generate_source_include_files()
2245     script = <<-EOS
2246 #include    "<%= self.filename_header() %>"
2247 #include    "hmi/hmi_windowscroll.h"
2248
2249 #include        <bstdio.h>
2250 #include        <bstdlib.h>
2251 #include        <tcode.h>
2252 #include        <tstring.h>
2253 #include        <btron/btron.h>
2254 #include        <btron/hmi.h>
2255 #include        <btron/vobj.h>
2256
2257 #if 1
2258 # define DP(arg) printf arg
2259 # define DP_ER(msg, err) printf("%s (%d/%x)\\n", msg, err>>16, err)
2260 #else
2261 # define DP(arg) /**/
2262 # define DP_ER(msg, err) /**/
2263 #endif
2264
2265     EOS
2266
2267     erb = ERB.new(script, nil, '-');
2268     erb.result(binding)
2269   end
2270
2271   def generate_source_mainloop_windowid_valuablelist()
2272     script = <<-EOS
2273 <%- @win.each_with_index do |w, idx| -%>
2274 <%= w.struct_name() %>_id<%- if idx != @win.length - 1 -%>, <%- end -%>
2275 <%- end -%>
2276     EOS
2277     erb = ERB.new(script, nil, '-');
2278     erb.result(binding)
2279   end
2280
2281   def generate_source_mainloop()
2282     script = <<-EOS
2283 LOCAL VOID <%= self.main_name() %>_setswitchbutdnflag(<%= self.main_name() %>_t *hmi)
2284 {
2285         hmi->flag = hmi->flag | <%= self.main_name().upcase %>_FLAG_SWITCHBUTDN;
2286 }
2287
2288 LOCAL VOID <%= self.main_name() %>_clearswitchbutdnflag(<%= self.main_name() %>_t *hmi)
2289 {
2290         hmi->flag = hmi->flag & ~<%= self.main_name().upcase %>_FLAG_SWITCHBUTDN;
2291 }
2292
2293 LOCAL Bool <%= self.main_name() %>_issetswitchbutdnflag(<%= self.main_name() %>_t *hmi)
2294 {
2295         if ((hmi->flag & <%= self.main_name().upcase %>_FLAG_SWITCHBUTDN) == 0) {
2296                 return False;
2297         }
2298         return True;
2299 }
2300
2301 <%- @win.each do |w| -%>
2302 LOCAL Bool <%= self.main_name() %>_is<%= w.struct_name() %>WID(<%= self.main_name() %>_t *hmi, WID wid)
2303 {
2304         if (hmi-><%= w.struct_name() %>->wid == wid) {
2305                 return True;
2306         }
2307         return False;
2308 }
2309
2310 <%- end -%>
2311 LOCAL VOID <%= self.main_name() %>_weventnull(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2312 {
2313         cidl_par(wev->s.wid, &wev->s.pos);
2314         if (wev->s.cmd != W_WORK)
2315                 return;         /*ºî¶ÈÎÎ°è³°*/
2316         if (wev->s.stat & ES_CMD)
2317                 return; /*Ì¿Îá¥¡¼¤¬²¡¤µ¤ì¤Æ¤¤¤ë*/
2318 <%- @win.each do |w| -%>
2319         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2320                 <%- if w.is_exist_controllparts() -%>
2321                 cidl_par(wev->s.wid, &wev->s.pos);
2322                 <%- end -%>
2323                 <%- if w.is_exportevent_mousemove() -%>
2324                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_MOUSEMOVE;
2325                 hmi->evt.data.<%= w.struct_name() %>_mousemove.pos = wev->s.pos;
2326                 hmi->evt.data.<%= w.struct_name() %>_mousemove.stat = wev->s.stat;
2327                 <%- elsif !w.is_exist_controllparts() -%>
2328                 gset_ptr(PS_SELECT, NULL, -1, -1);
2329                 <%- end -%>
2330                 return;
2331         }
2332 <%- end -%>
2333         /*¥¦¥£¥ó¥É¥¦³°*/
2334         hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MOUSEMOVE;
2335         hmi->evt.data.common_mousemove.pos = wev->s.pos;
2336 }
2337
2338 LOCAL VOID <%= self.main_name() %>_weventrequest(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2339 {
2340         switch (wev->g.cmd) {
2341         case    W_REDISP:       /*ºÆÉ½¼¨Í×µá*/
2342                 <%- @win.each do |w| -%>
2343                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2344                         <%- if w.is_exportevent_draw() -%>
2345                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2346                         <%- else -%>
2347                         <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2348                         <%- end -%>
2349                         break;
2350                 }
2351                 <%- end -%>
2352                 break;
2353         case    W_PASTE:        /*Å½¹þ¤ßÍ×µá*/
2354                 <%- @win.each do |w| -%>
2355                 <%- if w.is_exportevent_paste() -%>
2356                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2357                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_PASTE;
2358                         memcpy(&hmi-><%= w.struct_name() %>->savedwev, wev, sizeof(WEVENT));
2359                         break;
2360                 }
2361                 <%- end -%>
2362                 <%- end -%>
2363                 wrsp_evt(wev, 1); /*NACK*/
2364                 break;
2365         case    W_DELETE:       /*ÊÝÂ¸½ªÎ»*/
2366                 wrsp_evt(wev, 0);       /*ACK*/
2367                 <%- @win.each do |w| -%>
2368                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2369                         <%- if w.is_exportevent_close() -%>
2370                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_CLOSE;
2371                         evt->data.<%= w.struct_name() %>_close.save = True;
2372                         <%- else -%>
2373                         <%= w.struct_name() %>_close(hmi-><%= w.struct_name() %>);
2374                         <%- end -%>
2375                         break;
2376                 }
2377                 <%- end -%>
2378                 break;
2379         case    W_FINISH:       /*ÇÑ´þ½ªÎ»*/
2380                 wrsp_evt(wev, 0);       /*ACK*/
2381                 <%- @win.each do |w| -%>
2382                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->g.wid) == True) {
2383                         <%- if w.is_exportevent_close() -%>
2384                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_CLOSE;
2385                         evt->data.<%= w.struct_name() %>_close.save = False;
2386                         <%- else -%>
2387                         <%= w.struct_name() %>_close(hmi-><%= w.struct_name() %>);
2388                         <%- end -%>
2389                         break;
2390                 }
2391                 <%- end -%>
2392                 break;
2393         }
2394 }
2395
2396 LOCAL VOID <%= self.main_name() %>_weventbutdn(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2397 {
2398         W i, err;
2399         W dh, dv; /* TODO: add check for exist scrollable window */
2400
2401         switch  (wev->s.cmd) {
2402         case    W_PICT:
2403                 switch (wchk_dck(wev->s.time)) {
2404                 case    W_DCLICK:
2405                         <%- @win.each do |w| -%>
2406                         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2407                                 <%- if w.is_exportevent_close() -%>
2408                                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_CLOSE;
2409                                 evt->data.<%= w.struct_name() %>_close.save = True; /* TODO: tmp value */
2410                                 <%- else -%>
2411                                 <%= w.struct_name() %>_close(hmi-><%= w.struct_name() %>);
2412                                 <%- end -%>
2413                                 return;
2414                         }
2415                         <%- end -%>
2416                         return;
2417                 case    W_PRESS:
2418                         break;
2419                 default:
2420                         return;
2421                 }
2422         case    W_FRAM:
2423         case    W_TITL:
2424                 if (wmov_drg(wev, NULL) > 0) {
2425                         <%- @win.each do |w| -%>
2426                         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2427                                 <%- if w.is_exportevent_draw() -%>
2428                                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2429                                 <%- else -%>
2430                                 <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2431                                 <%- end -%>
2432                                 return;
2433                         }
2434                         <%- end -%>
2435                 }
2436                 return;
2437         case    W_LTHD:
2438         case    W_RTHD:
2439         case    W_LBHD:
2440         case    W_RBHD:
2441                 switch (wchk_dck(wev->s.time)) {
2442                 case    W_DCLICK:
2443                         i = wchg_wnd(wev->s.wid, NULL, W_MOVE);
2444                         break;
2445                 case    W_PRESS:
2446                         i = wrsz_drg(wev, NULL, NULL);
2447                         break;
2448                 default:
2449                         return;
2450                 }
2451
2452                 <%- @win.each do |w| -%>
2453                 <%- if w.is_attr_resizable() -%>
2454                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2455                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_RESIZE;
2456                         <%= w.struct_name() %>_resize(hmi-><%= w.struct_name() %>, &evt->data.<%= w.struct_name() %>_resize.work_sz);
2457                         hmi_windowscroll_updatebar(&hmi-><%= w.struct_name() %>->wscr);
2458                         if (i > 0) {
2459                                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST);
2460                         }
2461                         return;
2462                 }
2463                 <%- end -%>
2464                 <%- end -%>
2465                 return;
2466         case    W_RBAR:
2467                 <%- @win.each do |w| -%>
2468                 <%- if w.is_attr_scrollable() -%>
2469                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2470                         err = hmi_windowscroll_weventrbar(&hmi-><%= w.struct_name() %>->wscr, wev, &dh, &dv);
2471                         if (err < 0) {
2472                                 return;
2473                         }
2474                         if (err == 0) {
2475                                 <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2476                         } else {
2477                                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2478                         }
2479                         <%- if w.is_exportevent_scroll() -%>
2480                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2481                         evt->data.<%= w.struct_name() %>_scroll.dh = dh;
2482                         evt->data.<%= w.struct_name() %>_scroll.dv = dv;
2483                         <%- end -%>
2484                         return;
2485                 }
2486                 <%- end -%>
2487                 <%- end -%>
2488                 return;
2489         case    W_BBAR:
2490                 <%- @win.each do |w| -%>
2491                 <%- if w.is_attr_scrollable() -%>
2492                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2493                         err = hmi_windowscroll_weventbbar(&hmi-><%= w.struct_name() %>->wscr, wev, &dh, &dv);
2494                         if (err < 0) {
2495                                 return;
2496                         }
2497                         if (err == 0) {
2498                                 <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2499                         } else {
2500                                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2501                         }
2502                         <%- if w.is_exportevent_scroll() -%>
2503                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2504                         evt->data.<%= w.struct_name() %>_scroll.dh = dh;
2505                         evt->data.<%= w.struct_name() %>_scroll.dv = dv;
2506                         <%- end -%>
2507                         return;
2508                 }
2509                 <%- end -%>
2510                 <%- end -%>
2511                 return;
2512         case    W_WORK:
2513                 <%- @win.each do |w| -%>
2514                 if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2515                         <%= w.struct_name() %>_butdnwork(hmi-><%= w.struct_name() %>, wev, evt);
2516                         return;
2517                 }
2518                 <%- end -%>
2519                 return;
2520         }
2521
2522         return;
2523 }
2524
2525 LOCAL VOID <%= self.main_name() %>_weventswitch(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2526 {
2527         <%= self.main_name() %>_setswitchbutdnflag(hmi);
2528         <%- @win.each do |w| -%>
2529         <%- if w.is_exportevent_switch() -%>
2530         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2531                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SWITCH;
2532                 return;
2533         }
2534         <%- end -%>
2535         <%- end -%>
2536 }
2537
2538 LOCAL VOID <%= self.main_name() %>_weventreswitch(<%= self.main_name() %>_t *hmi, WEVENT *wev, <%= self.main_name() %>event_t *evt)
2539 {
2540         <%= self.main_name() %>_setswitchbutdnflag(hmi);
2541         <%- @win.each do |w| -%>
2542         if (<%= self.main_name() %>_is<%= w.struct_name() %>WID(hmi, wev->s.wid) == True) {
2543                 <%- if w.is_exportevent_switch() -%>
2544                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SWITCH;
2545                 <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST);
2546                 return;
2547                 <%- else -%>
2548                 <%- if w.is_exportevent_draw() -%>
2549                 evt->type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2550                 <%- else -%>
2551                 <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2552                 return;
2553                 <%- end -%>
2554                 <%- end -%>
2555         }
2556         <%- end -%>
2557 }
2558
2559 LOCAL VOID <%= self.main_name() %>_receivemessage(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t *evt)
2560 {
2561         MESSAGE msg;
2562         W err;
2563
2564         err = rcv_msg(MM_ALL, &msg, sizeof(MESSAGE), WAIT|NOCLR);
2565         if (err >= 0) {
2566                 if (msg.msg_type == MS_TMOUT) { /* should be use other type? */
2567                         evt->type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_TIMEOUT;
2568                         evt->data.common_timeout.code = msg.msg_body.TMOUT.code;
2569                 }
2570         }
2571         clr_msg(MM_ALL, MM_ALL);
2572 }
2573
2574 LOCAL Bool <%= self.main_name() %>_checkflag(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t **evt)
2575 {
2576         W err, dh, dv;
2577
2578         <%- @win.each do |w| -%>
2579         <%- if w.is_need_flag() and w.is_attr_scrollable() -%>
2580         if (<%= w.struct_name() %>_issetflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING) == True) {
2581                 err = hmi_windowscroll_weventrbar(&hmi-><%= w.struct_name() %>->wscr, &hmi->wev, &dh, &dv);
2582                 if (err < 0) {
2583                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2584                         return False;
2585                 }
2586                 if (err == 0) {
2587                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2588                 } else {
2589                         <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_RSCROLLING);
2590                 }
2591                 <%- if w.is_exportevent_scroll() -%>
2592                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2593                 hmi->evt.data.<%= w.struct_name() %>_scroll.dh = dh;
2594                 hmi->evt.data.<%= w.struct_name() %>_scroll.dv = dv;
2595                 <%- end -%>
2596                 return True;
2597         }
2598         if (<%= w.struct_name() %>_issetflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING) == True) {
2599                 err = hmi_windowscroll_weventbbar(&hmi-><%= w.struct_name() %>->wscr, &hmi->wev, &dh, &dv);
2600                 if (err < 0) {
2601                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2602                         return False;
2603                 }
2604                 if (err == 0) {
2605                         <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2606                 } else {
2607                         <%= w.struct_name() %>_setflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_BSCROLLING);
2608                 }
2609                 <%- if w.is_exportevent_scroll() -%>
2610                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_SCROLL;
2611                 hmi->evt.data.<%= w.struct_name() %>_scroll.dh = dh;
2612                 hmi->evt.data.<%= w.struct_name() %>_scroll.dv = dv;
2613                 <%- end -%>
2614                 return True;
2615         }
2616         <%- end -%>
2617         <%- end -%>
2618         <%- @win.each do |w| -%><%= w.generate_checkpartsflag_in_checkflag(self.main_name()) %><%- end -%>
2619
2620         return False;
2621 }
2622
2623 EXPORT W <%= self.main_name() %>_getevent(<%= self.main_name() %>_t *hmi, <%= self.main_name() %>event_t **evt)
2624 {
2625         WEVENT  *wev0;
2626         Bool ok;
2627
2628         hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_NONE;
2629         *evt = &hmi->evt;
2630         wev0 = &hmi->wev;
2631
2632         ok = <%= self.main_name() %>_issetswitchbutdnflag(hmi);
2633         if (ok == True) {
2634                 <%= self.main_name() %>_weventbutdn(hmi, wev0, &hmi->evt);
2635                 <%= self.main_name() %>_clearswitchbutdnflag(hmi);
2636                 return 0;
2637         }
2638
2639         <%- @win.each do |w| -%>
2640         <%- if w.is_need_flag() -%>
2641         if (<%= w.struct_name() %>_issetflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST) == True) {
2642                 <%- if w.is_exportevent_draw() -%>
2643                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_<%= w.struct_name().upcase %>_DRAW;
2644                 <%- else -%>
2645                 <%= w.struct_name() %>_redisp(hmi-><%= w.struct_name() %>);
2646                 <%- end -%>
2647                 <%= w.struct_name() %>_clearflag(hmi-><%= w.struct_name() %>, <%= w.struct_name().upcase %>_FLAG_DRAWREQUEST);
2648                 return 0;
2649         }
2650         <%- end -%>
2651         <%- end -%>
2652
2653         ok = <%= self.main_name() %>_checkflag(hmi, evt);
2654         if (ok == True) {
2655                 return 0;
2656         }
2657
2658         wget_evt(wev0, WAIT);
2659         switch (wev0->s.type) {
2660         case    EV_NULL:
2661                 <%= self.main_name() %>_weventnull(hmi, wev0, &hmi->evt);
2662                 break;
2663         case    EV_REQUEST:
2664                 <%= self.main_name() %>_weventrequest(hmi, wev0, &hmi->evt);
2665                 break;
2666         case    EV_RSWITCH:
2667                 <%= self.main_name() %>_weventreswitch(hmi, wev0, &hmi->evt);
2668                 break;
2669         case    EV_SWITCH:
2670                 <%= self.main_name() %>_weventswitch(hmi, wev0, &hmi->evt);
2671                 break;
2672         case    EV_BUTDWN:
2673                 <%= self.main_name() %>_weventbutdn(hmi, wev0, &hmi->evt);
2674                 break;
2675         case    EV_KEYDWN:
2676         case    EV_AUTKEY:
2677                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_KEYDOWN;
2678                 hmi->evt.data.common_keydown.keycode = wev0->e.data.key.code;
2679                 hmi->evt.data.common_keydown.keytop = wev0->e.data.key.keytop;
2680                 hmi->evt.data.common_keydown.stat = wev0->e.stat;
2681                 break;
2682         case    EV_INACT:
2683                 pdsp_msg(NULL);
2684                 break;
2685         case    EV_DEVICE:
2686                 oprc_dev(&wev0->e, NULL, 0);
2687                 break;
2688         case    EV_MSG:
2689                 <%= self.main_name() %>_receivemessage(hmi, &hmi->evt);
2690                 break;
2691         case    EV_MENU:
2692                 hmi->evt.type = <%= self.main_name().upcase %>EVENT_TYPE_COMMON_MENU;
2693                 hmi->evt.data.common_menu.pos = wev0->s.pos;
2694                 break;
2695         }
2696
2697         return 0;
2698 }
2699
2700     EOS
2701
2702     erb = ERB.new(script, nil, '-');
2703     erb.result(binding)
2704   end
2705
2706   def generate_struct()
2707     str = String.new();
2708     @win.each { |w|
2709       str += w.generate_source_struct();
2710     };
2711     script = <<-EOS
2712 #define <%= self.main_name().upcase %>_FLAG_SWITCHBUTDN 0x00000001
2713
2714 struct <%= self.main_name() %>_t_ {
2715         WEVENT wev;
2716         <%= self.main_name() %>event_t evt;
2717         UW flag;
2718         <%- @win.each do |w| -%>
2719         <%= w.struct_name() %>_t *<%= w.struct_name() %>;
2720         <%- end -%>
2721 };
2722
2723     EOS
2724     erb = ERB.new(script, nil, '-');
2725     str += erb.result(binding)
2726   end
2727
2728   def generate_windowfunctions()
2729     str = String.new();
2730     @win.each { |w|
2731       str += w.generate_source_functions(self.main_name());
2732     };
2733     str;
2734   end
2735
2736   def generate_source_new_del_wrappers()
2737     script = <<-EOS
2738 <%- @win.each do |w| -%>
2739 EXPORT <%= w.struct_name() %>_t* <%= self.main_name() %>_new<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.generate_initialize_arguments() %>)
2740 {
2741         <%- if w.is_attr_subwindow -%>
2742         if (parent == NULL) {
2743                 return NULL;
2744         }
2745         <%- end -%>
2746         if (hmi-><%= w.struct_name() %> != NULL) {
2747                 return NULL;
2748         }
2749         hmi-><%= w.struct_name() %> = <%= w.struct_name() %>_new(<%= w.generate_initialize_arguments_values() %>);
2750         return hmi-><%= w.struct_name() %>;
2751 }
2752
2753 EXPORT VOID <%= self.main_name() %>_delete<%= w.struct_name() %>(<%= self.main_name() %>_t *hmi, <%= w.struct_name() %>_t *window)
2754 {
2755         <%= w.struct_name() %>_delete(hmi-><%= w.struct_name() %>);
2756         hmi-><%= w.struct_name() %> = NULL;
2757 }
2758
2759 <%- end -%>
2760
2761 EXPORT <%= self.main_name() %>_t* <%= self.main_name() %>_new()
2762 {
2763         <%= self.main_name() %>_t *hmi;
2764
2765         hmi = (<%= self.main_name() %>_t *)malloc(sizeof(<%= self.main_name() %>_t));
2766         if (hmi == NULL) {
2767                 return NULL;
2768         }
2769         hmi->flag = 0;
2770         <%- @win.each do |w| -%>
2771         hmi-><%= w.struct_name() %> = NULL;
2772         <%- end -%>
2773
2774         return hmi;
2775 }
2776
2777 EXPORT VOID <%= self.main_name() %>_delete(<%= self.main_name() %>_t *hmi)
2778 {
2779         <%- @win.each do |w| -%>
2780         if (hmi-><%= w.struct_name() %> != NULL) {
2781                 <%= w.struct_name() %>_delete(hmi-><%= w.struct_name() %>);
2782         }
2783         <%- end -%>
2784         free(hmi);
2785 }
2786     EOS
2787
2788     erb = ERB.new(script, nil, '-');
2789     erb.result(binding)
2790   end
2791
2792   def generate_source_mainfunctions()
2793     str = String.new();
2794     @win.each { |w|
2795       str += w.generate_new_del_functions();
2796     };
2797     str += self.generate_source_new_del_wrappers()
2798     str;
2799   end
2800
2801   def generate_source()
2802     str = String.new();
2803     str += self.generate_struct();
2804     str += self.generate_windowfunctions();
2805     str += self.generate_source_mainloop();
2806     str += self.generate_source_mainfunctions();
2807     str;
2808   end
2809 end
2810
2811 #
2812
2813 def generate_header(filename, data)
2814   fd = File.open(filename, "w");
2815   fd.puts data.lisence_header();
2816   fd.puts <<-EOS
2817
2818 /* This file is automatically generated. */
2819
2820 #include    <basic.h>
2821 #include        <btron/dp.h>
2822 #include        <btron/hmi.h>
2823
2824   EOS
2825   fd.puts "#ifndef __" + filename.upcase.gsub(/\./, '_') + "__";
2826   fd.puts "#define __" + filename.upcase.gsub(/\./, '_') + "__";
2827   fd.puts "\n";
2828   fd.puts data.generate_header();
2829   fd.puts "#endif\n"
2830 end
2831
2832 def generate_source(filename, data)
2833   fd = File.open(filename, "w");
2834   fd.puts data.lisence_source();
2835   fd.puts <<-EOS
2836
2837 /* This file is automatically generated. */
2838
2839   EOS
2840   fd.puts data.generate_source_include_files();
2841
2842   fd.puts data.generate_source();
2843
2844 end
2845
2846 $KCODE = "EUC"
2847
2848 yaml = YAML.load_file(ARGV[0]);
2849 data = HMIData.new(yaml);
2850
2851 fname_header = yaml["generator"]["output_header"]
2852 fname_source = yaml["generator"]["output_source"]
2853
2854 generate_header(fname_header, data);
2855 generate_source(fname_source, data);