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 }
 739
 740 LOCAL VOID subjectoptionwindow_redisp(subjectoptionwindow_t *window)
 741 {
 742         RECT r;
 743         do {
 744                 if (wsta_dsp(window->wid, &r, NULL) == 0) {
 745                         break;
 746                 }
 747                 wera_wnd(window->wid, &r);
 748                 subjectoptionwindow_draw(window, &r);
 749         } while (wend_dsp(window->wid) > 0);
 750 }
 751
 752 EXPORT W subjectoptionwindow_requestredisp(subjectoptionwindow_t *window)
 753 {
 754         return wreq_dsp(window->wid);
 755 }
 756
 757 EXPORT GID subjectoptionwindow_getGID(subjectoptionwindow_t *window)
 758 {
 759         return wget_gid(window->wid);
 760 }
 761
 762 EXPORT WID subjectoptionwindow_getWID(subjectoptionwindow_t *window)
 763 {
 764         return window->wid;
 765 }
 766
 767 EXPORT W subjectoptionwindow_settitle(subjectoptionwindow_t *window, TC *title)
 768 {
 769         tc_strncpy(window->title, title, 256);
 770         window->title[256] = TNULL;
 771         return wset_tit(window->wid, -1, window->title, 0);
 772 }
 773
 774 EXPORT Bool subjectoptionwindow_isactive(subjectoptionwindow_t *window)
 775 {
 776         WID wid;
 777         wid = wget_act(NULL);
 778         if (window->wid == wid) {
 779                 return True;
 780         }
 781         return False;
 782 }
 783
 784 LOCAL VOID subjectoptionwindow_butdnwork(subjectoptionwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 785 {
 786         PAID id;
 787         W ret;
 788
 789         ret = cfnd_par(window->wid, wev->s.pos, &id);
 790         if (ret <= 0) {
 791                 return;
 792         }
 793         if (id == window->filter.id) {
 794                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
 795                 subjectoptionwindow_actionfilter(window, wev, evt);
 796                 return;
 797         }
 798         if (id == window->order.id) {
 799                 subjectoptionwindow_actionorder(window, wev, evt);
 800                 return;
 801         }
 802         if (id == window->orderby.id) {
 803                 subjectoptionwindow_actionorderby(window, wev, evt);
 804                 return;
 805         }
 806 }
 807
 808 EXPORT W subjectoptionwindow_open(subjectoptionwindow_t *window)
 809 {
 810         WID wid;
 811
 812         if (window->wid > 0) {
 813                 return 0;
 814         }
 815
 816         wid = wopn_wnd(WA_STD|WA_SUBW, window->parent->wid, &(window->r), NULL, 2, window->title, &window->bgpat, NULL);
 817         if (wid < 0) {
 818                 DP_ER("wopn_wnd: subjectoption error", wid);
 819                 return wid;
 820         }
 821         window->wid = wid;
 822         window->gid = wget_gid(wid);
 823
 824         window->filter.id = copn_par(wid, window->filter.dnum, NULL);
 825         if (window->filter.id < 0) {
 826                 DP_ER("ccre_xxx filter error:", window->filter.id);
 827         }
 828         cset_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 829         window->order.id = copn_par(wid, window->order.dnum, NULL);
 830         if (window->order.id < 0) {
 831                 DP_ER("ccre_xxx order error:", window->order.id);
 832         }
 833         cset_val(window->order.id, 1, (W*)(&window->order.value));
 834         window->orderby.id = copn_par(wid, window->orderby.dnum, NULL);
 835         if (window->orderby.id < 0) {
 836                 DP_ER("ccre_xxx orderby error:", window->orderby.id);
 837         }
 838         cset_val(window->orderby.id, 1, (W*)(&window->orderby.value));
 839
 840         wreq_dsp(wid);
 841
 842         return 0;
 843 }
 844
 845 EXPORT VOID subjectoptionwindow_close(subjectoptionwindow_t *window)
 846 {
 847         WDSTAT stat;
 848         W err;
 849
 850         if (window->wid < 0) {
 851                 return;
 852         }
 853
 854         stat.attr = WA_STD;
 855         err = wget_sts(window->wid, &stat, NULL);
 856         if (err >= 0) {
 857                 window->r = stat.r;
 858         }
 859         err = cget_val(window->orderby.id, 1, (W*)(&window->orderby.value));
 860         err = cget_val(window->order.id, 1, (W*)(&window->order.value));
 861         err = cget_val(window->filter.id, 1000, (W*)(window->filter.buf+7));
 862         if (err >= 0) {
 863                 window->filter.buf_written = err;
 864         }
 865         cdel_pwd(window->wid, NOCLR);
 866         wcls_wnd(window->wid, CLR);
 867         window->wid = -1;
 868         window->gid = -1;
 869 }
 870
 871 #define REGISTEREXTERNALWINDOW_FLAG_DRAWREQUEST 0x00000001
 872 #define REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT 0x0000000f
 873 #define REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION 0x00000010
 874
 875 #define registerexternalwindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
 876 #define registerexternalwindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
 877 #define registerexternalwindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
 878
 879 EXPORT W registerexternalwindow_setboradnametext(registerexternalwindow_t *window, TC *str, W len)
 880 {
 881         W cp_len;
 882
 883         if (len < 1000) {
 884                 cp_len = len;
 885         } else {
 886                 cp_len = 1000;
 887         }
 888         memcpy(window->boradname.buf+7, str, cp_len * sizeof(TC));
 889         window->boradname.buf[7 + cp_len] = TNULL;
 890         window->boradname.buf_written = cp_len;
 891         if (window->wid < 0) {
 892                 return 0;
 893         }
 894
 895         return cset_val(window->boradname.id, cp_len, (W*)(window->boradname.buf+7));
 896 }
 897
 898 EXPORT W registerexternalwindow_getboradnametext(registerexternalwindow_t *window, TC *str, W len)
 899 {
 900         W err, cp_len;
 901
 902         if (window->wid > 0) {
 903                 err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 904                 if (err < 0) {
 905                         return err;
 906                 }
 907                 window->boradname.buf_written = err;
 908         }
 909
 910         if (len < window->boradname.buf_written) {
 911                 cp_len = len;
 912         } else {
 913                 cp_len = window->boradname.buf_written;
 914         }
 915         memcpy(str, window->boradname.buf + 7, cp_len * sizeof(TC));
 916
 917         return cp_len;
 918 }
 919
 920 EXPORT W registerexternalwindow_cutboradnametext(registerexternalwindow_t *window, TC *str, W len, Bool cut)
 921 {
 922         W err, len0;
 923
 924         len0 = ccut_txt(window->boradname.id, len, str, cut == False ? 0 : 1);
 925         if (len0 < 0) {
 926                 return len0;
 927         }
 928
 929         if (cut != False) {
 930                 err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 931                 if (err < 0) {
 932                         return err;
 933                 }
 934                 window->boradname.buf_written = err;
 935                 return len0;
 936         }
 937
 938         return len0;
 939 }
 940
 941 EXPORT W registerexternalwindow_insertboradnametext(registerexternalwindow_t *window, TC *str, W len)
 942 {
 943         W err;
 944
 945         err = cins_txt(window->boradname.id, (PNT){0x8000, 0x8000}, str);
 946         if (err < 0) {
 947                 return err;
 948         }
 949
 950         err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 951         if (err < 0) {
 952                 return err;
 953         }
 954         window->boradname.buf_written = err;
 955
 956         return err;
 957 }
 958
 959 LOCAL VOID registerexternalwindow_actionboradname(registerexternalwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
 960 {
 961         W i, len;
 962
 963         i = cact_par(window->boradname.id, wev);
 964         if (i & 0x2000) {
 965                 window->boradname.nextaction = True;
 966                 switch (i) {
 967                 case    P_MENU:
 968                         if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
 969                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_KEYMENU;
 970                                 evt->data.registerexternalwindow_boradname_keymenu.keycode = wev->e.data.key.code;
 971                         } else {
 972                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_MENU;
 973                                 evt->data.registerexternalwindow_boradname_menu.pos = wev->s.pos;
 974                         }
 975                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
 976                         break;
 977                 default:
 978                         wugt_evt(wev);
 979                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT);
 980                         break;
 981                 }
 982                 return;
 983         }
 984         window->boradname.nextaction = False;
 985         if (i & 0x1000) {
 986                 len = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
 987                 if (len > 0) {
 988                         window->boradname.buf_written = len;
 989                 }
 990         }
 991         switch (i & 7) {
 992         case    P_BUT:
 993                 cchg_par(window->boradname.id, P_INACT);
 994                 cchg_par(window->boradname.id, P_ACT);
 995                 wugt_evt(wev);
 996                 break;
 997         case    P_TAB:
 998                 break;
 999         case    P_NL:
1000         case    P_END:
1001                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_DETERMINE;
1002                 evt->data.registerexternalwindow_boradname_determine.value = window->boradname.buf+7;
1003                 evt->data.registerexternalwindow_boradname_determine.len = window->boradname.buf_written;
1004                 break;
1005         case    P_MOVE:
1006                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_MOVE;
1007                 evt->data.registerexternalwindow_boradname_move.rel_wid = wev->s.wid;
1008                 evt->data.registerexternalwindow_boradname_move.pos = wev->s.pos;
1009                 break;
1010         case    P_COPY:
1011                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_BORADNAME_COPY;
1012                 evt->data.registerexternalwindow_boradname_copy.rel_wid = wev->s.wid;
1013                 evt->data.registerexternalwindow_boradname_copy.pos = wev->s.pos;
1014                 break;
1015         }
1016 }
1017
1018 EXPORT W registerexternalwindow_seturltext(registerexternalwindow_t *window, TC *str, W len)
1019 {
1020         W cp_len;
1021
1022         if (len < 1000) {
1023                 cp_len = len;
1024         } else {
1025                 cp_len = 1000;
1026         }
1027         memcpy(window->url.buf+7, str, cp_len * sizeof(TC));
1028         window->url.buf[7 + cp_len] = TNULL;
1029         window->url.buf_written = cp_len;
1030         if (window->wid < 0) {
1031                 return 0;
1032         }
1033
1034         return cset_val(window->url.id, cp_len, (W*)(window->url.buf+7));
1035 }
1036
1037 EXPORT W registerexternalwindow_geturltext(registerexternalwindow_t *window, TC *str, W len)
1038 {
1039         W err, cp_len;
1040
1041         if (window->wid > 0) {
1042                 err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1043                 if (err < 0) {
1044                         return err;
1045                 }
1046                 window->url.buf_written = err;
1047         }
1048
1049         if (len < window->url.buf_written) {
1050                 cp_len = len;
1051         } else {
1052                 cp_len = window->url.buf_written;
1053         }
1054         memcpy(str, window->url.buf + 7, cp_len * sizeof(TC));
1055
1056         return cp_len;
1057 }
1058
1059 EXPORT W registerexternalwindow_cuturltext(registerexternalwindow_t *window, TC *str, W len, Bool cut)
1060 {
1061         W err, len0;
1062
1063         len0 = ccut_txt(window->url.id, len, str, cut == False ? 0 : 1);
1064         if (len0 < 0) {
1065                 return len0;
1066         }
1067
1068         if (cut != False) {
1069                 err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1070                 if (err < 0) {
1071                         return err;
1072                 }
1073                 window->url.buf_written = err;
1074                 return len0;
1075         }
1076
1077         return len0;
1078 }
1079
1080 EXPORT W registerexternalwindow_inserturltext(registerexternalwindow_t *window, TC *str, W len)
1081 {
1082         W err;
1083
1084         err = cins_txt(window->url.id, (PNT){0x8000, 0x8000}, str);
1085         if (err < 0) {
1086                 return err;
1087         }
1088
1089         err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1090         if (err < 0) {
1091                 return err;
1092         }
1093         window->url.buf_written = err;
1094
1095         return err;
1096 }
1097
1098 LOCAL VOID registerexternalwindow_actionurl(registerexternalwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
1099 {
1100         W i, len;
1101
1102         i = cact_par(window->url.id, wev);
1103         if (i & 0x2000) {
1104                 window->url.nextaction = True;
1105                 switch (i) {
1106                 case    P_MENU:
1107                         if ((wev->s.type == EV_KEYDWN)&&(wev->s.stat & ES_CMD)) {
1108                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_KEYMENU;
1109                                 evt->data.registerexternalwindow_url_keymenu.keycode = wev->e.data.key.code;
1110                         } else {
1111                                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_MENU;
1112                                 evt->data.registerexternalwindow_url_menu.pos = wev->s.pos;
1113                         }
1114                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
1115                         break;
1116                 default:
1117                         wugt_evt(wev);
1118                         registerexternalwindow_setflag(window, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT);
1119                         break;
1120                 }
1121                 return;
1122         }
1123         window->url.nextaction = False;
1124         if (i & 0x1000) {
1125                 len = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1126                 if (len > 0) {
1127                         window->url.buf_written = len;
1128                 }
1129         }
1130         switch (i & 7) {
1131         case    P_BUT:
1132                 cchg_par(window->url.id, P_INACT);
1133                 cchg_par(window->url.id, P_ACT);
1134                 wugt_evt(wev);
1135                 break;
1136         case    P_TAB:
1137                 break;
1138         case    P_NL:
1139         case    P_END:
1140                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_DETERMINE;
1141                 evt->data.registerexternalwindow_url_determine.value = window->url.buf+7;
1142                 evt->data.registerexternalwindow_url_determine.len = window->url.buf_written;
1143                 break;
1144         case    P_MOVE:
1145                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_MOVE;
1146                 evt->data.registerexternalwindow_url_move.rel_wid = wev->s.wid;
1147                 evt->data.registerexternalwindow_url_move.pos = wev->s.pos;
1148                 break;
1149         case    P_COPY:
1150                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_URL_COPY;
1151                 evt->data.registerexternalwindow_url_copy.rel_wid = wev->s.wid;
1152                 evt->data.registerexternalwindow_url_copy.pos = wev->s.pos;
1153                 break;
1154         }
1155 }
1156
1157 EXPORT Bool registerexternalwindow_isopen(registerexternalwindow_t *window)
1158 {
1159         if (window->wid < 0) {
1160                 return False;
1161         }
1162         return True;
1163 }
1164
1165 LOCAL VOID registerexternalwindow_draw(registerexternalwindow_t *window, RECT *r)
1166 {
1167         cdsp_pwd(window->wid, r, P_RDISP);
1168 }
1169
1170 LOCAL VOID registerexternalwindow_redisp(registerexternalwindow_t *window)
1171 {
1172         RECT r;
1173         do {
1174                 if (wsta_dsp(window->wid, &r, NULL) == 0) {
1175                         break;
1176                 }
1177                 wera_wnd(window->wid, &r);
1178                 registerexternalwindow_draw(window, &r);
1179         } while (wend_dsp(window->wid) > 0);
1180 }
1181
1182 EXPORT W registerexternalwindow_requestredisp(registerexternalwindow_t *window)
1183 {
1184         return wreq_dsp(window->wid);
1185 }
1186
1187 EXPORT GID registerexternalwindow_getGID(registerexternalwindow_t *window)
1188 {
1189         return wget_gid(window->wid);
1190 }
1191
1192 EXPORT WID registerexternalwindow_getWID(registerexternalwindow_t *window)
1193 {
1194         return window->wid;
1195 }
1196
1197 EXPORT W registerexternalwindow_settitle(registerexternalwindow_t *window, TC *title)
1198 {
1199         tc_strncpy(window->title, title, 256);
1200         window->title[256] = TNULL;
1201         return wset_tit(window->wid, -1, window->title, 0);
1202 }
1203
1204 EXPORT Bool registerexternalwindow_isactive(registerexternalwindow_t *window)
1205 {
1206         WID wid;
1207         wid = wget_act(NULL);
1208         if (window->wid == wid) {
1209                 return True;
1210         }
1211         return False;
1212 }
1213
1214 LOCAL VOID registerexternalwindow_butdnwork(registerexternalwindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
1215 {
1216         PAID id;
1217         W ret;
1218
1219         ret = cfnd_par(window->wid, wev->s.pos, &id);
1220         if (ret <= 0) {
1221                 return;
1222         }
1223         if (id == window->boradname.id) {
1224                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
1225                 registerexternalwindow_actionboradname(window, wev, evt);
1226                 return;
1227         }
1228         if (id == window->url.id) {
1229                 memcpy(&window->savedwev, wev, sizeof(WEVENT));
1230                 registerexternalwindow_actionurl(window, wev, evt);
1231                 return;
1232         }
1233         if (id == window->determine.id) {
1234                 ret = cact_par(window->determine.id, wev);
1235                 if ((ret & 0x5000) != 0x5000) {
1236                         return;
1237                 }
1238                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_DETERMINE_PUSH;
1239                 return;
1240         }
1241         if (id == window->cancel.id) {
1242                 ret = cact_par(window->cancel.id, wev);
1243                 if ((ret & 0x5000) != 0x5000) {
1244                         return;
1245                 }
1246                 evt->type = BCHANLHMIEVENT_TYPE_REGISTEREXTERNALWINDOW_PARTS_CANCEL_PUSH;
1247                 return;
1248         }
1249 }
1250
1251 EXPORT W registerexternalwindow_open(registerexternalwindow_t *window)
1252 {
1253         WID wid;
1254         RECT r;
1255
1256         if (window->wid > 0) {
1257                 return 0;
1258         }
1259
1260         wid = wopn_wnd(WA_STD, window->parent, &(window->r), NULL, 2, window->title, &window->bgpat, NULL);
1261         if (wid < 0) {
1262                 DP_ER("wopn_wnd: subjectoption error", wid);
1263                 return wid;
1264         }
1265         window->wid = wid;
1266         window->gid = wget_gid(wid);
1267
1268         r = (RECT){{8, 8, 368, 34}};
1269         window->boradname.id = ccre_tbx(wid, TB_PARTS|P_DISP, &r, 1000, window->boradname.buf, NULL);
1270         if (window->boradname.id < 0) {
1271                 DP_ER("ccre_xxx boradname error:", window->boradname.id);
1272         }
1273         r = (RECT){{8, 38, 368, 64}};
1274         window->url.id = ccre_tbx(wid, TB_PARTS|P_DISP, &r, 1000, window->url.buf, NULL);
1275         if (window->url.id < 0) {
1276                 DP_ER("ccre_xxx url error:", window->url.id);
1277         }
1278         r = (RECT){{158, 108, 300, 134}};
1279         window->determine.id = ccre_msw(wid, MS_PARTS|P_DISP, &r, (TC[]){MC_STR, 0x3768, 0x446a, TNULL}, NULL);
1280         if (window->determine.id < 0) {
1281                 DP_ER("ccre_xxx determine error:", window->determine.id);
1282         }
1283         r = (RECT){{8, 108, 150, 134}};
1284         window->cancel.id = ccre_msw(wid, MS_PARTS|P_DISP, &r, (TC[]){MC_STR, 0x3c68, 0x246a, 0x3e43, 0x2437, TNULL}, NULL);
1285         if (window->cancel.id < 0) {
1286                 DP_ER("ccre_xxx cancel error:", window->cancel.id);
1287         }
1288
1289         wreq_dsp(wid);
1290
1291         return 0;
1292 }
1293
1294 EXPORT VOID registerexternalwindow_close(registerexternalwindow_t *window)
1295 {
1296         WDSTAT stat;
1297         W err;
1298
1299         if (window->wid < 0) {
1300                 return;
1301         }
1302
1303         stat.attr = WA_STD;
1304         err = wget_sts(window->wid, &stat, NULL);
1305         if (err >= 0) {
1306                 window->r = stat.r;
1307         }
1308         err = cget_val(window->url.id, 1000, (W*)(window->url.buf+7));
1309         if (err >= 0) {
1310                 window->url.buf_written = err;
1311         }
1312         err = cget_val(window->boradname.id, 1000, (W*)(window->boradname.buf+7));
1313         if (err >= 0) {
1314                 window->boradname.buf_written = err;
1315         }
1316         cdel_pwd(window->wid, NOCLR);
1317         wcls_wnd(window->wid, CLR);
1318         window->wid = -1;
1319         window->gid = -1;
1320 }
1321
1322 #define EXTERNALBBSWINDOW_FLAG_DRAWREQUEST 0x00000001
1323 #define EXTERNALBBSWINDOW_FLAG_RSCROLLING 0x00000002
1324 #define EXTERNALBBSWINDOW_FLAG_BSCROLLING 0x00000004
1325
1326 #define externalbbswindow_setflag(window, flagx) (window)->flag = (window)->flag | (flagx)
1327 #define externalbbswindow_clearflag(window, flagx) (window)->flag = (window)->flag & ~(flagx)
1328 #define externalbbswindow_issetflag(window, flagx) (((window)->flag & (flagx)) == 0 ? False : True)
1329
1330 EXPORT VOID externalbbswindow_scrollbyvalue(externalbbswindow_t *window, W dh, W dv)
1331 {
1332         hmi_windowscroll_scrollworkrect(&window->wscr, dh, dv);
1333 }
1334
1335 EXPORT W externalbbswindow_setdrawrect(externalbbswindow_t *window, W l, W t, W r, W b)
1336 {
1337         return hmi_windowscroll_setdrawrect(&window->wscr, l, t, r, b);
1338 }
1339
1340 EXPORT W externalbbswindow_setworkrect(externalbbswindow_t *window, W l, W t, W r, W b)
1341 {
1342         return hmi_windowscroll_setworkrect(&window->wscr, l, t, r, b);
1343 }
1344
1345 EXPORT W externalbbswindow_scrollworkarea(externalbbswindow_t *window, W dh, W dv)
1346 {
1347         W err;
1348         err = wscr_wnd(window->wid, NULL, dh, dv, W_MOVE|W_RDSET);
1349         if (err < 0) {
1350                 return err;
1351         }
1352         if ((err & W_RDSET) != 0) {
1353                 externalbbswindow_setflag(window, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST);
1354         }
1355         return 0;
1356 }
1357
1358 EXPORT W externalbbswindow_getworkrect(externalbbswindow_t *window, RECT *r)
1359 {
1360         return wget_wrk(window->wid, r);
1361 }
1362
1363 EXPORT Bool externalbbswindow_isopen(externalbbswindow_t *window)
1364 {
1365         if (window->wid < 0) {
1366                 return False;
1367         }
1368         return True;
1369 }
1370
1371 EXPORT VOID externalbbswindow_responsepasterequest(externalbbswindow_t *window, W nak, PNT *pos)
1372 {
1373         if (pos != NULL) {
1374                 window->savedwev.r.r.p.rightbot.x = pos->x;
1375                 window->savedwev.r.r.p.rightbot.y = pos->y;
1376         }
1377         wrsp_evt(&window->savedwev, nak);
1378 }
1379
1380 EXPORT W externalbbswindow_startredisp(externalbbswindow_t *window, RECT *r)
1381 {
1382         return wsta_dsp(window->wid, r, NULL);
1383 }
1384
1385 EXPORT W externalbbswindow_endredisp(externalbbswindow_t *window)
1386 {
1387         return wend_dsp(window->wid);
1388 }
1389
1390 EXPORT W externalbbswindow_eraseworkarea(externalbbswindow_t *window, RECT *r)
1391 {
1392         return wera_wnd(window->wid, r);
1393 }
1394
1395 EXPORT W externalbbswindow_requestredisp(externalbbswindow_t *window)
1396 {
1397         return wreq_dsp(window->wid);
1398 }
1399
1400 EXPORT GID externalbbswindow_startdrag(externalbbswindow_t *window)
1401 {
1402         return wsta_drg(window->wid, 0);
1403 }
1404
1405 EXPORT W externalbbswindow_getdrag(externalbbswindow_t *window, PNT *pos, WID *wid, PNT *pos_butup)
1406 {
1407         W etype;
1408
1409         etype = wget_drg(pos, &window->savedwev);
1410         *wid = window->savedwev.s.wid;
1411         if (etype == EV_BUTUP) {
1412                 *pos_butup = window->savedwev.s.pos;
1413         }
1414
1415         return etype;
1416 }
1417
1418 EXPORT VOID externalbbswindow_enddrag(externalbbswindow_t *window)
1419 {
1420         wend_drg();
1421 }
1422
1423 EXPORT GID externalbbswindow_getGID(externalbbswindow_t *window)
1424 {
1425         return wget_gid(window->wid);
1426 }
1427
1428 EXPORT WID externalbbswindow_getWID(externalbbswindow_t *window)
1429 {
1430         return window->wid;
1431 }
1432
1433 EXPORT W externalbbswindow_settitle(externalbbswindow_t *window, TC *title)
1434 {
1435         tc_strncpy(window->title, title, 256);
1436         window->title[256] = TNULL;
1437         return wset_tit(window->wid, -1, window->title, 0);
1438 }
1439
1440 EXPORT Bool externalbbswindow_isactive(externalbbswindow_t *window)
1441 {
1442         WID wid;
1443         wid = wget_act(NULL);
1444         if (window->wid == wid) {
1445                 return True;
1446         }
1447         return False;
1448 }
1449
1450 LOCAL VOID externalbbswindow_butdnwork(externalbbswindow_t *window, WEVENT *wev, bchanlhmievent_t *evt)
1451 {
1452         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_BUTDN;
1453         evt->data.externalbbswindow_butdn.type = wchk_dck(wev->s.time);
1454         evt->data.externalbbswindow_butdn.pos = wev->s.pos;
1455         memcpy(&window->savedwev, wev, sizeof(WEVENT));
1456 }
1457
1458 LOCAL VOID externalbbswindow_resize(externalbbswindow_t *window, SIZE *sz)
1459 {
1460         RECT work;
1461         Bool workchange = False;
1462
1463         wget_wrk(window->wid, &work);
1464         if (work.c.left != 0) {
1465                 work.c.left = 0;
1466                 workchange = True;
1467         }
1468         if (work.c.top != 0) {
1469                 work.c.top = 0;
1470                 workchange = True;
1471         }
1472         wset_wrk(window->wid, &work);
1473         gset_vis(window->gid, work);
1474
1475         if (workchange == True) {
1476                 wera_wnd(window->wid, NULL);
1477                 wreq_dsp(window->wid);
1478         }
1479
1480         sz->v = work.c.bottom - work.c.top;
1481         sz->h = work.c.right - work.c.left;
1482 }
1483
1484 EXPORT W externalbbswindow_open(externalbbswindow_t *window)
1485 {
1486         WID wid;
1487
1488         if (window->wid > 0) {
1489                 return 0;
1490         }
1491
1492         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);
1493         if (wid < 0) {
1494                 DP_ER("wopn_wnd: subjectoption error", wid);
1495                 return wid;
1496         }
1497         window->wid = wid;
1498         window->gid = wget_gid(wid);
1499         hmi_windowscroll_settarget(&window->wscr, wid);
1500
1501
1502         wreq_dsp(wid);
1503
1504         return 0;
1505 }
1506
1507 EXPORT VOID externalbbswindow_close(externalbbswindow_t *window)
1508 {
1509         WDSTAT stat;
1510         W err;
1511
1512         if (window->wid < 0) {
1513                 return;
1514         }
1515
1516         stat.attr = WA_STD;
1517         err = wget_sts(window->wid, &stat, NULL);
1518         if (err >= 0) {
1519                 window->r = stat.r;
1520         }
1521         wcls_wnd(window->wid, CLR);
1522         window->wid = -1;
1523         window->gid = -1;
1524 }
1525
1526 LOCAL VOID bchanlhmi_setswitchbutdnflag(bchanlhmi_t *hmi)
1527 {
1528         hmi->flag = hmi->flag | BCHANLHMI_FLAG_SWITCHBUTDN;
1529 }
1530
1531 LOCAL VOID bchanlhmi_clearswitchbutdnflag(bchanlhmi_t *hmi)
1532 {
1533         hmi->flag = hmi->flag & ~BCHANLHMI_FLAG_SWITCHBUTDN;
1534 }
1535
1536 LOCAL Bool bchanlhmi_issetswitchbutdnflag(bchanlhmi_t *hmi)
1537 {
1538         if ((hmi->flag & BCHANLHMI_FLAG_SWITCHBUTDN) == 0) {
1539                 return False;
1540         }
1541         return True;
1542 }
1543
1544 LOCAL Bool bchanlhmi_issubjectwindowWID(bchanlhmi_t *hmi, WID wid)
1545 {
1546         if (hmi->subjectwindow->wid == wid) {
1547                 return True;
1548         }
1549         return False;
1550 }
1551
1552 LOCAL Bool bchanlhmi_isbbsmenuwindowWID(bchanlhmi_t *hmi, WID wid)
1553 {
1554         if (hmi->bbsmenuwindow->wid == wid) {
1555                 return True;
1556         }
1557         return False;
1558 }
1559
1560 LOCAL Bool bchanlhmi_issubjectoptionwindowWID(bchanlhmi_t *hmi, WID wid)
1561 {
1562         if (hmi->subjectoptionwindow->wid == wid) {
1563                 return True;
1564         }
1565         return False;
1566 }
1567
1568 LOCAL Bool bchanlhmi_isregisterexternalwindowWID(bchanlhmi_t *hmi, WID wid)
1569 {
1570         if (hmi->registerexternalwindow->wid == wid) {
1571                 return True;
1572         }
1573         return False;
1574 }
1575
1576 LOCAL Bool bchanlhmi_isexternalbbswindowWID(bchanlhmi_t *hmi, WID wid)
1577 {
1578         if (hmi->externalbbswindow->wid == wid) {
1579                 return True;
1580         }
1581         return False;
1582 }
1583
1584 LOCAL VOID bchanlhmi_weventnull(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1585 {
1586         cidl_par(wev->s.wid, &wev->s.pos);
1587         if (wev->s.cmd != W_WORK)
1588                 return;         /*ºî¶ÈÎÎ°è³°*/
1589         if (wev->s.stat & ES_CMD)
1590                 return; /*Ì¿Îá¥¡¼¤¬²¡¤µ¤ì¤Æ¤¤¤ë*/
1591         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1592                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_MOUSEMOVE;
1593                 hmi->evt.data.subjectwindow_mousemove.pos = wev->s.pos;
1594                 hmi->evt.data.subjectwindow_mousemove.stat = wev->s.stat;
1595                 return;
1596         }
1597         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1598                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_MOUSEMOVE;
1599                 hmi->evt.data.bbsmenuwindow_mousemove.pos = wev->s.pos;
1600                 hmi->evt.data.bbsmenuwindow_mousemove.stat = wev->s.stat;
1601                 return;
1602         }
1603         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1604                 cidl_par(wev->s.wid, &wev->s.pos);
1605                 return;
1606         }
1607         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1608                 cidl_par(wev->s.wid, &wev->s.pos);
1609                 return;
1610         }
1611         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1612                 gset_ptr(PS_SELECT, NULL, -1, -1);
1613                 return;
1614         }
1615         /*¥¦¥£¥ó¥É¥¦³°*/
1616         hmi->evt.type = BCHANLHMIEVENT_TYPE_COMMON_MOUSEMOVE;
1617         hmi->evt.data.common_mousemove.pos = wev->s.pos;
1618 }
1619
1620 LOCAL VOID bchanlhmi_weventrequest(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1621 {
1622         switch (wev->g.cmd) {
1623         case    W_REDISP:       /*ºÆÉ½¼¨Í×µá*/
1624                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1625                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
1626                         break;
1627                 }
1628                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->g.wid) == True) {
1629                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
1630                         break;
1631                 }
1632                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->g.wid) == True) {
1633                         subjectoptionwindow_redisp(hmi->subjectoptionwindow);
1634                         break;
1635                 }
1636                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->g.wid) == True) {
1637                         registerexternalwindow_redisp(hmi->registerexternalwindow);
1638                         break;
1639                 }
1640                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1641                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
1642                         break;
1643                 }
1644                 break;
1645         case    W_PASTE:        /*Å½¹þ¤ßÍ×µá*/
1646                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1647                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_PASTE;
1648                         memcpy(&hmi->subjectwindow->savedwev, wev, sizeof(WEVENT));
1649                         break;
1650                 }
1651                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1652                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_PASTE;
1653                         memcpy(&hmi->externalbbswindow->savedwev, wev, sizeof(WEVENT));
1654                         break;
1655                 }
1656                 wrsp_evt(wev, 1); /*NACK*/
1657                 break;
1658         case    W_DELETE:       /*ÊÝÂ¸½ªÎ»*/
1659                 wrsp_evt(wev, 0);       /*ACK*/
1660                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1661                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_CLOSE;
1662                         evt->data.subjectwindow_close.save = True;
1663                         break;
1664                 }
1665                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->g.wid) == True) {
1666                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_CLOSE;
1667                         evt->data.bbsmenuwindow_close.save = True;
1668                         break;
1669                 }
1670                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->g.wid) == True) {
1671                         subjectoptionwindow_close(hmi->subjectoptionwindow);
1672                         break;
1673                 }
1674                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->g.wid) == True) {
1675                         registerexternalwindow_close(hmi->registerexternalwindow);
1676                         break;
1677                 }
1678                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1679                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_CLOSE;
1680                         evt->data.externalbbswindow_close.save = True;
1681                         break;
1682                 }
1683                 break;
1684         case    W_FINISH:       /*ÇÑ´þ½ªÎ»*/
1685                 wrsp_evt(wev, 0);       /*ACK*/
1686                 if (bchanlhmi_issubjectwindowWID(hmi, wev->g.wid) == True) {
1687                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_CLOSE;
1688                         evt->data.subjectwindow_close.save = False;
1689                         break;
1690                 }
1691                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->g.wid) == True) {
1692                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_CLOSE;
1693                         evt->data.bbsmenuwindow_close.save = False;
1694                         break;
1695                 }
1696                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->g.wid) == True) {
1697                         subjectoptionwindow_close(hmi->subjectoptionwindow);
1698                         break;
1699                 }
1700                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->g.wid) == True) {
1701                         registerexternalwindow_close(hmi->registerexternalwindow);
1702                         break;
1703                 }
1704                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->g.wid) == True) {
1705                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_CLOSE;
1706                         evt->data.externalbbswindow_close.save = False;
1707                         break;
1708                 }
1709                 break;
1710         }
1711 }
1712
1713 LOCAL VOID bchanlhmi_weventbutdn(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1714 {
1715         W i, err;
1716         W dh, dv; /* TODO: add check for exist scrollable window */
1717
1718         switch  (wev->s.cmd) {
1719         case    W_PICT:
1720                 switch (wchk_dck(wev->s.time)) {
1721                 case    W_DCLICK:
1722                         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1723                                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_CLOSE;
1724                                 evt->data.subjectwindow_close.save = True; /* TODO: tmp value */
1725                                 return;
1726                         }
1727                         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1728                                 evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_CLOSE;
1729                                 evt->data.bbsmenuwindow_close.save = True; /* TODO: tmp value */
1730                                 return;
1731                         }
1732                         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1733                                 subjectoptionwindow_close(hmi->subjectoptionwindow);
1734                                 return;
1735                         }
1736                         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1737                                 registerexternalwindow_close(hmi->registerexternalwindow);
1738                                 return;
1739                         }
1740                         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1741                                 evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_CLOSE;
1742                                 evt->data.externalbbswindow_close.save = True; /* TODO: tmp value */
1743                                 return;
1744                         }
1745                         return;
1746                 case    W_PRESS:
1747                         break;
1748                 default:
1749                         return;
1750                 }
1751         case    W_FRAM:
1752         case    W_TITL:
1753                 if (wmov_drg(wev, NULL) > 0) {
1754                         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1755                                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
1756                                 return;
1757                         }
1758                         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1759                                 evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
1760                                 return;
1761                         }
1762                         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1763                                 subjectoptionwindow_redisp(hmi->subjectoptionwindow);
1764                                 return;
1765                         }
1766                         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1767                                 registerexternalwindow_redisp(hmi->registerexternalwindow);
1768                                 return;
1769                         }
1770                         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1771                                 evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
1772                                 return;
1773                         }
1774                 }
1775                 return;
1776         case    W_LTHD:
1777         case    W_RTHD:
1778         case    W_LBHD:
1779         case    W_RBHD:
1780                 switch (wchk_dck(wev->s.time)) {
1781                 case    W_DCLICK:
1782                         i = wchg_wnd(wev->s.wid, NULL, W_MOVE);
1783                         break;
1784                 case    W_PRESS:
1785                         i = wrsz_drg(wev, NULL, NULL);
1786                         break;
1787                 default:
1788                         return;
1789                 }
1790
1791                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1792                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_RESIZE;
1793                         subjectwindow_resize(hmi->subjectwindow, &evt->data.subjectwindow_resize.work_sz);
1794                         hmi_windowscroll_updatebar(&hmi->subjectwindow->wscr);
1795                         if (i > 0) {
1796                                 subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_DRAWREQUEST);
1797                         }
1798                         return;
1799                 }
1800                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1801                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_RESIZE;
1802                         bbsmenuwindow_resize(hmi->bbsmenuwindow, &evt->data.bbsmenuwindow_resize.work_sz);
1803                         hmi_windowscroll_updatebar(&hmi->bbsmenuwindow->wscr);
1804                         if (i > 0) {
1805                                 bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_DRAWREQUEST);
1806                         }
1807                         return;
1808                 }
1809                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1810                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_RESIZE;
1811                         externalbbswindow_resize(hmi->externalbbswindow, &evt->data.externalbbswindow_resize.work_sz);
1812                         hmi_windowscroll_updatebar(&hmi->externalbbswindow->wscr);
1813                         if (i > 0) {
1814                                 externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST);
1815                         }
1816                         return;
1817                 }
1818                 return;
1819         case    W_RBAR:
1820                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1821                         err = hmi_windowscroll_weventrbar(&hmi->subjectwindow->wscr, wev, &dh, &dv);
1822                         if (err < 0) {
1823                                 return;
1824                         }
1825                         if (err == 0) {
1826                                 subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1827                         } else {
1828                                 subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1829                         }
1830                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
1831                         evt->data.subjectwindow_scroll.dh = dh;
1832                         evt->data.subjectwindow_scroll.dv = dv;
1833                         return;
1834                 }
1835                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1836                         err = hmi_windowscroll_weventrbar(&hmi->bbsmenuwindow->wscr, wev, &dh, &dv);
1837                         if (err < 0) {
1838                                 return;
1839                         }
1840                         if (err == 0) {
1841                                 bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
1842                         } else {
1843                                 bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
1844                         }
1845                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
1846                         evt->data.bbsmenuwindow_scroll.dh = dh;
1847                         evt->data.bbsmenuwindow_scroll.dv = dv;
1848                         return;
1849                 }
1850                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1851                         err = hmi_windowscroll_weventrbar(&hmi->externalbbswindow->wscr, wev, &dh, &dv);
1852                         if (err < 0) {
1853                                 return;
1854                         }
1855                         if (err == 0) {
1856                                 externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
1857                         } else {
1858                                 externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
1859                         }
1860                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
1861                         evt->data.externalbbswindow_scroll.dh = dh;
1862                         evt->data.externalbbswindow_scroll.dv = dv;
1863                         return;
1864                 }
1865                 return;
1866         case    W_BBAR:
1867                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1868                         err = hmi_windowscroll_weventbbar(&hmi->subjectwindow->wscr, wev, &dh, &dv);
1869                         if (err < 0) {
1870                                 return;
1871                         }
1872                         if (err == 0) {
1873                                 subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
1874                         } else {
1875                                 subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
1876                         }
1877                         evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
1878                         evt->data.subjectwindow_scroll.dh = dh;
1879                         evt->data.subjectwindow_scroll.dv = dv;
1880                         return;
1881                 }
1882                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1883                         err = hmi_windowscroll_weventbbar(&hmi->bbsmenuwindow->wscr, wev, &dh, &dv);
1884                         if (err < 0) {
1885                                 return;
1886                         }
1887                         if (err == 0) {
1888                                 bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
1889                         } else {
1890                                 bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
1891                         }
1892                         evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
1893                         evt->data.bbsmenuwindow_scroll.dh = dh;
1894                         evt->data.bbsmenuwindow_scroll.dv = dv;
1895                         return;
1896                 }
1897                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1898                         err = hmi_windowscroll_weventbbar(&hmi->externalbbswindow->wscr, wev, &dh, &dv);
1899                         if (err < 0) {
1900                                 return;
1901                         }
1902                         if (err == 0) {
1903                                 externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
1904                         } else {
1905                                 externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
1906                         }
1907                         evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
1908                         evt->data.externalbbswindow_scroll.dh = dh;
1909                         evt->data.externalbbswindow_scroll.dv = dv;
1910                         return;
1911                 }
1912                 return;
1913         case    W_WORK:
1914                 if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1915                         subjectwindow_butdnwork(hmi->subjectwindow, wev, evt);
1916                         return;
1917                 }
1918                 if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1919                         bbsmenuwindow_butdnwork(hmi->bbsmenuwindow, wev, evt);
1920                         return;
1921                 }
1922                 if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1923                         subjectoptionwindow_butdnwork(hmi->subjectoptionwindow, wev, evt);
1924                         return;
1925                 }
1926                 if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1927                         registerexternalwindow_butdnwork(hmi->registerexternalwindow, wev, evt);
1928                         return;
1929                 }
1930                 if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1931                         externalbbswindow_butdnwork(hmi->externalbbswindow, wev, evt);
1932                         return;
1933                 }
1934                 return;
1935         }
1936
1937         return;
1938 }
1939
1940 LOCAL VOID bchanlhmi_weventswitch(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1941 {
1942         bchanlhmi_setswitchbutdnflag(hmi);
1943 }
1944
1945 LOCAL VOID bchanlhmi_weventreswitch(bchanlhmi_t *hmi, WEVENT *wev, bchanlhmievent_t *evt)
1946 {
1947         bchanlhmi_setswitchbutdnflag(hmi);
1948         if (bchanlhmi_issubjectwindowWID(hmi, wev->s.wid) == True) {
1949                 evt->type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
1950         }
1951         if (bchanlhmi_isbbsmenuwindowWID(hmi, wev->s.wid) == True) {
1952                 evt->type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
1953         }
1954         if (bchanlhmi_issubjectoptionwindowWID(hmi, wev->s.wid) == True) {
1955                 subjectoptionwindow_redisp(hmi->subjectoptionwindow);
1956                 return;
1957         }
1958         if (bchanlhmi_isregisterexternalwindowWID(hmi, wev->s.wid) == True) {
1959                 registerexternalwindow_redisp(hmi->registerexternalwindow);
1960                 return;
1961         }
1962         if (bchanlhmi_isexternalbbswindowWID(hmi, wev->s.wid) == True) {
1963                 evt->type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
1964         }
1965 }
1966
1967 LOCAL VOID bchanlhmi_receivemessage(bchanlhmi_t *hmi, bchanlhmievent_t *evt)
1968 {
1969         MESSAGE msg;
1970         W err;
1971
1972         err = rcv_msg(MM_ALL, &msg, sizeof(MESSAGE), WAIT|NOCLR);
1973         if (err >= 0) {
1974                 if (msg.msg_type == MS_TMOUT) { /* should be use other type? */
1975                         evt->type = BCHANLHMIEVENT_TYPE_COMMON_TIMEOUT;
1976                         evt->data.common_timeout.code = msg.msg_body.TMOUT.code;
1977                 }
1978         }
1979         clr_msg(MM_ALL, MM_ALL);
1980 }
1981
1982 LOCAL Bool bchanlhmi_checkflag(bchanlhmi_t *hmi, bchanlhmievent_t **evt)
1983 {
1984         W err, dh, dv;
1985
1986         if (subjectwindow_issetflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING) == True) {
1987                 err = hmi_windowscroll_weventrbar(&hmi->subjectwindow->wscr, &hmi->wev, &dh, &dv);
1988                 if (err < 0) {
1989                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1990                         return False;
1991                 }
1992                 if (err == 0) {
1993                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1994                 } else {
1995                         subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_RSCROLLING);
1996                 }
1997                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
1998                 hmi->evt.data.subjectwindow_scroll.dh = dh;
1999                 hmi->evt.data.subjectwindow_scroll.dv = dv;
2000                 return True;
2001         }
2002         if (subjectwindow_issetflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING) == True) {
2003                 err = hmi_windowscroll_weventbbar(&hmi->subjectwindow->wscr, &hmi->wev, &dh, &dv);
2004                 if (err < 0) {
2005                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
2006                         return False;
2007                 }
2008                 if (err == 0) {
2009                         subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
2010                 } else {
2011                         subjectwindow_setflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_BSCROLLING);
2012                 }
2013                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_SCROLL;
2014                 hmi->evt.data.subjectwindow_scroll.dh = dh;
2015                 hmi->evt.data.subjectwindow_scroll.dv = dv;
2016                 return True;
2017         }
2018         if (bbsmenuwindow_issetflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING) == True) {
2019                 err = hmi_windowscroll_weventrbar(&hmi->bbsmenuwindow->wscr, &hmi->wev, &dh, &dv);
2020                 if (err < 0) {
2021                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
2022                         return False;
2023                 }
2024                 if (err == 0) {
2025                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
2026                 } else {
2027                         bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_RSCROLLING);
2028                 }
2029                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
2030                 hmi->evt.data.bbsmenuwindow_scroll.dh = dh;
2031                 hmi->evt.data.bbsmenuwindow_scroll.dv = dv;
2032                 return True;
2033         }
2034         if (bbsmenuwindow_issetflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING) == True) {
2035                 err = hmi_windowscroll_weventbbar(&hmi->bbsmenuwindow->wscr, &hmi->wev, &dh, &dv);
2036                 if (err < 0) {
2037                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
2038                         return False;
2039                 }
2040                 if (err == 0) {
2041                         bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
2042                 } else {
2043                         bbsmenuwindow_setflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_BSCROLLING);
2044                 }
2045                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_SCROLL;
2046                 hmi->evt.data.bbsmenuwindow_scroll.dh = dh;
2047                 hmi->evt.data.bbsmenuwindow_scroll.dv = dv;
2048                 return True;
2049         }
2050         if (externalbbswindow_issetflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING) == True) {
2051                 err = hmi_windowscroll_weventrbar(&hmi->externalbbswindow->wscr, &hmi->wev, &dh, &dv);
2052                 if (err < 0) {
2053                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
2054                         return False;
2055                 }
2056                 if (err == 0) {
2057                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
2058                 } else {
2059                         externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_RSCROLLING);
2060                 }
2061                 hmi->evt.type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
2062                 hmi->evt.data.externalbbswindow_scroll.dh = dh;
2063                 hmi->evt.data.externalbbswindow_scroll.dv = dv;
2064                 return True;
2065         }
2066         if (externalbbswindow_issetflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING) == True) {
2067                 err = hmi_windowscroll_weventbbar(&hmi->externalbbswindow->wscr, &hmi->wev, &dh, &dv);
2068                 if (err < 0) {
2069                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
2070                         return False;
2071                 }
2072                 if (err == 0) {
2073                         externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
2074                 } else {
2075                         externalbbswindow_setflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_BSCROLLING);
2076                 }
2077                 hmi->evt.type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_SCROLL;
2078                 hmi->evt.data.externalbbswindow_scroll.dh = dh;
2079                 hmi->evt.data.externalbbswindow_scroll.dv = dv;
2080                 return True;
2081         }
2082         if (subjectoptionwindow_issetflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_OTHEREVENT) == True) {
2083                 subjectoptionwindow_clearflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_OTHEREVENT);
2084                 subjectoptionwindow_setflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION);
2085                 return False;
2086         } else if (subjectoptionwindow_issetflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION) == True) {
2087                 subjectoptionwindow_clearflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_PARTS_NEXTACTION);
2088                 if (hmi->subjectoptionwindow->filter.nextaction == True) {
2089                         hmi->wev.s.type = EV_NULL;
2090                         subjectoptionwindow_actionfilter(hmi->subjectoptionwindow, &hmi->wev, &hmi->evt);
2091                         return True;
2092                 }
2093         }
2094         if (registerexternalwindow_issetflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT) == True) {
2095                 registerexternalwindow_clearflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_OTHEREVENT);
2096                 registerexternalwindow_setflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
2097                 return False;
2098         } else if (registerexternalwindow_issetflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION) == True) {
2099                 registerexternalwindow_clearflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_PARTS_NEXTACTION);
2100                 if (hmi->registerexternalwindow->boradname.nextaction == True) {
2101                         hmi->wev.s.type = EV_NULL;
2102                         registerexternalwindow_actionboradname(hmi->registerexternalwindow, &hmi->wev, &hmi->evt);
2103                         return True;
2104                 }
2105                 if (hmi->registerexternalwindow->url.nextaction == True) {
2106                         hmi->wev.s.type = EV_NULL;
2107                         registerexternalwindow_actionurl(hmi->registerexternalwindow, &hmi->wev, &hmi->evt);
2108                         return True;
2109                 }
2110         }
2111
2112         return False;
2113 }
2114
2115 EXPORT W bchanlhmi_getevent(bchanlhmi_t *hmi, bchanlhmievent_t **evt)
2116 {
2117         WEVENT  *wev0;
2118         Bool ok;
2119
2120         hmi->evt.type = BCHANLHMIEVENT_TYPE_NONE;
2121         *evt = &hmi->evt;
2122         wev0 = &hmi->wev;
2123
2124         ok = bchanlhmi_issetswitchbutdnflag(hmi);
2125         if (ok == True) {
2126                 bchanlhmi_weventbutdn(hmi, wev0, &hmi->evt);
2127                 bchanlhmi_clearswitchbutdnflag(hmi);
2128                 return 0;
2129         }
2130
2131         if (subjectwindow_issetflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_DRAWREQUEST) == True) {
2132                 hmi->evt.type = BCHANLHMIEVENT_TYPE_SUBJECTWINDOW_DRAW;
2133                 subjectwindow_clearflag(hmi->subjectwindow, SUBJECTWINDOW_FLAG_DRAWREQUEST);
2134                 return 0;
2135         }
2136         if (bbsmenuwindow_issetflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_DRAWREQUEST) == True) {
2137                 hmi->evt.type = BCHANLHMIEVENT_TYPE_BBSMENUWINDOW_DRAW;
2138                 bbsmenuwindow_clearflag(hmi->bbsmenuwindow, BBSMENUWINDOW_FLAG_DRAWREQUEST);
2139                 return 0;
2140         }
2141         if (subjectoptionwindow_issetflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_DRAWREQUEST) == True) {
2142                 subjectoptionwindow_redisp(hmi->subjectoptionwindow);
2143                 subjectoptionwindow_clearflag(hmi->subjectoptionwindow, SUBJECTOPTIONWINDOW_FLAG_DRAWREQUEST);
2144                 return 0;
2145         }
2146         if (registerexternalwindow_issetflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_DRAWREQUEST) == True) {
2147                 registerexternalwindow_redisp(hmi->registerexternalwindow);
2148                 registerexternalwindow_clearflag(hmi->registerexternalwindow, REGISTEREXTERNALWINDOW_FLAG_DRAWREQUEST);
2149                 return 0;
2150         }
2151         if (externalbbswindow_issetflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST) == True) {
2152                 hmi->evt.type = BCHANLHMIEVENT_TYPE_EXTERNALBBSWINDOW_DRAW;
2153                 externalbbswindow_clearflag(hmi->externalbbswindow, EXTERNALBBSWINDOW_FLAG_DRAWREQUEST);
2154                 return 0;
2155         }
2156
2157         ok = bchanlhmi_checkflag(hmi, evt);
2158         if (ok == True) {
2159                 return 0;
2160         }
2161
2162         wget_evt(wev0, WAIT);
2163         switch (wev0->s.type) {
2164         case    EV_NULL:
2165                 bchanlhmi_weventnull(hmi, wev0, &hmi->evt);
2166                 break;
2167         case    EV_REQUEST:
2168                 bchanlhmi_weventrequest(hmi, wev0, &hmi->evt);
2169                 break;
2170         case    EV_RSWITCH:
2171                 bchanlhmi_weventreswitch(hmi, wev0, &hmi->evt);
2172                 break;
2173         case    EV_SWITCH:
2174                 bchanlhmi_weventswitch(hmi, wev0, &hmi->evt);
2175                 break;
2176         case    EV_BUTDWN:
2177                 bchanlhmi_weventbutdn(hmi, wev0, &hmi->evt);
2178                 break;
2179         case    EV_KEYDWN:
2180         case    EV_AUTKEY:
2181                 hmi->evt.type = BCHANLHMIEVENT_TYPE_COMMON_KEYDOWN;
2182                 hmi->evt.data.common_keydown.keycode = wev0->e.data.key.code;
2183                 hmi->evt.data.common_keydown.keytop = wev0->e.data.key.keytop;
2184                 hmi->evt.data.common_keydown.stat = wev0->e.stat;
2185                 break;
2186         case    EV_INACT:
2187                 pdsp_msg(NULL);
2188                 break;
2189         case    EV_DEVICE:
2190                 oprc_dev(&wev0->e, NULL, 0);
2191                 break;
2192         case    EV_MSG:
2193                 bchanlhmi_receivemessage(hmi, &hmi->evt);
2194                 break;
2195         case    EV_MENU:
2196                 hmi->evt.type = BCHANLHMIEVENT_TYPE_COMMON_MENU;
2197                 hmi->evt.data.common_menu.pos = wev0->s.pos;
2198                 break;
2199         }
2200
2201         return 0;
2202 }
2203
2204 EXPORT subjectwindow_t* subjectwindow_new(RECT *r, WID parent, TC *title, PAT *bgpat)
2205 {
2206         subjectwindow_t *window;
2207         W err;
2208
2209         window = (subjectwindow_t*)malloc(sizeof(subjectwindow_t));
2210         if (window == NULL) {
2211                 return NULL;
2212         }
2213         window->flag = 0;
2214         window->wid = -1;
2215         window->gid = -1;
2216         window->parent = parent;
2217         window->r = *r;
2218         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
2219         if (err < 0) {
2220                 free(window);
2221                 return NULL;
2222         }
2223
2224         err = subjectwindow_open(window, title);
2225         if (err < 0) {
2226                 hmi_windowscroll_finalize(&window->wscr);
2227                 free(window);
2228                 return NULL;
2229         }
2230
2231         return window;
2232 }
2233
2234 LOCAL VOID subjectwindow_delete(subjectwindow_t *window)
2235 {
2236         if (window->wid > 0) {
2237                 wcls_wnd(window->wid, CLR);
2238         }
2239         hmi_windowscroll_finalize(&window->wscr);
2240         free(window);
2241 }
2242
2243 EXPORT bbsmenuwindow_t* bbsmenuwindow_new(RECT *r, WID parent, TC *title, PAT *bgpat)
2244 {
2245         bbsmenuwindow_t *window;
2246         W err;
2247
2248         window = (bbsmenuwindow_t*)malloc(sizeof(bbsmenuwindow_t));
2249         if (window == NULL) {
2250                 return NULL;
2251         }
2252         window->flag = 0;
2253         window->wid = -1;
2254         window->gid = -1;
2255         window->parent = parent;
2256         window->r = *r;
2257         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
2258         if (err < 0) {
2259                 free(window);
2260                 return NULL;
2261         }
2262
2263         err = bbsmenuwindow_open(window, title);
2264         if (err < 0) {
2265                 hmi_windowscroll_finalize(&window->wscr);
2266                 free(window);
2267                 return NULL;
2268         }
2269
2270         return window;
2271 }
2272
2273 LOCAL VOID bbsmenuwindow_delete(bbsmenuwindow_t *window)
2274 {
2275         if (window->wid > 0) {
2276                 wcls_wnd(window->wid, CLR);
2277         }
2278         hmi_windowscroll_finalize(&window->wscr);
2279         free(window);
2280 }
2281
2282 EXPORT subjectoptionwindow_t* subjectoptionwindow_new(PNT *p, subjectwindow_t *parent, TC *title, PAT *bgpat, W dnum_filter, W dnum_order, W dnum_orderby)
2283 {
2284         subjectoptionwindow_t *window;
2285
2286         window = (subjectoptionwindow_t*)malloc(sizeof(subjectoptionwindow_t));
2287         if (window == NULL) {
2288                 return NULL;
2289         }
2290         window->wid = -1;
2291         window->gid = -1;
2292         window->parent = parent;
2293         window->r.c.left = p->x;
2294         window->r.c.top = p->y;
2295         window->r.c.right = p->x + 400;
2296         window->r.c.bottom = p->y + 200;
2297         tc_strset(window->title, TNULL, 256+1);
2298         if (title != 0) {
2299                 tc_strncpy(window->title, title, 256);
2300         } else {
2301                 window->title[0] = 0x2539;
2302                 window->title[1] = 0x256c;
2303                 window->title[2] = 0x306c;
2304                 window->title[3] = 0x4d77;
2305                 window->title[4] = 0x405f;
2306                 window->title[5] = 0x446a;
2307         }
2308         window->filter.id = -1;
2309         window->filter.dnum = dnum_filter;
2310         memset(window->filter.buf, 0, sizeof(TC)*1000);
2311         window->filter.buf[0] = MC_ATTR;
2312         *(COLOR*)(window->filter.buf + 1) = -1;
2313         window->filter.buf[3] = -1;
2314         window->filter.buf[4] = 0;
2315         window->filter.buf[5] = 16;
2316         window->filter.buf[6] = 16;
2317         window->filter.buf[7] = TNULL;
2318         window->filter.nextaction = False;
2319         window->order.id = -1;
2320         window->order.dnum = dnum_order;
2321         window->order.value = 0;
2322         window->orderby.id = -1;
2323         window->orderby.dnum = dnum_orderby;
2324         window->orderby.value = 0;
2325
2326
2327         return window;
2328 }
2329
2330 LOCAL VOID subjectoptionwindow_delete(subjectoptionwindow_t *window)
2331 {
2332         if (window->wid > 0) {
2333                 cdel_pwd(window->wid, NOCLR);
2334                 wcls_wnd(window->wid, CLR);
2335         }
2336         free(window);
2337 }
2338
2339 EXPORT registerexternalwindow_t* registerexternalwindow_new(PNT *p, WID parent, TC *title, PAT *bgpat)
2340 {
2341         registerexternalwindow_t *window;
2342
2343         window = (registerexternalwindow_t*)malloc(sizeof(registerexternalwindow_t));
2344         if (window == NULL) {
2345                 return NULL;
2346         }
2347         window->wid = -1;
2348         window->gid = -1;
2349         window->parent = parent;
2350         window->r.c.left = p->x;
2351         window->r.c.top = p->y;
2352         window->r.c.right = p->x + 400;
2353         window->r.c.bottom = p->y + 200;
2354         tc_strset(window->title, TNULL, 256+1);
2355         if (title != 0) {
2356                 tc_strncpy(window->title, title, 256);
2357         } else {
2358                 window->title[0] = 0x3330;
2359                 window->title[1] = 0x4974;
2360                 window->title[2] = 0x4844;
2361                 window->title[3] = 0x244e;
2362                 window->title[4] = 0x4449;
2363                 window->title[5] = 0x3243;
2364         }
2365         window->boradname.id = -1;
2366         memset(window->boradname.buf, 0, sizeof(TC)*1000);
2367         window->boradname.buf[0] = MC_ATTR;
2368         *(COLOR*)(window->boradname.buf + 1) = -1;
2369         window->boradname.buf[3] = -1;
2370         window->boradname.buf[4] = 0;
2371         window->boradname.buf[5] = 16;
2372         window->boradname.buf[6] = 16;
2373         window->boradname.buf[7] = TNULL;
2374         window->boradname.nextaction = False;
2375         window->url.id = -1;
2376         memset(window->url.buf, 0, sizeof(TC)*1000);
2377         window->url.buf[0] = MC_ATTR;
2378         *(COLOR*)(window->url.buf + 1) = -1;
2379         window->url.buf[3] = -1;
2380         window->url.buf[4] = 0;
2381         window->url.buf[5] = 8;
2382         window->url.buf[6] = 16;
2383         window->url.buf[7] = TNULL;
2384         window->url.nextaction = False;
2385         window->determine.id = -1;
2386         window->cancel.id = -1;
2387
2388
2389         return window;
2390 }
2391
2392 LOCAL VOID registerexternalwindow_delete(registerexternalwindow_t *window)
2393 {
2394         if (window->wid > 0) {
2395                 cdel_pwd(window->wid, NOCLR);
2396                 wcls_wnd(window->wid, CLR);
2397         }
2398         free(window);
2399 }
2400
2401 EXPORT externalbbswindow_t* externalbbswindow_new(RECT *r, WID parent, TC *title, PAT *bgpat)
2402 {
2403         externalbbswindow_t *window;
2404         W err;
2405
2406         window = (externalbbswindow_t*)malloc(sizeof(externalbbswindow_t));
2407         if (window == NULL) {
2408                 return NULL;
2409         }
2410         window->flag = 0;
2411         window->wid = -1;
2412         window->gid = -1;
2413         window->parent = parent;
2414         window->r = *r;
2415         err = hmi_windowscroll_initialize(&window->wscr, window->wid);
2416         if (err < 0) {
2417                 free(window);
2418                 return NULL;
2419         }
2420         tc_strset(window->title, TNULL, 256+1);
2421         if (title != 0) {
2422                 tc_strncpy(window->title, title, 256);
2423         } else {
2424                 window->title[0] = 0x3330;
2425                 window->title[1] = 0x4974;
2426                 window->title[2] = 0x4844;
2427         }
2428
2429
2430         return window;
2431 }
2432
2433 LOCAL VOID externalbbswindow_delete(externalbbswindow_t *window)
2434 {
2435         if (window->wid > 0) {
2436                 wcls_wnd(window->wid, CLR);
2437         }
2438         hmi_windowscroll_finalize(&window->wscr);
2439         free(window);
2440 }
2441
2442 EXPORT subjectwindow_t* bchanlhmi_newsubjectwindow(bchanlhmi_t *hmi, RECT *r, WID parent, TC *title, PAT *bgpat)
2443 {
2444         if (hmi->subjectwindow != NULL) {
2445                 return NULL;
2446         }
2447         hmi->subjectwindow = subjectwindow_new(r, parent, title, bgpat);
2448         return hmi->subjectwindow;
2449 }
2450
2451 EXPORT VOID bchanlhmi_deletesubjectwindow(bchanlhmi_t *hmi, subjectwindow_t *window)
2452 {
2453         subjectwindow_delete(hmi->subjectwindow);
2454         hmi->subjectwindow = NULL;
2455 }
2456
2457 EXPORT bbsmenuwindow_t* bchanlhmi_newbbsmenuwindow(bchanlhmi_t *hmi, RECT *r, WID parent, TC *title, PAT *bgpat)
2458 {
2459         if (hmi->bbsmenuwindow != NULL) {
2460                 return NULL;
2461         }
2462         hmi->bbsmenuwindow = bbsmenuwindow_new(r, parent, title, bgpat);
2463         return hmi->bbsmenuwindow;
2464 }
2465
2466 EXPORT VOID bchanlhmi_deletebbsmenuwindow(bchanlhmi_t *hmi, bbsmenuwindow_t *window)
2467 {
2468         bbsmenuwindow_delete(hmi->bbsmenuwindow);
2469         hmi->bbsmenuwindow = NULL;
2470 }
2471
2472 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)
2473 {
2474         if (parent == NULL) {
2475                 return NULL;
2476         }
2477         if (hmi->subjectoptionwindow != NULL) {
2478                 return NULL;
2479         }
2480         hmi->subjectoptionwindow = subjectoptionwindow_new(p, parent, title, bgpat, dnum_filter, dnum_order, dnum_orderby);
2481         return hmi->subjectoptionwindow;
2482 }
2483
2484 EXPORT VOID bchanlhmi_deletesubjectoptionwindow(bchanlhmi_t *hmi, subjectoptionwindow_t *window)
2485 {
2486         subjectoptionwindow_delete(hmi->subjectoptionwindow);
2487         hmi->subjectoptionwindow = NULL;
2488 }
2489
2490 EXPORT registerexternalwindow_t* bchanlhmi_newregisterexternalwindow(bchanlhmi_t *hmi, PNT *p, WID parent, TC *title, PAT *bgpat)
2491 {
2492         if (hmi->registerexternalwindow != NULL) {
2493                 return NULL;
2494         }
2495         hmi->registerexternalwindow = registerexternalwindow_new(p, parent, title, bgpat);
2496         return hmi->registerexternalwindow;
2497 }
2498
2499 EXPORT VOID bchanlhmi_deleteregisterexternalwindow(bchanlhmi_t *hmi, registerexternalwindow_t *window)
2500 {
2501         registerexternalwindow_delete(hmi->registerexternalwindow);
2502         hmi->registerexternalwindow = NULL;
2503 }
2504
2505 EXPORT externalbbswindow_t* bchanlhmi_newexternalbbswindow(bchanlhmi_t *hmi, RECT *r, WID parent, TC *title, PAT *bgpat)
2506 {
2507         if (hmi->externalbbswindow != NULL) {
2508                 return NULL;
2509         }
2510         hmi->externalbbswindow = externalbbswindow_new(r, parent, title, bgpat);
2511         return hmi->externalbbswindow;
2512 }
2513
2514 EXPORT VOID bchanlhmi_deleteexternalbbswindow(bchanlhmi_t *hmi, externalbbswindow_t *window)
2515 {
2516         externalbbswindow_delete(hmi->externalbbswindow);
2517         hmi->externalbbswindow = NULL;
2518 }
2519
2520
2521 EXPORT bchanlhmi_t* bchanlhmi_new()
2522 {
2523         bchanlhmi_t *hmi;
2524
2525         hmi = (bchanlhmi_t *)malloc(sizeof(bchanlhmi_t));
2526         if (hmi == NULL) {
2527                 return NULL;
2528         }
2529         hmi->flag = 0;
2530         hmi->subjectwindow = NULL;
2531         hmi->bbsmenuwindow = NULL;
2532         hmi->subjectoptionwindow = NULL;
2533         hmi->registerexternalwindow = NULL;
2534         hmi->externalbbswindow = NULL;
2535
2536         return hmi;
2537 }
2538
2539 EXPORT VOID bchanlhmi_delete(bchanlhmi_t *hmi)
2540 {
2541         if (hmi->subjectwindow != NULL) {
2542                 subjectwindow_delete(hmi->subjectwindow);
2543         }
2544         if (hmi->bbsmenuwindow != NULL) {
2545                 bbsmenuwindow_delete(hmi->bbsmenuwindow);
2546         }
2547         if (hmi->subjectoptionwindow != NULL) {
2548                 subjectoptionwindow_delete(hmi->subjectoptionwindow);
2549         }
2550         if (hmi->registerexternalwindow != NULL) {
2551                 registerexternalwindow_delete(hmi->registerexternalwindow);
2552         }
2553         if (hmi->externalbbswindow != NULL) {
2554                 externalbbswindow_delete(hmi->externalbbswindow);
2555         }
2556         free(hmi);
2557 }