~ubuntu-branches/ubuntu/precise/gnome-games/precise-proposed

« back to all changes in this revision

Viewing changes to glines/glines.c

  • Committer: Package Import Robot
  • Author(s): Rodrigo Moya
  • Date: 2011-05-30 13:32:04 UTC
  • mfrom: (1.3.4)
  • mto: (163.1.3 precise)
  • mto: This revision was merged to the branch mainline in revision 143.
  • Revision ID: package-import@ubuntu.com-20110530133204-celaq1v1dsxc48q1
Tags: upstream-3.0.2
ImportĀ upstreamĀ versionĀ 3.0.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
121
121
/* Pre-rendering image data prepared from file. */
122
122
static GamesPreimage *ball_preimage = NULL;
123
123
/* The tile images with balls rendered on them. */
124
 
static GdkPixmap *ball_pixmap = NULL;
 
124
static cairo_surface_t *ball_surface = NULL;
125
125
/* The balls rendered to a size appropriate for the preview. */
126
 
static GdkPixmap *preview_pixmaps[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
 
126
static cairo_surface_t *preview_surfaces[7] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL };
127
127
 
128
 
/* A pixmap of a blank tile. */
129
 
static GdkPixmap *blank_pixmap = NULL;
130
 
static GdkPixmap *blank_preview_pixmap = NULL;
 
128
/* A cairo_surface_t of a blank tile. */
 
129
static cairo_surface_t *blank_surface = NULL;
 
130
static cairo_surface_t *blank_preview_surface = NULL;
131
131
 
132
132
static GtkWidget *fast_moves_toggle_button = NULL;
133
133
 
268
268
  /* Since we get called both by configure and after loading an image.
269
269
   * it is possible the pixmaps aren't initialised. If they aren't
270
270
   * we don't do anything. */
271
 
  if (!ball_pixmap)
 
271
  if (!ball_surface)
272
272
    return;
273
273
 
274
274
  if (ball_preimage) {
298
298
  g_free (warning_message);
299
299
  warning_message = NULL;
300
300
 
301
 
  cr = gdk_cairo_create (ball_pixmap);
 
301
  cr = cairo_create (ball_surface);
302
302
  gdk_cairo_set_source_color (cr, &backgnd.color);
303
303
 
304
304
  cairo_rectangle (cr, 0, 0, boxsize * 4, boxsize * 7);
307
307
  gdk_cairo_set_source_pixbuf (cr, ball_pixbuf, 0, 0);
308
308
  cairo_mask (cr, cairo_get_source (cr));
309
309
 
310
 
  cr_blank = gdk_cairo_create (blank_pixmap);
 
310
  cr_blank = cairo_create (blank_surface);
311
311
  gdk_cairo_set_source_color (cr_blank, &backgnd.color);
312
312
 
313
313
  cairo_rectangle (cr_blank, 0, 0, boxsize, boxsize);
319
319
}
320
320
 
321
321
static void
322
 
refresh_preview_pixmaps (void)
 
322
refresh_preview_surfaces (void)
323
323
{
324
324
  guint i;
325
325
  GdkPixbuf *scaled = NULL;
342
342
   * This code assumes that each preview window is identical. */
343
343
 
344
344
  for (i = 0; i < 7; i++)
345
 
    if (preview_pixmaps[i])
346
 
      g_object_unref (preview_pixmaps[i]);
 
345
    if (preview_surfaces[i])
 
346
      cairo_surface_destroy (preview_surfaces[i]);
347
347
 
348
348
  if (ball_preimage)
349
349
    scaled = games_preimage_render (ball_preimage, 4 * preview_width,
356
356
  }
357
357
 
358
358
  for (i = 0; i < 7; i++) {
359
 
    preview_pixmaps[i] = gdk_pixmap_new (gtk_widget_get_window (widget),
360
 
                                         preview_width, preview_height, -1);
361
 
    cr = gdk_cairo_create (preview_pixmaps[i]);
 
359
    preview_surfaces[i] = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
 
360
                                                             CAIRO_CONTENT_COLOR_ALPHA,
 
361
                                                             preview_width, preview_height);
 
362
    cr = cairo_create (preview_surfaces[i]);
362
363
    gdk_cairo_set_source_color (cr, &gtk_widget_get_style (widget)->bg[GTK_STATE_NORMAL]);
363
364
    gdk_cairo_rectangle (cr, &preview_rect);
364
365
    cairo_fill (cr);
369
370
    cairo_destroy (cr);
370
371
  }
371
372
 
372
 
  if (blank_preview_pixmap)
373
 
    g_object_unref (blank_preview_pixmap);
 
373
  if (blank_preview_surface)
 
374
    cairo_surface_destroy (blank_preview_surface);
374
375
 
375
 
  blank_preview_pixmap = gdk_pixmap_new (gtk_widget_get_window (widget), 
376
 
                                         preview_width, preview_height, -1);
377
 
  cr = gdk_cairo_create (blank_preview_pixmap);
 
376
  blank_preview_surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget),
 
377
                                                             CAIRO_CONTENT_COLOR_ALPHA,
 
378
                                                             preview_width, preview_height);
 
379
  cr = cairo_create (blank_preview_surface);
378
380
  gdk_cairo_set_source_color (cr, &gtk_widget_get_style (widget)->bg[GTK_STATE_NORMAL]);
379
381
  gdk_cairo_rectangle (cr, &preview_rect);
380
382
  cairo_fill (cr);
473
475
draw_preview (void)
474
476
{
475
477
  guint i;
 
478
  cairo_pattern_t *pattern;
476
479
 
477
480
  for (i = 0; i < MAXNPIECES; i++) {
478
481
 
479
482
    if (i < npieces)
480
 
      gdk_window_set_back_pixmap (gtk_widget_get_window (preview_widgets[i]),
481
 
                                  preview_pixmaps[preview[i] - 1], FALSE);
 
483
      pattern = cairo_pattern_create_for_surface (preview_surfaces[preview[i] - 1]);
482
484
    else
483
 
      gdk_window_set_back_pixmap (gtk_widget_get_window (preview_widgets[i]),
484
 
                                  blank_preview_pixmap, FALSE);
 
485
      pattern = cairo_pattern_create_for_surface (blank_preview_surface);
485
486
 
486
 
    gdk_window_clear (gtk_widget_get_window (preview_widgets[i]));
 
487
    gdk_window_set_background_pattern (gtk_widget_get_window (preview_widgets[i]),
 
488
                                       pattern);
 
489
    cairo_pattern_destroy (pattern);
 
490
    gtk_widget_queue_draw (preview_widgets[i]);
487
491
  }
488
 
 
489
492
}
490
493
 
491
494
static void
519
522
game_over (void)
520
523
{
521
524
  int pos;
522
 
  GamesScoreValue hiscore;
523
525
 
524
526
  set_statusbar_message (_("Game Over!"));
525
 
  hiscore.plain = score;
526
 
  pos = games_scores_add_score (highscores, hiscore);
 
527
  pos = games_scores_add_plain_score (highscores, score);
527
528
  show_scores (pos, TRUE);
528
529
  return;
529
530
}
783
784
  key = event->keyval;
784
785
 
785
786
  switch (key) {
786
 
  case GDK_Left:
787
 
  case GDK_KP_Left:
 
787
  case GDK_KEY_Left:
 
788
  case GDK_KEY_KP_Left:
788
789
    move_cursor (-1, 0);
789
790
    break;
790
 
  case GDK_Right:
791
 
  case GDK_KP_Right:
 
791
  case GDK_KEY_Right:
 
792
  case GDK_KEY_KP_Right:
792
793
    move_cursor (1, 0);
793
794
    break;
794
 
  case GDK_Up:
795
 
  case GDK_KP_Up:
 
795
  case GDK_KEY_Up:
 
796
  case GDK_KEY_KP_Up:
796
797
    move_cursor (0, -1);
797
798
    break;
798
 
  case GDK_Down:
799
 
  case GDK_KP_Down:
 
799
  case GDK_KEY_Down:
 
800
  case GDK_KEY_KP_Down:
800
801
    move_cursor (0, 1);
801
802
    break;
802
 
  case GDK_Home:
803
 
  case GDK_KP_Home:
 
803
  case GDK_KEY_Home:
 
804
  case GDK_KEY_KP_Home:
804
805
    move_cursor (-999, 0);
805
806
    break;
806
 
  case GDK_End:
807
 
  case GDK_KP_End:
 
807
  case GDK_KEY_End:
 
808
  case GDK_KEY_KP_End:
808
809
    move_cursor (999, 0);
809
810
    break;
810
 
  case GDK_Page_Up:
811
 
  case GDK_KP_Page_Up:
 
811
  case GDK_KEY_Page_Up:
 
812
  case GDK_KEY_KP_Page_Up:
812
813
    move_cursor (0, -999);
813
814
    break;
814
 
  case GDK_Page_Down:
815
 
  case GDK_KP_Page_Down:
 
815
  case GDK_KEY_Page_Down:
 
816
  case GDK_KEY_KP_Page_Down:
816
817
    move_cursor (0, 999);
817
818
    break;
818
819
 
819
 
  case GDK_space:
820
 
  case GDK_Return:
821
 
  case GDK_KP_Enter:
 
820
  case GDK_KEY_space:
 
821
  case GDK_KEY_Return:
 
822
  case GDK_KEY_KP_Enter:
822
823
    if (show_cursor)
823
824
      cell_clicked (widget, cursor_x, cursor_y);
824
825
    break;
828
829
}
829
830
 
830
831
static void
831
 
draw_grid (void)
 
832
draw_grid (cairo_t *cr)
832
833
{
833
 
  cairo_t *cr;
834
834
  GdkColor color;
835
835
  guint w, h;
836
836
  guint i;
837
 
  GtkAllocation allocation;
838
 
 
839
 
  gtk_widget_get_allocation (draw_area, &allocation);
840
 
  w = allocation.width;
841
 
  h = allocation.height;
842
 
 
843
 
  cr = gdk_cairo_create (gtk_widget_get_window (draw_area));
 
837
 
 
838
  w = gtk_widget_get_allocated_width(draw_area);
 
839
  h = gtk_widget_get_allocated_height(draw_area);
 
840
 
844
841
  gdk_color_parse ("#525F6C", &color);
845
842
  gdk_cairo_set_source_color (cr, &color);
846
843
  cairo_set_line_width (cr, 1.0);
859
856
 
860
857
  cairo_rectangle (cr, 0.5, 0.5, w - 0.5, h - 0.5);
861
858
  cairo_stroke (cr);
862
 
 
863
 
  cairo_destroy (cr);
864
859
}
865
860
 
866
 
/* Redraw a part of the field */
867
861
static gboolean
868
 
field_expose_event (GtkWidget * widget, GdkEventExpose * event, gpointer gp)
 
862
field_draw_callback (GtkWidget * widget, cairo_t *cr)
869
863
{
870
 
  GdkWindow *window = gtk_widget_get_window (widget);
871
 
  cairo_t *cr;
872
 
  guint x_start, x_end, y_start, y_end, i, j, idx;
873
 
 
874
 
  x_start = event->area.x / boxsize;
875
 
  x_end = (event->area.x + event->area.width - 1) / boxsize + 1;
876
 
 
877
 
  y_start = event->area.y / boxsize;
878
 
  y_end = (event->area.y + event->area.height - 1) / boxsize + 1;
879
 
 
880
 
  cr = gdk_cairo_create (window);
881
 
 
882
 
  for (i = y_start; i < y_end; i++) {
883
 
    for (j = x_start; j < x_end; j++) {
 
864
  guint i, j, idx;
 
865
  GdkColor cursorColor;
 
866
 
 
867
  for (i = 0; i < vfieldsize; i++) {
 
868
    for (j = 0; j < hfieldsize; j++) {
884
869
      int phase, color;
885
870
 
886
871
      idx = j + i * hfieldsize;
893
878
 
894
879
        phase = ABS (ABS (3 - phase) - 3);
895
880
 
896
 
        gdk_cairo_set_source_pixmap (cr, ball_pixmap,
897
 
                                     (1.0 * j - phase) * boxsize,
898
 
                                     (1.0 * i - color) * boxsize);
 
881
        cairo_set_source_surface (cr, ball_surface,
 
882
                                 (1.0 * j - phase) * boxsize,
 
883
                                 (1.0 * i - color) * boxsize);
899
884
      } else {
900
 
        gdk_cairo_set_source_pixmap (cr, blank_pixmap, 0, 0);
 
885
        cairo_set_source_surface (cr, blank_surface, 1.0 * j * boxsize, 1.0 * i * boxsize);
901
886
      }
902
887
 
903
888
      cairo_fill (cr);
904
889
    }
905
890
  }
906
891
 
907
 
  if (show_cursor && cursor_x >= x_start && cursor_x <= x_end
908
 
      && cursor_y >= y_start && cursor_y <= y_end) {
909
 
    GdkColor color;
910
 
 
911
 
    if (((backgnd.color.red + backgnd.color.green + backgnd.color.blue) / 3) >
912
 
        (G_MAXUINT16 / 2))
913
 
      gdk_color_parse ("#000000", &color);
914
 
    else
915
 
      gdk_color_parse ("#FFFFFF", &color);
916
 
 
917
 
    gdk_cairo_set_source_color (cr, &color);
918
 
    cairo_set_line_width (cr, 1.0);
919
 
    cairo_rectangle (cr,
920
 
                     cursor_x * boxsize + 1.5, cursor_y * boxsize + 1.5,
921
 
                     boxsize - 2.5, boxsize - 2.5);
922
 
    cairo_stroke (cr);
923
 
  }
924
 
 
925
 
  cairo_destroy (cr);
926
 
 
927
 
  draw_grid ();
 
892
  /* Cursor */
 
893
  if (((backgnd.color.red + backgnd.color.green + backgnd.color.blue) / 3) >
 
894
      (G_MAXUINT16 / 2))
 
895
    gdk_color_parse ("#000000", &cursorColor);
 
896
  else
 
897
    gdk_color_parse ("#FFFFFF", &cursorColor);
 
898
 
 
899
  gdk_cairo_set_source_color (cr, &cursorColor);
 
900
  cairo_set_line_width (cr, 1.0);
 
901
  cairo_rectangle (cr,
 
902
                   cursor_x * boxsize + 1.5, cursor_y * boxsize + 1.5,
 
903
                   boxsize - 2.5, boxsize - 2.5);
 
904
  cairo_stroke (cr);
 
905
 
 
906
  draw_grid (cr);
928
907
 
929
908
  return FALSE;
930
909
}
1226
1205
  gchar *license = games_get_license (_("Five or More"));
1227
1206
 
1228
1207
  gtk_show_about_dialog (GTK_WINDOW (app),
1229
 
#if GTK_CHECK_VERSION (2, 11, 0)
1230
1208
                         "program-name", _("Five or More"),
1231
 
#else
1232
 
                         "name", _("Five or More"),
1233
 
#endif
1234
1209
                         "version", VERSION,
1235
1210
                         "comments", _("GNOME port of the once-popular Color Lines game.\n\nFive or More is a part of GNOME Games."),
1236
1211
                         "copyright",
1249
1224
static void
1250
1225
set_backgnd_color (const gchar * str)
1251
1226
{
1252
 
  GdkColormap *colormap;
1253
 
  GtkStyle *widget_style, *temp_style;
1254
 
 
1255
1227
  if (!str)
1256
1228
    str = g_strdup ("#000000");
1257
1229
 
1263
1235
  if (!gdk_color_parse (backgnd.name, &backgnd.color)) {
1264
1236
    gdk_color_parse ("#000000", &backgnd.color);
1265
1237
  }
1266
 
 
1267
 
  colormap = gtk_widget_get_colormap (draw_area);
1268
 
  gdk_colormap_alloc_color (colormap, &backgnd.color, FALSE, TRUE);
1269
 
  widget_style = gtk_widget_get_style (draw_area);
1270
 
  temp_style = gtk_style_copy (widget_style);
1271
 
  temp_style->bg[0] = backgnd.color;
1272
 
  temp_style->bg[1] = backgnd.color;
1273
 
  temp_style->bg[2] = backgnd.color;
1274
 
  temp_style->bg[3] = backgnd.color;
1275
 
  temp_style->bg[4] = backgnd.color;
1276
 
  gtk_widget_set_style (draw_area, temp_style);
1277
1238
}
1278
1239
 
1279
1240
static void
1301
1262
  ball_preimage = load_image (ball_filename);
1302
1263
 
1303
1264
  refresh_pixmaps ();
1304
 
  refresh_preview_pixmaps ();
 
1265
  refresh_preview_surfaces ();
1305
1266
}
1306
1267
 
1307
1268
static void
1438
1399
                                               GTK_DIALOG_DESTROY_WITH_PARENT,
1439
1400
                                               GTK_STOCK_CLOSE,
1440
1401
                                               GTK_RESPONSE_CLOSE, NULL);
1441
 
    gtk_dialog_set_has_separator (GTK_DIALOG (pref_dialog), FALSE);
1442
1402
    g_signal_connect (pref_dialog, "response",
1443
1403
                      G_CALLBACK (pref_dialog_response), NULL);
1444
1404
    g_signal_connect (pref_dialog, "delete-event",
1551
1511
  preview_width = event->width;
1552
1512
  preview_height = event->height;
1553
1513
 
1554
 
  refresh_preview_pixmaps ();
 
1514
  refresh_preview_surfaces ();
1555
1515
 
1556
1516
  draw_preview ();
1557
1517
 
1561
1521
static int
1562
1522
configure_event_callback (GtkWidget * widget, GdkEventConfigure * event)
1563
1523
{
1564
 
  if (ball_pixmap)
1565
 
    g_object_unref (ball_pixmap);
 
1524
  if (ball_surface)
 
1525
    cairo_surface_destroy(ball_surface);
1566
1526
 
1567
 
  if (blank_pixmap)
1568
 
    g_object_unref (blank_pixmap);
 
1527
  if (blank_surface)
 
1528
    cairo_surface_destroy (blank_surface);
1569
1529
 
1570
1530
  boxsize = (event->width - 1) / hfieldsize;
1571
 
  ball_pixmap = gdk_pixmap_new (gtk_widget_get_window (draw_area), boxsize * 4, 
1572
 
                                boxsize * 7, -1);
1573
 
  blank_pixmap = gdk_pixmap_new (gtk_widget_get_window (draw_area), boxsize, 
1574
 
                                 boxsize, -1);
 
1531
  ball_surface = gdk_window_create_similar_surface (gtk_widget_get_window (draw_area),
 
1532
                                                    CAIRO_CONTENT_COLOR_ALPHA,
 
1533
                                                    boxsize * 4, boxsize * 7);
 
1534
  blank_surface = gdk_window_create_similar_surface (gtk_widget_get_window (draw_area),
 
1535
                                                     CAIRO_CONTENT_COLOR_ALPHA,
 
1536
                                                     boxsize, boxsize);
1575
1537
  refresh_pixmaps ();
1576
1538
 
1577
1539
  refresh_screen ();
1623
1585
  return FALSE;
1624
1586
}
1625
1587
 
1626
 
#endif /* WITH_SMCLIENT */
1627
 
 
1628
 
static void
1629
 
load_properties (void)
1630
 
{
1631
 
  gchar *buf;
1632
 
 
1633
 
  ball_filename = games_conf_get_string_with_default (KEY_PREFERENCES_GROUP, KEY_BALL_THEME, DEFAULT_BALL_THEME);
1634
 
 
1635
 
  move_timeout = games_conf_get_integer (KEY_PREFERENCES_GROUP, KEY_MOVE_TIMEOUT, NULL);
1636
 
  if (move_timeout <= 0)
1637
 
    move_timeout = 100;
1638
 
 
1639
 
  buf = games_conf_get_string_with_default (KEY_PREFERENCES_GROUP, KEY_BACKGROUND_COLOR, "#000000"); /* FIXMEchpe? */
1640
 
  set_backgnd_color (buf);
1641
 
  g_free (buf);
1642
 
 
1643
 
  load_theme ();
1644
 
}
1645
 
 
1646
1588
static void
1647
1589
restart (void)
1648
1590
{
1674
1616
  }
1675
1617
}
1676
1618
 
 
1619
#endif /* WITH_SMCLIENT */
 
1620
 
 
1621
static void
 
1622
load_properties (void)
 
1623
{
 
1624
  gchar *buf;
 
1625
 
 
1626
  ball_filename = games_conf_get_string_with_default (KEY_PREFERENCES_GROUP, KEY_BALL_THEME, DEFAULT_BALL_THEME);
 
1627
 
 
1628
  move_timeout = games_conf_get_integer (KEY_PREFERENCES_GROUP, KEY_MOVE_TIMEOUT, NULL);
 
1629
  if (move_timeout <= 0)
 
1630
    move_timeout = 100;
 
1631
 
 
1632
  buf = games_conf_get_string_with_default (KEY_PREFERENCES_GROUP, KEY_BACKGROUND_COLOR, "#000000"); /* FIXMEchpe? */
 
1633
  set_backgnd_color (buf);
 
1634
  g_free (buf);
 
1635
 
 
1636
  load_theme ();
 
1637
}
 
1638
 
1677
1639
static const GtkActionEntry actions[] = {
1678
1640
  {"GameMenu", NULL, N_("_Game")},
1679
1641
  {"SettingsMenu", NULL, N_("_Settings")},
1773
1735
  rgen = g_rand_new ();
1774
1736
 
1775
1737
  context = g_option_context_new (NULL);
1776
 
#if GLIB_CHECK_VERSION (2, 12, 0)
1777
1738
  g_option_context_set_translation_domain (context, GETTEXT_PACKAGE);
1778
 
#endif
1779
 
 
1780
1739
  g_option_context_add_group (context, gtk_get_option_group (TRUE));
1781
1740
#ifdef WITH_SMCLIENT
1782
1741
  g_option_context_add_group (context, egg_sm_client_get_option_group ());
1833
1792
  ui_manager = gtk_ui_manager_new ();
1834
1793
 
1835
1794
  games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar);
1836
 
  gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR (statusbar), FALSE);
 
1795
  gtk_window_set_has_resize_grip (GTK_WINDOW (app), TRUE);
1837
1796
 
1838
1797
  vbox = gtk_vbox_new (FALSE, 0);
1839
1798
  gtk_container_add (GTK_CONTAINER (app), vbox);
1892
1851
                    G_CALLBACK (key_press_event), NULL);
1893
1852
  g_signal_connect (draw_area, "configure-event",
1894
1853
                    G_CALLBACK (configure_event_callback), NULL);
1895
 
  g_signal_connect (draw_area, "expose-event",
1896
 
                    G_CALLBACK (field_expose_event), NULL);
 
1854
  g_signal_connect (draw_area, "draw",
 
1855
                    G_CALLBACK (field_draw_callback), NULL);
1897
1856
  gridframe = games_grid_frame_new (hfieldsize, vfieldsize);
1898
1857
  games_grid_frame_set_padding (GAMES_GRID_FRAME (gridframe), 1, 1);
1899
1858
  gtk_container_add (GTK_CONTAINER (gridframe), draw_area);