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