gpe-lights.c

此程序用于在运行嵌入式Linux系统的手机上

      game.height = 3;
      game.cubeform = TRUE;
      game.consistent = TRUE; /* not used */
      game.states = 2;
      for (i = 0; i < 8; i++)
	{
	  if ((i/2)*2 == i) /* i is even */
	    game.neighbours[i] = TRUE;
	  else /* i is odd */
	    game.neighbours[i] = FALSE;
	}
    }
}

static void
new_game (void)
{
  char buf[10];
  int nl;

  reset_grid ();

  nl = game.width * game.height * (game.cubeform ? 6 : 1 );
  sprintf (buf, "/%.2d", nl);
  gtk_label_set (GTK_LABEL(lights_label), buf);

  set_moves (0);
  set_lights_off ();
  gtk_widget_draw (draw_area, NULL);
}

static void
load_theme (char *fname)
{
  char *fn;

  fn = g_strconcat (PREFIX "/share/" PACKAGE "/", fname, NULL);

  if (access (fn, F_OK))
    {
      printf (_("Could not find the \'%s\' theme for Lights Out\n"), fn);
      exit (1);
    }

  if (theme)
    g_free (theme);

  theme = g_strdup (fname);

  lights = gdk_pixbuf_new_from_file (fn, NULL);

  g_free (fn);

  gtk_widget_draw (draw_area, NULL);
}

static void
create_light_grid (char *fname)
{
  draw_area = gtk_drawing_area_new ();

  gtk_widget_pop_colormap ();
  gtk_widget_pop_visual ();

  gtk_widget_set_events (draw_area, gtk_widget_get_events (draw_area) | GAME_EVENTS);

  gtk_container_add (GTK_CONTAINER (align), draw_area);

  gtk_widget_realize (draw_area);
  gtk_widget_show (draw_area);

  load_theme (fname);

  gtk_drawing_area_size (GTK_DRAWING_AREA (draw_area),
			 (game.cubeform ? 4 : 1) * game.width * LIGHT_SIZE,
			 (game.cubeform ? 3 : 1) * game.height * LIGHT_SIZE);
  gtk_signal_connect (GTK_OBJECT(draw_area), "event", (GtkSignalFunc) area_event, 0);
}

static void
pref_game_type_cb (GtkWidget *widget, int new_type)
{
  if (new_type == pref_game_type)
    return;

  if (!pref_dialog)
    return;

  pref_game_type = new_type;
}

static void
set_selection (GtkWidget *widget, char *new_theme)
{
  pref_theme = new_theme;
}

static void
pref_randomize_cb (GtkWidget *widget, void *data)
{
  pref_randomize = GTK_TOGGLE_BUTTON(widget)->active;
}

static void
free_cb (GtkWidget *widget, void *data)
{
  free (data);
}

static void
create_menu (GtkWidget *menu)
{
  struct dirent *e;
  char *dname = PREFIX "/share/" PACKAGE;
  DIR *dir;
  int itemno = 0;

  dir = opendir (dname);

  if (!dir)
    return;

  while ((e = readdir (dir)) != NULL)
    {
      GtkWidget *item;
      char *s = strdup (e->d_name);

      if (!strstr (e->d_name, ".png"))
	{
	  free (s);
	  continue;
	}

      item = gtk_menu_item_new_with_label (s);
      gtk_widget_show (item);
      gtk_menu_append (GTK_MENU(menu), item);
      gtk_signal_connect (GTK_OBJECT(item), "activate", (GtkSignalFunc)set_selection, s);
      gtk_signal_connect (GTK_OBJECT(item), "destroy", (GtkSignalFunc)free_cb, s);

      if (!strcmp (theme, s))
	gtk_menu_set_active (GTK_MENU(menu), itemno);

      itemno++;
    }
  closedir (dir);
}

static void
pref_cancel (GtkWidget *widget, void *data)
{
  gtk_widget_destroy (pref_dialog);
  pref_dialog = 0;
}

static void
pref_apply (GtkWidget *widget, void *data)
{
  if (pref_theme_default != theme_default)
    {
      theme_default = pref_theme_default;
#if 0
      gnome_config_set_bool ("/"PACKAGE"/Preferences/Themedef", theme_default);
#endif
    }

  if (pref_theme)
    load_theme (pref_theme);

#if 0
  if (theme_default)
    gnome_config_set_string ("/"PACKAGE"/Preferences/Theme", theme);
#endif

  if (pref_game_type != game_type)
    {
      game_type = pref_game_type;
#if 0
      gnome_config_set_int ("/"PACKAGE"/Preferences/Gametype", game_type);
#endif

      load_game_values (game_type);

      gtk_drawing_area_size (GTK_DRAWING_AREA (draw_area),
			     (game.cubeform ? 4 : 1) * game.width * LIGHT_SIZE,
			     (game.cubeform ? 3 : 1) * game.height * LIGHT_SIZE);

      new_game ();
    }

  if (pref_randomize != randomize)
    {
      randomize = pref_randomize;
#if 0
      gnome_config_set_bool ("/"PACKAGE"/Preferences/Randomize", randomize);
#endif
    }

  pref_cancel (0,0);
}

static void
prefs (void)
{
  GtkWidget *hbox, *cb, *frame, *fv, *vbox, *table, *button;
  GtkWidget *menu, *omenu;
  GtkWidget *ok, *cancel;
  guint width, height;
  gboolean portrait;
  
  if (pref_dialog)
    return;

  width = gdk_screen_width ();
  height = gdk_screen_height ();

  portrait = (height > width) ? TRUE : FALSE;

  pref_game_type = 0;
  pref_theme = 0;
  pref_theme_default = theme_default;

  pref_dialog = gtk_dialog_new ();

  gtk_window_set_title (GTK_WINDOW (pref_dialog), _("Lights Out: Preferences"));
  gpe_set_window_icon (pref_dialog, "icon");

  gtk_widget_realize (pref_dialog);

  ok = gtk_button_new_from_stock (GTK_STOCK_OK);
  cancel = gtk_button_new_from_stock (GTK_STOCK_CANCEL);

  gtk_signal_connect (GTK_OBJECT(pref_dialog), "delete_event", (GtkSignalFunc)pref_cancel, NULL);

  if (portrait)
    table = gtk_table_new (1, 5, FALSE);
  else
    table = gtk_table_new (2, 3, FALSE);
  gtk_widget_show (table);

  omenu = gtk_option_menu_new ();
  menu = gtk_menu_new ();
  create_menu (menu);
  gtk_widget_show (omenu);
  gtk_option_menu_set_menu (GTK_OPTION_MENU(omenu), menu);

  frame = gtk_frame_new (_("Theme"));
  gtk_container_border_width (GTK_CONTAINER (frame), 5);

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox);

  if (! portrait)
    {
      GtkWidget *label;

      label = gtk_label_new (_("Select theme: "));
      gtk_widget_show (label);

      gtk_box_pack_start_defaults (GTK_BOX(hbox), label);
    }

  gtk_box_pack_start_defaults (GTK_BOX(hbox), omenu);

  fv = gtk_vbox_new (0, 5);
  gtk_widget_show (fv);

  gtk_box_pack_start_defaults (GTK_BOX(fv), hbox);

  gtk_widget_show (frame);
  
  if (portrait)
    {
      gtk_table_attach (GTK_TABLE (table), fv, 0, 1, 3, 4, GTK_EXPAND |
			GTK_FILL, 0, 0, 0);
    }
  else
    {
      gtk_container_border_width (GTK_CONTAINER (fv), 5);
      gtk_container_add (GTK_CONTAINER (frame), fv);
      gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 0, 1, GTK_EXPAND |
			GTK_FILL, 0, 0, 0);
    }

  frame = gtk_frame_new (_("Game type"));
  gtk_container_set_border_width (GTK_CONTAINER(frame), 5);
  gtk_widget_show (frame);
  vbox = gtk_vbox_new (TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER(vbox), 5);
  gtk_widget_show (vbox);

  button = gtk_radio_button_new_with_label (NULL, "Merlin's Magic Square");
  if (game_type == MERLIN)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (pref_game_type_cb), (gpointer) MERLIN);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_radio_button_new_with_label
    (gtk_radio_button_group (GTK_RADIO_BUTTON(button)), "Lights Out Keychain");
  if (game_type == KEYCHAIN)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (pref_game_type_cb), (gpointer)KEYCHAIN);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_radio_button_new_with_label
    (gtk_radio_button_group (GTK_RADIO_BUTTON(button)), "Lights Out");
  if (game_type == CLASSIC)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (pref_game_type_cb), (gpointer) CLASSIC);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_radio_button_new_with_label
    (gtk_radio_button_group (GTK_RADIO_BUTTON(button)), "Lights Out 2000");
  if (game_type == TWOK)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (pref_game_type_cb), (gpointer) TWOK);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_radio_button_new_with_label
    (gtk_radio_button_group (GTK_RADIO_BUTTON(button)), "Lights Out Delux");
  if (game_type == DELUX)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (pref_game_type_cb), (gpointer) DELUX);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  button = gtk_radio_button_new_with_label
    (gtk_radio_button_group (GTK_RADIO_BUTTON(button)), "Lights Out Cube");
  if (game_type == CUBE)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (button), TRUE);
  gtk_signal_connect (GTK_OBJECT (button), "clicked",
		      GTK_SIGNAL_FUNC (pref_game_type_cb), (gpointer) CUBE);
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
  gtk_widget_show (button);

  gtk_container_add (GTK_CONTAINER (frame), vbox);
  gtk_table_attach (GTK_TABLE (table), frame, 0, 1, 0, 3, GTK_EXPAND |
		    GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);

  frame = gtk_frame_new (_("Miscellaneous"));
  gtk_container_set_border_width (GTK_CONTAINER(frame), 5);
  gtk_widget_show (frame);
  vbox = gtk_vbox_new (TRUE, 0);
  gtk_widget_show (vbox);

  cb = gtk_check_button_new_with_label (_("Randomize grid"));
  gtk_signal_connect (GTK_OBJECT(cb), "clicked", (GtkSignalFunc)pref_randomize_cb, NULL);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(cb), randomize);
  gtk_widget_show (cb);
  gtk_box_pack_start (GTK_BOX (vbox), cb, FALSE, FALSE, 0);

  if (portrait)
    {
      gtk_table_attach (GTK_TABLE (table), vbox, 0, 1, 4, 5, GTK_EXPAND |
			GTK_FILL, 0, 0, 0);
    }
  else
    {
      gtk_container_set_border_width (GTK_CONTAINER(vbox), 5);
      gtk_container_add (GTK_CONTAINER (frame), vbox);
      gtk_table_attach (GTK_TABLE (table), frame, 1, 2, 1, 2, GTK_EXPAND |
			GTK_FILL, 0, 0, 0);
    }

  gtk_box_pack_start_defaults (GTK_BOX (GTK_DIALOG (pref_dialog)->vbox), table);

  gtk_widget_show (ok);
  gtk_widget_show (cancel);
  
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref_dialog)->action_area), ok, TRUE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (GTK_DIALOG (pref_dialog)->action_area), cancel, TRUE, TRUE, 0);
  
  gtk_signal_connect (GTK_OBJECT (ok), "clicked", GTK_SIGNAL_FUNC (pref_apply), NULL);
  gtk_signal_connect (GTK_OBJECT (cancel), "clicked", GTK_SIGNAL_FUNC (pref_cancel), NULL);

  gtk_widget_show (pref_dialog);

  pref_game_type = game_type;
}

struct gpe_icon my_icons[] = {
  { "icon", PREFIX "/share/pixmaps/gpe-lights.png" },
  { NULL }
};

int
main (int argc, char *argv[])
{
  GtkWidget *label;
  GtkWidget *window;
  GtkWidget *toolbar;
  GtkWidget *pw;

  gpe_application_init (&argc, &argv);

  bindtextdomain (PACKAGE, PACKAGE_LOCALE_DIR);
  textdomain (PACKAGE);
  bind_textdomain_codeset (PACKAGE, "UTF-8");

  srand (time (NULL));

  gpe_load_icons (my_icons);

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

  gtk_signal_connect (GTK_OBJECT (window), "delete_event",
		      GTK_SIGNAL_FUNC(gtk_main_quit),
		      NULL);

  vb = gtk_vbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER (window), vb);

  toolbar = gtk_toolbar_new ();
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);  

  gtk_box_pack_start (GTK_BOX (vb), toolbar, FALSE, FALSE, 0);

  gtk_widget_realize (window);
  gpe_set_window_icon (window, "icon");
  gtk_window_set_title (GTK_WINDOW (window), _("Lights Out"));

  pw = gtk_image_new_from_stock (GTK_STOCK_NEW, GTK_ICON_SIZE_SMALL_TOOLBAR);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			   _("New"), _("New game"), _("Tap here to start a new game."),
			   pw, GTK_SIGNAL_FUNC (new_game), NULL);
  
  pw = gtk_image_new_from_stock (GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_SMALL_TOOLBAR);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar),
			   _("Prefs"), _("Preferences"), _("Tap here to configure Lights Out."),
			   pw, GTK_SIGNAL_FUNC (prefs), NULL);

  pw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR);
  gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Exit"), 
			   _("Exit"), _("Exit the program."), pw, 
			   GTK_SIGNAL_FUNC (gtk_exit), NULL);

  align = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  gtk_box_pack_start (GTK_BOX (vb), align, TRUE, TRUE, 0);

  /* Set game values.  */
#if 0
  fname = gnome_config_get_string ("/"PACKAGE"/Preferences/Theme=bulb.png");
  game_type = gnome_config_get_int ("/"PACKAGE"/Preferences/Gametype=CLASSIC");
  sound = gnome_config_get_bool ("/"PACKAGE"/Preferences/Sound=TRUE");
  randomize = gnome_config_get_bool ("/"PACKAGE"/Preferences/Randomize=FALSE");
  theme_default = gnome_config_get_bool ("/"PACKAGE"/Preferences/Themedef=FALSE");
#endif

  fname = g_strdup ("bulb.png");

  load_game_values (game_type);
  create_light_grid (fname);
  g_free (fname);

  status_box = gtk_hbox_new (FALSE, 0);
  gtk_box_pack_end (GTK_BOX(vb), status_box, FALSE, TRUE, 0);

  label = gtk_label_new (_("  Moves: "));
  moves_label = gtk_label_new ("");
  gtk_box_pack_end (GTK_BOX(status_box), moves_label, FALSE, TRUE, 0);
  gtk_box_pack_end (GTK_BOX(status_box), label, FALSE, TRUE, 0);

  label = gtk_label_new (_(" Lights off: "));
  lights_off = gtk_label_new ("00");
  lights_label = gtk_label_new ("/0");
  gtk_box_pack_start (GTK_BOX(status_box), label, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX(status_box), lights_off, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX(status_box), lights_label, FALSE, TRUE, 0);

  new_game ();

  gtk_widget_show_all (window);

  gtk_main ();

  return 0;
}