git.cworth.org Git - grrobot/blob - src/grrobot.c

   1 /* grrobot - Ricochet Robot using GTK+, libxsvg, and Cairo
   2  *
   3  * Copyright © 2003 Carl Worth
   4  *
   5  * Permission to use, copy, modify, distribute, and sell this software
   6  * and its documentation for any purpose is hereby granted without
   7  * fee, provided that the above copyright notice appear in all copies
   8  * and that both that copyright notice and this permission notice
   9  * appear in supporting documentation, and that the name of Carl Worth
  10  * not be used in advertising or publicity pertaining to distribution
  11  * of the software without specific, written prior permission.
  12  * Carl Worth makes no representations about the suitability of this
  13  * software for any purpose.  It is provided "as is" without express
  14  * or implied warranty.
  15  *
  16  * CARL WORTH DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  17  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
  18  * NO EVENT SHALL CARL WORTH BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  19  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
  20  * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
  21  * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  22  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  23  *
  24  * Author: Carl Worth <carl@theworths.org>
  25  */
  26
  27 #ifdef HAVE_CONFIG_H
  28 #include "config.h"
  29 #endif
  30
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34
  35 #include <gtk/gtk.h>
  36 #include <gdk/gdkkeysyms.h>
  37
  38 #include "grr_board_view.h"
  39 #include "grr_util.h"
  40 #include "args.h"
  41
  42 typedef struct grr_game {
  43     rr_client_t *client;
  44     rr_board_t *board;
  45
  46     GtkWidget *window;
  47     grr_board_view_t *board_view;
  48     GtkWidget *message_entry;
  49     GtkWidget *bid_entry;
  50
  51     GtkTextBuffer *message_buffer;
  52     GtkWidget *message_view;
  53     int msg_id;
  54     int last_move_msg_id;
  55     rr_robot_t last_move_robot;
  56
  57     rr_gamestate_t state;
  58 } grr_game_t;
  59
  60 static void
  61 grr_game_pass (grr_game_t *game);
  62
  63 static void
  64 grr_game_zap (grr_game_t *game);
  65
  66 static void
  67 grr_game_next (grr_game_t *game);
  68
  69 static int
  70 grr_game_printf (grr_game_t *game, const char *fmt, ...);
  71
  72 static int
  73 grr_game_vprintf (grr_game_t *game, const char *fmt, va_list ap);
  74
  75 static int
  76 grr_game_print (grr_game_t *game, const char *msg);
  77
  78 static int
  79 grr_game_start_gui (grr_game_t *game, const char *user);
  80
  81 static void
  82 grr_game_read_notices (grr_game_t *game);
  83
  84 static GSource *
  85 grr_game_notices_source_new (grr_game_t *game);
  86
  87 int
  88 main (int argc, char **argv)
  89 {
  90     args_t args;
  91     rr_status_t status;
  92     grr_game_t game;
  93     GSource *source;
  94
  95     char *diagram;
  96
  97     gtk_init (&argc, &argv);
  98
  99     args_parse (&args, argc, argv);
 100
 101     if (args.file) {
 102         game.board = rr_board_create_from_file (args.file);
 103         if (game.board == NULL) {
 104             fprintf (stderr, "Failed to parse board from %s\n", args.file);
 105             return 1;
 106         }
 107         game.client = NULL;
 108     } else {
 109         GPollFD *poll_fd;
 110
 111         game.client = rr_client_create (args.host, args.port, args.user);
 112         if (game.client == NULL) {
 113             fprintf (stderr, "Failed connecting to %s:%s as %s\n",
 114                      args.host, args.port, args.user);
 115             return 1;
 116         }
 117
 118         if (args.watch) {
 119             status = rr_client_watch (game.client, args.game);
 120             if (status == RR_STATUS_NO_GAME) {
 121                 fprintf (stderr, "No game %s to watch\n", args.game);
 122             }
 123         } else {
 124             status = rr_client_join (game.client, args.game);
 125             if (status == RR_STATUS_NO_GAME) {
 126                 status = rr_client_new (game.client, args.game);
 127             }
 128         }
 129
 130         game.board = rr_board_create (16, 16);
 131         game.msg_id = 0;
 132         game.last_move_msg_id = 0;
 133         game.last_move_robot = RR_ROBOT_NONE;
 134
 135         source = grr_game_notices_source_new (&game);
 136         poll_fd = g_new (GPollFD, 1);
 137         poll_fd->fd = rr_client_fd (game.client);
 138         poll_fd->events = G_IO_IN;
 139         g_source_add_poll (source, poll_fd);
 140
 141         g_source_set_priority (source, GDK_PRIORITY_EVENTS);
 142         g_source_attach (source, NULL);
 143         g_source_unref (source);
 144
 145         rr_client_show (game.client, &diagram);
 146         rr_board_parse (game.board, diagram);
 147         free (diagram);
 148     }
 149
 150     return grr_game_start_gui (&game, args.user);
 151 }
 152
 153 typedef struct _GrrNoticeSource {
 154     GSource source;
 155     grr_game_t *game;
 156 } GrrNoticeSource;
 157
 158 static gboolean
 159 grr_game_notices_prepare (GSource   *source,
 160                           gint      *timeout)
 161 {
 162     GrrNoticeSource *src = (GrrNoticeSource*)source;
 163     grr_game_t *game = src->game;
 164     gboolean retval;
 165
 166     GDK_THREADS_ENTER ();
 167     *timeout = -1;
 168     retval = rr_client_notice_pending (game->client);
 169     GDK_THREADS_LEAVE ();
 170
 171     return retval;
 172 }
 173
 174 static gboolean
 175 grr_game_notices_check (GSource     *source)
 176 {
 177     GrrNoticeSource *src = (GrrNoticeSource*)source;
 178     grr_game_t *game = src->game;
 179     gboolean retval;
 180
 181     GDK_THREADS_ENTER ();
 182     retval = rr_client_notice_pending (game->client);
 183     GDK_THREADS_LEAVE ();
 184
 185     return retval;
 186 }
 187
 188 static gboolean
 189 grr_game_notices_dispatch (GSource      *source,
 190                            GSourceFunc  callback,
 191                            gpointer     user_data)
 192 {
 193     GrrNoticeSource *src = (GrrNoticeSource*)source;
 194     grr_game_t *game = src->game;
 195
 196     grr_game_read_notices (game);
 197
 198     return TRUE;
 199 }
 200
 201 static GSourceFuncs game_notices_funcs = {
 202   grr_game_notices_prepare,
 203   grr_game_notices_check,
 204   grr_game_notices_dispatch,
 205   NULL
 206 };
 207
 208 static GSource *
 209 grr_game_notices_source_new (grr_game_t *game)
 210 {
 211     GSource *source = g_source_new (&game_notices_funcs, sizeof (GrrNoticeSource));
 212     GrrNoticeSource *src = (GrrNoticeSource*)source;
 213     src->game = game;
 214     return source;
 215 }
 216
 217 static void
 218 grr_game_read_notices (grr_game_t *game)
 219 {
 220     rr_board_t *board = game->board;
 221     rr_status_t status;
 222     rr_notice_t *notice;
 223
 224     while (rr_client_notice_pending (game->client)) {
 225         status = rr_client_next_notice (game->client, &notice);
 226         if (status) {
 227             if (status == RR_STATUS_EOF)
 228                 fprintf (stderr, "The server has disconnected, exiting.\n");
 229             else
 230                 fprintf (stderr, "Error during rr_client_next_notice: %s\n",
 231                          rr_status_str (status));
 232             gtk_main_quit ();
 233         }
 234         if (!notice) {
 235             fprintf (stderr, "Missing notice\n");
 236             continue;
 237         }
 238
 239         switch (notice->type) {
 240         case RR_NOTICE_USER:
 241             grr_game_printf (game,
 242                              "\nGLOBAL: %s has connected.", notice->u.string);
 243             break;
 244         case RR_NOTICE_QUIT:
 245             grr_game_printf (game,
 246                              "\nGLOBAL: %s has disconnected.", notice->u.string);
 247             break;
 248         case RR_NOTICE_GAME:
 249             grr_game_printf (game,
 250                              "\nGLOBAL: New game available: %s.", notice->u.string);
 251             break;
 252         case RR_NOTICE_DISPOSE:
 253             grr_game_printf (game,
 254                              "\nGLOBAL: Game %s has been disposed.", notice->u.string);
 255             break;
 256         case RR_NOTICE_MESSAGE:
 257             grr_game_printf (game, "\n%s> %s",
 258                              notice->u.message.username,
 259                              notice->u.message.text);
 260             break;
 261         case RR_NOTICE_BOARD:
 262             rr_board_parse (board, notice->u.string);
 263             gtk_widget_queue_draw (GTK_WIDGET (game->window));
 264             break;
 265         case RR_NOTICE_GAMESTATE:
 266             game->state = notice->u.gamestate;
 267             grr_game_printf (game, "\nGame state changed to: %s.",
 268                              rr_gamestate_str (notice->u.gamestate));
 269             break;
 270         case RR_NOTICE_TURN:
 271             /* XXX: Setting game->state here is goofy. Cleaner would
 272                be to make the server send a NOTICE GAMESTATE NEW
 273                here. */
 274             game->state = RR_GAMESTATE_NEW;
 275
 276             grr_game_print (game, "\nNew round!");
 277             rr_board_set_goal_target (board, notice->u.target);
 278             gtk_widget_queue_draw (GTK_WIDGET (game->window));
 279             break;
 280         case RR_NOTICE_GAMEOVER:
 281             grr_game_printf (game, "\nGame over. New game will begin now.");
 282             break;
 283         case RR_NOTICE_JOIN:
 284             grr_game_printf (game, "\nUser %s has joined the game.",
 285                              notice->u.string);
 286             break;
 287         case RR_NOTICE_WATCH:
 288             grr_game_printf (game, "\nUser %s has started watching the game.",
 289                              notice->u.string);
 290             break;
 291         case RR_NOTICE_PART:
 292             grr_game_printf (game, "\nUser %s has left the game.",
 293                              notice->u.string);
 294             break;
 295         case RR_NOTICE_BID:
 296             grr_game_printf (game, "\nUser %s bids %d.",
 297                              notice->u.bid.username,
 298                              notice->u.bid.number);
 299             break;
 300         case RR_NOTICE_REVOKE:
 301             grr_game_printf (game, "\nUser %s revokes previous bid.",
 302                              notice->u.string);
 303             break;
 304         case RR_NOTICE_ABANDON:
 305             grr_game_printf (game, "\nUser %s is willing to abandon this turn.",
 306                              notice->u.string);
 307             break;
 308         case RR_NOTICE_NOBID:
 309             grr_game_printf (game, "\nUser %s sees no point in bidding further this round",
 310                              notice->u.string);
 311             break;
 312         case RR_NOTICE_MOVE:
 313             if (game->msg_id == game->last_move_msg_id
 314                 && game->last_move_robot == notice->u.move.robot) {
 315                 game->last_move_msg_id = grr_game_printf (game, ",%c",
 316                                  rr_direction_char (notice->u.move.direction));
 317             } else {
 318                 game->last_move_msg_id = grr_game_printf (game, "\nMove #%d: %s %c",
 319                                  notice->u.move.count,
 320                                  rr_robot_str (notice->u.move.robot),
 321                                  rr_direction_char (notice->u.move.direction));
 322                 game->last_move_robot = notice->u.move.robot;
 323             }
 324             break;
 325         case RR_NOTICE_UNDO:
 326             grr_game_print (game, "\nUNDO");
 327             break;
 328         case RR_NOTICE_RESET:
 329             grr_game_print (game, "\nRESET");
 330             break;
 331         case RR_NOTICE_SCORE:
 332             grr_game_printf (game, "\nScore for %s: %d.",
 333                              notice->u.bid.username,
 334                              notice->u.bid.number);
 335             break;
 336         case RR_NOTICE_ACTIVATE:
 337             grr_game_printf (game, "\nYour turn.",
 338                              notice->u.number);
 339             break;
 340         case RR_NOTICE_ACTIVE:
 341             grr_game_printf (game, "\nUser %s now active to demonstrate solution in %d moves.",
 342                              notice->u.bid.username,
 343                              notice->u.bid.number);
 344             break;
 345         case RR_NOTICE_TIMER:
 346             grr_game_printf (game, "\nTime remaining: %d seconds.",
 347                              notice->u.number);
 348             break;
 349         case RR_NOTICE_POSITION:
 350         {
 351             int x, y;
 352             rr_board_find_robot (board, notice->u.position.robot, &x, &y);
 353             rr_board_add_robot (board, notice->u.position.robot,
 354                                 notice->u.position.x, notice->u.position.y);
 355             grr_board_view_mark_damage (game->board_view, x, y);
 356             grr_board_view_mark_damage (game->board_view,
 357                                         notice->u.position.x, notice->u.position.y);
 358         }
 359         break;
 360         default:
 361             fprintf (stderr, "Unknown notice: %d\n", notice->type);
 362             break;
 363         }
 364         free (notice);
 365     }
 366 }
 367
 368 static gboolean
 369 grr_game_key_press_callback (GtkWidget *widget,
 370                              GdkEventKey *event,
 371                              grr_game_t *game)
 372 {
 373     if (GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (game->message_entry))
 374         || GTK_WIDGET_HAS_FOCUS (GTK_WIDGET (game->bid_entry))
 375         ) {
 376         if (event->keyval == GDK_Escape) {
 377             gtk_entry_set_text (GTK_ENTRY (game->message_entry), "");
 378             gtk_entry_set_text (GTK_ENTRY (game->bid_entry), "");
 379             gtk_widget_grab_focus (GTK_WIDGET (game->message_view));
 380
 381             return TRUE;
 382         } else {
 383             return FALSE;
 384         }
 385     }
 386
 387     switch (event->keyval) {
 388     case GDK_N:
 389     case GDK_n:
 390     case GDK_T:
 391     case GDK_t:
 392         grr_game_next (game);
 393         break;
 394     case GDK_P:
 395     case GDK_p:
 396         grr_game_pass (game);
 397         break;
 398     case GDK_Z:
 399     case GDK_z:
 400         grr_game_zap (game);
 401         break;
 402     case GDK_B:
 403     case GDK_b:
 404         grr_board_view_set_active_robot (game->board_view, RR_ROBOT_BLUE);
 405         break;
 406     case GDK_G:
 407     case GDK_g:
 408         grr_board_view_set_active_robot (game->board_view, RR_ROBOT_GREEN);
 409         break;
 410     case GDK_R:
 411     case GDK_r:
 412         grr_board_view_set_active_robot (game->board_view, RR_ROBOT_RED);
 413         break;
 414     case GDK_Y:
 415     case GDK_y:
 416         grr_board_view_set_active_robot (game->board_view, RR_ROBOT_YELLOW);
 417         break;
 418     case GDK_Up:
 419         grr_board_view_move_active (game->board_view, RR_DIRECTION_NORTH);
 420         break;
 421     case GDK_Right:
 422         grr_board_view_move_active (game->board_view, RR_DIRECTION_EAST);
 423         break;
 424     case GDK_Down:
 425         grr_board_view_move_active (game->board_view, RR_DIRECTION_SOUTH);
 426         break;
 427     case GDK_Left:
 428         grr_board_view_move_active (game->board_view, RR_DIRECTION_WEST);
 429         break;
 430     case GDK_BackSpace:
 431         grr_board_view_undo (game->board_view);
 432         break;
 433     case GDK_0:
 434     case GDK_1:
 435     case GDK_2:
 436     case GDK_3:
 437     case GDK_4:
 438     case GDK_5:
 439     case GDK_6:
 440     case GDK_7:
 441     case GDK_8:
 442     case GDK_9:
 443         {
 444             int pos = -1;
 445             const gchar *key = gdk_keyval_name (event->keyval);
 446             gtk_widget_grab_focus (GTK_WIDGET (game->bid_entry));
 447             gtk_editable_insert_text (GTK_EDITABLE (game->bid_entry),
 448                                       key, strlen (key), &pos);
 449             gtk_editable_set_position (GTK_EDITABLE (game->bid_entry), -1);
 450         }
 451         break;
 452     case GDK_space:
 453     case GDK_slash:
 454         gtk_widget_grab_focus (GTK_WIDGET (game->message_entry));
 455         if (event->keyval == GDK_slash) {
 456             int pos = -1;
 457             gtk_editable_insert_text (GTK_EDITABLE (game->message_entry),
 458                                       "/", 1, &pos);
 459             gtk_editable_set_position (GTK_EDITABLE (game->message_entry), -1);
 460         }
 461         break;
 462     case GDK_Q:
 463     case GDK_q:
 464         if (event->state & GDK_CONTROL_MASK) {
 465             gtk_main_quit ();
 466         }
 467         break;
 468     }
 469
 470     return TRUE;
 471 }
 472
 473 /* XXX: Messy, messy. I can't seem to make up my mind whether client
 474    functions like such as these should be called here or in
 475    grr_board_view. */
 476 static void
 477 grr_game_pass (grr_game_t *game)
 478 {
 479     if (game->client == NULL)
 480         return;
 481
 482     if (game->state == RR_GAMESTATE_SHOW)
 483         rr_client_pass (game->client);
 484     else
 485         rr_client_revoke (game->client);
 486 }
 487
 488 static void
 489 grr_game_zap (grr_game_t *game)
 490 {
 491     if (game->client == NULL)
 492         return;
 493
 494     rr_client_nobid (game->client);
 495 }
 496
 497 static void
 498 grr_game_next (grr_game_t *game)
 499 {
 500     if (game->client == NULL)
 501         return;
 502
 503     if (game->state == RR_GAMESTATE_DONE)
 504         rr_client_turn (game->client);
 505     else
 506         rr_client_abandon (game->client);
 507 }
 508
 509 static void
 510 grr_game_pass_callback (GtkWidget *widget,
 511                         grr_game_t *game)
 512 {
 513     grr_game_pass (game);
 514 }
 515
 516 static void
 517 grr_game_zap_callback (GtkWidget *widget,
 518                         grr_game_t *game)
 519 {
 520     grr_game_zap (game);
 521 }
 522
 523 static void
 524 grr_game_next_callback (GtkWidget *widget,
 525                         grr_game_t *game)
 526 {
 527     grr_game_next (game);
 528 }
 529
 530 static void
 531 grr_game_bid_entry_callback (GtkWidget *widget,
 532                              grr_game_t *game)
 533 {
 534     const gchar *bid_text;
 535     char *end;
 536     long bid;
 537
 538     if (game->client == NULL)
 539         return;
 540
 541     bid_text = gtk_entry_get_text (GTK_ENTRY (game->bid_entry));
 542
 543     if (bid_text && bid_text[0]) {
 544         bid = strtol (bid_text, &end, 10);
 545         if (*end != '\0' && ! isspace (*end)) {
 546             grr_game_printf (game, "\nInvalid bid value: %s", bid_text);
 547         } else {
 548             if (bid == 0)
 549                 rr_client_revoke (game->client);
 550             else
 551                 rr_client_bid (game->client, bid);
 552         }
 553     }
 554
 555     gtk_entry_set_text (GTK_ENTRY (game->bid_entry), "");
 556     gtk_widget_grab_focus (GTK_WIDGET (game->message_view));
 557 }
 558
 559 static void
 560 grr_game_message_entry_callback (GtkWidget *widget,
 561                                  grr_game_t *game)
 562 {
 563     rr_status_t status;
 564     const gchar *entry_text;
 565     char **response;
 566     int i;
 567
 568     if (game->client == NULL)
 569         return;
 570
 571     entry_text = gtk_entry_get_text (GTK_ENTRY (game->message_entry));
 572
 573     if (entry_text && entry_text[0]) {
 574         if (entry_text[0] == '/') {
 575             status = rr_client_request (game->client, entry_text + 1, &response);
 576             if (status) {
 577                 grr_game_printf (game, "\nERROR: %s.", rr_status_str (status));
 578             } else {
 579                 if (response[0]) {
 580                     grr_game_print (game, "\n");
 581                     for (i=0; response[i]; i++)
 582                         grr_game_printf (game, "%s ", response[i]);
 583                 }
 584             }
 585         } else {
 586             rr_client_message (game->client, entry_text);
 587         }
 588     }
 589
 590     gtk_entry_set_text (GTK_ENTRY (game->message_entry), "");
 591     gtk_widget_grab_focus (GTK_WIDGET (game->message_view));
 592
 593 /* XXX: Huh? Why is this triggering valgrind?
 594     free (response);
 595 */
 596
 597 }
 598
 599 static int
 600 grr_game_printf (grr_game_t *game, const char *fmt, ...)
 601 {
 602     int msg_id;
 603
 604     va_list ap;
 605
 606     va_start (ap, fmt);
 607     msg_id = grr_game_vprintf (game, fmt, ap);
 608     va_end (ap);
 609
 610     return msg_id;
 611 }
 612
 613 static int
 614 grr_game_vprintf (grr_game_t *game, const char *fmt, va_list ap)
 615 {
 616     char *msg;
 617     int msg_id;
 618
 619     grr_sprintf_alloc_va (&msg, fmt, ap);
 620     if (msg == NULL)
 621         return 0;
 622
 623     msg_id = grr_game_print (game, msg);
 624
 625     free (msg);
 626
 627     return msg_id;
 628 }
 629
 630 static int
 631 grr_game_print (grr_game_t *game, const char *msg)
 632 {
 633     GtkTextIter iter;
 634     GtkTextMark *mark;
 635
 636     /* There might be a lighter way to do this, but this seems to
 637        work. */
 638
 639     gtk_text_buffer_get_end_iter (game->message_buffer, &iter);
 640
 641     mark = gtk_text_buffer_get_mark (game->message_buffer, "end");
 642
 643     gtk_text_buffer_move_mark (game->message_buffer, mark, &iter);
 644
 645     gtk_text_buffer_insert (game->message_buffer, &iter, msg, -1);
 646
 647     gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (game->message_view),
 648                                   mark, 0.0, TRUE, 0.0, 1.0);
 649
 650     return ++game->msg_id;
 651 }
 652
 653 static int
 654 grr_game_start_gui (grr_game_t *game, const char *user)
 655 {
 656     GtkWidget *board_frame;
 657     GtkWidget *vpaned;
 658     GtkWidget *sw;
 659     GtkWidget *vbox;
 660     GtkWidget *hbox;
 661     GtkWidget *window;
 662     GtkWidget *message_view;
 663     GtkWidget *message_entry;
 664     GtkWidget *bid_entry;
 665     GtkWidget *bid_button;
 666     GtkWidget *pass_button;
 667     GtkWidget *zap_button;
 668     GtkWidget *next_button;
 669     GtkWidget *user_label;
 670
 671     game->state = RR_GAMESTATE_NEW;
 672
 673     game->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 674     window = game->window;
 675
 676     gtk_window_set_title (GTK_WINDOW (window), "Ricochet Robot");
 677     gtk_window_set_default_size (GTK_WINDOW (window), 512, 512);
 678
 679     g_signal_connect (G_OBJECT (window), "destroy",
 680                       G_CALLBACK (exit), NULL);
 681     gtk_container_set_border_width (GTK_CONTAINER (window), 0);
 682
 683     vbox = gtk_vbox_new (FALSE, 1);
 684     gtk_container_add (GTK_CONTAINER (window), vbox);
 685     {
 686         GtkTextIter iter;
 687         game->board_view = grr_board_view_new (game->board);
 688         grr_board_view_set_client (GRR_BOARD_VIEW (game->board_view), game->client);
 689         game->message_buffer = gtk_text_buffer_new (NULL);
 690         gtk_text_buffer_get_iter_at_offset (game->message_buffer,
 691                                             &iter, -1);
 692         gtk_text_buffer_create_mark (game->message_buffer,
 693                                      "end", &iter, FALSE);
 694         game->message_view = gtk_text_view_new_with_buffer (game->message_buffer);
 695
 696         vpaned = gtk_vpaned_new ();
 697         gtk_container_set_border_width (GTK_CONTAINER (vpaned), 0);
 698         gtk_box_pack_start (GTK_BOX (vbox), vpaned,
 699                             TRUE, TRUE, 0);
 700         {
 701             board_frame = gtk_aspect_frame_new (NULL, 0.5, 0.5, 1.0, FALSE);
 702             gtk_paned_pack1 (GTK_PANED (vpaned), board_frame, TRUE, TRUE);
 703             {
 704                 gtk_container_add (GTK_CONTAINER (board_frame), GTK_WIDGET (game->board_view));
 705                 gtk_widget_show (GTK_WIDGET (game->board_view));
 706             }
 707             gtk_widget_show (board_frame);
 708
 709             sw = gtk_scrolled_window_new (NULL, NULL);
 710             gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
 711                                             GTK_POLICY_NEVER,
 712                                             GTK_POLICY_AUTOMATIC);
 713             gtk_paned_pack2 (GTK_PANED (vpaned), sw, FALSE, TRUE);
 714             {
 715                 message_view = game->message_view;
 716                 gtk_text_view_set_editable (GTK_TEXT_VIEW (message_view), FALSE);
 717                 gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (message_view), FALSE);
 718                 gtk_container_add (GTK_CONTAINER (sw), message_view);
 719                 gtk_widget_show (message_view);
 720             }
 721             gtk_widget_show (sw);
 722         }
 723         gtk_widget_show (vpaned);
 724
 725         hbox = gtk_hbox_new (FALSE, 1);
 726         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 727         {
 728             user_label = gtk_label_new (user);
 729             gtk_box_pack_start (GTK_BOX (hbox), user_label,
 730                                 FALSE, FALSE, 1);
 731             gtk_widget_show (user_label);
 732
 733             game->message_entry = gtk_entry_new ();
 734             message_entry = game->message_entry;
 735             gtk_box_pack_start (GTK_BOX (hbox), message_entry,
 736                                 TRUE, TRUE, 1);
 737             gtk_widget_show (message_entry);
 738             g_signal_connect (G_OBJECT (message_entry), "activate",
 739                               G_CALLBACK (grr_game_message_entry_callback),
 740                               (gpointer) game);
 741         }
 742         gtk_widget_show (hbox);
 743
 744         hbox = gtk_hbox_new (FALSE, 1);
 745         gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
 746         {
 747             bid_button = gtk_button_new_with_label ("Bid:");
 748             gtk_box_pack_start (GTK_BOX (hbox), bid_button,
 749                                 FALSE, FALSE, 1);
 750             gtk_widget_show (bid_button);
 751             g_signal_connect (G_OBJECT (bid_button), "clicked",
 752                               G_CALLBACK (grr_game_bid_entry_callback),
 753                               (gpointer) game);
 754
 755             game->bid_entry = gtk_entry_new ();
 756             bid_entry = game->bid_entry;
 757             gtk_entry_set_max_length (GTK_ENTRY (bid_entry), 3);
 758             gtk_entry_set_width_chars (GTK_ENTRY (bid_entry), 4);
 759             gtk_box_pack_start (GTK_BOX (hbox), bid_entry,
 760                                 FALSE, FALSE, 0);
 761             gtk_widget_show (bid_entry);
 762             g_signal_connect (G_OBJECT (bid_entry), "activate",
 763                               G_CALLBACK (grr_game_bid_entry_callback),
 764                               (gpointer) game);
 765
 766             pass_button = gtk_button_new_with_label ("Pass");
 767             gtk_box_pack_start (GTK_BOX (hbox), pass_button,
 768                                 FALSE, FALSE, 1);
 769             gtk_widget_show (pass_button);
 770             g_signal_connect (G_OBJECT (pass_button), "clicked",
 771                               G_CALLBACK (grr_game_pass_callback),
 772                               (gpointer) game);
 773
 774             zap_button = gtk_button_new_with_label ("Zap timer");
 775             gtk_box_pack_start (GTK_BOX (hbox), zap_button,
 776                                 FALSE, FALSE, 1);
 777             gtk_widget_show (zap_button);
 778             g_signal_connect (G_OBJECT (zap_button), "clicked",
 779                               G_CALLBACK (grr_game_zap_callback),
 780                               (gpointer) game);
 781
 782             next_button = gtk_button_new_with_label ("Next turn");
 783             gtk_box_pack_start (GTK_BOX (hbox), next_button,
 784                                 FALSE, FALSE, 1);
 785             gtk_widget_show (next_button);
 786             g_signal_connect (G_OBJECT (next_button), "clicked",
 787                               G_CALLBACK (grr_game_next_callback),
 788                               (gpointer) game);
 789         }
 790         gtk_widget_show (hbox);
 791     }
 792     gtk_widget_show (vbox);
 793
 794     g_signal_connect (G_OBJECT (window), "key_press_event",
 795                       G_CALLBACK (grr_game_key_press_callback),
 796                       (gpointer) game);
 797
 798     gtk_widget_show (window);
 799
 800     gtk_main ();
 801
 802     return 0;
 803 }