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