src/bchanl_hmi.c

   1 /*
   2  * bchanl_hmi.c
   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
  27 /* This file is automatically generated. */
  28
  29 #include    "bchanl_hmi.h"
  30 #include    "hmi/hmi_windowscroll.h"
  31
  32 #include        <bstdio.h>
  33 #include        <bstdlib.h>
  34 #include        <tcode.h>
  35 #include        <tstring.h>
  36 #include        <btron/btron.h>
  37 #include        <btron/hmi.h>
  38 #include        <btron/vobj.h>
  39
  40 #if 1
  41 # define DP(arg) printf arg
  42 # define DP_ER(msg, err) printf("%s (%d/%x)\n", msg, err>>16, err)
  43 #else
  44 # define DP(arg) /**/
  45 # define DP_ER(msg, err) /**/
  46 #endif
  47
  48 struct subjectwindow_t_ {
  49         UW flag;
  50         WID wid;
  51         GID gid;
  52         WID parent;
  53         RECT r;
  54         PAT bgpat;
  55         hmi_windowscroll_t wscr;
  56         WEVENT savedwev;
  57 };
  58
  59 struct bbsmenuwindow_t_ {
  60         UW flag;
  61         WID wid;
  62         GID gid;
  63         WID parent;
  64         RECT r;
  65         PAT bgpat;
  66         hmi_windowscroll_t wscr;
  67         WEVENT savedwev;
  68 };
  69
  70 struct subjectoptionwindow_t_ {
  71         UW flag;
  72         WID wid;
  73         GID gid;
  74         subjectwindow_t *parent;
  75         RECT r;
  76         PAT bgpat;
  77         TC title[256+1];
  78         WEVENT savedwev;
  79         struct {
  80                 PAID id;
  81                 W dnum;
  82                 TC buf[1000+7+1];
  83                 W buf_written;
  84                 Bool appended;
  85                 Bool nextaction;
  86         } filter;
  87         struct {
  88                 PAID id;
  89                 W dnum;
  90                 SUBJECTOPTIONWINDOW_ORDERVALUE_T value;
  91         } order;
  92         struct {
  93                 PAID id;
  94                 W dnum;
  95                 SUBJECTOPTIONWINDOW_ORDERBYVALUE_T value;
  96         } orderby;
  97 };
  98
  99 struct registerexternalwindow_t_ {
 100         UW flag;
 101         WID wid;
 102         GID gid;
 103         WID parent;
 104         RECT r;
 105         PAT bgpat;
 106         TC title[256+1];
 107         WEVENT savedwev;
 108         struct {
 109                 PAID id;
 110
 111                 TC buf[1000+7+1];
 112                 W buf_written;
 113                 Bool appended;
 114                 Bool nextaction;
 115         } boradname;
 116         struct {
 117                 PAID id;
 118
 119                 TC buf[1000+7+1];
 120                 W buf_written;
 121                 Bool appended;
 122                 Bool nextaction;
 123         } url;
 124         struct {
 125                 PAID id;
 126
 127         } determine;
 128         struct {
 129                 PAID id;
 130
 131         } cancel;
 132 };
 133
 134 struct externalbbswindow_t_ {
 135         UW flag;
 136         WID wid;
 137         GID gid;
 138         WID parent;
 139         RECT r;
 140         PAT bgpat;
 141         hmi_windowscroll_t wscr;
 142         TC title[256+1];
 143         WEVENT savedwev;
 144 };
 145
 146 #define BCHANLHMI_FLAG_SWITCHBUTDN 0x00000001
 147
 148 struct bchanlhmi_t_ {
 149         WEVENT wev;
 150         bchanlhmievent_t evt;
 151         UW flag;
 152         subjectwindow_t *subjectwindow;
 153         bbsmenuwindow_t *bbsmenuwindow;
 154         subjectoptionwindow_t *subjectoptionwindow;
 155         registerexternalwindow_t *registerexternalwindow;
 156         externalbbswindow_t *externalbbswindow;
 157 };
 158
 159 #define SUBJECTWINDOW_FLAG_DRAWREQUEST 0x00000001
 160 #define SUBJECTWINDOW_FLAG_RSCROLLING 0x00000002
 161 #define SUBJECTWINDOW_FLAG_BSCROLLING 0x00000004
 162
 163 #define subjectwindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
 164 #define subjectwindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
 165 #define subjectwindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
 166
 167 EXPORT VOID subjectwindow_scrollbyvalue(subjectwindow_t *window, W dh, W dv)
 168 {
 169         hmi_windowscroll_scrollworkrect(&window->wscr, dh, dv);
 170 }
 171
 172 EXPORT W subjectwindow_setdrawrect(subjectwindow_t *window, W l, W t, W r, W b)
 173 {
 174         return hmi_windowscroll_setdrawrect(&window->wscr, l, t, r, b);
 175 }
 176
 177 EXPORT W subjectwindow_setworkrect(subjectwindow_t *window, W l, W t, W r, W b)
 178 {
 179         return hmi_windowscroll_setworkrect(&window->wscr, l, t, r, b);
 180 }
 181
 182 EXPORT W subjectwindow_scrollworkarea(subjectwindow_t *window, W dh, W dv)
 183 {
 184         W err;
 185         err = wscr_wnd(window->wid, NULL, dh, dv, W_MOVE|W_RDSET);
 186         if (err < 0) {
 187                 return err;
 188         }
 189         if ((err & W_RDSET) != 0) {
 190                 subjectwindow_setflag(window, SUBJECTWINDOW_FLAG_DRAWREQUEST);
 191         }
 192         return 0;
 193 }
 194
 195 EXPORT W subjectwindow_getworkrect(subjectwindow_t *window, RECT *r)
 196 {
 197         return wget_wrk(window->wid, r);
 198 }
 199
 200 EXPORT VOID subjectwindow_responsepasterequest(subjectwindow_t *window, W nak, PNT *pos)
 201 {
 202         if (pos != NULL) {
 203                 window->savedwev.r.r.p.rightbot.x = pos->x;
 204                 window->savedwev.r.r.p.rightbot.y = pos->y;
 205         }
 206         wrsp_evt(&window->savedwev, nak);
 207 }
 208
 209 EXPORT W subjectwindow_startredisp(subjectwindow_t *window, RECT *r)
 210 {
 211         return wsta_dsp(window->wid, r, NULL);
 212 }
 213
 214 EXPORT W subjectwindow_endredisp(subjectwindow_t *window)
 215 {
 216         return wend_dsp(window->wid);
 217 }
 218
 219 EXPORT W subjectwindow_eraseworkarea(subjectwindow_t *window, RECT *r)
 220 {
 221         return wera_wnd(window->wid, r);
 222 }
 223
 224 EXPORT W subjectwindow_requestredisp(subjectwindow_t *window)
 225 {
 226         return wreq_dsp(window->wid);
 227 }
 228
 229 EXPORT GID subjectwindow_startdrag(subjectwindow_t *window)
 230 {
 231         return wsta_drg(window->wid, 0);
 232 }
 233
 234 EXPORT W subjectwindow_getdrag(subjectwindow_t *window, PNT *pos, WID *wid, PNT *pos_butup)
 235 {
 236         W etype;
 237
 238         etype = wget_drg(pos, &window->savedwev);
 239         *wid = window->savedwev.s.wid;
 240         if (etype == EV_BUTUP) {
 241                 *pos_butup = window->savedwev.s.pos;
 242         }
 243
 244         return etype;
 245 }
 246
 247 EXPORT VOID subjectwindow_enddrag(subjectwindow_t *window)
 248 {
 249         wend_drg();
 250 }
 251
 252 EXPORT GID subjectwindow_getGID(subjectwindow_t *window)
 253 {
 254         return wget_gid(window->wid);
 255 }
 256
 257 EXPORT WID subjectwindow_getWID(subjectwindow_t *window)
 258 {
 259         return window->wid;
 260 }
 261
 262 EXPORT W subjectwindow_settitle(subjectwindow_t *window, TC *title)
 263 {
 264         return wset_tit(window->wid, -1, title, 0);
 265 }
 266
 267 EXPORT Bool subjectwindow_isactive(subjectwindow_t *window)
 268 {
 269         WID wid;
 270         wid = wget_act(NULL);
 271         if (window->wid == wid) {
 272                 return True;
 273         }
 274         return False;
 275 }
 276
 277 LOCAL VOID subjectwindow_butdnwork(subjectwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 278 {
 279         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_BUTDN;
 280         evt->data.subjectwindow_butdn.type = wchk_dck(wev->s.time);
 281         evt->data.subjectwindow_butdn.pos = wev->s.pos;
 282         memcpy(&window->savedwev, wev, sizeof(WEVENT));
 283 }
 284
 285 LOCAL VOID subjectwindow_resize(subjectwindow_t *window, SIZE *sz)
 286 {
 287         RECT work;
 288         Bool workchange = False;
 289
 290         wget_wrk(window->wid, &work);
 291         if (work.c.left != 0) {
 292                 work.c.left = 0;
 293                 workchange = True;
 294         }
 295         if (work.c.top != 0) {
 296                 work.c.top = 0;
 297                 workchange = True;
 298         }
 299         wset_wrk(window->wid, &work);
 300         gset_vis(window->gid, work);
 301
 302         if (workchange == True) {
 303                 wera_wnd(window->wid, NULL);
 304                 wreq_dsp(window->wid);
 305         }
 306
 307         sz->v = work.c.bottom - work.c.top;
 308         sz->h = work.c.right - work.c.left;
 309 }
 310
 311 LOCAL W subjectwindow_open(subjectwindow_t *window, TC *title)
 312 {
 313         WID wid;
 314
 315         if (window->wid > 0) {
 316                 return 0;
 317         }
 318
 319         wid = wopn_wnd(WA_STD|WA_SIZE|WA_HHDL|WA_VHDL|WA_BBAR|WA_RBAR, window->parent, &(window->r), NULL, 2, title, &window->bgpat, NULL);
 320         if (wid < 0) {
 321                 DP_ER("wopn_wnd: subjectoption error", wid);
 322                 return wid;
 323         }
 324         window->wid = wid;
 325         window->gid = wget_gid(wid);
 326         hmi_windowscroll_settarget(&window->wscr, wid);
 327
 328
 329         wreq_dsp(wid);
 330
 331         return 0;
 332 }
 333
 334 #define BBSMENUWINDOW_FLAG_DRAWREQUEST 0x00000001
 335 #define BBSMENUWINDOW_FLAG_RSCROLLING 0x00000002
 336 #define BBSMENUWINDOW_FLAG_BSCROLLING 0x00000004
 337
 338 #define bbsmenuwindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
 339 #define bbsmenuwindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
 340 #define bbsmenuwindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
 341
 342 EXPORT VOID bbsmenuwindow_scrollbyvalue(bbsmenuwindow_t *window, W dh, W dv)
 343 {
 344         hmi_windowscroll_scrollworkrect(&window->wscr, dh, dv);
 345 }
 346
 347 EXPORT W bbsmenuwindow_setdrawrect(bbsmenuwindow_t *window, W l, W t, W r, W b)
 348 {
 349         return hmi_windowscroll_setdrawrect(&window->wscr, l, t, r, b);
 350 }
 351
 352 EXPORT W bbsmenuwindow_setworkrect(bbsmenuwindow_t *window, W l, W t, W r, W b)
 353 {
 354         return hmi_windowscroll_setworkrect(&window->wscr, l, t, r, b);
 355 }
 356
 357 EXPORT W bbsmenuwindow_scrollworkarea(bbsmenuwindow_t *window, W dh, W dv)
 358 {
 359         W err;
 360         err = wscr_wnd(window->wid, NULL, dh, dv, W_MOVE|W_RDSET);
 361         if (err < 0) {
 362                 return err;
 363         }
 364         if ((err & W_RDSET) != 0) {
 365                 bbsmenuwindow_setflag(window, BBSMENUWINDOW_FLAG_DRAWREQUEST);
 366         }
 367         return 0;
 368 }
 369
 370 EXPORT W bbsmenuwindow_getworkrect(bbsmenuwindow_t *window, RECT *r)
 371 {
 372         return wget_wrk(window->wid, r);
 373 }
 374
 375 EXPORT W bbsmenuwindow_startredisp(bbsmenuwindow_t *window, RECT *r)
 376 {
 377         return wsta_dsp(window->wid, r, NULL);
 378 }
 379
 380 EXPORT W bbsmenuwindow_endredisp(bbsmenuwindow_t *window)
 381 {
 382         return wend_dsp(window->wid);
 383 }
 384
 385 EXPORT W bbsmenuwindow_eraseworkarea(bbsmenuwindow_t *window, RECT *r)
 386 {
 387         return wera_wnd(window->wid, r);
 388 }
 389
 390 EXPORT W bbsmenuwindow_requestredisp(bbsmenuwindow_t *window)
 391 {
 392         return wreq_dsp(window->wid);
 393 }
 394
 395 EXPORT GID bbsmenuwindow_startdrag(bbsmenuwindow_t *window)
 396 {
 397         return wsta_drg(window->wid, 0);
 398 }
 399
 400 EXPORT W bbsmenuwindow_getdrag(bbsmenuwindow_t *window, PNT *pos, WID *wid, PNT *pos_butup)
 401 {
 402         W etype;
 403
 404         etype = wget_drg(pos, &window->savedwev);
 405         *wid = window->savedwev.s.wid;
 406         if (etype == EV_BUTUP) {
 407                 *pos_butup = window->savedwev.s.pos;
 408         }
 409
 410         return etype;
 411 }
 412
 413 EXPORT VOID bbsmenuwindow_enddrag(bbsmenuwindow_t *window)
 414 {
 415         wend_drg();
 416 }
 417
 418 EXPORT GID bbsmenuwindow_getGID(bbsmenuwindow_t *window)
 419 {
 420         return wget_gid(window->wid);
 421 }
 422
 423 EXPORT WID bbsmenuwindow_getWID(bbsmenuwindow_t *window)
 424 {
 425         return window->wid;
 426 }
 427
 428 EXPORT W bbsmenuwindow_settitle(bbsmenuwindow_t *window, TC *title)
 429 {
 430         return wset_tit(window->wid, -1, title, 0);
 431 }
 432
 433 EXPORT Bool bbsmenuwindow_isactive(bbsmenuwindow_t *window)
 434 {
 435         WID wid;
 436         wid = wget_act(NULL);
 437         if (window->wid == wid) {
 438                 return True;
 439         }
 440         return False;
 441 }
 442
 443 LOCAL VOID bbsmenuwindow_butdnwork(bbsmenuwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 444 {
 445         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_BUTDN;
 446         evt->data.bbsmenuwindow_butdn.type = wchk_dck(wev->s.time);
 447         evt->data.bbsmenuwindow_butdn.pos = wev->s.pos;
 448         memcpy(&window->savedwev, wev, sizeof(WEVENT));
 449 }
 450
 451 LOCAL VOID bbsmenuwindow_resize(bbsmenuwindow_t *window, SIZE *sz)
 452 {
 453         RECT work;
 454         Bool workchange = False;
 455
 456         wget_wrk(window->wid, &work);
 457         if (work.c.left != 0) {
 458                 work.c.left = 0;
 459                 workchange = True;
 460         }
 461         if (work.c.top != 0) {
 462                 work.c.top = 0;
 463                 workchange = True;
 464         }
 465         wset_wrk(window->wid, &work);
 466         gset_vis(window->gid, work);
 467
 468         if (workchange == True) {
 469                 wera_wnd(window->wid, NULL);
 470                 wreq_dsp(window->wid);
 471         }
 472
 473         sz->v = work.c.bottom - work.c.top;
 474         sz->h = work.c.right - work.c.left;
 475 }
 476
 477 LOCAL W bbsmenuwindow_open(bbsmenuwindow_t *window, TC *title)
 478 {
 479         WID wid;
 480
 481         if (window->wid > 0) {
 482                 return 0;
 483         }
 484
 485         wid = wopn_wnd(WA_STD|WA_SIZE|WA_HHDL|WA_VHDL|WA_BBAR|WA_RBAR, window->parent, &(window->r), NULL, 2, title, &window->bgpat, NULL);
 486         if (wid < 0) {
 487                 DP_ER("wopn_wnd: subjectoption error", wid);
 488                 return wid;
 489         }
 490         window->wid = wid;
 491         window->gid = wget_gid(wid);
 492         hmi_windowscroll_settarget(&window->wscr, wid);
 493
 494
 495         wreq_dsp(wid);
 496
 497         return 0;
 498 }
 499
 500 #define SUBJECTOPTIONWINDOW_FLAG_DRAWREQUEST 0x00000001
 501 #define SUBJECTOPTIONWINDOW_FLAG_PARTS_OTHEREVENT 0x0000000f
 502 #define SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION 0x00000010
 503
 504 #define subjectoptionwindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
 505 #define subjectoptionwindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
 506 #define subjectoptionwindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
 507
 508 EXPORT W subjectoptionwindow_setfiltertext(subjectoptionwindow_t *window, TC *str, W len)
 509 {
 510         W cp_len;
 511
 512         if (len < 1000) {
 513                 cp_len = len;
 514         } else {
 515                 cp_len = 1000;
 516         }
 517         memcpy(window->filter.buf+7, str, cp_len * sizeof(TC));
 518         window->filter.buf[7 + cp_len] = TNULL;
 519         window->filter.buf_written = cp_len;
 520         if (window->wid < 0) {
 521                 return 0;
 522         }
 523
 524         return cset_val(window->filter.id, cp_len, (W*)(window->filter.buf+7));
 525 }
 526
 527 EXPORT W subjectoptionwindow_getfiltertext(subjectoptionwindow_t *window, TC *str, W len)
 528 {
 529         W err, cp_len;
 530
 531         if (window->wid > 0) {
 532                 err = cget_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 533                 if (err < 0) {
 534                         return err;
 535                 }
 536                 window->filter.buf_written = err;
 537         }
 538
 539         if (len < window->filter.buf_written) {
 540                 cp_len = len;
 541         } else {
 542                 cp_len = window->filter.buf_written;
 543         }
 544         memcpy(str, window->filter.buf + 7, cp_len * sizeof(TC));
 545
 546         return cp_len;
 547 }
 548
 549 EXPORT W subjectoptionwindow_cutfiltertext(subjectoptionwindow_t *window, TC *str, W len, Bool cut)
 550 {
 551         W err, len0;
 552
 553         len0 = ccut_txt(window->filter.id, len, str, cut == False ? 0 : 1);
 554         if (len0 < 0) {
 555                 return len0;
 556         }
 557
 558         if (cut != False) {
 559                 err = cget_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 560                 if (err < 0) {
 561                         return err;
 562                 }
 563                 window->filter.buf_written = err;
 564                 return len0;
 565         }
 566
 567         return len0;
 568 }
 569
 570 EXPORT W subjectoptionwindow_insertfiltertext(subjectoptionwindow_t *window, TC *str, W len)
 571 {
 572         W err;
 573
 574         err = cins_txt(window->filter.id, (PNT){0x8000, 0x8000}, str);
 575         if (err < 0) {
 576                 return err;
 577         }
 578
 579         err = cget_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 580         if (err < 0) {
 581                 return err;
 582         }
 583         window->filter.buf_written = err;
 584
 585         return err;
 586 }
 587
 588 LOCAL VOID subjectoptionwindow_actionfilter(subjectoptionwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 589 {
 590         W i, len;
 591
 592         i = cact_par(window->filter.id, wev);
 593         if (i & 0x2000) {
 594                 window->filter.nextaction = True;
 595                 switch (i) {
 596                 case    P_MENU:
 597                         if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
 598                                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_FILTER_KEYMENU;
 599                                 evt->data.subjectoptionwindow_filter_keymenu.keycode = wev->e.data.key.code;
 600                         } else {
 601                                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_FILTER_MENU;
 602                                 evt->data.subjectoptionwindow_filter_menu.pos = wev->s.pos;
 603                         }
 604                         subjectoptionwindow_setflag(window, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION);
 605                         break;
 606                 default:
 607                         wugt_evt(wev);
 608                         subjectoptionwindow_setflag(window, SUBJECTOPTIONWINDOW_FLAG_PARTS_OTHEREVENT);
 609                         break;
 610                 }
 611                 return;
 612         }
 613         window->filter.nextaction = False;
 614         if (i & 0x1000) {
 615                 len = cget_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 616                 if (len > 0) {
 617                         window->filter.buf_written = len;
 618                 }
 619         }
 620         switch (i & 7) {
 621         case    P_BUT:
 622                 cchg_par(window->filter.id, P_INACT);
 623                 cchg_par(window->filter.id, P_ACT);
 624                 wugt_evt(wev);
 625                 break;
 626         case    P_TAB:
 627                 break;
 628         case    P_NL:
 629         case    P_END:
 630                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_FILTER_DETERMINE;
 631                 evt->data.subjectoptionwindow_filter_determine.value = window->filter.buf+7;
 632                 evt->data.subjectoptionwindow_filter_determine.len = window->filter.buf_written;
 633                 break;
 634         case    P_MOVE:
 635                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_FILTER_MOVE;
 636                 evt->data.subjectoptionwindow_filter_move.rel_wid = wev->s.wid;
 637                 evt->data.subjectoptionwindow_filter_move.pos = wev->s.pos;
 638                 break;
 639         case    P_COPY:
 640                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_FILTER_COPY;
 641                 evt->data.subjectoptionwindow_filter_copy.rel_wid = wev->s.wid;
 642                 evt->data.subjectoptionwindow_filter_copy.pos = wev->s.pos;
 643                 break;
 644         }
 645 }
 646
 647 EXPORT W subjectoptionwindow_setordervalue(subjectoptionwindow_t *window, SUBJECTOPTIONWINDOW_ORDERVALUE_T value)
 648 {
 649         W val;
 650
 651         val = window->order.value = value;
 652         if (window->wid < 0) {
 653                 return 0;
 654         }
 655
 656         return cset_val(window->order.id, 1, (W*)(&val));
 657 }
 658
 659 EXPORT W subjectoptionwindow_getordervalue(subjectoptionwindow_t *window, SUBJECTOPTIONWINDOW_ORDERVALUE_T *value)
 660 {
 661         W val,err;
 662
 663         if (window->wid > 0) {
 664                 err = cget_val(window->order.id, 1, (W*)(&val));
 665                 if (err < 0) {
 666                         return err;
 667                 }
 668         }
 669         *value = window->order.value = val;
 670
 671         return 0;
 672 }
 673
 674 LOCAL VOID subjectoptionwindow_actionorder(subjectoptionwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 675 {
 676         W i;
 677
 678         i = cact_par(window->order.id, wev);
 679         if ((i & 0x5000) != 0x5000) {
 680                 return;
 681         }
 682         window->order.value = i & 0xfff;
 683         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_ORDER_CHANGE;
 684         evt->data.subjectoptionwindow_order_change.value = window->order.value;
 685 }
 686
 687 EXPORT W subjectoptionwindow_setorderbyvalue(subjectoptionwindow_t *window, SUBJECTOPTIONWINDOW_ORDERBYVALUE_T value)
 688 {
 689         W val;
 690
 691         val = window->orderby.value = value;
 692         if (window->wid < 0) {
 693                 return 0;
 694         }
 695
 696         return cset_val(window->orderby.id, 1, (W*)(&val));
 697 }
 698
 699 EXPORT W subjectoptionwindow_getorderbyvalue(subjectoptionwindow_t *window, SUBJECTOPTIONWINDOW_ORDERBYVALUE_T *value)
 700 {
 701         W val,err;
 702
 703         if (window->wid > 0) {
 704                 err = cget_val(window->orderby.id, 1, (W*)(&val));
 705                 if (err < 0) {
 706                         return err;
 707                 }
 708         }
 709         *value = window->orderby.value = val;
 710
 711         return 0;
 712 }
 713
 714 LOCAL VOID subjectoptionwindow_actionorderby(subjectoptionwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 715 {
 716         W i;
 717
 718         i = cact_par(window->orderby.id, wev);
 719         if ((i & 0x5000) != 0x5000) {
 720                 return;
 721         }
 722         window->orderby.value = i & 0xfff;
 723         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTOPTIONWINDOW_PARTS_ORDERBY_CHANGE;
 724         evt->data.subjectoptionwindow_orderby_change.value = window->orderby.value;
 725 }
 726
 727 EXPORT Bool subjectoptionwindow_isopen(subjectoptionwindow_t *window)
 728 {
 729         if (window->wid < 0) {
 730                 return False;
 731         }
 732         return True;
 733 }
 734
 735 LOCAL VOID subjectoptionwindow_draw(subjectoptionwindow_t *window, RECT *r)
 736 {
 737         cdsp_pwd(window->wid, r, P_RDISP);
 738         gset_chc(window->gid, 0x10000000, -1);
 739         gdra_stp(window->gid, 8, 26, (TC[]){0x2555, 0x2523, 0x256b, 0x253f, 0x2127, TNULL}, 5, G_STORE);
 740         gset_chc(window->gid, 0x10000000, -1);
 741         gdra_stp(window->gid, 8, 58, (TC[]){0x4a42, 0x2459, 0x3d67, 0x2127, TNULL}, 4, G_STORE);
 742 }
 743
 744 LOCAL VOID subjectoptionwindow_redisp(subjectoptionwindow_t *window)
 745 {
 746         RECT r;
 747         do {
 748                 if (wsta_dsp(window->wid, &r, NULL) == 0) {
 749                         break;
 750                 }
 751                 wera_wnd(window->wid, &r);
 752                 subjectoptionwindow_draw(window, &r);
 753         } while (wend_dsp(window->wid) > 0);
 754 }
 755
 756 EXPORT W subjectoptionwindow_requestredisp(subjectoptionwindow_t *window)
 757 {
 758         return wreq_dsp(window->wid);
 759 }
 760
 761 EXPORT GID subjectoptionwindow_getGID(subjectoptionwindow_t *window)
 762 {
 763         return wget_gid(window->wid);
 764 }
 765
 766 EXPORT WID subjectoptionwindow_getWID(subjectoptionwindow_t *window)
 767 {
 768         return window->wid;
 769 }
 770
 771 EXPORT W subjectoptionwindow_settitle(subjectoptionwindow_t *window, TC *title)
 772 {
 773         tc_strncpy(window->title, title, 256);
 774         window->title[256] = TNULL;
 775         return wset_tit(window->wid, -1, window->title, 0);
 776 }
 777
 778 EXPORT Bool subjectoptionwindow_isactive(subjectoptionwindow_t *window)
 779 {
 780         WID wid;
 781         wid = wget_act(NULL);
 782         if (window->wid == wid) {
 783                 return True;
 784         }
 785         return False;
 786 }
 787
 788 LOCAL VOID subjectoptionwindow_butdnwork(subjectoptionwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 789 {
 790         PAID id;
 791         W ret;
 792
 793         ret = cfnd_par(window->wid, wev->s.pos, &id);
 794         if (ret <= 0) {
 795                 return;
 796         }
 797         if (id == window->filter.id) {
 798                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
 799                 subjectoptionwindow_actionfilter(window, wev, evt);
 800                 return;
 801         }
 802         if (id == window->order.id) {
 803                 subjectoptionwindow_actionorder(window, wev, evt);
 804                 return;
 805         }
 806         if (id == window->orderby.id) {
 807                 subjectoptionwindow_actionorderby(window, wev, evt);
 808                 return;
 809         }
 810 }
 811
 812 EXPORT W subjectoptionwindow_open(subjectoptionwindow_t *window)
 813 {
 814         WID wid;
 815
 816         if (window->wid > 0) {
 817                 return 0;
 818         }
 819
 820         wid = wopn_wnd(WA_STD|WA_SUBW, window->parent->wid, &(window->r), NULL, 2, window->title, &window->bgpat, NULL);
 821         if (wid < 0) {
 822                 DP_ER("wopn_wnd: subjectoption error", wid);
 823                 return wid;
 824         }
 825         window->wid = wid;
 826         window->gid = wget_gid(wid);
 827
 828         window->filter.id = copn_par(wid, window->filter.dnum, NULL);
 829         if (window->filter.id < 0) {
 830                 DP_ER("ccre_xxx filter error:", window->filter.id);
 831         }
 832         cset_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 833         window->order.id = copn_par(wid, window->order.dnum, NULL);
 834         if (window->order.id < 0) {
 835                 DP_ER("ccre_xxx order error:", window->order.id);
 836         }
 837         cset_val(window->order.id, 1, (W*)(&window->order.value));
 838         window->orderby.id = copn_par(wid, window->orderby.dnum, NULL);
 839         if (window->orderby.id < 0) {
 840                 DP_ER("ccre_xxx orderby error:", window->orderby.id);
 841         }
 842         cset_val(window->orderby.id, 1, (W*)(&window->orderby.value));
 843
 844         wreq_dsp(wid);
 845
 846         return 0;
 847 }
 848
 849 EXPORT VOID subjectoptionwindow_close(subjectoptionwindow_t *window)
 850 {
 851         WDSTAT stat;
 852         W err;
 853
 854         if (window->wid < 0) {
 855                 return;
 856         }
 857
 858         stat.attr = WA_STD;
 859         err = wget_sts(window->wid, &stat, NULL);
 860         if (err >= 0) {
 861                 window->r = stat.r;
 862         }
 863         err = cget_val(window->orderby.id, 1, (W*)(&window->orderby.value));
 864         err = cget_val(window->order.id, 1, (W*)(&window->order.value));
 865         err = cget_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 866         if (err >= 0) {
 867                 window->filter.buf_written = err;
 868         }
 869         cdel_pwd(window->wid, NOCLR);
 870         wcls_wnd(window->wid, CLR);
 871         window->wid = -1;
 872         window->gid = -1;
 873 }
 874
 875 #define REGISTEREXTERNALWINDOW_FLAG_DRAWREQUEST 0x00000001
 876 #define REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT 0x0000000f
 877 #define REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION 0x00000010
 878
 879 #define registerexternalwindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
 880 #define registerexternalwindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
 881 #define registerexternalwindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
 882
 883 EXPORT W registerexternalwindow_setboradnametext(registerexternalwindow_t *window, TC *str, W len)
 884 {
 885         W cp_len;
 886
 887         if (len < 1000) {
 888                 cp_len = len;
 889         } else {
 890                 cp_len = 1000;
 891         }
 892         memcpy(window->boradname.buf+7, str, cp_len * sizeof(TC));
 893         window->boradname.buf[7 + cp_len] = TNULL;
 894         window->boradname.buf_written = cp_len;
 895         if (window->wid < 0) {
 896                 return 0;
 897         }
 898
 899         return cset_val(window->boradname.id, cp_len, (W*)(window->boradname.buf+7));
 900 }
 901
 902 EXPORT W registerexternalwindow_getboradnametext(registerexternalwindow_t *window, TC *str, W len)
 903 {
 904         W err, cp_len;
 905
 906         if (window->wid > 0) {
 907                 err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 908                 if (err < 0) {
 909                         return err;
 910                 }
 911                 window->boradname.buf_written = err;
 912         }
 913
 914         if (len < window->boradname.buf_written) {
 915                 cp_len = len;
 916         } else {
 917                 cp_len = window->boradname.buf_written;
 918         }
 919         memcpy(str, window->boradname.buf + 7, cp_len * sizeof(TC));
 920
 921         return cp_len;
 922 }
 923
 924 EXPORT W registerexternalwindow_cutboradnametext(registerexternalwindow_t *window, TC *str, W len, Bool cut)
 925 {
 926         W err, len0;
 927
 928         len0 = ccut_txt(window->boradname.id, len, str, cut == False ? 0 : 1);
 929         if (len0 < 0) {
 930                 return len0;
 931         }
 932
 933         if (cut != False) {
 934                 err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 935                 if (err < 0) {
 936                         return err;
 937                 }
 938                 window->boradname.buf_written = err;
 939                 return len0;
 940         }
 941
 942         return len0;
 943 }
 944
 945 EXPORT W registerexternalwindow_insertboradnametext(registerexternalwindow_t *window, TC *str, W len)
 946 {
 947         W err;
 948
 949         err = cins_txt(window->boradname.id, (PNT){0x8000, 0x8000}, str);
 950         if (err < 0) {
 951                 return err;
 952         }
 953
 954         err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 955         if (err < 0) {
 956                 return err;
 957         }
 958         window->boradname.buf_written = err;
 959
 960         return err;
 961 }
 962
 963 LOCAL VOID registerexternalwindow_actionboradname(registerexternalwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 964 {
 965         W i, len;
 966
 967         i = cact_par(window->boradname.id, wev);
 968         if (i & 0x2000) {
 969                 window->boradname.nextaction = True;
 970                 switch (i) {
 971                 case    P_MENU:
 972                         if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
 973                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_KEYMENU;
 974                                 evt->data.registerexternalwindow_boradname_keymenu.keycode = wev->e.data.key.code;
 975                         } else {
 976                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_MENU;
 977                                 evt->data.registerexternalwindow_boradname_menu.pos = wev->s.pos;
 978                         }
 979                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
 980                         break;
 981                 default:
 982                         wugt_evt(wev);
 983                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT);
 984                         break;
 985                 }
 986                 return;
 987         }
 988         window->boradname.nextaction = False;
 989         if (i & 0x1000) {
 990                 len = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 991                 if (len > 0) {
 992                         window->boradname.buf_written = len;
 993                 }
 994         }
 995         switch (i & 7) {
 996         case    P_BUT:
 997                 cchg_par(window->boradname.id, P_INACT);
 998                 cchg_par(window->boradname.id, P_ACT);
 999                 wugt_evt(wev);
1000                 break;
1001         case    P_TAB:
1002                 break;
1003         case    P_NL:
1004         case    P_END:
1005                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_DETERMINE;
1006                 evt->data.registerexternalwindow_boradname_determine.value = window->boradname.buf+7;
1007                 evt->data.registerexternalwindow_boradname_determine.len = window->boradname.buf_written;
1008                 break;
1009         case    P_MOVE:
1010                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_MOVE;
1011                 evt->data.registerexternalwindow_boradname_move.rel_wid = wev->s.wid;
1012                 evt->data.registerexternalwindow_boradname_move.pos = wev->s.pos;
1013                 break;
1014         case    P_COPY:
1015                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_COPY;
1016                 evt->data.registerexternalwindow_boradname_copy.rel_wid = wev->s.wid;
1017                 evt->data.registerexternalwindow_boradname_copy.pos = wev->s.pos;
1018                 break;
1019         }
1020 }
1021
1022 EXPORT W registerexternalwindow_seturltext(registerexternalwindow_t *window, TC *str, W len)
1023 {
1024         W cp_len;
1025
1026         if (len < 1000) {
1027                 cp_len = len;
1028         } else {
1029                 cp_len = 1000;
1030         }
1031         memcpy(window->url.buf+7, str, cp_len * sizeof(TC));
1032         window->url.buf[7 + cp_len] = TNULL;
1033         window->url.buf_written = cp_len;
1034         if (window->wid < 0) {
1035                 return 0;
1036         }
1037
1038         return cset_val(window->url.id, cp_len, (W*)(window->url.buf+7));
1039 }
1040
1041 EXPORT W registerexternalwindow_geturltext(registerexternalwindow_t *window, TC *str, W len)
1042 {
1043         W err, cp_len;
1044
1045         if (window->wid > 0) {
1046                 err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1047                 if (err < 0) {
1048                         return err;
1049                 }
1050                 window->url.buf_written = err;
1051         }
1052
1053         if (len < window->url.buf_written) {
1054                 cp_len = len;
1055         } else {
1056                 cp_len = window->url.buf_written;
1057         }
1058         memcpy(str, window->url.buf + 7, cp_len * sizeof(TC));
1059
1060         return cp_len;
1061 }
1062
1063 EXPORT W registerexternalwindow_cuturltext(registerexternalwindow_t *window, TC *str, W len, Bool cut)
1064 {
1065         W err, len0;
1066
1067         len0 = ccut_txt(window->url.id, len, str, cut == False ? 0 : 1);
1068         if (len0 < 0) {
1069                 return len0;
1070         }
1071
1072         if (cut != False) {
1073                 err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1074                 if (err < 0) {
1075                         return err;
1076                 }
1077                 window->url.buf_written = err;
1078                 return len0;
1079         }
1080
1081         return len0;
1082 }
1083
1084 EXPORT W registerexternalwindow_inserturltext(registerexternalwindow_t *window, TC *str, W len)
1085 {
1086         W err;
1087
1088         err = cins_txt(window->url.id, (PNT){0x8000, 0x8000}, str);
1089         if (err < 0) {
1090                 return err;
1091         }
1092
1093         err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1094         if (err < 0) {
1095                 return err;
1096         }
1097         window->url.buf_written = err;
1098
1099         return err;
1100 }
1101
1102 LOCAL VOID registerexternalwindow_actionurl(registerexternalwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
1103 {
1104         W i, len;
1105
1106         i = cact_par(window->url.id, wev);
1107         if (i & 0x2000) {
1108                 window->url.nextaction = True;
1109                 switch (i) {
1110                 case    P_MENU:
1111                         if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
1112                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_KEYMENU;
1113                                 evt->data.registerexternalwindow_url_keymenu.keycode = wev->e.data.key.code;
1114                         } else {
1115                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_MENU;
1116                                 evt->data.registerexternalwindow_url_menu.pos = wev->s.pos;
1117                         }
1118                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
1119                         break;
1120                 default:
1121                         wugt_evt(wev);
1122                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT);
1123                         break;
1124                 }
1125                 return;
1126         }
1127         window->url.nextaction = False;
1128         if (i & 0x1000) {
1129                 len = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1130                 if (len > 0) {
1131                         window->url.buf_written = len;
1132                 }
1133         }
1134         switch (i & 7) {
1135         case    P_BUT:
1136                 cchg_par(window->url.id, P_INACT);
1137                 cchg_par(window->url.id, P_ACT);
1138                 wugt_evt(wev);
1139                 break;
1140         case    P_TAB:
1141                 break;
1142         case    P_NL:
1143         case    P_END:
1144                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_DETERMINE;
1145                 evt->data.registerexternalwindow_url_determine.value = window->url.buf+7;
1146                 evt->data.registerexternalwindow_url_determine.len = window->url.buf_written;
1147                 break;
1148         case    P_MOVE:
1149                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_MOVE;
1150                 evt->data.registerexternalwindow_url_move.rel_wid = wev->s.wid;
1151                 evt->data.registerexternalwindow_url_move.pos = wev->s.pos;
1152                 break;
1153         case    P_COPY:
1154                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_COPY;
1155                 evt->data.registerexternalwindow_url_copy.rel_wid = wev->s.wid;
1156                 evt->data.registerexternalwindow_url_copy.pos = wev->s.pos;
1157                 break;
1158         }
1159 }
1160
1161 EXPORT Bool registerexternalwindow_isopen(registerexternalwindow_t *window)
1162 {
1163         if (window->wid < 0) {
1164                 return False;
1165         }
1166         return True;
1167 }
1168
1169 LOCAL VOID registerexternalwindow_draw(registerexternalwindow_t *window, RECT *r)
1170 {
1171         cdsp_pwd(window->wid, r, P_RDISP);
1172         gset_chc(window->gid, 0x10000000, -1);
1173         gdra_stp(window->gid, 8, 26, (TC[]){0x4844, 0x4c3e, 0x2127, TNULL}, 3, G_STORE);
1174         gset_chc(window->gid, 0x10000000, -1);
1175         gdra_stp(window->gid, 8, 58, (TC[]){0x2355, 0x2352, 0x234c, 0x2127, TNULL}, 4, G_STORE);
1176 }
1177
1178 LOCAL VOID registerexternalwindow_redisp(registerexternalwindow_t *window)
1179 {
1180         RECT r;
1181         do {
1182                 if (wsta_dsp(window->wid, &r, NULL) == 0) {
1183                         break;
1184                 }
1185                 wera_wnd(window->wid, &r);
1186                 registerexternalwindow_draw(window, &r);
1187         } while (wend_dsp(window->wid) > 0);
1188 }
1189
1190 EXPORT W registerexternalwindow_requestredisp(registerexternalwindow_t *window)
1191 {
1192         return wreq_dsp(window->wid);
1193 }
1194
1195 EXPORT GID registerexternalwindow_getGID(registerexternalwindow_t *window)
1196 {
1197         return wget_gid(window->wid);
1198 }
1199
1200 EXPORT WID registerexternalwindow_getWID(registerexternalwindow_t *window)
1201 {
1202         return window->wid;
1203 }
1204
1205 EXPORT W registerexternalwindow_settitle(registerexternalwindow_t *window, TC *title)
1206 {
1207         tc_strncpy(window->title, title, 256);
1208         window->title[256] = TNULL;
1209         return wset_tit(window->wid, -1, window->title, 0);
1210 }
1211
1212 EXPORT Bool registerexternalwindow_isactive(registerexternalwindow_t *window)
1213 {
1214         WID wid;
1215         wid = wget_act(NULL);
1216         if (window->wid == wid) {
1217                 return True;
1218         }
1219         return False;
1220 }
1221
1222 LOCAL VOID registerexternalwindow_butdnwork(registerexternalwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
1223 {
1224         PAID id;
1225         W ret;
1226
1227         ret = cfnd_par(window->wid, wev->s.pos, &id);
1228         if (ret <= 0) {
1229                 return;
1230         }
1231         if (id == window->boradname.id) {
1232                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
1233                 registerexternalwindow_actionboradname(window, wev, evt);
1234                 return;
1235         }
1236         if (id == window->url.id) {
1237                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
1238                 registerexternalwindow_actionurl(window, wev, evt);
1239                 return;
1240         }
1241         if (id == window->determine.id) {
1242                 ret = cact_par(window->determine.id, wev);
1243                 if ((ret & 0x5000) != 0x5000) {
1244                         return;
1245                 }
1246                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_DETERMINE_PUSH;
1247                 return;
1248         }
1249         if (id == window->cancel.id) {
1250                 ret = cact_par(window->cancel.id, wev);
1251                 if ((ret & 0x5000) != 0x5000) {
1252                         return;
1253                 }
1254                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_CANCEL_PUSH;
1255                 return;
1256         }
1257 }
1258
1259 EXPORT W registerexternalwindow_open(registerexternalwindow_t *window)
1260 {
1261         WID wid;
1262         RECT r;
1263
1264         if (window->wid > 0) {
1265                 return 0;
1266         }
1267
1268         wid = wopn_wnd(WA_STD, window->parent, &(window->r), NULL, 2, window->title, &window->bgpat, NULL);
1269         if (wid < 0) {
1270                 DP_ER("wopn_wnd: subjectoption error", wid);
1271                 return wid;
1272         }
1273         window->wid = wid;
1274         window->gid = wget_gid(wid);
1275
1276         r = (RECT){{80, 8, 368, 34}};
1277         window->boradname.id = ccre_tbx(wid, TB_PARTS|P_DISP, &r, 1000, window->boradname.buf, NULL);
1278         if (window->boradname.id < 0) {
1279                 DP_ER("ccre_xxx boradname error:", window->boradname.id);
1280         }
1281         r = (RECT){{80, 38, 368, 64}};
1282         window->url.id = ccre_tbx(wid, TB_PARTS|P_DISP, &r, 1000, window->url.buf, NULL);
1283         if (window->url.id < 0) {
1284                 DP_ER("ccre_xxx url error:", window->url.id);
1285         }
1286         r = (RECT){{226, 72, 368, 98}};
1287         window->determine.id = ccre_msw(wid, MS_PARTS|P_DISP, &r, (TC[]){MC_STR, 0x4449, 0x3243, TNULL}, NULL);
1288         if (window->determine.id < 0) {
1289                 DP_ER("ccre_xxx determine error:", window->determine.id);
1290         }
1291         r = (RECT){{8, 72, 150, 98}};
1292         window->cancel.id = ccre_msw(wid, MS_PARTS|P_DISP, &r, (TC[]){MC_STR, 0x3c68, 0x246a, 0x3e43, 0x2437, TNULL}, NULL);
1293         if (window->cancel.id < 0) {
1294                 DP_ER("ccre_xxx cancel error:", window->cancel.id);
1295         }
1296
1297         wreq_dsp(wid);
1298
1299         return 0;
1300 }
1301
1302 EXPORT VOID registerexternalwindow_close(registerexternalwindow_t *window)
1303 {
1304         WDSTAT stat;
1305         W err;
1306
1307         if (window->wid < 0) {
1308                 return;
1309         }
1310
1311         stat.attr = WA_STD;
1312         err = wget_sts(window->wid, &stat, NULL);
1313         if (err >= 0) {
1314                 window->r = stat.r;
1315         }
1316         err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1317         if (err >= 0) {
1318                 window->url.buf_written = err;
1319         }
1320         err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
1321         if (err >= 0) {
1322                 window->boradname.buf_written = err;
1323         }
1324         cdel_pwd(window->wid, NOCLR);
1325         wcls_wnd(window->wid, CLR);
1326         window->wid = -1;
1327         window->gid = -1;
1328 }
1329
1330 #define EXTERNALBBSWINDOW_FLAG_DRAWREQUEST 0x00000001
1331 #define EXTERNALBBSWINDOW_FLAG_RSCROLLING 0x00000002
1332 #define EXTERNALBBSWINDOW_FLAG_BSCROLLING 0x00000004
1333
1334 #define externalbbswindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
1335 #define externalbbswindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
1336 #define externalbbswindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
1337
1338 EXPORT VOID externalbbswindow_scrollbyvalue(externalbbswindow_t *window, W dh, W dv)
1339 {
1340         hmi_windowscroll_scrollworkrect(&window->wscr, dh, dv);
1341 }
1342
1343 EXPORT W externalbbswindow_setdrawrect(externalbbswindow_t *window, W l, W t, W r, W b)
1344 {
1345         return hmi_windowscroll_setdrawrect(&window->wscr, l, t, r, b);
1346 }
1347
1348 EXPORT W externalbbswindow_setworkrect(externalbbswindow_t *window, W l, W t, W r, W b)
1349 {
1350         return hmi_windowscroll_setworkrect(&window->wscr, l, t, r, b);
1351 }
1352
1353 EXPORT W externalbbswindow_scrollworkarea(externalbbswindow_t *window, W dh, W dv)
1354 {
1355         W err;
1356         err = wscr_wnd(window->wid, NULL, dh, dv, W_MOVE|W_RDSET);
1357         if (err < 0) {
1358                 return err;
1359         }
1360         if ((err & W_RDSET) != 0) {
1361                 externalbbswindow_setflag(window, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST);
1362         }
1363         return 0;
1364 }
1365
1366 EXPORT W externalbbswindow_getworkrect(externalbbswindow_t *window, RECT *r)
1367 {
1368         return wget_wrk(window->wid, r);
1369 }
1370
1371 EXPORT Bool externalbbswindow_isopen(externalbbswindow_t *window)
1372 {
1373         if (window->wid < 0) {
1374                 return False;
1375         }
1376         return True;
1377 }
1378
1379 EXPORT VOID externalbbswindow_responsepasterequest(externalbbswindow_t *window, W nak, PNT *pos)
1380 {
1381         if (pos != NULL) {
1382                 window->savedwev.r.r.p.rightbot.x = pos->x;
1383                 window->savedwev.r.r.p.rightbot.y = pos->y;
1384         }
1385         wrsp_evt(&window->savedwev, nak);
1386 }
1387
1388 EXPORT W externalbbswindow_startredisp(externalbbswindow_t *window, RECT *r)
1389 {
1390         return wsta_dsp(window->wid, r, NULL);
1391 }
1392
1393 EXPORT W externalbbswindow_endredisp(externalbbswindow_t *window)
1394 {
1395         return wend_dsp(window->wid);
1396 }
1397
1398 EXPORT W externalbbswindow_eraseworkarea(externalbbswindow_t *window, RECT *r)
1399 {
1400         return wera_wnd(window->wid, r);
1401 }
1402
1403 EXPORT W externalbbswindow_requestredisp(externalbbswindow_t *window)
1404 {
1405         return wreq_dsp(window->wid);
1406 }
1407
1408 EXPORT GID externalbbswindow_startdrag(externalbbswindow_t *window)
1409 {
1410         return wsta_drg(window->wid, 0);
1411 }
1412
1413 EXPORT W externalbbswindow_getdrag(externalbbswindow_t *window, PNT *pos, WID *wid, PNT *pos_butup)
1414 {
1415         W etype;
1416
1417         etype = wget_drg(pos, &window->savedwev);
1418         *wid = window->savedwev.s.wid;
1419         if (etype == EV_BUTUP) {
1420                 *pos_butup = window->savedwev.s.pos;
1421         }
1422
1423         return etype;
1424 }
1425
1426 EXPORT VOID externalbbswindow_enddrag(externalbbswindow_t *window)
1427 {
1428         wend_drg();
1429 }
1430
1431 EXPORT GID externalbbswindow_getGID(externalbbswindow_t *window)
1432 {
1433         return wget_gid(window->wid);
1434 }
1435
1436 EXPORT WID externalbbswindow_getWID(externalbbswindow_t *window)
1437 {
1438         return window->wid;
1439 }
1440
1441 EXPORT W externalbbswindow_settitle(externalbbswindow_t *window, TC *title)
1442 {
1443         tc_strncpy(window->title, title, 256);
1444         window->title[256] = TNULL;
1445         return wset_tit(window->wid, -1, window->title, 0);
1446 }
1447
1448 EXPORT Bool externalbbswindow_isactive(externalbbswindow_t *window)
1449 {
1450         WID wid;
1451         wid = wget_act(NULL);
1452         if (window->wid == wid) {
1453                 return True;
1454         }
1455         return False;
1456 }
1457
1458 LOCAL VOID externalbbswindow_butdnwork(externalbbswindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
1459 {
1460         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_BUTDN;
1461         evt->data.externalbbswindow_butdn.type = wchk_dck(wev->s.time);
1462         evt->data.externalbbswindow_butdn.pos = wev->s.pos;
1463         memcpy(&window->savedwev, wev, sizeof(WEVENT));
1464 }
1465
1466 LOCAL VOID externalbbswindow_resize(externalbbswindow_t *window, SIZE *sz)
1467 {
1468         RECT work;
1469         Bool workchange = False;
1470
1471         wget_wrk(window->wid, &work);
1472         if (work.c.left != 0) {
1473                 work.c.left = 0;
1474                 workchange = True;
1475         }
1476         if (work.c.top != 0) {
1477                 work.c.top = 0;
1478                 workchange = True;
1479         }
1480         wset_wrk(window->wid, &work);
1481         gset_vis(window->gid, work);
1482
1483         if (workchange == True) {
1484                 wera_wnd(window->wid, NULL);
1485                 wreq_dsp(window->wid);
1486         }
1487
1488         sz->v = work.c.bottom - work.c.top;
1489         sz->h = work.c.right - work.c.left;
1490 }
1491
1492 EXPORT W externalbbswindow_open(externalbbswindow_t *window)
1493 {
1494         WID wid;
1495
1496         if (window->wid > 0) {
1497                 return 0;
1498         }
1499
1500         wid = wopn_wnd(WA_STD|WA_SIZE|WA_HHDL|WA_VHDL|WA_BBAR|WA_RBAR, window->parent, &(window->r), NULL, 2, window->title, &window->bgpat, NULL);
1501         if (wid < 0) {
1502                 DP_ER("wopn_wnd: subjectoption error", wid);
1503                 return wid;
1504         }
1505         window->wid = wid;
1506         window->gid = wget_gid(wid);
1507         hmi_windowscroll_settarget(&window->wscr, wid);
1508
1509
1510         wreq_dsp(wid);
1511
1512         return 0;
1513 }
1514
1515 EXPORT VOID externalbbswindow_close(externalbbswindow_t *window)
1516 {
1517         WDSTAT stat;
1518         W err;
1519
1520         if (window->wid < 0) {
1521                 return;
1522         }
1523
1524         stat.attr = WA_STD;
1525         err = wget_sts(window->wid, &stat, NULL);
1526         if (err >= 0) {
1527                 window->r = stat.r;
1528         }
1529         wcls_wnd(window->wid, CLR);
1530         window->wid = -1;
1531         window->gid = -1;
1532 }
1533
1534 LOCAL VOID bchanlhmi_setswitchbutdnflag(bchanlhmi_t *hmi)
1535 {
1536         hmi->flag = hmi->flag | BCHANLHMI_FLAG_SWITCHBUTDN;
1537 }
1538
1539 LOCAL VOID bchanlhmi_clearswitchbutdnflag(bchanlhmi_t *hmi)
1540 {
1541         hmi->flag = hmi->flag & ~BCHANLHMI_FLAG_SWITCHBUTDN;
1542 }
1543
1544 LOCAL Bool bchanlhmi_issetswitchbutdnflag(bchanlhmi_t *hmi)
1545 {
1546         if ((hmi->flag & BCHANLHMI_FLAG_SWITCHBUTDN) == 0) {
1547                 return False;
1548         }
1549         return True;
1550 }
1551
1552 LOCAL Bool bchanlhmi_issubjectwindowWID(bchanlhmi_t *hmi, WID wid)
1553 {
1554         if (hmi->subjectwindow->wid == wid) {
1555                 return True;
1556         }
1557         return False;
1558 }
1559
1560 LOCAL Bool bchanlhmi_isbbsmenuwindowWID(bchanlhmi_t *hmi, WID wid)
1561 {
1562         if (hmi->bbsmenuwindow->wid == wid) {
1563                 return True;
1564         }
1565         return False;
1566 }
1567
1568 LOCAL Bool bchanlhmi_issubjectoptionwindowWID(bchanlhmi_t *hmi, WID wid)
1569 {
1570         if (hmi->subjectoptionwindow->wid == wid) {
1571                 return True;
1572         }
1573         return False;
1574 }
1575
1576 LOCAL Bool bchanlhmi_isregisterexternalwindowWID(bchanlhmi_t *hmi, WID wid)
1577 {
1578         if (hmi->registerexternalwindow->wid == wid) {
1579                 return True;
1580         }
1581         return False;
1582 }
1583
1584 LOCAL Bool bchanlhmi_isexternalbbswindowWID(bchanlhmi_t *hmi, WID wid)
1585 {
1586         if (hmi->externalbbswindow->wid == wid) {
1587                 return True;
1588         }
1589         return False;
1590 }
1591
1592 LOCAL VOID bchanlhmi_weventnull(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1593 {
1594         cidl_par(wev->s.wid, &wev->s.pos);
1595         if (wev->s.cmd != W_WORK)
1596                 return;         /*ºî¶ÈÎÎ°è³°*/
1597         if (wev->s.stat & ES_CMD)
1598                 return; /*Ì¿Îá¥¡¼¤¬²¡¤µ¤ì¤Æ¤¤¤ë*/
1599         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1600                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_MOUSEMOVE;
1601                 hmi->evt.data.subjectwindow_mousemove.pos = wev->s.pos;
1602                 hmi->evt.data.subjectwindow_mousemove.stat = wev->s.stat;
1603                 return;
1604         }
1605         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1606                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_MOUSEMOVE;
1607                 hmi->evt.data.bbsmenuwindow_mousemove.pos = wev->s.pos;
1608                 hmi->evt.data.bbsmenuwindow_mousemove.stat = wev->s.stat;
1609                 return;
1610         }
1611         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1612                 cidl_par(wev->s.wid, &wev->s.pos);
1613                 return;
1614         }
1615         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1616                 cidl_par(wev->s.wid, &wev->s.pos);
1617                 return;
1618         }
1619         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1620                 gset_ptr(PS_SELECT, NULL, -1, -1);
1621                 return;
1622         }
1623         /*¥¦¥£¥ó¥É¥¦³°*/
1624         hmi->evt.type = BCHANLHMIEVENT_TYPE_COMMON_MOUSEMOVE;
1625         hmi->evt.data.common_mousemove.pos = wev->s.pos;
1626 }
1627
1628 LOCAL VOID bchanlhmi_weventrequest(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1629 {
1630         switch (wev->g.cmd) {
1631         case    W_REDISP:       /*ºÆÉ½¼¨Í×µá*/
1632                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1633                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
1634                         break;
1635                 }
1636                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->g.wid) == True) {
1637                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
1638                         break;
1639                 }
1640                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->g.wid) == True) {
1641                         subjectoptionwindow_redisp(hmi->subjectoptionwindow);
1642                         break;
1643                 }
1644                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->g.wid) == True) {
1645                         registerexternalwindow_redisp(hmi->registerexternalwindow);
1646                         break;
1647                 }
1648                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1649                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
1650                         break;
1651                 }
1652                 break;
1653         case    W_PASTE:        /*Å½¹þ¤ßÍ×µá*/
1654                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1655                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_PASTE;
1656                         memcpy(&hmi->subjectwindow->savedwev, wev, sizeof(WEVENT));
1657                         break;
1658                 }
1659                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1660                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_PASTE;
1661                         memcpy(&hmi->externalbbswindow->savedwev, wev, sizeof(WEVENT));
1662                         break;
1663                 }
1664                 wrsp_evt(wev, 1); /*NACK*/
1665                 break;
1666         case    W_DELETE:       /*ÊÝÂ¸½ªÎ»*/
1667                 wrsp_evt(wev, 0);       /*ACK*/
1668                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1669                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_CLOSE;
1670                         evt->data.subjectwindow_close.save = True;
1671                         break;
1672                 }
1673                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->g.wid) == True) {
1674                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_CLOSE;
1675                         evt->data.bbsmenuwindow_close.save = True;
1676                         break;
1677                 }
1678                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->g.wid) == True) {
1679                         subjectoptionwindow_close(hmi->subjectoptionwindow);
1680                         break;
1681                 }
1682                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->g.wid) == True) {
1683                         registerexternalwindow_close(hmi->registerexternalwindow);
1684                         break;
1685                 }
1686                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1687                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_CLOSE;
1688                         evt->data.externalbbswindow_close.save = True;
1689                         break;
1690                 }
1691                 break;
1692         case    W_FINISH:       /*ÇÑ´þ½ªÎ»*/
1693                 wrsp_evt(wev, 0);       /*ACK*/
1694                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1695                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_CLOSE;
1696                         evt->data.subjectwindow_close.save = False;
1697                         break;
1698                 }
1699                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->g.wid) == True) {
1700                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_CLOSE;
1701                         evt->data.bbsmenuwindow_close.save = False;
1702                         break;
1703                 }
1704                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->g.wid) == True) {
1705                         subjectoptionwindow_close(hmi->subjectoptionwindow);
1706                         break;
1707                 }
1708                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->g.wid) == True) {
1709                         registerexternalwindow_close(hmi->registerexternalwindow);
1710                         break;
1711                 }
1712                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1713                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_CLOSE;
1714                         evt->data.externalbbswindow_close.save = False;
1715                         break;
1716                 }
1717                 break;
1718         }
1719 }
1720
1721 LOCAL VOID bchanlhmi_weventbutdn(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1722 {
1723         W i, err;
1724         W dh, dv; /* TODO: add check for exist scrollable window */
1725
1726         switch  (wev->s.cmd) {
1727         case    W_PICT:
1728                 switch (wchk_dck(wev->s.time)) {
1729                 case    W_DCLICK:
1730                         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1731                                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_CLOSE;
1732                                 evt->data.subjectwindow_close.save = True; /* TODO: tmp value */
1733                                 return;
1734                         }
1735                         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1736                                 evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_CLOSE;
1737                                 evt->data.bbsmenuwindow_close.save = True; /* TODO: tmp value */
1738                                 return;
1739                         }
1740                         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1741                                 subjectoptionwindow_close(hmi->subjectoptionwindow);
1742                                 return;
1743                         }
1744                         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1745                                 registerexternalwindow_close(hmi->registerexternalwindow);
1746                                 return;
1747                         }
1748                         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1749                                 evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_CLOSE;
1750                                 evt->data.externalbbswindow_close.save = True; /* TODO: tmp value */
1751                                 return;
1752                         }
1753                         return;
1754                 case    W_PRESS:
1755                         break;
1756                 default:
1757                         return;
1758                 }
1759         case    W_FRAM:
1760         case    W_TITL:
1761                 if (wmov_drg(wev, NULL) > 0) {
1762                         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1763                                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
1764                                 return;
1765                         }
1766                         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1767                                 evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
1768                                 return;
1769                         }
1770                         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1771                                 subjectoptionwindow_redisp(hmi->subjectoptionwindow);
1772                                 return;
1773                         }
1774                         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1775                                 registerexternalwindow_redisp(hmi->registerexternalwindow);
1776                                 return;
1777                         }
1778                         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1779                                 evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
1780                                 return;
1781                         }
1782                 }
1783                 return;
1784         case    W_LTHD:
1785         case    W_RTHD:
1786         case    W_LBHD:
1787         case    W_RBHD:
1788                 switch (wchk_dck(wev->s.time)) {
1789                 case    W_DCLICK:
1790                         i = wchg_wnd(wev->s.wid, NULL, W_MOVE);
1791                         break;
1792                 case    W_PRESS:
1793                         i = wrsz_drg(wev, NULL, NULL);
1794                         break;
1795                 default:
1796                         return;
1797                 }
1798
1799                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1800                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_RESIZE;
1801                         subjectwindow_resize(hmi->subjectwindow, &evt->data.subjectwindow_resize.work_sz);
1802                         hmi_windowscroll_updatebar(&hmi->subjectwindow->wscr);
1803                         if (i > 0) {
1804                                 subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_DRAWREQUEST);
1805                         }
1806                         return;
1807                 }
1808                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1809                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_RESIZE;
1810                         bbsmenuwindow_resize(hmi->bbsmenuwindow, &evt->data.bbsmenuwindow_resize.work_sz);
1811                         hmi_windowscroll_updatebar(&hmi->bbsmenuwindow->wscr);
1812                         if (i > 0) {
1813                                 bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_DRAWREQUEST);
1814                         }
1815                         return;
1816                 }
1817                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1818                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_RESIZE;
1819                         externalbbswindow_resize(hmi->externalbbswindow, &evt->data.externalbbswindow_resize.work_sz);
1820                         hmi_windowscroll_updatebar(&hmi->externalbbswindow->wscr);
1821                         if (i > 0) {
1822                                 externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST);
1823                         }
1824                         return;
1825                 }
1826                 return;
1827         case    W_RBAR:
1828                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1829                         err = hmi_windowscroll_weventrbar(&hmi->subjectwindow->wscr, wev, &dh, &dv);
1830                         if (err < 0) {
1831                                 return;
1832                         }
1833                         if (err == 0) {
1834                                 subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1835                         } else {
1836                                 subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1837                         }
1838                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
1839                         evt->data.subjectwindow_scroll.dh = dh;
1840                         evt->data.subjectwindow_scroll.dv = dv;
1841                         return;
1842                 }
1843                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1844                         err = hmi_windowscroll_weventrbar(&hmi->bbsmenuwindow->wscr, wev, &dh, &dv);
1845                         if (err < 0) {
1846                                 return;
1847                         }
1848                         if (err == 0) {
1849                                 bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
1850                         } else {
1851                                 bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
1852                         }
1853                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
1854                         evt->data.bbsmenuwindow_scroll.dh = dh;
1855                         evt->data.bbsmenuwindow_scroll.dv = dv;
1856                         return;
1857                 }
1858                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1859                         err = hmi_windowscroll_weventrbar(&hmi->externalbbswindow->wscr, wev, &dh, &dv);
1860                         if (err < 0) {
1861                                 return;
1862                         }
1863                         if (err == 0) {
1864                                 externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
1865                         } else {
1866                                 externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
1867                         }
1868                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
1869                         evt->data.externalbbswindow_scroll.dh = dh;
1870                         evt->data.externalbbswindow_scroll.dv = dv;
1871                         return;
1872                 }
1873                 return;
1874         case    W_BBAR:
1875                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1876                         err = hmi_windowscroll_weventbbar(&hmi->subjectwindow->wscr, wev, &dh, &dv);
1877                         if (err < 0) {
1878                                 return;
1879                         }
1880                         if (err == 0) {
1881                                 subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
1882                         } else {
1883                                 subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
1884                         }
1885                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
1886                         evt->data.subjectwindow_scroll.dh = dh;
1887                         evt->data.subjectwindow_scroll.dv = dv;
1888                         return;
1889                 }
1890                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1891                         err = hmi_windowscroll_weventbbar(&hmi->bbsmenuwindow->wscr, wev, &dh, &dv);
1892                         if (err < 0) {
1893                                 return;
1894                         }
1895                         if (err == 0) {
1896                                 bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
1897                         } else {
1898                                 bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
1899                         }
1900                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
1901                         evt->data.bbsmenuwindow_scroll.dh = dh;
1902                         evt->data.bbsmenuwindow_scroll.dv = dv;
1903                         return;
1904                 }
1905                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1906                         err = hmi_windowscroll_weventbbar(&hmi->externalbbswindow->wscr, wev, &dh, &dv);
1907                         if (err < 0) {
1908                                 return;
1909                         }
1910                         if (err == 0) {
1911                                 externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
1912                         } else {
1913                                 externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
1914                         }
1915                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
1916                         evt->data.externalbbswindow_scroll.dh = dh;
1917                         evt->data.externalbbswindow_scroll.dv = dv;
1918                         return;
1919                 }
1920                 return;
1921         case    W_WORK:
1922                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1923                         subjectwindow_butdnwork(hmi->subjectwindow, wev, evt);
1924                         return;
1925                 }
1926                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1927                         bbsmenuwindow_butdnwork(hmi->bbsmenuwindow, wev, evt);
1928                         return;
1929                 }
1930                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1931                         subjectoptionwindow_butdnwork(hmi->subjectoptionwindow, wev, evt);
1932                         return;
1933                 }
1934                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1935                         registerexternalwindow_butdnwork(hmi->registerexternalwindow, wev, evt);
1936                         return;
1937                 }
1938                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1939                         externalbbswindow_butdnwork(hmi->externalbbswindow, wev, evt);
1940                         return;
1941                 }
1942                 return;
1943         }
1944
1945         return;
1946 }
1947
1948 LOCAL VOID bchanlhmi_weventswitch(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1949 {
1950         bchanlhmi_setswitchbutdnflag(hmi);
1951 }
1952
1953 LOCAL VOID bchanlhmi_weventreswitch(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1954 {
1955         bchanlhmi_setswitchbutdnflag(hmi);
1956         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1957                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
1958         }
1959         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1960                 evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
1961         }
1962         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1963                 subjectoptionwindow_redisp(hmi->subjectoptionwindow);
1964                 return;
1965         }
1966         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1967                 registerexternalwindow_redisp(hmi->registerexternalwindow);
1968                 return;
1969         }
1970         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1971                 evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
1972         }
1973 }
1974
1975 LOCAL VOID bchanlhmi_receivemessage(bchanlhmi_t *hmi, bchanlhmievent_t *evt)
1976 {
1977         MESSAGE msg;
1978         W err;
1979
1980         err = rcv_msg(MM_ALL, &msg, sizeof(MESSAGE), WAIT|NOCLR);
1981         if (err >= 0) {
1982                 if (msg.msg_type == MS_TMOUT) { /* should be use other type? */
1983                         evt->type = BCHANLHMIEVENT_TYPE_COMMON_TIMEOUT;
1984                         evt->data.common_timeout.code = msg.msg_body.TMOUT.code;
1985                 }
1986         }
1987         clr_msg(MM_ALL, MM_ALL);
1988 }
1989
1990 LOCAL Bool bchanlhmi_checkflag(bchanlhmi_t *hmi, bchanlhmievent_t **evt)
1991 {
1992         W err, dh, dv;
1993
1994         if (subjectwindow_issetflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING) == True) {
1995                 err = hmi_windowscroll_weventrbar(&hmi->subjectwindow->wscr, &hmi->wev, &dh, &dv);
1996                 if (err < 0) {
1997                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1998                         return False;
1999                 }
2000                 if (err == 0) {
2001                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
2002                 } else {
2003                         subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
2004                 }
2005                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
2006                 hmi->evt.data.subjectwindow_scroll.dh = dh;
2007                 hmi->evt.data.subjectwindow_scroll.dv = dv;
2008                 return True;
2009         }
2010         if (subjectwindow_issetflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING) == True) {
2011                 err = hmi_windowscroll_weventbbar(&hmi->subjectwindow->wscr, &hmi->wev, &dh, &dv);
2012                 if (err < 0) {
2013                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
2014                         return False;
2015                 }
2016                 if (err == 0) {
2017                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
2018                 } else {
2019                         subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
2020                 }
2021                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
2022                 hmi->evt.data.subjectwindow_scroll.dh = dh;
2023                 hmi->evt.data.subjectwindow_scroll.dv = dv;
2024                 return True;
2025         }
2026         if (bbsmenuwindow_issetflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING) == True) {
2027                 err = hmi_windowscroll_weventrbar(&hmi->bbsmenuwindow->wscr, &hmi->wev, &dh, &dv);
2028                 if (err < 0) {
2029                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
2030                         return False;
2031                 }
2032                 if (err == 0) {
2033                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
2034                 } else {
2035                         bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
2036                 }
2037                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
2038                 hmi->evt.data.bbsmenuwindow_scroll.dh = dh;
2039                 hmi->evt.data.bbsmenuwindow_scroll.dv = dv;
2040                 return True;
2041         }
2042         if (bbsmenuwindow_issetflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING) == True) {
2043                 err = hmi_windowscroll_weventbbar(&hmi->bbsmenuwindow->wscr, &hmi->wev, &dh, &dv);
2044                 if (err < 0) {
2045                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
2046                         return False;
2047                 }
2048                 if (err == 0) {
2049                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
2050                 } else {
2051                         bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
2052                 }
2053                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
2054                 hmi->evt.data.bbsmenuwindow_scroll.dh = dh;
2055                 hmi->evt.data.bbsmenuwindow_scroll.dv = dv;
2056                 return True;
2057         }
2058         if (externalbbswindow_issetflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING) == True) {
2059                 err = hmi_windowscroll_weventrbar(&hmi->externalbbswindow->wscr, &hmi->wev, &dh, &dv);
2060                 if (err < 0) {
2061                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
2062                         return False;
2063                 }
2064                 if (err == 0) {
2065                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
2066                 } else {
2067                         externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
2068                 }
2069                 hmi->evt.type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
2070                 hmi->evt.data.externalbbswindow_scroll.dh = dh;
2071                 hmi->evt.data.externalbbswindow_scroll.dv = dv;
2072                 return True;
2073         }
2074         if (externalbbswindow_issetflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING) == True) {
2075                 err = hmi_windowscroll_weventbbar(&hmi->externalbbswindow->wscr, &hmi->wev, &dh, &dv);
2076                 if (err < 0) {
2077                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
2078                         return False;
2079                 }
2080                 if (err == 0) {
2081                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
2082                 } else {
2083                         externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
2084                 }
2085                 hmi->evt.type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
2086                 hmi->evt.data.externalbbswindow_scroll.dh = dh;
2087                 hmi->evt.data.externalbbswindow_scroll.dv = dv;
2088                 return True;
2089         }
2090         if (subjectoptionwindow_issetflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_OTHEREVENT) == True) {
2091                 subjectoptionwindow_clearflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_OTHEREVENT);
2092                 subjectoptionwindow_setflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION);
2093                 return False;
2094         } else if (subjectoptionwindow_issetflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION) == True) {
2095                 subjectoptionwindow_clearflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION);
2096                 if (hmi->subjectoptionwindow->filter.nextaction == True) {
2097                         hmi->wev.s.type = EV_NULL;
2098                         subjectoptionwindow_actionfilter(hmi->subjectoptionwindow, &hmi->wev, &hmi->evt);
2099                         return True;
2100                 }
2101         }
2102         if (registerexternalwindow_issetflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT) == True) {
2103                 registerexternalwindow_clearflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT);
2104                 registerexternalwindow_setflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
2105                 return False;
2106         } else if (registerexternalwindow_issetflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION) == True) {
2107                 registerexternalwindow_clearflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
2108                 if (hmi->registerexternalwindow->boradname.nextaction == True) {
2109                         hmi->wev.s.type = EV_NULL;
2110                         registerexternalwindow_actionboradname(hmi->registerexternalwindow, &hmi->wev, &hmi->evt);
2111                         return True;
2112                 }
2113                 if (hmi->registerexternalwindow->url.nextaction == True) {
2114                         hmi->wev.s.type = EV_NULL;
2115                         registerexternalwindow_actionurl(hmi->registerexternalwindow, &hmi->wev, &hmi->evt);
2116                         return True;
2117                 }
2118         }
2119
2120         return False;
2121 }
2122
2123 EXPORT W bchanlhmi_getevent(bchanlhmi_t *hmi, bchanlhmievent_t **evt)
2124 {
2125         WEVENT  *wev0;
2126         Bool ok;
2127
2128         hmi->evt.type = BCHANLHMIEVENT_TYPE_NONE;
2129         *evt = &hmi->evt;
2130         wev0 = &hmi->wev;
2131
2132         ok = bchanlhmi_issetswitchbutdnflag(hmi);
2133         if (ok == True) {
2134                 bchanlhmi_weventbutdn(hmi, wev0, &hmi->evt);
2135                 bchanlhmi_clearswitchbutdnflag(hmi);
2136                 return 0;
2137         }
2138
2139         if (subjectwindow_issetflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_DRAWREQUEST) == True) {
2140                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
2141                 subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_DRAWREQUEST);
2142                 return 0;
2143         }
2144         if (bbsmenuwindow_issetflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_DRAWREQUEST) == True) {
2145                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
2146                 bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_DRAWREQUEST);
2147                 return 0;
2148         }
2149         if (subjectoptionwindow_issetflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_DRAWREQUEST) == True) {
2150                 subjectoptionwindow_redisp(hmi->subjectoptionwindow);
2151                 subjectoptionwindow_clearflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_DRAWREQUEST);
2152                 return 0;
2153         }
2154         if (registerexternalwindow_issetflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_DRAWREQUEST) == True) {
2155                 registerexternalwindow_redisp(hmi->registerexternalwindow);
2156                 registerexternalwindow_clearflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_DRAWREQUEST);
2157                 return 0;
2158         }
2159         if (externalbbswindow_issetflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST) == True) {
2160                 hmi->evt.type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
2161                 externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST);
2162                 return 0;
2163         }
2164
2165         ok = bchanlhmi_checkflag(hmi, evt);
2166         if (ok == True) {
2167                 return 0;
2168         }
2169
2170         wget_evt(wev0, WAIT);
2171         switch (wev0->s.type) {
2172         case    EV_NULL:
2173                 bchanlhmi_weventnull(hmi, wev0, &hmi->evt);
2174                 break;
2175         case    EV_REQUEST:
2176                 bchanlhmi_weventrequest(hmi, wev0, &hmi->evt);
2177                 break;
2178         case    EV_RSWITCH:
2179                 bchanlhmi_weventreswitch(hmi, wev0, &hmi->evt);
2180                 break;
2181         case    EV_SWITCH:
2182                 bchanlhmi_weventswitch(hmi, wev0, &hmi->evt);
2183                 break;
2184         case    EV_BUTDWN:
2185                 bchanlhmi_weventbutdn(hmi, wev0, &hmi->evt);
2186                 break;
2187         case    EV_KEYDWN:
2188         case    EV_AUTKEY:
2189                 hmi->evt.type = BCHANLHMIEVENT_TYPE_COMMON_KEYDOWN;
2190                 hmi->evt.data.common_keydown.keycode = wev0->e.data.key.code;
2191                 hmi->evt.data.common_keydown.keytop = wev0->e.data.key.keytop;
2192                 hmi->evt.data.common_keydown.stat = wev0->e.stat;
2193                 break;
2194         case    EV_INACT:
2195                 pdsp_msg(NULL);
2196                 break;
2197         case    EV_DEVICE:
2198                 oprc_dev(&wev0->e, NULL, 0);
2199                 break;
2200         case    EV_MSG:
2201                 bchanlhmi_receivemessage(hmi, &hmi->evt);
2202                 break;
2203         case    EV_MENU:
2204                 hmi->evt.type = BCHANLHMIEVENT_TYPE_COMMON_MENU;
2205                 hmi->evt.data.common_menu.pos = wev0->s.pos;
2206                 break;
2207         }
2208
2209         return 0;
2210 }
2211
2212 EXPORT subjectwindow_t* subjectwindow_new(RECT *r, WID parent, TC *title, PAT *bgpat)
2213 {
2214         subjectwindow_t *window;
2215         W err;
2216
2217         window = (subjectwindow_t*)malloc(sizeof(subjectwindow_t));
2218         if (window == NULL) {
2219                 return NULL;
2220         }
2221         window->flag = 0;
2222         window->wid = -1;
2223         window->gid = -1;
2224         window->parent = parent;
2225         window->r = *r;
2226         if (bgpat != NULL) {
2227                 window->bgpat = *bgpat;
2228         } else {
2229                 window->bgpat = (PAT){{0, 16, 16, 0x10ffffff, 0, FILL100}};
2230         }
2231         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
2232         if (err < 0) {
2233                 free(window);
2234                 return NULL;
2235         }
2236
2237         err = subjectwindow_open(window, title);
2238         if (err < 0) {
2239                 hmi_windowscroll_finalize(&window->wscr);
2240                 free(window);
2241                 return NULL;
2242         }
2243
2244         return window;
2245 }
2246
2247 LOCAL VOID subjectwindow_delete(subjectwindow_t *window)
2248 {
2249         if (window->wid > 0) {
2250                 wcls_wnd(window->wid, CLR);
2251         }
2252         hmi_windowscroll_finalize(&window->wscr);
2253         free(window);
2254 }
2255
2256 EXPORT bbsmenuwindow_t* bbsmenuwindow_new(RECT *r, WID parent, TC *title, PAT *bgpat)
2257 {
2258         bbsmenuwindow_t *window;
2259         W err;
2260
2261         window = (bbsmenuwindow_t*)malloc(sizeof(bbsmenuwindow_t));
2262         if (window == NULL) {
2263                 return NULL;
2264         }
2265         window->flag = 0;
2266         window->wid = -1;
2267         window->gid = -1;
2268         window->parent = parent;
2269         window->r = *r;
2270         if (bgpat != NULL) {
2271                 window->bgpat = *bgpat;
2272         } else {
2273                 window->bgpat = (PAT){{0, 16, 16, 0x10ffffff, 0, FILL100}};
2274         }
2275         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
2276         if (err < 0) {
2277                 free(window);
2278                 return NULL;
2279         }
2280
2281         err = bbsmenuwindow_open(window, title);
2282         if (err < 0) {
2283                 hmi_windowscroll_finalize(&window->wscr);
2284                 free(window);
2285                 return NULL;
2286         }
2287
2288         return window;
2289 }
2290
2291 LOCAL VOID bbsmenuwindow_delete(bbsmenuwindow_t *window)
2292 {
2293         if (window->wid > 0) {
2294                 wcls_wnd(window->wid, CLR);
2295         }
2296         hmi_windowscroll_finalize(&window->wscr);
2297         free(window);
2298 }
2299
2300 EXPORT subjectoptionwindow_t* subjectoptionwindow_new(PNT *p, subjectwindow_t *parent, TC *title, PAT *bgpat, W dnum_filter, W dnum_order, W dnum_orderby)
2301 {
2302         subjectoptionwindow_t *window;
2303
2304         window = (subjectoptionwindow_t*)malloc(sizeof(subjectoptionwindow_t));
2305         if (window == NULL) {
2306                 return NULL;
2307         }
2308         window->wid = -1;
2309         window->gid = -1;
2310         window->parent = parent;
2311         window->r.c.left = p->x;
2312         window->r.c.top = p->y;
2313         window->r.c.right = p->x + 384;
2314         window->r.c.bottom = p->y + 160;
2315         if (bgpat != NULL) {
2316                 window->bgpat = *bgpat;
2317         } else {
2318                 window->bgpat = (PAT){{0, 16, 16, 0x10ffffff, 0, FILL100}};
2319         }
2320         tc_strset(window->title, TNULL, 256+1);
2321         if (title != 0) {
2322                 tc_strncpy(window->title, title, 256);
2323         } else {
2324                 window->title[0] = 0x2539;
2325                 window->title[1] = 0x256c;
2326                 window->title[2] = 0x306c;
2327                 window->title[3] = 0x4d77;
2328                 window->title[4] = 0x405f;
2329                 window->title[5] = 0x446a;
2330         }
2331         window->filter.id = -1;
2332         window->filter.dnum = dnum_filter;
2333         memset(window->filter.buf, 0, sizeof(TC)*1000);
2334         window->filter.buf[0] = MC_ATTR;
2335         *(COLOR*)(window->filter.buf + 1) = -1;
2336         window->filter.buf[3] = -1;
2337         window->filter.buf[4] = 0;
2338         window->filter.buf[5] = 16;
2339         window->filter.buf[6] = 16;
2340         window->filter.buf[7] = TNULL;
2341         window->filter.nextaction = False;
2342         window->order.id = -1;
2343         window->order.dnum = dnum_order;
2344         window->order.value = 0;
2345         window->orderby.id = -1;
2346         window->orderby.dnum = dnum_orderby;
2347         window->orderby.value = 0;
2348
2349
2350         return window;
2351 }
2352
2353 LOCAL VOID subjectoptionwindow_delete(subjectoptionwindow_t *window)
2354 {
2355         if (window->wid > 0) {
2356                 cdel_pwd(window->wid, NOCLR);
2357                 wcls_wnd(window->wid, CLR);
2358         }
2359         free(window);
2360 }
2361
2362 EXPORT registerexternalwindow_t* registerexternalwindow_new(PNT *p, WID parent, TC *title, PAT *bgpat)
2363 {
2364         registerexternalwindow_t *window;
2365
2366         window = (registerexternalwindow_t*)malloc(sizeof(registerexternalwindow_t));
2367         if (window == NULL) {
2368                 return NULL;
2369         }
2370         window->wid = -1;
2371         window->gid = -1;
2372         window->parent = parent;
2373         window->r.c.left = p->x;
2374         window->r.c.top = p->y;
2375         window->r.c.right = p->x + 384;
2376         window->r.c.bottom = p->y + 138;
2377         if (bgpat != NULL) {
2378                 window->bgpat = *bgpat;
2379         } else {
2380                 window->bgpat = (PAT){{0, 16, 16, 0x10ffffff, 0, FILL100}};
2381         }
2382         tc_strset(window->title, TNULL, 256+1);
2383         if (title != 0) {
2384                 tc_strncpy(window->title, title, 256);
2385         } else {
2386                 window->title[0] = 0x3330;
2387                 window->title[1] = 0x4974;
2388                 window->title[2] = 0x4844;
2389                 window->title[3] = 0x244e;
2390                 window->title[4] = 0x4449;
2391                 window->title[5] = 0x3243;
2392         }
2393         window->boradname.id = -1;
2394         memset(window->boradname.buf, 0, sizeof(TC)*1000);
2395         window->boradname.buf[0] = MC_ATTR;
2396         *(COLOR*)(window->boradname.buf + 1) = -1;
2397         window->boradname.buf[3] = -1;
2398         window->boradname.buf[4] = 0;
2399         window->boradname.buf[5] = 16;
2400         window->boradname.buf[6] = 16;
2401         window->boradname.buf[7] = TNULL;
2402         window->boradname.nextaction = False;
2403         window->url.id = -1;
2404         memset(window->url.buf, 0, sizeof(TC)*1000);
2405         window->url.buf[0] = MC_ATTR;
2406         *(COLOR*)(window->url.buf + 1) = -1;
2407         window->url.buf[3] = -1;
2408         window->url.buf[4] = 0;
2409         window->url.buf[5] = 8;
2410         window->url.buf[6] = 16;
2411         window->url.buf[7] = TNULL;
2412         window->url.nextaction = False;
2413         window->determine.id = -1;
2414         window->cancel.id = -1;
2415
2416
2417         return window;
2418 }
2419
2420 LOCAL VOID registerexternalwindow_delete(registerexternalwindow_t *window)
2421 {
2422         if (window->wid > 0) {
2423                 cdel_pwd(window->wid, NOCLR);
2424                 wcls_wnd(window->wid, CLR);
2425         }
2426         free(window);
2427 }
2428
2429 EXPORT externalbbswindow_t* externalbbswindow_new(RECT *r, WID parent, TC *title, PAT *bgpat)
2430 {
2431         externalbbswindow_t *window;
2432         W err;
2433
2434         window = (externalbbswindow_t*)malloc(sizeof(externalbbswindow_t));
2435         if (window == NULL) {
2436                 return NULL;
2437         }
2438         window->flag = 0;
2439         window->wid = -1;
2440         window->gid = -1;
2441         window->parent = parent;
2442         window->r = *r;
2443         if (bgpat != NULL) {
2444                 window->bgpat = *bgpat;
2445         } else {
2446                 window->bgpat = (PAT){{0, 16, 16, 0x10ffffff, 0, FILL100}};
2447         }
2448         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
2449         if (err < 0) {
2450                 free(window);
2451                 return NULL;
2452         }
2453         tc_strset(window->title, TNULL, 256+1);
2454         if (title != 0) {
2455                 tc_strncpy(window->title, title, 256);
2456         } else {
2457                 window->title[0] = 0x3330;
2458                 window->title[1] = 0x4974;
2459                 window->title[2] = 0x4844;
2460         }
2461
2462
2463         return window;
2464 }
2465
2466 LOCAL VOID externalbbswindow_delete(externalbbswindow_t *window)
2467 {
2468         if (window->wid > 0) {
2469                 wcls_wnd(window->wid, CLR);
2470         }
2471         hmi_windowscroll_finalize(&window->wscr);
2472         free(window);
2473 }
2474
2475 EXPORT subjectwindow_t* bchanlhmi_newsubjectwindow(bchanlhmi_t *hmi, RECT *r, WID parent, TC *title, PAT *bgpat)
2476 {
2477         if (hmi->subjectwindow != NULL) {
2478                 return NULL;
2479         }
2480         hmi->subjectwindow = subjectwindow_new(r, parent, title, bgpat);
2481         return hmi->subjectwindow;
2482 }
2483
2484 EXPORT VOID bchanlhmi_deletesubjectwindow(bchanlhmi_t *hmi, subjectwindow_t *window)
2485 {
2486         subjectwindow_delete(hmi->subjectwindow);
2487         hmi->subjectwindow = NULL;
2488 }
2489
2490 EXPORT bbsmenuwindow_t* bchanlhmi_newbbsmenuwindow(bchanlhmi_t *hmi, RECT *r, WID parent, TC *title, PAT *bgpat)
2491 {
2492         if (hmi->bbsmenuwindow != NULL) {
2493                 return NULL;
2494         }
2495         hmi->bbsmenuwindow = bbsmenuwindow_new(r, parent, title, bgpat);
2496         return hmi->bbsmenuwindow;
2497 }
2498
2499 EXPORT VOID bchanlhmi_deletebbsmenuwindow(bchanlhmi_t *hmi, bbsmenuwindow_t *window)
2500 {
2501         bbsmenuwindow_delete(hmi->bbsmenuwindow);
2502         hmi->bbsmenuwindow = NULL;
2503 }
2504
2505 EXPORT subjectoptionwindow_t* bchanlhmi_newsubjectoptionwindow(bchanlhmi_t *hmi, PNT *p, subjectwindow_t *parent, TC *title, PAT *bgpat, W dnum_filter, W dnum_order, W dnum_orderby)
2506 {
2507         if (parent == NULL) {
2508                 return NULL;
2509         }
2510         if (hmi->subjectoptionwindow != NULL) {
2511                 return NULL;
2512         }
2513         hmi->subjectoptionwindow = subjectoptionwindow_new(p, parent, title, bgpat, dnum_filter, dnum_order, dnum_orderby);
2514         return hmi->subjectoptionwindow;
2515 }
2516
2517 EXPORT VOID bchanlhmi_deletesubjectoptionwindow(bchanlhmi_t *hmi, subjectoptionwindow_t *window)
2518 {
2519         subjectoptionwindow_delete(hmi->subjectoptionwindow);
2520         hmi->subjectoptionwindow = NULL;
2521 }
2522
2523 EXPORT registerexternalwindow_t* bchanlhmi_newregisterexternalwindow(bchanlhmi_t *hmi, PNT *p, WID parent, TC *title, PAT *bgpat)
2524 {
2525         if (hmi->registerexternalwindow != NULL) {
2526                 return NULL;
2527         }
2528         hmi->registerexternalwindow = registerexternalwindow_new(p, parent, title, bgpat);
2529         return hmi->registerexternalwindow;
2530 }
2531
2532 EXPORT VOID bchanlhmi_deleteregisterexternalwindow(bchanlhmi_t *hmi, registerexternalwindow_t *window)
2533 {
2534         registerexternalwindow_delete(hmi->registerexternalwindow);
2535         hmi->registerexternalwindow = NULL;
2536 }
2537
2538 EXPORT externalbbswindow_t* bchanlhmi_newexternalbbswindow(bchanlhmi_t *hmi, RECT *r, WID parent, TC *title, PAT *bgpat)
2539 {
2540         if (hmi->externalbbswindow != NULL) {
2541                 return NULL;
2542         }
2543         hmi->externalbbswindow = externalbbswindow_new(r, parent, title, bgpat);
2544         return hmi->externalbbswindow;
2545 }
2546
2547 EXPORT VOID bchanlhmi_deleteexternalbbswindow(bchanlhmi_t *hmi, externalbbswindow_t *window)
2548 {
2549         externalbbswindow_delete(hmi->externalbbswindow);
2550         hmi->externalbbswindow = NULL;
2551 }
2552
2553
2554 EXPORT bchanlhmi_t* bchanlhmi_new()
2555 {
2556         bchanlhmi_t *hmi;
2557
2558         hmi = (bchanlhmi_t *)malloc(sizeof(bchanlhmi_t));
2559         if (hmi == NULL) {
2560                 return NULL;
2561         }
2562         hmi->flag = 0;
2563         hmi->subjectwindow = NULL;
2564         hmi->bbsmenuwindow = NULL;
2565         hmi->subjectoptionwindow = NULL;
2566         hmi->registerexternalwindow = NULL;
2567         hmi->externalbbswindow = NULL;
2568
2569         return hmi;
2570 }
2571
2572 EXPORT VOID bchanlhmi_delete(bchanlhmi_t *hmi)
2573 {
2574         if (hmi->subjectwindow != NULL) {
2575                 subjectwindow_delete(hmi->subjectwindow);
2576         }
2577         if (hmi->bbsmenuwindow != NULL) {
2578                 bbsmenuwindow_delete(hmi->bbsmenuwindow);
2579         }
2580         if (hmi->subjectoptionwindow != NULL) {
2581                 subjectoptionwindow_delete(hmi->subjectoptionwindow);
2582         }
2583         if (hmi->registerexternalwindow != NULL) {
2584                 registerexternalwindow_delete(hmi->registerexternalwindow);
2585         }
2586         if (hmi->externalbbswindow != NULL) {
2587                 externalbbswindow_delete(hmi->externalbbswindow);
2588         }
2589         free(hmi);
2590 }