← Back to branch summary

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

« back to all changes in this revision

Viewing changes to gnomine/minefield.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:
gnomine/minefield.c
97
97
                                       guint y);
98
98
static gint get_cell_index (GtkMineField * mfield, guint x, guint y);
99
99
static void setup_sign (sign * signp, const char *file, guint minesizepixels);
100
 
static void gtk_mine_draw (GtkMineField * mfield, guint x, guint y);
 
100
static void gtk_mine_queue_draw (GtkMineField * mfield, guint x, guint y);
101
101
static gint gtk_minefield_button_press (GtkWidget * widget,
102
102
                                        GdkEventButton * event);
103
103
static gint gtk_minefield_button_release (GtkWidget * widget,
104
104
                                          GdkEventButton * event);
105
105
static void gtk_minefield_check_field (GtkMineField * mfield, gint x, gint y);
106
106
static void gtk_minefield_class_init (GtkMineFieldClass * class);
107
 
static gboolean gtk_minefield_expose (GtkWidget * widget, GdkEventExpose * event);
 
107
static gboolean gtk_minefield_draw (GtkWidget * widget, cairo_t * cr);
108
108
static void gtk_minefield_init (GtkMineField * mfield);
109
109
static void gtk_minefield_lose (GtkMineField * mfield);
110
110
static gint gtk_minefield_motion_notify (GtkWidget * widget,
117
117
static void gtk_minefield_show (GtkMineField * mfield, guint x, guint y);
118
118
static void gtk_minefield_size_allocate (GtkWidget * widget,
119
119
                                         GtkAllocation * allocation);
120
 
static void gtk_minefield_size_request (GtkWidget * widget,
121
 
                                        GtkRequisition * requisition);
122
120
static void gtk_minefield_set_mark (GtkMineField * mfield, guint x,
123
121
                                    guint y, int mark);
124
122
static void gtk_minefield_toggle_mark (GtkMineField * mfield, guint x,
350
348
  attributes.height = allocation.height;
351
349
  attributes.wclass = GDK_INPUT_OUTPUT;
352
350
  attributes.visual = gtk_widget_get_visual (widget);
353
 
  attributes.colormap = gtk_widget_get_colormap (widget);
354
351
  attributes.event_mask = gtk_widget_get_events (widget);
355
352
  attributes.event_mask |= GDK_EXPOSURE_MASK |
356
353
    GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK;
357
354
 
358
 
  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 
355
  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
359
356
 
360
357
  window = gdk_window_new (gtk_widget_get_parent_window (widget),
361
358
                           &attributes, attributes_mask);
401
398
    xofs = allocation->x + (allocation->width - width) / 2;
402
399
    yofs = allocation->y + (allocation->height - height) / 2;
403
400
 
404
 
 
405
 
    if (!mfield->thick_line)
406
 
      mfield->thick_line = gdk_gc_new (window);
407
 
    gdk_gc_copy (mfield->thick_line, gtk_widget_get_style (widget)->black_gc);
408
 
    gdk_gc_set_line_attributes (mfield->thick_line,
409
 
                                MAX (1, 0.1 * minesizepixels),
410
 
                                GDK_LINE_SOLID,
411
 
                                GDK_CAP_ROUND, GDK_JOIN_ROUND);
412
 
 
413
401
    gdk_window_move_resize (window, xofs, yofs, width, height);
414
402
  }
415
403
}
416
404
 
417
405
static void
418
 
gtk_minefield_size_request (GtkWidget * widget, GtkRequisition * requisition)
419
 
{
420
 
  GtkMineField *mf = GTK_MINEFIELD (widget);
421
 
  /* request the minimum size - to allow the widget window to be resized */
422
 
  requisition->width = mf->xsize * MINESIZE_MIN;
423
 
  requisition->height = mf->ysize * MINESIZE_MIN;
424
 
}
425
 
 
426
 
static void
427
 
gtk_mine_draw (GtkMineField * mfield, guint x, guint y)
 
406
gtk_minefield_get_preferred_width (GtkWidget *widget, gint *minimum, gint *natural)
 
407
{
 
408
  GtkMineField *mf = GTK_MINEFIELD (widget);
 
409
 
 
410
  /* request the minimum size - to allow the widget window to be resized */
 
411
  *minimum = *natural = mf->xsize * MINESIZE_MIN;
 
412
}
 
413
 
 
414
static void
 
415
gtk_minefield_get_preferred_height (GtkWidget *widget, gint *minimum, gint *natural)
 
416
{
 
417
  GtkMineField *mf = GTK_MINEFIELD (widget);
 
418
 
 
419
  /* request the minimum size - to allow the widget window to be resized */
 
420
  *minimum = *natural = mf->ysize * MINESIZE_MIN;
 
421
}
 
422
 
 
423
static void
 
424
gtk_mine_queue_draw (GtkMineField * mfield, guint x, guint y)
 
425
{
 
426
  guint minesizepixels = mfield->minesizepixels;
 
427
 
 
428
  gtk_widget_queue_draw_area (GTK_WIDGET (mfield),
 
429
                              x * minesizepixels, y * minesizepixels,
 
430
                              minesizepixels, minesizepixels);
 
431
}
 
432
 
 
433
static void
 
434
gtk_mine_draw (GtkMineField * mfield, cairo_t *cr, guint x, guint y)
428
435
{
429
436
  int c = get_cell_index (mfield, x, y);
430
437
  int noshadow;
431
438
  gboolean clicked;
432
439
  int n, nm;
433
440
  guint minesizepixels;
434
 
  static GdkGC *dots;
435
 
  static const char stipple_data[] = { 0x03, 0x03, 0x0c, 0x0c };
436
 
  static GdkPixmap *stipple = NULL;
437
441
  GtkStyle *style;
438
442
  GtkWidget *widget = GTK_WIDGET (mfield);
439
 
  GdkRectangle rect;
440
 
  GdkWindow *window;
441
443
 
442
444
  g_return_if_fail (c != -1);
443
445
 
444
 
  window = gtk_widget_get_window (widget);
445
446
  style = gtk_widget_get_style (widget);
446
447
 
447
 
  /* This gives us a dotted line to increase the contrast between
448
 
   * buttons and the "sea". */
449
 
  if (stipple == NULL) {
450
 
    stipple = gdk_bitmap_create_from_data (NULL, stipple_data, 4, 4);
451
 
    dots = gdk_gc_new (window);
452
 
    gdk_gc_copy (dots, style->dark_gc[2]);
453
 
    gdk_gc_set_stipple (dots, stipple);
454
 
    g_object_unref (stipple);
455
 
    gdk_gc_set_fill (dots, GDK_STIPPLED);
456
 
  }
457
 
 
458
448
  minesizepixels = mfield->minesizepixels;
459
449
 
460
450
  noshadow = mfield->mines[c].shown;
461
451
 
462
452
  clicked = mfield->mines[c].down;
463
453
 
464
 
  /* gtk_paint_box needs a clipping rectangle. */
465
 
  rect.x = x * minesizepixels;
466
 
  rect.y = y * minesizepixels;
467
 
  rect.width = minesizepixels;
468
 
  rect.height = minesizepixels;
469
 
 
470
454
  if (noshadow) {               /* draw grid on ocean floor */
 
455
    double dots[] = {2, 2};
 
456
 
471
457
    gtk_paint_box (style,
472
 
                   window,
 
458
                   cr,
473
459
                   clicked ? GTK_STATE_ACTIVE : GTK_STATE_NORMAL,
474
460
                   GTK_SHADOW_IN,
475
 
                   &rect,
476
461
                   widget,
477
462
                   "button", x * minesizepixels, y * minesizepixels, minesizepixels, minesizepixels);
478
463
    if (y == 0) {               /* top row only */
479
 
      gdk_draw_line (window,    /* top */
480
 
                     dots, x * minesizepixels, 0, x * minesizepixels + minesizepixels - 1, 0);
 
464
      cairo_move_to (cr, x * minesizepixels, 0);
 
465
      cairo_line_to (cr, x * minesizepixels + minesizepixels - 1, 0);
481
466
    }
482
467
    if (x == 0) {               /* left column only */
483
 
      gdk_draw_line (window,    /* left */
484
 
                     dots, 0, y * minesizepixels, 0, y * minesizepixels + minesizepixels - 1);
 
468
      cairo_move_to (cr, 0, y * minesizepixels);
 
469
      cairo_line_to (cr, 0, y * minesizepixels + minesizepixels - 1);
485
470
    }
486
 
    gdk_draw_line (window,      /* right */
487
 
                   dots,
488
 
                   x * minesizepixels + minesizepixels - 1,
489
 
                   y * minesizepixels,
490
 
                   x * minesizepixels + minesizepixels - 1, y * minesizepixels + minesizepixels - 1);
491
 
    gdk_draw_line (window,      /* bottom */
492
 
                   dots,
493
 
                   x * minesizepixels,
494
 
                   y * minesizepixels + minesizepixels - 1,
495
 
                   x * minesizepixels + minesizepixels - 1, y * minesizepixels + minesizepixels - 1);
 
471
    cairo_move_to (cr, x * minesizepixels + minesizepixels - 1 + 0.5, y * minesizepixels + 0.5);
 
472
    cairo_line_to (cr, x * minesizepixels + minesizepixels - 1 + 0.5, y * minesizepixels + minesizepixels - 1 + 0.5);
 
473
    cairo_move_to (cr, x * minesizepixels + 0.5, y * minesizepixels + minesizepixels - 1 + 0.5);
 
474
    cairo_line_to (cr, x * minesizepixels + minesizepixels - 1 + 0.5, y * minesizepixels + minesizepixels - 1 + 0.5);
496
475
 
 
476
    cairo_save (cr);
 
477
    gdk_cairo_set_source_color (cr, &gtk_widget_get_style (widget)->dark[gtk_widget_get_state (widget)]);
 
478
    cairo_set_line_width (cr, 1);
 
479
    cairo_set_dash (cr, dots, 2, 0);
 
480
    cairo_stroke (cr);
 
481
    cairo_restore (cr);
497
482
  } else {                      /* draw shadow around possible mine location */
498
483
    gtk_paint_box (style,
499
 
                   window,
 
484
                   cr,
500
485
                   clicked ? GTK_STATE_ACTIVE : GTK_STATE_SELECTED,
501
486
                   clicked ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
502
 
                   &rect,
503
487
                   widget,
504
488
                   "button", x * minesizepixels, y * minesizepixels, minesizepixels, minesizepixels);
505
489
  }
512
496
    g_assert (nm >= 0 && nm <= 9);
513
497
 
514
498
    if (mfield->use_overmine_warning && n < nm) {
515
 
      gdk_draw_pixbuf (window, NULL,
516
 
                       mfield->warning.scaledpixbuf, 0, 0,
517
 
                       x * minesizepixels + (minesizepixels - mfield->warning.width) / 2,
518
 
                       y * minesizepixels + (minesizepixels - mfield->warning.height) / 2,
519
 
                       mfield->warning.width, mfield->warning.height,
520
 
                       GDK_RGB_DITHER_NORMAL, 0, 0);
 
499
      gdk_cairo_set_source_pixbuf (cr, mfield->warning.scaledpixbuf,
 
500
                                   x * minesizepixels + (minesizepixels - mfield->warning.width) / 2,
 
501
                                   y * minesizepixels + (minesizepixels - mfield->warning.height) / 2);
 
502
      cairo_rectangle (cr,
 
503
                       x * minesizepixels + (minesizepixels - mfield->warning.width) / 2,
 
504
                       y * minesizepixels + (minesizepixels - mfield->warning.height) / 2,
 
505
                       mfield->warning.width, mfield->warning.height);
 
506
      cairo_fill (cr);
521
507
    }
522
508
 
523
509
    if (n != 0) {
524
 
      gdk_draw_layout (window,
525
 
                       style->black_gc,
526
 
                       x * minesizepixels + mfield->numstr[n].dx,
527
 
                       y * minesizepixels + mfield->numstr[n].dy,
528
 
                       PANGO_LAYOUT (mfield->numstr[n].layout));
 
510
      cairo_move_to (cr,                     
 
511
                     x * minesizepixels + mfield->numstr[n].dx,
 
512
                     y * minesizepixels + mfield->numstr[n].dy);
 
513
      pango_cairo_show_layout (cr, PANGO_LAYOUT (mfield->numstr[n].layout));
529
514
    }
530
515
 
531
516
  } else if (mfield->mines[c].marked == MINE_QUESTION) {
532
 
    gdk_draw_pixbuf (window, NULL,
533
 
                     mfield->question.scaledpixbuf, 0, 0,
534
 
                     x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
535
 
                     y * minesizepixels + (minesizepixels - mfield->flag.height) / 2,
536
 
                     mfield->flag.width, mfield->flag.height,
537
 
                     GDK_RGB_DITHER_NORMAL, 0, 0);
 
517
    gdk_cairo_set_source_pixbuf (cr, mfield->question.scaledpixbuf,
 
518
                                 x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
 
519
                                 y * minesizepixels + (minesizepixels - mfield->flag.height) / 2);
 
520
    cairo_rectangle (cr,
 
521
                     x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
 
522
                     y * minesizepixels + (minesizepixels - mfield->flag.height) / 2,
 
523
                     mfield->flag.width, mfield->flag.height);
 
524
    cairo_fill (cr);
538
525
  } else if (mfield->mines[c].marked == MINE_MARKED) {
539
 
    gdk_draw_pixbuf (window, NULL,
540
 
                     mfield->flag.scaledpixbuf, 0, 0,
541
 
                     x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
542
 
                     y * minesizepixels + (minesizepixels - mfield->flag.height) / 2,
543
 
                     mfield->flag.width, mfield->flag.height,
544
 
                     GDK_RGB_DITHER_NORMAL, 0, 0);
 
526
    gdk_cairo_set_source_pixbuf (cr, mfield->flag.scaledpixbuf,
 
527
                                 x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
 
528
                                 y * minesizepixels + (minesizepixels - mfield->flag.height) / 2);
 
529
    cairo_rectangle (cr,
 
530
                     x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
 
531
                     y * minesizepixels + (minesizepixels - mfield->flag.height) / 2,
 
532
                     mfield->flag.width, mfield->flag.height);
 
533
    cairo_fill (cr);
545
534
 
546
535
    if (mfield->lose && mfield->mines[c].mined != 1) {
547
536
      int x1 = x * minesizepixels + 0.1 * minesizepixels;
549
538
      int x2 = x * minesizepixels + 0.9 * minesizepixels;
550
539
      int y2 = y * minesizepixels + 0.9 * minesizepixels;
551
540
 
552
 
      gdk_draw_line (window, mfield->thick_line, x1, y1, x2, y2);
553
 
      gdk_draw_line (window, mfield->thick_line, x1, y2, x2, y1);
 
541
      cairo_move_to (cr, x1, y1);
 
542
      cairo_line_to (cr, x2, y2);
 
543
      cairo_move_to (cr, x1, y2);
 
544
      cairo_line_to (cr, x2, y1);
 
545
 
 
546
      cairo_save (cr);
 
547
      gdk_cairo_set_source_color (cr, &gtk_widget_get_style (widget)->black);
 
548
      cairo_set_line_width (cr, MAX (1, 0.1 * minesizepixels));
 
549
      cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
 
550
      cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
 
551
      cairo_stroke (cr);
 
552
      cairo_restore (cr);
554
553
    }
555
554
  } else if (mfield->lose && mfield->mines[c].mined) {
556
 
    gdk_draw_pixbuf (window, NULL,
557
 
                     mfield->mine.scaledpixbuf, 0, 0,
558
 
                     x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
559
 
                     y * minesizepixels + (minesizepixels - mfield->flag.height) / 2,
560
 
                     mfield->flag.width, mfield->flag.height,
561
 
                     GDK_RGB_DITHER_NORMAL, 0, 0);
 
555
    gdk_cairo_set_source_pixbuf (cr, mfield->mine.scaledpixbuf,
 
556
                                 x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
 
557
                                 y * minesizepixels + (minesizepixels - mfield->flag.height) / 2);
 
558
    cairo_rectangle (cr,
 
559
                     x * minesizepixels + (minesizepixels - mfield->flag.width) / 2,
 
560
                     y * minesizepixels + (minesizepixels - mfield->flag.height) / 2,
 
561
                     mfield->flag.width, mfield->flag.height);
 
562
    cairo_fill (cr);
562
563
  }
563
564
  if (mfield->lose && mfield->mines[c].mined && mfield->mines[c].shown) {
564
 
    gdk_draw_pixbuf (window, NULL,
565
 
                     mfield->bang.scaledpixbuf, 0, 0,
566
 
                     x * minesizepixels + (minesizepixels - mfield->bang.width) / 2,
567
 
                     y * minesizepixels + (minesizepixels - mfield->bang.height) / 2,
568
 
                     mfield->bang.width, mfield->bang.height,
569
 
                     GDK_RGB_DITHER_NORMAL, 0, 0);
570
 
 
 
565
    gdk_cairo_set_source_pixbuf (cr, mfield->bang.scaledpixbuf,
 
566
                                 x * minesizepixels + (minesizepixels - mfield->bang.width) / 2,
 
567
                                 y * minesizepixels + (minesizepixels - mfield->bang.height) / 2);
 
568
    cairo_rectangle (cr,
 
569
                     x * minesizepixels + (minesizepixels - mfield->bang.width) / 2,
 
570
                     y * minesizepixels + (minesizepixels - mfield->bang.height) / 2,
 
571
                     mfield->bang.width, mfield->bang.height);
 
572
    cairo_fill (cr);
571
573
  }
572
574
}
573
575
 
574
576
static gboolean
575
 
gtk_minefield_expose (GtkWidget * widget, GdkEventExpose * event)
 
577
gtk_minefield_draw (GtkWidget * widget, cairo_t * cr)
576
578
{
577
579
  g_return_val_if_fail (widget != NULL, FALSE);
578
580
  g_return_val_if_fail (GTK_IS_MINEFIELD (widget), FALSE);
579
 
  g_return_val_if_fail (event != NULL, FALSE);
580
581
 
581
582
  if (gtk_widget_is_drawable (widget)) {
582
 
    guint x1, y1, x2, y2, x, y;
 
583
    guint x, y;
583
584
    GtkMineField *mfield = GTK_MINEFIELD (widget);
584
 
    GdkRectangle *area = &event->area;
585
585
 
586
586
    /* mine square numbers must be resized to fit the mine size */
587
587
    gtk_minefield_setup_signs (mfield);
588
588
    gtk_minefield_setup_numbers (mfield);
589
589
 
590
 
    if (area) {
591
 
      x1 = area->x / mfield->minesizepixels;
592
 
      y1 = area->y / mfield->minesizepixels;
593
 
      x2 = (area->x + area->width - 1) / mfield->minesizepixels;
594
 
      y2 = (area->y + area->height - 1) / mfield->minesizepixels;
595
 
    } else {
596
 
      x1 = 0;
597
 
      y1 = 0;
598
 
      x2 = mfield->xsize - 1;
599
 
      y2 = mfield->ysize - 1;
600
 
    }
601
 
 
602
 
    /* These are necessary because we get an expose call before a
603
 
     * resize at the old size, but after we have changed our data. */
604
 
    if (x2 >= mfield->xsize)
605
 
      x2 = mfield->xsize - 1;
606
 
    if (y2 >= mfield->ysize)
607
 
      y2 = mfield->ysize - 1;
608
 
 
609
 
    for (x = x1; x <= x2; x++)
610
 
      for (y = y1; y <= y2; y++)
611
 
        gtk_mine_draw (mfield, x, y);
 
590
    for (x = 0; x < mfield->xsize; x++)
 
591
      for (y = 0; y < mfield->ysize; y++)
 
592
        gtk_mine_draw (mfield, cr, x, y);
612
593
  }
613
594
  return FALSE;
614
595
}
631
612
          mfield->mines[c].marked == MINE_NOMARK) {
632
613
        mfield->mines[c].shown = 1;
633
614
        mfield->shown++;
634
 
        gtk_mine_draw (mfield, nx, ny);
 
615
        gtk_mine_queue_draw (mfield, nx, ny);
635
616
        changed = 1;
636
617
      }
637
618
    }
708
689
    if (mfield->mines[i].mined || mfield->mines[i].marked) {
709
690
      y = i / mfield->xsize;
710
691
      x = i % mfield->xsize;
711
 
      gtk_mine_draw (mfield, x, y);
 
692
      gtk_mine_queue_draw (mfield, x, y);
712
693
    }
713
694
  }
714
695
}
726
707
          mfield->mines[c].marked != MINE_MARKED) {
727
708
 
728
709
        mfield->mines[c].marked = MINE_MARKED;  /* mark it */
729
 
        gtk_mine_draw (mfield, x, y);   /* draw it */
 
710
        gtk_mine_queue_draw (mfield, x, y);     /* draw it */
730
711
        mfield->flag_count++;   /* up the count */
731
 
        g_signal_emit (GTK_OBJECT (mfield),     /* display the count */
 
712
        g_signal_emit (G_OBJECT (mfield),       /* display the count */
732
713
                       minefield_signals[MARKS_CHANGED_SIGNAL], 0, NULL);
733
714
      }
734
715
    }
740
721
  /* now stop the clock.  (MARKS_CHANGED_SIGNAL starts it) */
741
722
  /* Make sure this is the last thing called so it is safe to
742
723
   * start a new game in the win_signal handler. */
743
 
  g_signal_emit (GTK_OBJECT (mfield), minefield_signals[WIN_SIGNAL], 0, NULL);
 
724
  g_signal_emit (G_OBJECT (mfield), minefield_signals[WIN_SIGNAL], 0, NULL);
744
725
}
745
726
 
746
727
static void
817
798
  if (mfield->mines[c].marked != MINE_MARKED && mfield->mines[c].shown != 1) {
818
799
    mfield->mines[c].shown = 1;
819
800
    mfield->shown++;
820
 
    gtk_mine_draw (mfield, x, y);
 
801
    gtk_mine_queue_draw (mfield, x, y);
821
802
    if (mfield->mines[c].mined == 1) {
822
803
      gtk_minefield_lose (mfield);
823
804
    } else {
869
850
 
870
851
      /* Redraw if too many marks placed */
871
852
      if (is_valid != was_valid)
872
 
        gtk_mine_draw (mfield, nx, ny);
 
853
        gtk_mine_queue_draw (mfield, nx, ny);
873
854
    }
874
855
  }
875
856
 
876
857
  /* Update marking */
877
858
  mfield->mines[c].marked = mark;
878
 
  gtk_mine_draw (mfield, x, y);
879
 
  g_signal_emit (GTK_OBJECT (mfield),
 
859
  gtk_mine_queue_draw (mfield, x, y);
 
860
  g_signal_emit (G_OBJECT (mfield),
880
861
                 minefield_signals[MARKS_CHANGED_SIGNAL], 0, NULL);
881
862
}
882
863
    
918
899
      continue;
919
900
    if (mfield->mines[c2].marked != MINE_MARKED && !mfield->mines[c2].shown) {
920
901
      mfield->mines[c2].down = 1;
921
 
      gtk_mine_draw (mfield, nx, ny);
 
902
      gtk_mine_queue_draw (mfield, nx, ny);
922
903
    }
923
904
  }
924
905
  mfield->multi_mode = 1;
985
966
          lose = 1;
986
967
        }
987
968
      }
988
 
      gtk_mine_draw (mfield, nx, ny);
 
969
      gtk_mine_queue_draw (mfield, nx, ny);
989
970
    }
990
971
  }
991
972
  if (lose) {
1026
1007
    /* If left or middle mouse button down. */
1027
1008
    if (mfield->buttondown[0] || mfield->buttondown[1]) {
1028
1009
      mfield->mines[mfield->celldown].down = 0;
1029
 
      gtk_mine_draw (mfield, mfield->celldownx, mfield->celldowny);
 
1010
      gtk_mine_queue_draw (mfield, mfield->celldownx, mfield->celldowny);
1030
1011
 
1031
1012
      if (mfield->multi_mode)
1032
1013
        gtk_minefield_multi_release (mfield, mfield->celldownx,
1035
1016
      mfield->celldowny = y;
1036
1017
      mfield->celldown = c;
1037
1018
      mfield->mines[c].down = 1;
1038
 
      gtk_mine_draw (mfield, x, y);
 
1019
      gtk_mine_queue_draw (mfield, x, y);
1039
1020
 
1040
1021
      /* Clear action is active and the current cell is shown. */
1041
1022
      if (mfield->action == CLEAR_ACTION && mfield->mines[c].shown)
1044
1025
      /*  Update clicked field on right click drag.*/
1045
1026
      mfield->mines[mfield->celldown].down = 0;
1046
1027
      mfield->action = NO_ACTION;
1047
 
      gtk_mine_draw (mfield, mfield->celldownx, mfield->celldowny);
 
1028
      gtk_mine_queue_draw (mfield, mfield->celldownx, mfield->celldowny);
1048
1029
 
1049
1030
      mfield->celldownx = x;
1050
1031
      mfield->celldowny = y;
1095
1076
    mfield->buttondown[event->button - 1]++;
1096
1077
 
1097
1078
    /* Redraw the cell, which is now being pressed. */
1098
 
    gtk_mine_draw (mfield, x, y);
 
1079
    gtk_mine_queue_draw (mfield, x, y);
1099
1080
 
1100
1081
    /* Determine what action to do. Normally this is
1101
1082
     * left button = show, middle = clear and right = flag.
1137
1118
      }
1138
1119
    }
1139
1120
    if (mfield->action != FLAG_ACTION) {
1140
 
      g_signal_emit (GTK_OBJECT (mfield),
 
1121
      g_signal_emit (G_OBJECT (mfield),
1141
1122
                     minefield_signals[LOOK_SIGNAL], 0, NULL);
1142
1123
    }
1143
1124
  }
1176
1157
       break;
1177
1158
    }
1178
1159
    if (!mfield->lose && !mfield->win) {
1179
 
      g_signal_emit (GTK_OBJECT (mfield),
 
1160
      g_signal_emit (G_OBJECT (mfield),
1180
1161
                     minefield_signals[UNLOOK_SIGNAL], 0, NULL);
1181
1162
    }
1182
1163
    mfield->mines[mfield->celldown].down = 0;
1183
1164
    mfield->action = NO_ACTION;
1184
1165
    mfield->buttondown[event->button - 1] = 0;
1185
 
    gtk_mine_draw (mfield, mfield->celldownx, mfield->celldowny);
 
1166
    gtk_mine_queue_draw (mfield, mfield->celldownx, mfield->celldowny);
1186
1167
  }
1187
1168
  return FALSE;
1188
1169
}
1192
1173
gtk_minefield_class_init (GtkMineFieldClass * class)
1193
1174
{
1194
1175
  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
1195
 
  GtkObjectClass *object_class = GTK_OBJECT_CLASS (class);
 
1176
  GObjectClass *object_class = G_OBJECT_CLASS (class);
1196
1177
 
1197
1178
  parent_class = g_type_class_peek_parent (class);
1198
1179
 
1199
1180
  widget_class->realize = gtk_minefield_realize;
1200
1181
  widget_class->unrealize = gtk_minefield_unrealize;
1201
1182
  widget_class->size_allocate = gtk_minefield_size_allocate;
1202
 
  widget_class->size_request = gtk_minefield_size_request;
1203
 
  widget_class->expose_event = gtk_minefield_expose;
 
1183
  widget_class->get_preferred_width = gtk_minefield_get_preferred_width;
 
1184
  widget_class->get_preferred_height = gtk_minefield_get_preferred_height;
 
1185
  widget_class->draw = gtk_minefield_draw;
1204
1186
  widget_class->button_press_event = gtk_minefield_button_press;
1205
1187
  widget_class->button_release_event = gtk_minefield_button_release;
1206
1188
  widget_class->motion_notify_event = gtk_minefield_motion_notify;
1267
1249
  mfield->bang.preimage = NULL;
1268
1250
  mfield->warning.preimage = NULL;
1269
1251
  mfield->grand = g_rand_new ();
1270
 
  mfield->thick_line = NULL;
1271
1252
}
1272
1253
 
1273
1254
void
1479
1460
 
1480
1461
  /* Makes sure that the program knows about the successful
1481
1462
   * hint before a possible win. */
1482
 
  g_signal_emit (GTK_OBJECT (mfield),
 
1463
  g_signal_emit (G_OBJECT (mfield),
1483
1464
                 minefield_signals[HINT_SIGNAL], 0, NULL);
1484
1465
  gtk_minefield_show (mfield, x, y);
1485
 
  gtk_mine_draw (mfield, x, y);
 
1466
  gtk_mine_queue_draw (mfield, x, y);
1486
1467
  retval = MINEFIELD_HINT_ACCEPTED;
1487
1468
 
1488
1469
cleanup: