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