gdk3 1.2.0-x86-mingw32

data/vendor/local/share/gtk-3.0/demo/entry_buffer.c

@@ -0,0 +1,66 @@
+/* Entry/Entry Buffer
+ *
+ * GtkEntryBuffer provides the text content in a GtkEntry.
+ *
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+GtkWidget *
+do_entry_buffer (GtkWidget *do_widget)
+{
+  GtkWidget *content_area;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  GtkWidget *entry;
+  GtkEntryBuffer *buffer;
+
+  if (!window)
+  {
+    window = gtk_dialog_new_with_buttons ("GtkEntryBuffer",
+                                          GTK_WINDOW (do_widget),
+                                          0,
+                                          GTK_STOCK_CLOSE,
+                                          GTK_RESPONSE_NONE,
+                                          NULL);
+    gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+    g_signal_connect (window, "response",
+                      G_CALLBACK (gtk_widget_destroy), NULL);
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
+
+    content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
+
+    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+    gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+    label = gtk_label_new (NULL);
+    gtk_label_set_markup (GTK_LABEL (label), "Entries share a buffer. Typing in one is reflected in the other.");
+    gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+    /* Create a buffer */
+    buffer = gtk_entry_buffer_new (NULL, 0);
+
+    /* Create our first entry */
+    entry = gtk_entry_new_with_buffer (buffer);
+    gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+    /* Create the second entry */
+    entry = gtk_entry_new_with_buffer (buffer);
+    gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
+    gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+    g_object_unref (buffer);
+  }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

data/vendor/local/share/gtk-3.0/demo/entry_completion.c

@@ -0,0 +1,98 @@
+/* Entry/Entry Completion
+ *
+ * GtkEntryCompletion provides a mechanism for adding support for
+ * completion in GtkEntry.
+ *
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+/* Creates a tree model containing the completions */
+GtkTreeModel *
+create_completion_model (void)
+{
+  GtkListStore *store;
+  GtkTreeIter iter;
+
+  store = gtk_list_store_new (1, G_TYPE_STRING);
+
+  /* Append one word */
+  gtk_list_store_append (store, &iter);
+  gtk_list_store_set (store, &iter, 0, "GNOME", -1);
+
+  /* Append another word */
+  gtk_list_store_append (store, &iter);
+  gtk_list_store_set (store, &iter, 0, "total", -1);
+
+  /* And another word */
+  gtk_list_store_append (store, &iter);
+  gtk_list_store_set (store, &iter, 0, "totally", -1);
+
+  return GTK_TREE_MODEL (store);
+}
+
+
+GtkWidget *
+do_entry_completion (GtkWidget *do_widget)
+{
+  GtkWidget *content_area;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  GtkWidget *entry;
+  GtkEntryCompletion *completion;
+  GtkTreeModel *completion_model;
+
+  if (!window)
+    {
+      window = gtk_dialog_new_with_buttons ("GtkEntryCompletion",
+                                            GTK_WINDOW (do_widget),
+                                            0,
+                                            GTK_STOCK_CLOSE,
+                                            GTK_RESPONSE_NONE,
+                                            NULL);
+      gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+      g_signal_connect (window, "response",
+                        G_CALLBACK (gtk_widget_destroy), NULL);
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
+
+      vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+      gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
+      gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+      label = gtk_label_new (NULL);
+      gtk_label_set_markup (GTK_LABEL (label), "Completion demo, try writing <b>total</b> or <b>gnome</b> for example.");
+      gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+      /* Create our entry */
+      entry = gtk_entry_new ();
+      gtk_box_pack_start (GTK_BOX (vbox), entry, FALSE, FALSE, 0);
+
+      /* Create the completion object */
+      completion = gtk_entry_completion_new ();
+
+      /* Assign the completion to the entry */
+      gtk_entry_set_completion (GTK_ENTRY (entry), completion);
+      g_object_unref (completion);
+
+      /* Create a tree model and use it as the completion model */
+      completion_model = create_completion_model ();
+      gtk_entry_completion_set_model (completion, completion_model);
+      g_object_unref (completion_model);
+
+      /* Use model column 0 as the text column */
+      gtk_entry_completion_set_text_column (completion, 0);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

data/vendor/local/share/gtk-3.0/demo/expander.c

@@ -0,0 +1,59 @@
+/* Expander
+ *
+ * GtkExpander allows to provide additional content that is initially hidden.
+ * This is also known as "disclosure triangle".
+ *
+ */
+
+#include <gtk/gtk.h>
+
+static GtkWidget *window = NULL;
+
+
+GtkWidget *
+do_expander (GtkWidget *do_widget)
+{
+  GtkWidget *content_area;
+  GtkWidget *vbox;
+  GtkWidget *label;
+  GtkWidget *expander;
+
+  if (!window)
+  {
+    window = gtk_dialog_new_with_buttons ("GtkExpander",
+                                          GTK_WINDOW (do_widget),
+                                          0,
+                                          GTK_STOCK_CLOSE,
+                                          GTK_RESPONSE_NONE,
+                                          NULL);
+    gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
+
+    g_signal_connect (window, "response",
+                      G_CALLBACK (gtk_widget_destroy), NULL);
+    g_signal_connect (window, "destroy",
+                      G_CALLBACK (gtk_widget_destroyed), &window);
+
+    content_area = gtk_dialog_get_content_area (GTK_DIALOG (window));
+
+    vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
+    gtk_box_pack_start (GTK_BOX (content_area), vbox, TRUE, TRUE, 0);
+    gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
+
+    label = gtk_label_new ("Expander demo. Click on the triangle for details.");
+    gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
+
+    /* Create the expander */
+    expander = gtk_expander_new ("Details");
+    gtk_box_pack_start (GTK_BOX (vbox), expander, FALSE, FALSE, 0);
+
+    label = gtk_label_new ("Details can be shown or hidden.");
+    gtk_container_add (GTK_CONTAINER (expander), label);
+  }
+
+  if (!gtk_widget_get_visible (window))
+    gtk_widget_show_all (window);
+  else
+    gtk_widget_destroy (window);
+
+  return window;
+}

data/vendor/local/share/gtk-3.0/demo/fancy.css

@@ -0,0 +1,65 @@
+GtkButton#fancy {
+    transition: none;
+    background-image: linear-gradient(to bottom,
+                                      alpha(white, 0.7),
+                                      alpha(white, 0) 30%),
+                      linear-gradient(to top,
+                                      alpha(#babdb6, 0.4),
+                                      alpha(#babdb6, 0) 50%),
+                      linear-gradient(135deg,
+                                      #eeeeec,
+                                      white 20%,
+                                      #d3d7cf,
+                                      white 80%,
+                                      #babdb6);
+    color: #3465a4;
+    font-weight: bold;
+    text-shadow: 0 1px white;
+}
+
+GtkButton#fancy:hover {
+    transition: all 250ms linear;
+    background-image: linear-gradient(to bottom,
+                                      alpha(white, 1),
+                                      alpha(white, 0)),
+                      linear-gradient(135deg,
+                                      #eeeeec 10%,
+                                      white 40%,
+                                      #d3d7cf,
+                                      white 70%,
+                                      #babdb6);
+    color: #204a87;
+}
+
+GtkButton#fancy:active,
+GtkButton#fancy:active:hover {
+    transition: none;
+    background-image: linear-gradient(to bottom,
+                                      alpha(#555753, 0.5),
+                                      alpha(#babdb6, 0.3)),
+                      linear-gradient(135deg,
+                                      #eeeeec,
+                                      white 20%,
+                                      #d3d7cf,
+                                      white 80%,
+                                      #babdb6);
+    color: white;
+    text-shadow: 0 1px black;
+}
+
+GtkButton#fancy:backdrop,
+GtkButton#fancy:backdrop:hover {
+    transition: none;
+    background-image: linear-gradient(135deg,
+                                      alpha(#eeeeec, 0.5) 10%,
+                                      alpha(white, 0.5) 40%,
+                                      alpha(#d3d7cf, 0.5),
+                                      alpha(white, 0.5) 70%,
+                                      alpha(#babdb6, 0.5));
+    color: #babdb6;
+}
+
+GtkButton#fancy * {
+    /* Yeah this should be inherited by default */
+    color: inherit;
+}

data/vendor/local/share/gtk-3.0/demo/hypertext.c

@@ -0,0 +1,291 @@
+/* Text Widget/Hypertext
+ *
+ * Usually, tags modify the appearance of text in the view, e.g. making it
+ * bold or colored or underlined. But tags are not restricted to appearance.
+ * They can also affect the behavior of mouse and key presses, as this demo
+ * shows.
+ */
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+/* Inserts a piece of text into the buffer, giving it the usual
+ * appearance of a hyperlink in a web browser: blue and underlined.
+ * Additionally, attaches some data on the tag, to make it recognizable
+ * as a link.
+ */
+static void
+insert_link (GtkTextBuffer *buffer,
+             GtkTextIter   *iter,
+             gchar         *text,
+             gint           page)
+{
+  GtkTextTag *tag;
+
+  tag = gtk_text_buffer_create_tag (buffer, NULL,
+                                    "foreground", "blue",
+                                    "underline", PANGO_UNDERLINE_SINGLE,
+                                    NULL);
+  g_object_set_data (G_OBJECT (tag), "page", GINT_TO_POINTER (page));
+  gtk_text_buffer_insert_with_tags (buffer, iter, text, -1, tag, NULL);
+}
+
+/* Fills the buffer with text and interspersed links. In any real
+ * hypertext app, this method would parse a file to identify the links.
+ */
+static void
+show_page (GtkTextBuffer *buffer,
+           gint           page)
+{
+  GtkTextIter iter;
+
+  gtk_text_buffer_set_text (buffer, "", 0);
+  gtk_text_buffer_get_iter_at_offset (buffer, &iter, 0);
+  if (page == 1)
+    {
+      gtk_text_buffer_insert (buffer, &iter, "Some text to show that simple ", -1);
+      insert_link (buffer, &iter, "hypertext", 3);
+      gtk_text_buffer_insert (buffer, &iter, " can easily be realized with ", -1);
+      insert_link (buffer, &iter, "tags", 2);
+      gtk_text_buffer_insert (buffer, &iter, ".", -1);
+    }
+  else if (page == 2)
+    {
+      gtk_text_buffer_insert (buffer, &iter,
+                              "A tag is an attribute that can be applied to some range of text. "
+                              "For example, a tag might be called \"bold\" and make the text inside "
+                              "the tag bold. However, the tag concept is more general than that; "
+                              "tags don't have to affect appearance. They can instead affect the "
+                              "behavior of mouse and key presses, \"lock\" a range of text so the "
+                              "user can't edit it, or countless other things.\n", -1);
+      insert_link (buffer, &iter, "Go back", 1);
+    }
+  else if (page == 3)
+    {
+      GtkTextTag *tag;
+
+      tag = gtk_text_buffer_create_tag (buffer, NULL,
+                                        "weight", PANGO_WEIGHT_BOLD,
+                                        NULL);
+      gtk_text_buffer_insert_with_tags (buffer, &iter, "hypertext:\n", -1, tag, NULL);
+      gtk_text_buffer_insert (buffer, &iter,
+                              "machine-readable text that is not sequential but is organized "
+                              "so that related items of information are connected.\n", -1);
+      insert_link (buffer, &iter, "Go back", 1);
+    }
+}
+
+/* Looks at all tags covering the position of iter in the text view,
+ * and if one of them is a link, follow it by showing the page identified
+ * by the data attached to it.
+ */
+static void
+follow_if_link (GtkWidget   *text_view,
+                GtkTextIter *iter)
+{
+  GSList *tags = NULL, *tagp = NULL;
+
+  tags = gtk_text_iter_get_tags (iter);
+  for (tagp = tags;  tagp != NULL;  tagp = tagp->next)
+    {
+      GtkTextTag *tag = tagp->data;
+      gint page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "page"));
+
+      if (page != 0)
+        {
+          show_page (gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view)), page);
+          break;
+        }
+    }
+
+  if (tags)
+    g_slist_free (tags);
+}
+
+/* Links can be activated by pressing Enter.
+ */
+static gboolean
+key_press_event (GtkWidget *text_view,
+                 GdkEventKey *event)
+{
+  GtkTextIter iter;
+  GtkTextBuffer *buffer;
+
+  switch (event->keyval)
+    {
+      case GDK_KEY_Return:
+      case GDK_KEY_KP_Enter:
+        buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
+        gtk_text_buffer_get_iter_at_mark (buffer, &iter,
+                                          gtk_text_buffer_get_insert (buffer));
+        follow_if_link (text_view, &iter);
+        break;
+
+      default:
+        break;
+    }
+
+  return FALSE;
+}
+
+/* Links can also be activated by clicking.
+ */
+static gboolean
+event_after (GtkWidget *text_view,
+             GdkEvent  *ev)
+{
+  GtkTextIter start, end, iter;
+  GtkTextBuffer *buffer;
+  GdkEventButton *event;
+  gint x, y;
+
+  if (ev->type != GDK_BUTTON_RELEASE)
+    return FALSE;
+
+  event = (GdkEventButton *)ev;
+
+  if (event->button != GDK_BUTTON_PRIMARY)
+    return FALSE;
+
+  buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text_view));
+
+  /* we shouldn't follow a link if the user has selected something */
+  gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
+  if (gtk_text_iter_get_offset (&start) != gtk_text_iter_get_offset (&end))
+    return FALSE;
+
+  gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
+                                         GTK_TEXT_WINDOW_WIDGET,
+                                         event->x, event->y, &x, &y);
+
+  gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (text_view), &iter, x, y);
+
+  follow_if_link (text_view, &iter);
+
+  return FALSE;
+}
+
+static gboolean hovering_over_link = FALSE;
+static GdkCursor *hand_cursor = NULL;
+static GdkCursor *regular_cursor = NULL;
+
+/* Looks at all tags covering the position (x, y) in the text view,
+ * and if one of them is a link, change the cursor to the "hands" cursor
+ * typically used by web browsers.
+ */
+static void
+set_cursor_if_appropriate (GtkTextView    *text_view,
+                           gint            x,
+                           gint            y)
+{
+  GSList *tags = NULL, *tagp = NULL;
+  GtkTextIter iter;
+  gboolean hovering = FALSE;
+
+  gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
+
+  tags = gtk_text_iter_get_tags (&iter);
+  for (tagp = tags;  tagp != NULL;  tagp = tagp->next)
+    {
+      GtkTextTag *tag = tagp->data;
+      gint page = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "page"));
+
+      if (page != 0)
+        {
+          hovering = TRUE;
+          break;
+        }
+    }
+
+  if (hovering != hovering_over_link)
+    {
+      hovering_over_link = hovering;
+
+      if (hovering_over_link)
+        gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), hand_cursor);
+      else
+        gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), regular_cursor);
+    }
+
+  if (tags)
+    g_slist_free (tags);
+}
+
+/* Update the cursor image if the pointer moved.
+ */
+static gboolean
+motion_notify_event (GtkWidget      *text_view,
+                     GdkEventMotion *event)
+{
+  gint x, y;
+
+  gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (text_view),
+                                         GTK_TEXT_WINDOW_WIDGET,
+                                         event->x, event->y, &x, &y);
+
+  set_cursor_if_appropriate (GTK_TEXT_VIEW (text_view), x, y);
+
+  return FALSE;
+}
+
+GtkWidget *
+do_hypertext (GtkWidget *do_widget)
+{
+  static GtkWidget *window = NULL;
+
+  if (!window)
+    {
+      GtkWidget *view;
+      GtkWidget *sw;
+      GtkTextBuffer *buffer;
+
+      hand_cursor = gdk_cursor_new (GDK_HAND2);
+      regular_cursor = gdk_cursor_new (GDK_XTERM);
+
+      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+      gtk_window_set_screen (GTK_WINDOW (window),
+                             gtk_widget_get_screen (do_widget));
+      gtk_window_set_default_size (GTK_WINDOW (window),
+                                   450, 450);
+
+      g_signal_connect (window, "destroy",
+                        G_CALLBACK (gtk_widget_destroyed), &window);
+
+      gtk_window_set_title (GTK_WINDOW (window), "Hypertext");
+      gtk_container_set_border_width (GTK_CONTAINER (window), 0);
+
+      view = gtk_text_view_new ();
+      gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (view), GTK_WRAP_WORD);
+      g_signal_connect (view, "key-press-event",
+                        G_CALLBACK (key_press_event), NULL);
+      g_signal_connect (view, "event-after",
+                        G_CALLBACK (event_after), NULL);
+      g_signal_connect (view, "motion-notify-event",
+                        G_CALLBACK (motion_notify_event), NULL);
+
+      buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
+
+      sw = gtk_scrolled_window_new (NULL, NULL);
+      gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
+                                      GTK_POLICY_AUTOMATIC,
+                                      GTK_POLICY_AUTOMATIC);
+      gtk_container_add (GTK_CONTAINER (window), sw);
+      gtk_container_add (GTK_CONTAINER (sw), view);
+
+      show_page (buffer, 1);
+
+      gtk_widget_show_all (sw);
+    }
+
+  if (!gtk_widget_get_visible (window))
+    {
+      gtk_widget_show (window);
+    }
+  else
+    {
+      gtk_widget_destroy (window);
+      window = NULL;
+    }
+
+  return window;
+}