src/motif.c

   1 /*
   2  * X11 GUI for slide puzzle game
   3  * Copyright © 2022 Nick Bowler
   4  *
   5  * This program is free software: you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation, either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  17  */
  18
  19 #include <config.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <getopt.h>
  23
  24 #include <Xm/XmAll.h>
  25
  26 #include "help.h"
  27 #include "motif.h"
  28 #include "motifopt.h"
  29 #include "game.h"
  30
  31 #define PROGNAME "rrace"
  32 static const char *progname = PROGNAME;
  33 static const struct option lopts[] = { LOPTS_INITIALIZER, {0} };
  34
  35 static char * const default_resources[] = {
  36         "*title: RRace",
  37         "*game.height: 371", // 365 + 2*shadowThickness
  38         "*game.width: 498",
  39
  40         "*game.XmFrame.shadowThickness: 3",
  41         "*game.XmFrame.shadowType: shadow_in",
  42         "*goalArea.leftOffset: 1",
  43
  44         "*gameNew.accelerator: Ctrl<Key>N",
  45         "*gameNew.acceleratorText: Ctrl+N",
  46         "*gameExit.accelerator: Ctrl<Key>Q",
  47         "*gameExit.acceleratorText: Ctrl+Q",
  48
  49         NULL
  50 };
  51
  52 static void print_version(void)
  53 {
  54         printf("%s %s\n", PROGNAME, PACKAGE_VERSION);
  55         printf("Copyright (C) 2022 Nick Bowler\n");
  56         puts("License GPLv3+: GNU GPL version 3 or any later version");
  57         puts("This is free software: you are free to change and redistribute it.");
  58         puts("There is NO WARRANTY, to the extent permitted by law.");
  59 }
  60
  61 static void print_usage(FILE *f)
  62 {
  63         fprintf(f, "Usage: %s [options]\n", progname);
  64         if (f != stdout)
  65                 fprintf(f, "Try %s --help for more information.\n", progname);
  66 }
  67
  68 static void print_help(void)
  69 {
  70         struct lopt_help help = {0};
  71         const struct option *opt;
  72
  73         print_usage(stdout);
  74
  75         putchar('\n');
  76         puts("Options:");
  77         for (opt = lopts; opt->name; opt++) {
  78                 if (!lopt_get_help(opt, &help))
  79                         continue;
  80                 help_print_option(opt, help.arg, help.desc, 20);
  81         }
  82         putchar('\n');
  83
  84         printf("Report bugs to <%s>.\n", PACKAGE_BUGREPORT);
  85 }
  86
  87 static Widget early_setup(XtAppContext *app, int argc, char **argv)
  88 {
  89         Widget shell;
  90         int opt;
  91
  92         /* Check for --help/--version early (before X connection) */
  93         opterr = 0;
  94         while ((opt = getopt_long_only(argc, argv, "", lopts, NULL)) != -1) {
  95                 switch (opt) {
  96                 case LOPT_VERSION:
  97                         print_version();
  98                         exit(EXIT_SUCCESS);
  99                 case LOPT_HELP:
 100                         print_help();
 101                         exit(EXIT_SUCCESS);
 102                 }
 103         }
 104
 105         shell = XtOpenApplication(app, PACKAGE_TARNAME, NULL, 0,
 106                                   &argc, argv, (String *)default_resources,
 107                                   sessionShellWidgetClass, NULL, 0);
 108
 109         opterr = optind = 1;
 110         while ((opt = getopt_long_only(argc, argv, "", lopts, NULL)) != -1) {
 111                 switch (opt) {
 112                 default:
 113                         print_usage(stderr);
 114                         exit(EXIT_FAILURE);
 115                 }
 116         }
 117
 118         if (argv[optind]) {
 119                 fprintf(stderr, "%s: excess command-line arguments.\n",
 120                                 progname);
 121                 print_usage(stderr);
 122                 exit(EXIT_FAILURE);
 123         }
 124
 125         return shell;
 126 }
 127
 128 static struct app_state state;
 129
 130 static void proc_exit(Widget w, XEvent *e, String *argv, Cardinal *argc)
 131 {
 132         XtAppSetExitFlag(XtWidgetToApplicationContext(w));
 133 }
 134
 135 static void proc_new_game(Widget w, XEvent *e, String *argv, Cardinal *argc)
 136 {
 137         Widget shell;
 138
 139         for (shell = w; !XtIsWMShell(shell);)
 140                 shell = XtParent(shell);
 141
 142         game_reset(&state.board);
 143
 144         x11_redraw_goal(&state, -1);
 145         x11_redraw_game(&state, -1);
 146         x11_redraw_icon(&state, shell);
 147
 148         game_begin(&state.board);
 149 }
 150
 151 static const XtActionsRec menu_actions[] = {
 152         { "gameNew", proc_new_game },
 153         { "gameExit", proc_exit }
 154 };
 155
 156 static XtAppContext app_initialize(int argc, char **argv)
 157 {
 158         XtAppContext app;
 159         Widget shell;
 160         int i;
 161
 162         if (argc > 0)
 163                 progname = argv[0];
 164
 165         shell = early_setup(&app, argc, argv);
 166         XtAppAddActions(app, (void *)menu_actions, XtNumber(menu_actions));
 167         ui_initialize(&state, shell);
 168         x11_initialize(&state, shell);
 169
 170         /* Begin with the game in winning state */
 171         game_reset(&state.board);
 172         for (i = 0; i < 3; i++)
 173                 state.board.game[i] = state.board.goal[i] << GOAL_SHIFT;
 174         game_finish(&state.board);
 175
 176         state.use_ewmh_icons = ewmh_probe_wm_icon(shell);
 177         XtRealizeWidget(shell);
 178
 179         x11_redraw_icon(&state, shell);
 180
 181         return app;
 182 }
 183
 184 int main(int argc, char **argv)
 185 {
 186         XtAppMainLoop(app_initialize(argc, argv));
 187         return 0;
 188 }