home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 2002 April / pcpro0402.iso / essentials / graphics / Gimp / gimp-src-20001226.exe / src / gimp / app / about_dialog.c next >
Encoding:
C/C++ Source or Header  |  2000-12-17  |  19.2 KB  |  720 lines
  1. /* The GIMP -- an image manipulation program
  2.  * Copyright (C) 1995 Spencer Kimball and Peter Mattis
  3.  *
  4.  * This program is free software; you can redistribute it and/or modify
  5.  * it under the terms of the GNU General Public License as published by
  6.  * the Free Software Foundation; either version 2 of the License, or
  7.  * (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17.  */
  18.  
  19. #include "config.h"
  20.  
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <time.h>
  25.  
  26. #include <gtk/gtk.h>
  27. #include <gdk/gdkkeysyms.h>
  28.  
  29. #include "apptypes.h"
  30.  
  31. #include "about_dialog.h"
  32. #include "appenv.h"
  33. #include "authors.h"
  34. #include "gimpdnd.h"
  35. #include "gimphelp.h"
  36.  
  37. #include "libgimp/gimpfeatures.h"
  38.  
  39. #include "libgimp/gimpenv.h"
  40. #include "libgimp/gimpintl.h"
  41. #include "libgimp/gimpmath.h"
  42.  
  43. #include "pixmaps/wilber2.xpm"
  44.  
  45.  
  46. #define ANIMATION_STEPS 16
  47. #define ANIMATION_SIZE   2
  48.  
  49. static gboolean  about_dialog_load_logo   (GtkWidget      *window);
  50. static void      about_dialog_destroy     (GtkObject      *object,
  51.                        gpointer        data);
  52. static void      about_dialog_unmap       (GtkWidget      *widget,
  53.                        GdkEvent       *event,
  54.                        gpointer        data);
  55. static gint      about_dialog_logo_expose (GtkWidget      *widget,
  56.                        GdkEventExpose *event,
  57.                        gpointer        data);
  58. static gint      about_dialog_button      (GtkWidget      *widget,
  59.                        GdkEventButton *event,
  60.                        gpointer        data);
  61. static gint      about_dialog_key         (GtkWidget      *widget,
  62.                        GdkEventKey    *event,
  63.                        gpointer        data);
  64. static void      about_dialog_tool_drop   (GtkWidget      *widget,
  65.                        ToolType        tool,
  66.                        gpointer        data);
  67. static gint      about_dialog_timer       (gpointer        data);
  68.  
  69.  
  70. static GtkWidget *about_dialog     = NULL;
  71. static GtkWidget *logo_area        = NULL;
  72. static GtkWidget *scroll_area      = NULL;
  73. static GdkPixmap *logo_pixmap      = NULL;
  74. static GdkPixmap *scroll_pixmap    = NULL;
  75. static guchar    *dissolve_map     = NULL;
  76. static gint       dissolve_width;
  77. static gint       dissolve_height;
  78. static gint       logo_width       = 0;
  79. static gint       logo_height      = 0;
  80. static gboolean   do_animation     = FALSE;
  81. static gboolean   do_scrolling     = FALSE;
  82. static gint       scroll_state     = 0;
  83. static gint       frame            = 0;
  84. static gint       offset           = 0;
  85. static gint       timer            = 0;
  86. static gint       hadja_state      = 0;
  87. static gchar    **scroll_text      = authors;
  88. static gint       nscroll_texts    = sizeof (authors) / sizeof (authors[0]);
  89. static gint       scroll_text_widths[sizeof (authors) / sizeof (authors[0])];
  90. static gint       cur_scroll_text  = 0;
  91. static gint       cur_scroll_index = 0;
  92. static gint       shuffle_array[sizeof (authors) / sizeof (authors[0])];
  93.  
  94. /*  dnd stuff  */
  95. static GtkTargetEntry tool_target_table[] =
  96. {
  97.   GIMP_TARGET_TOOL
  98. };
  99. static guint n_tool_targets = (sizeof (tool_target_table) /
  100.                                sizeof (tool_target_table[0]));
  101.  
  102. static gchar *drop_text[] = 
  103. { 
  104.   "We are The GIMP." ,
  105.   "Prepare to be manipulated.",
  106.   "Resistance is futile."
  107. };
  108.  
  109. static gchar *hadja_text[] =
  110. {
  111.   "Hadjaha!",
  112.   "Nej!",
  113. #ifndef GDK_USE_UTF8_MBS
  114.   "TvΣrtom!"
  115. #else
  116.   "Tv├ñrtom!"
  117. #endif
  118. };
  119.  
  120. void
  121. about_dialog_create (void)
  122. {
  123.   GtkWidget *vbox;
  124.   GtkWidget *aboutframe;
  125.   GtkWidget *label;
  126.   GtkWidget *alignment;
  127.   GtkStyle  *style;
  128.   GdkFont   *font;
  129.   gint       max_width;
  130.   gint       i;
  131.   gchar     *label_text;
  132.  
  133.   if (!about_dialog)
  134.     {
  135.       about_dialog = gtk_window_new (GTK_WINDOW_DIALOG);
  136.       gtk_window_set_wmclass (GTK_WINDOW (about_dialog), "about_dialog", "Gimp");
  137.       gtk_window_set_title (GTK_WINDOW (about_dialog), _("About the GIMP"));
  138.       gtk_window_set_policy (GTK_WINDOW (about_dialog), FALSE, FALSE, FALSE);
  139.       gtk_window_set_position (GTK_WINDOW (about_dialog), GTK_WIN_POS_CENTER);
  140.  
  141.       gimp_help_connect_help_accel (about_dialog, gimp_standard_help_func,
  142.                     "dialogs/about.html");
  143.  
  144.       gtk_signal_connect (GTK_OBJECT (about_dialog), "destroy",
  145.               GTK_SIGNAL_FUNC (about_dialog_destroy),
  146.               NULL);
  147.       gtk_signal_connect (GTK_OBJECT (about_dialog), "unmap_event",
  148.               GTK_SIGNAL_FUNC (about_dialog_unmap),
  149.               NULL);
  150.       gtk_signal_connect (GTK_OBJECT (about_dialog), "button_press_event",
  151.               GTK_SIGNAL_FUNC (about_dialog_button),
  152.               NULL);
  153.       gtk_signal_connect (GTK_OBJECT (about_dialog), "key_press_event",
  154.               GTK_SIGNAL_FUNC (about_dialog_key),
  155.               NULL);
  156.       
  157.       /*  dnd stuff  */
  158.       gtk_drag_dest_set (about_dialog,
  159.              GTK_DEST_DEFAULT_MOTION |
  160.              GTK_DEST_DEFAULT_DROP,
  161.              tool_target_table, n_tool_targets,
  162.              GDK_ACTION_COPY); 
  163.       gimp_dnd_tool_dest_set (about_dialog, about_dialog_tool_drop, NULL);
  164.  
  165.       gtk_widget_set_events (about_dialog, GDK_BUTTON_PRESS_MASK);
  166.  
  167.       if (!about_dialog_load_logo (about_dialog))
  168.     {
  169.       gtk_widget_destroy (about_dialog);
  170.       about_dialog = NULL;
  171.       return;
  172.     }
  173.  
  174.       vbox = gtk_vbox_new (FALSE, 1);
  175.       gtk_container_set_border_width (GTK_CONTAINER (vbox), 1);
  176.       gtk_container_add (GTK_CONTAINER (about_dialog), vbox);
  177.       gtk_widget_show (vbox);
  178.  
  179.       aboutframe = gtk_frame_new (NULL);
  180.       gtk_frame_set_shadow_type (GTK_FRAME (aboutframe), GTK_SHADOW_IN);
  181.       gtk_container_set_border_width (GTK_CONTAINER (aboutframe), 0);
  182.       gtk_box_pack_start (GTK_BOX (vbox), aboutframe, TRUE, TRUE, 0);
  183.       gtk_widget_show (aboutframe);
  184.  
  185.       logo_area = gtk_drawing_area_new ();
  186.       gtk_signal_connect (GTK_OBJECT (logo_area), "expose_event",
  187.               GTK_SIGNAL_FUNC (about_dialog_logo_expose),
  188.               NULL);
  189.       gtk_drawing_area_size (GTK_DRAWING_AREA (logo_area),
  190.                  logo_width, logo_height);
  191.       gtk_widget_set_events (logo_area, GDK_EXPOSURE_MASK);
  192.       gtk_container_add (GTK_CONTAINER (aboutframe), logo_area);
  193.       gtk_widget_show (logo_area);
  194.  
  195.       gtk_widget_realize (logo_area);
  196.       gdk_window_set_background (logo_area->window, &logo_area->style->black);
  197.  
  198.       /* this is a font, provide only one single font definition */
  199.       font = gdk_font_load (_("-*-helvetica-medium-r-normal--*-140-*-*-*-*-*-*"));
  200.       if (font)
  201.     {
  202.       style = gtk_style_new ();
  203.       gdk_font_unref (style->font);
  204.       style->font = font;
  205.       gdk_font_ref (style->font);
  206.       gtk_widget_push_style (style);
  207.       gtk_style_unref (style);
  208.     }
  209.       label_text = g_strdup_printf (_("Version %s brought to you by"),
  210.                     GIMP_VERSION);
  211.       label = gtk_label_new (label_text);
  212.       g_free (label_text);
  213.       label_text = NULL;
  214.       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
  215.       gtk_widget_show (label);
  216.  
  217.       label = gtk_label_new ("Spencer Kimball & Peter Mattis");
  218.       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
  219.       gtk_widget_show (label);
  220.  
  221.       gtk_widget_pop_style ();
  222.  
  223.       alignment = gtk_alignment_new (0.5, 0.5, 0.0, 0.0);
  224.       gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, TRUE, 0);
  225.       gtk_widget_show (alignment);
  226.  
  227.       aboutframe = gtk_frame_new (NULL);
  228.       gtk_frame_set_shadow_type (GTK_FRAME (aboutframe), GTK_SHADOW_IN);
  229.       gtk_container_set_border_width (GTK_CONTAINER (aboutframe), 0);
  230.       gtk_container_add (GTK_CONTAINER (alignment), aboutframe);
  231.       gtk_widget_show (aboutframe);
  232.  
  233.       max_width = 0;
  234.       for (i = 0; i < nscroll_texts; i++)
  235.     {
  236.       scroll_text_widths[i] = gdk_string_width (aboutframe->style->font,
  237.                             scroll_text[i]);
  238.       max_width = MAX (max_width, scroll_text_widths[i]);
  239.     }
  240.       for (i = 0; i < (sizeof (drop_text) / sizeof (drop_text[0])); i++)
  241.     {
  242.       max_width = MAX (max_width, 
  243.                gdk_string_width (aboutframe->style->font, drop_text[i]));
  244.     }
  245.       for (i = 0; i < (sizeof (hadja_text) / sizeof (hadja_text[0])); i++)
  246.     {
  247.       max_width = MAX (max_width,
  248.                gdk_string_width (aboutframe->style->font, hadja_text[i]));
  249.     }
  250.       scroll_area = gtk_drawing_area_new ();
  251.       gtk_drawing_area_size (GTK_DRAWING_AREA (scroll_area),
  252.                  max_width + 10,
  253.                  aboutframe->style->font->ascent +
  254.                  aboutframe->style->font->descent);
  255.       gtk_widget_set_events (scroll_area, GDK_BUTTON_PRESS_MASK);
  256.       gtk_container_add (GTK_CONTAINER (aboutframe), scroll_area);
  257.       gtk_widget_show (scroll_area);
  258.  
  259.       label = gtk_label_new (_("Please visit http://www.gimp.org/ for more info"));
  260.       gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
  261.       gtk_widget_show (label);
  262.  
  263.       gtk_widget_realize (scroll_area);
  264.       gdk_window_set_background (scroll_area->window,
  265.                  &scroll_area->style->white);
  266.     }
  267.  
  268.   if (!GTK_WIDGET_VISIBLE (about_dialog))
  269.     {
  270.       gtk_widget_show (about_dialog);
  271.  
  272.       do_animation = TRUE;
  273.       do_scrolling = FALSE;
  274.       scroll_state = 0;
  275.       frame = 0;
  276.       offset = 0;
  277.       cur_scroll_text = 0;
  278.  
  279.       if (!double_speed && hadja_state != 7)
  280.     {
  281.       for (i = 0; i < nscroll_texts; i++) 
  282.         {
  283.           shuffle_array[i] = i;
  284.         }
  285.  
  286.       for (i = 0; i < nscroll_texts; i++) 
  287.         {
  288.           gint j;
  289.  
  290.           j = rand() % nscroll_texts;
  291.           if (i != j) 
  292.         {
  293.           gint t;
  294.  
  295.           t = shuffle_array[j];
  296.           shuffle_array[j] = shuffle_array[i];
  297.           shuffle_array[i] = t;
  298.         }
  299.         }
  300.       cur_scroll_text = rand() % nscroll_texts;
  301.     }
  302.     }
  303.   else 
  304.     {
  305.       gdk_window_raise (about_dialog->window);
  306.     }
  307. }
  308.  
  309. static gboolean
  310. about_dialog_load_logo (GtkWidget *window)
  311. {
  312.   GtkWidget *preview;
  313.   GdkGC     *gc;
  314.   gchar      buf[1024];
  315.   gchar     *filename;
  316.   guchar    *pixelrow;
  317.   FILE      *fp;
  318.   gint       count;
  319.   gint       i, j, k;
  320.  
  321.   if (logo_pixmap)
  322.     return TRUE;
  323.  
  324.   filename = g_strconcat (gimp_data_directory (),
  325.               G_DIR_SEPARATOR_S,
  326.               "gimp_logo.ppm",
  327.               NULL);
  328.   fp = fopen (filename, "rb");
  329.   g_free (filename);
  330.  
  331.   if (!fp)
  332.     return FALSE;
  333.  
  334.   fgets (buf, 1024, fp);
  335.  
  336.   if (strncmp (buf, "P6", 2) != 0)
  337.     {
  338.       fclose (fp);
  339.       return FALSE;
  340.     }
  341.  
  342.   fgets (buf, 1024, fp);
  343.   fgets (buf, 1024, fp);
  344.   sscanf (buf, "%d %d", &logo_width, &logo_height);
  345.  
  346.   fgets (buf, 1024, fp);
  347.   if (strncmp (buf, "255", 3) != 0)
  348.     {
  349.       fclose (fp);
  350.       return FALSE;
  351.     }
  352.  
  353.   preview = gtk_preview_new (GTK_PREVIEW_COLOR);
  354.   gtk_preview_size (GTK_PREVIEW (preview), logo_width, logo_height);
  355.   pixelrow = g_new (guchar, logo_width * 3);
  356.  
  357.   for (i = 0; i < logo_height; i++)
  358.     {
  359.       count = fread (pixelrow, sizeof (guchar), logo_width * 3, fp);
  360.       if (count != (logo_width * 3))
  361.     {
  362.       gtk_widget_destroy (preview);
  363.       g_free (pixelrow);
  364.       fclose (fp);
  365.       return FALSE;
  366.     }
  367.  
  368.       gtk_preview_draw_row (GTK_PREVIEW (preview), pixelrow, 0, i, logo_width);
  369.     }
  370.  
  371.   gtk_widget_realize (window);
  372.   logo_pixmap = gdk_pixmap_new (window->window, logo_width, logo_height, 
  373.                 gtk_preview_get_visual ()->depth);
  374.   gc = gdk_gc_new (logo_pixmap);
  375.   gtk_preview_put (GTK_PREVIEW (preview),
  376.            logo_pixmap, gc,
  377.            0, 0, 0, 0, logo_width, logo_height);
  378.   gdk_gc_destroy (gc);
  379.  
  380.   gtk_widget_unref (preview);
  381.   g_free (pixelrow);
  382.  
  383.   fclose (fp);
  384.  
  385.   dissolve_width =
  386.     (logo_width / ANIMATION_SIZE) + (logo_width % ANIMATION_SIZE == 0 ? 0 : 1);
  387.   dissolve_height =
  388.     (logo_height / ANIMATION_SIZE) + (logo_height % ANIMATION_SIZE == 0 ? 0 : 1);
  389.  
  390.   dissolve_map = g_new (guchar, dissolve_width * dissolve_height);
  391.  
  392.   srand (time (NULL));
  393.  
  394.   for (i = 0, k = 0; i < dissolve_height; i++)
  395.     for (j = 0; j < dissolve_width; j++, k++)
  396.       dissolve_map[k] = rand () % ANIMATION_STEPS;
  397.  
  398.   return TRUE;
  399. }
  400.  
  401. static void
  402. about_dialog_destroy (GtkObject *object,
  403.               gpointer   data)
  404. {
  405.   about_dialog = NULL;
  406.   about_dialog_unmap (NULL, NULL, NULL);
  407. }
  408.  
  409. static void
  410. about_dialog_unmap (GtkWidget *widget,
  411.             GdkEvent  *event,
  412.             gpointer   data)
  413. {
  414.   if (timer)
  415.     {
  416.       gtk_timeout_remove (timer);
  417.       timer = 0;
  418.     }
  419. }
  420.  
  421. static gint
  422. about_dialog_logo_expose (GtkWidget      *widget,
  423.               GdkEventExpose *event,
  424.               gpointer        data)
  425. {
  426.   if (do_animation)
  427.     {
  428.       if (!timer)
  429.     {
  430.       about_dialog_timer (widget);
  431.       timer = gtk_timeout_add (75, about_dialog_timer, NULL);
  432.     }
  433.     }
  434.   else
  435.     {
  436.       /* If we draw beyond the boundaries of the pixmap, then X
  437.      will generate an expose area for those areas, starting
  438.      an infinite cycle. We now set allow_grow = FALSE, so
  439.      the drawing area can never be bigger than the preview.
  440.          Otherwise, it would be necessary to intersect event->area
  441.          with the pixmap boundary rectangle. */
  442.  
  443.       gdk_draw_pixmap (widget->window,
  444.                widget->style->black_gc,
  445.                logo_pixmap, 
  446.                event->area.x, event->area.y,
  447.                event->area.x, event->area.y,
  448.                event->area.width, event->area.height);
  449.     }
  450.  
  451.   return FALSE;
  452. }
  453.  
  454. static gint
  455. about_dialog_button (GtkWidget      *widget,
  456.              GdkEventButton *event,
  457.              gpointer        data)
  458. {
  459.   if (timer)
  460.     gtk_timeout_remove (timer);
  461.   timer = 0;
  462.   frame = 0;
  463.  
  464.   gtk_widget_hide (about_dialog);
  465.  
  466.   return FALSE;
  467. }
  468.  
  469. static gint
  470. about_dialog_key (GtkWidget      *widget,
  471.           GdkEventKey    *event,
  472.           gpointer        data)
  473. {
  474.   gint i;
  475.   
  476.   if (hadja_state == 7)
  477.     return FALSE;
  478.     
  479.   switch (event->keyval)
  480.     {
  481.     case GDK_h:
  482.     case GDK_H:
  483.       if (hadja_state == 0 || hadja_state == 5)
  484.     hadja_state++;
  485.       else
  486.     hadja_state = 1;
  487.       break;
  488.     case GDK_a:
  489.     case GDK_A:
  490.       if (hadja_state == 1 || hadja_state == 4 || hadja_state == 6)
  491.     hadja_state++;
  492.       else
  493.     hadja_state = 0;
  494.       break;
  495.     case GDK_d:
  496.     case GDK_D:
  497.       if (hadja_state == 2)
  498.     hadja_state++;
  499.       else
  500.     hadja_state = 0;
  501.       break;
  502.     case GDK_j:
  503.     case GDK_J:
  504.       if (hadja_state == 3)
  505.     hadja_state++;
  506.       else
  507.     hadja_state = 0;
  508.       break;
  509.     default:
  510.       hadja_state = 0;
  511.     }
  512.  
  513.   if (hadja_state == 7)
  514.     {
  515.       scroll_text = hadja_text;
  516.       nscroll_texts = sizeof (hadja_text) / sizeof (hadja_text[0]);
  517.       
  518.       for (i = 0; i < nscroll_texts; i++)
  519.     {
  520.       shuffle_array[i] = i;
  521.       scroll_text_widths[i] = gdk_string_width (scroll_area->style->font,
  522.                             scroll_text[i]);
  523.     }
  524.       
  525.       scroll_state = 0;
  526.       cur_scroll_index = 0;
  527.       cur_scroll_text = 0;
  528.       offset = 0;
  529.     }
  530.   
  531.   return FALSE;
  532. }
  533.  
  534. static void
  535. about_dialog_tool_drop (GtkWidget *widget,
  536.             ToolType   tool,
  537.             gpointer   data)
  538. {
  539.   GdkPixmap *pixmap = NULL;
  540.   GdkBitmap *mask   = NULL;
  541.   gint width  = 0;
  542.   gint height = 0;
  543.   gint i;
  544.   
  545.   if (do_animation)
  546.     return;
  547.  
  548.   if (timer)
  549.     gtk_timeout_remove (timer);
  550.  
  551.   timer = gtk_timeout_add (75, about_dialog_timer, NULL);
  552.  
  553.   frame = 0;
  554.   do_animation = TRUE;
  555.   do_scrolling = FALSE;
  556.  
  557.   gdk_draw_rectangle (logo_pixmap,
  558.               logo_area->style->white_gc,
  559.               TRUE,
  560.               0, 0,
  561.               logo_area->allocation.width,
  562.               logo_area->allocation.height);
  563.  
  564.   pixmap =
  565.     gdk_pixmap_create_from_xpm_d (widget->window,
  566.                                   &mask,
  567.                                   NULL,
  568.                                   wilber2_xpm);
  569.  
  570.   gdk_window_get_size (pixmap, &width, &height);
  571.  
  572.   if (logo_area->allocation.width  >= width &&
  573.       logo_area->allocation.height >= height)
  574.     {
  575.       gint x, y;
  576.  
  577.       x = (logo_area->allocation.width  - width) / 2;
  578.       y = (logo_area->allocation.height - height) / 2;
  579.  
  580.       gdk_gc_set_clip_mask (logo_area->style->black_gc, mask);
  581.       gdk_gc_set_clip_origin (logo_area->style->black_gc, x, y);
  582.  
  583.       gdk_draw_pixmap (logo_pixmap,
  584.                        logo_area->style->black_gc,
  585.                        pixmap, 0, 0,
  586.                        x, y,
  587.                        width, height);
  588.  
  589.       gdk_gc_set_clip_mask (logo_area->style->black_gc, NULL);
  590.       gdk_gc_set_clip_origin (logo_area->style->black_gc, 0, 0);
  591.     }
  592.  
  593.   gdk_pixmap_unref (pixmap);
  594.   gdk_bitmap_unref (mask);
  595.  
  596.   scroll_text = drop_text;
  597.   nscroll_texts = sizeof (drop_text) / sizeof (drop_text[0]);
  598.  
  599.   for (i = 0; i < nscroll_texts; i++)
  600.     {
  601.       shuffle_array[i] = i;
  602.       scroll_text_widths[i] = gdk_string_width (scroll_area->style->font,
  603.                         scroll_text[i]);
  604.     }
  605.  
  606.   scroll_state = 0;
  607.   cur_scroll_index = 0;
  608.   cur_scroll_text = 0;
  609.   offset = 0;
  610.  
  611.   double_speed = TRUE;
  612. }
  613.  
  614. static gint
  615. about_dialog_timer (gpointer data)
  616. {
  617.   gint i, j, k;
  618.   gint return_val;
  619.  
  620.   return_val = TRUE;
  621.  
  622.   if (do_animation)
  623.     {
  624.       if (logo_area->allocation.width != 1)
  625.     {
  626.       for (i = 0, k = 0; i < dissolve_height; i++)
  627.         for (j = 0; j < dissolve_width; j++, k++)
  628.           if (frame == dissolve_map[k])
  629.         {
  630.           gdk_draw_pixmap (logo_area->window,
  631.                    logo_area->style->black_gc,
  632.                    logo_pixmap,
  633.                    j * ANIMATION_SIZE, i * ANIMATION_SIZE,
  634.                    j * ANIMATION_SIZE, i * ANIMATION_SIZE,
  635.                    ANIMATION_SIZE, ANIMATION_SIZE);
  636.         }
  637.  
  638.       frame += 1;
  639.  
  640.       if (frame == ANIMATION_STEPS)
  641.         {
  642.           do_animation = FALSE;
  643.           do_scrolling = TRUE;
  644.           frame = 0;
  645.  
  646.           timer = gtk_timeout_add (75, about_dialog_timer, NULL);
  647.  
  648.           return FALSE;
  649.         }
  650.     }
  651.     }
  652.  
  653.   if (do_scrolling)
  654.     {
  655.       if (!scroll_pixmap)
  656.     scroll_pixmap = gdk_pixmap_new (scroll_area->window,
  657.                     scroll_area->allocation.width,
  658.                     scroll_area->allocation.height,
  659.                     -1);
  660.  
  661.       switch (scroll_state)
  662.     {
  663.     case 1:
  664.       scroll_state = 2;
  665.       timer = gtk_timeout_add (700, about_dialog_timer, NULL);
  666.       return_val = FALSE;
  667.       break;
  668.     case 2:
  669.       scroll_state = 3;
  670.       timer = gtk_timeout_add (75, about_dialog_timer, NULL);
  671.       return_val = FALSE;
  672.       break;
  673.     }
  674.  
  675.       if (offset > (scroll_text_widths[cur_scroll_text] +
  676.             scroll_area->allocation.width))
  677.     {
  678.       scroll_state = 0;
  679.       cur_scroll_index += 1;
  680.       if (cur_scroll_index == nscroll_texts)
  681.         cur_scroll_index = 0;
  682.       
  683.       cur_scroll_text = shuffle_array[cur_scroll_index];
  684.  
  685.       offset = 0;
  686.     }
  687.  
  688.       gdk_draw_rectangle (scroll_pixmap,
  689.               scroll_area->style->white_gc,
  690.               TRUE, 0, 0,
  691.               scroll_area->allocation.width,
  692.               scroll_area->allocation.height);
  693.       gdk_draw_string (scroll_pixmap,
  694.                scroll_area->style->font,
  695.                scroll_area->style->black_gc,
  696.                scroll_area->allocation.width - offset,
  697.                scroll_area->style->font->ascent,
  698.                scroll_text[cur_scroll_text]);
  699.       gdk_draw_pixmap (scroll_area->window,
  700.                scroll_area->style->black_gc,
  701.                scroll_pixmap, 0, 0, 0, 0,
  702.                scroll_area->allocation.width,
  703.                scroll_area->allocation.height);
  704.  
  705.       offset += 15;
  706.       if (scroll_state == 0)
  707.     {
  708.       if (offset > ((scroll_area->allocation.width +
  709.              scroll_text_widths[cur_scroll_text]) / 2))
  710.         {
  711.           scroll_state = 1;
  712.           offset = (scroll_area->allocation.width +
  713.             scroll_text_widths[cur_scroll_text]) / 2;
  714.         }
  715.     }
  716.     }
  717.  
  718.   return return_val;
  719. }
  720.