gnushogi/dspwrappers.c

   1 /*
   2  * FILE: dspwrappers.c
   3  *
   4  *     Wrapper functions which call analogous functions in rawdsp.c
   5  *     or cursesdsp.c depending on the interface.
   6  *
   7  * ----------------------------------------------------------------------
   8  *
   9  * Copyright (c) 2012 Free Software Foundation
  10  *
  11  * GNU SHOGI is based on GNU CHESS
  12  *
  13  * This file is part of GNU SHOGI.
  14  *
  15  * GNU Shogi is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the
  17  * Free Software Foundation; either version 3 of the License,
  18  * or (at your option) any later version.
  19  *
  20  * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
  21  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  22  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  23  * for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License along
  26  * with GNU Shogi; see the file COPYING. If not, see
  27  * <http://www.gnu.org/licenses/>.
  28  * ----------------------------------------------------------------------
  29  *
  30  */
  31
  32 #include "gnushogi.h"
  33 #include "dspwrappers.h"
  34 #include "rawdsp.h"
  35 #include "cursesdsp.h"
  36
  37
  38 void
  39 ChangeAlphaWindow(void)
  40 {
  41     switch (display_type)
  42     {
  43     case DISPLAY_RAW:
  44     case DISPLAY_X:
  45         Raw_ChangeAlphaWindow();
  46         break;
  47
  48     case DISPLAY_CURSES:
  49         Curses_ChangeAlphaWindow();
  50         break;
  51     }
  52 }
  53
  54
  55 void
  56 ChangeBetaWindow(void)
  57 {
  58     switch (display_type)
  59     {
  60     case DISPLAY_RAW:
  61     case DISPLAY_X:
  62         Raw_ChangeBetaWindow();
  63         break;
  64
  65     case DISPLAY_CURSES:
  66         Curses_ChangeBetaWindow();
  67         break;
  68     }
  69 }
  70
  71
  72 void
  73 ChangeHashDepth(void)
  74 {
  75     switch (display_type)
  76     {
  77     case DISPLAY_RAW:
  78     case DISPLAY_X:
  79         Raw_ChangeHashDepth();
  80         break;
  81
  82     case DISPLAY_CURSES:
  83         Curses_ChangeHashDepth();
  84         break;
  85     }
  86 }
  87
  88
  89 void
  90 ChangeSearchDepth(void)
  91 {
  92     switch (display_type)
  93     {
  94     case DISPLAY_RAW:
  95     case DISPLAY_X:
  96         Raw_ChangeSearchDepth();
  97         break;
  98
  99     case DISPLAY_CURSES:
 100         Curses_ChangeSearchDepth();
 101         break;
 102     }
 103 }
 104
 105
 106 void
 107 ChangeXwindow(void)
 108 {
 109     switch (display_type)
 110     {
 111     case DISPLAY_RAW:
 112     case DISPLAY_X:
 113         Raw_ChangeXwindow();
 114         break;
 115
 116     case DISPLAY_CURSES:
 117         Curses_ChangeXwindow();
 118         break;
 119     }
 120 }
 121
 122
 123 void
 124 ClearScreen(void)
 125 {
 126     switch (display_type)
 127     {
 128     case DISPLAY_RAW:
 129     case DISPLAY_X:
 130         Raw_ClearScreen();
 131         break;
 132
 133     case DISPLAY_CURSES:
 134         Curses_ClearScreen();
 135         break;
 136     }
 137 }
 138
 139
 140 void
 141 DoDebug(void)
 142 {
 143     switch (display_type)
 144     {
 145     case DISPLAY_RAW:
 146     case DISPLAY_X:
 147         Raw_DoDebug();
 148         break;
 149
 150     case DISPLAY_CURSES:
 151         Curses_DoDebug();
 152         break;
 153     }
 154 }
 155
 156
 157 void
 158 DoTable(short table[NO_SQUARES])
 159 {
 160     switch (display_type)
 161     {
 162     case DISPLAY_RAW:
 163     case DISPLAY_X:
 164         Raw_DoTable(table);
 165         break;
 166
 167     case DISPLAY_CURSES:
 168         Curses_DoTable(table);
 169         break;
 170     }
 171 }
 172
 173
 174 void
 175 EditBoard(void)
 176 {
 177     switch (display_type)
 178     {
 179     case DISPLAY_RAW:
 180     case DISPLAY_X:
 181         Raw_EditBoard();
 182         break;
 183
 184     case DISPLAY_CURSES:
 185         Curses_EditBoard();
 186         break;
 187     }
 188 }
 189
 190
 191 void
 192 ExitShogi(void)
 193 {
 194     switch (display_type)
 195     {
 196     case DISPLAY_RAW:
 197     case DISPLAY_X:
 198         Raw_ExitShogi();
 199         break;
 200
 201     case DISPLAY_CURSES:
 202         Curses_ExitShogi();
 203         break;
 204     }
 205 }
 206
 207
 208 void
 209 GiveHint(void)
 210 {
 211     switch (display_type)
 212     {
 213     case DISPLAY_RAW:
 214     case DISPLAY_X:
 215         Raw_GiveHint();
 216         break;
 217
 218     case DISPLAY_CURSES:
 219         Curses_GiveHint();
 220         break;
 221     }
 222 }
 223
 224
 225 void
 226 Initialize(void)
 227 {
 228     switch (display_type)
 229     {
 230     case DISPLAY_RAW:
 231     case DISPLAY_X:
 232         Raw_Initialize();
 233         break;
 234
 235     case DISPLAY_CURSES:
 236         Curses_Initialize();
 237         break;
 238     }
 239 }
 240
 241
 242 void
 243 OutputMove(void)
 244 {
 245     switch (display_type)
 246     {
 247     case DISPLAY_RAW:
 248     case DISPLAY_X:
 249         Raw_OutputMove();
 250         break;
 251
 252     case DISPLAY_CURSES:
 253         Curses_OutputMove();
 254         break;
 255     }
 256 }
 257
 258
 259 void
 260 SetContempt(void)
 261 {
 262     switch (display_type)
 263     {
 264     case DISPLAY_RAW:
 265     case DISPLAY_X:
 266         Raw_SetContempt();
 267         break;
 268
 269     case DISPLAY_CURSES:
 270         Curses_SetContempt();
 271         break;
 272     }
 273 }
 274
 275
 276 void
 277 SearchStartStuff(short side)
 278 {
 279     switch (display_type)
 280     {
 281     case DISPLAY_RAW:
 282     case DISPLAY_X:
 283         Raw_SearchStartStuff(side);
 284         break;
 285
 286     case DISPLAY_CURSES:
 287         Curses_SearchStartStuff(side);
 288         break;
 289     }
 290 }
 291
 292
 293 void
 294 SelectLevel(char *sx)
 295 {
 296     switch (display_type)
 297     {
 298     case DISPLAY_RAW:
 299     case DISPLAY_X:
 300         Raw_SelectLevel(sx);
 301         break;
 302
 303     case DISPLAY_CURSES:
 304         Curses_SelectLevel(sx);
 305         break;
 306     }
 307 }
 308
 309
 310 void
 311 ShowCurrentMove(short pnt, short f, short t)
 312 {
 313     switch (display_type)
 314     {
 315     case DISPLAY_RAW:
 316     case DISPLAY_X:
 317         Raw_ShowCurrentMove(pnt, f, t);
 318         break;
 319
 320     case DISPLAY_CURSES:
 321         Curses_ShowCurrentMove(pnt, f, t);
 322         break;
 323     }
 324 }
 325
 326
 327 void
 328 ShowDepth(char ch)
 329 {
 330     switch (display_type)
 331     {
 332     case DISPLAY_RAW:
 333     case DISPLAY_X:
 334         Raw_ShowDepth(ch);
 335         break;
 336
 337     case DISPLAY_CURSES:
 338         Curses_ShowDepth(ch);
 339         break;
 340     }
 341 }
 342
 343
 344 void
 345 ShowGameType(void)
 346 {
 347     switch (display_type)
 348     {
 349     case DISPLAY_RAW:
 350     case DISPLAY_X:
 351         Raw_ShowGameType();
 352         break;
 353
 354     case DISPLAY_CURSES:
 355         Curses_ShowGameType();
 356         break;
 357     }
 358 }
 359
 360
 361 void
 362 ShowLine(unsigned short *bstline)
 363 {
 364     switch (display_type)
 365     {
 366     case DISPLAY_RAW:
 367     case DISPLAY_X:
 368         Raw_ShowLine(bstline);
 369         break;
 370
 371     case DISPLAY_CURSES:
 372         Curses_ShowLine(bstline);
 373         break;
 374     }
 375 }
 376
 377
 378 void
 379 ShowMessage(char *s)
 380 {
 381     switch (display_type)
 382     {
 383     case DISPLAY_RAW:
 384     case DISPLAY_X:
 385         Raw_ShowMessage(s);
 386         break;
 387
 388     case DISPLAY_CURSES:
 389         Curses_ShowMessage(s);
 390         break;
 391     }
 392 }
 393
 394
 395 void
 396 ShowPatternCount(short side, short n)
 397 {
 398     switch (display_type)
 399     {
 400     case DISPLAY_RAW:
 401     case DISPLAY_X:
 402         Raw_ShowPatternCount(side, n);
 403         break;
 404
 405     case DISPLAY_CURSES:
 406         Curses_ShowPatternCount(side, n);
 407         break;
 408     }
 409 }
 410
 411
 412 void
 413 ShowPostnValue(short sq)
 414 {
 415     switch (display_type)
 416     {
 417     case DISPLAY_RAW:
 418     case DISPLAY_X:
 419         Raw_ShowPostnValue(sq);
 420         break;
 421
 422     case DISPLAY_CURSES:
 423         Curses_ShowPostnValue(sq);
 424         break;
 425     }
 426 }
 427
 428
 429 void
 430 ShowPostnValues(void)
 431 {
 432     switch (display_type)
 433     {
 434     case DISPLAY_RAW:
 435     case DISPLAY_X:
 436         Raw_ShowPostnValues();
 437         break;
 438
 439     case DISPLAY_CURSES:
 440         Curses_ShowPostnValues();
 441         break;
 442     }
 443 }
 444
 445
 446 void
 447 ShowResponseTime(void)
 448 {
 449     switch (display_type)
 450     {
 451     case DISPLAY_RAW:
 452     case DISPLAY_X:
 453         Raw_ShowResponseTime();
 454         break;
 455
 456     case DISPLAY_CURSES:
 457         Curses_ShowResponseTime();
 458         break;
 459     }
 460 }
 461
 462
 463 void
 464 ShowResults(short score, unsigned short *bstline, char ch)
 465 {
 466     switch (display_type)
 467     {
 468     case DISPLAY_RAW:
 469     case DISPLAY_X:
 470         Raw_ShowResults(score, bstline, ch);
 471         break;
 472
 473     case DISPLAY_CURSES:
 474         Curses_ShowResults(score, bstline, ch);
 475         break;
 476     }
 477 }
 478
 479
 480 void
 481 ShowSidetoMove(void)
 482 {
 483     switch (display_type)
 484     {
 485     case DISPLAY_RAW:
 486     case DISPLAY_X:
 487         Raw_ShowSidetoMove();
 488         break;
 489
 490     case DISPLAY_CURSES:
 491         Curses_ShowSidetoMove();
 492         break;
 493     }
 494 }
 495
 496
 497 void
 498 ShowStage(void)
 499 {
 500     switch (display_type)
 501     {
 502     case DISPLAY_RAW:
 503     case DISPLAY_X:
 504         Raw_ShowStage();
 505         break;
 506
 507     case DISPLAY_CURSES:
 508         Curses_ShowStage();
 509         break;
 510     }
 511 }
 512
 513
 514 void
 515 TerminateSearch(int sig)
 516 {
 517     switch (display_type)
 518     {
 519     case DISPLAY_RAW:
 520     case DISPLAY_X:
 521         Raw_TerminateSearch(sig);
 522         break;
 523
 524     case DISPLAY_CURSES:
 525         Curses_TerminateSearch(sig);
 526         break;
 527     }
 528 }
 529
 530
 531 void
 532 UpdateDisplay(short f, short t, short redraw, short isspec)
 533 {
 534     switch (display_type)
 535     {
 536     case DISPLAY_RAW:
 537     case DISPLAY_X:
 538         Raw_UpdateDisplay(f, t, redraw, isspec);
 539         break;
 540
 541     case DISPLAY_CURSES:
 542         Curses_UpdateDisplay(f, t, redraw, isspec);
 543         break;
 544     }
 545 }
 546
 547
 548 void
 549 help(void)
 550 {
 551     switch (display_type)
 552     {
 553     case DISPLAY_RAW:
 554     case DISPLAY_X:
 555         Raw_help();
 556         break;
 557
 558     case DISPLAY_CURSES:
 559         Curses_help();
 560         break;
 561     }
 562 }
 563