gtk-stats: Replace uses of deprecated GTK APIs

As of this change, requires GTK 2.24

pandatool/src/gtk-stats/gtkStatsGraph.cxx

@@ -45,7 +45,7 @@ GtkStatsGraph(GtkStatsMonitor *monitor) :
 
   GtkWidget *parent_window = monitor->get_window();
 
-  GdkDisplay *display = gdk_drawable_get_display(parent_window->window);
+  GdkDisplay *display = gdk_window_get_display(gtk_widget_get_window(parent_window));
   _hand_cursor = gdk_cursor_new_for_display(display, GDK_HAND2);
 
   _pixmap = nullptr;
@@ -323,12 +323,14 @@ gboolean GtkStatsGraph::
 handle_motion(GtkWidget *widget, int graph_x, int graph_y) {
   _potential_drag_mode = consider_drag_start(graph_x, graph_y);
 
+  GdkWindow *window = gtk_widget_get_window(_window);
+
   if (_potential_drag_mode == DM_guide_bar ||
       _drag_mode == DM_guide_bar) {
-    gdk_window_set_cursor(_window->window, _hand_cursor);
+    gdk_window_set_cursor(window, _hand_cursor);
 
   } else {
-    gdk_window_set_cursor(_window->window, nullptr);
+    gdk_window_set_cursor(window, nullptr);
   }
 
   return TRUE;
@@ -344,7 +346,8 @@ setup_pixmap(int xsize, int ysize) {
   _pixmap_xsize = std::max(xsize, 0);
   _pixmap_ysize = std::max(ysize, 0);
 
-  _pixmap = gdk_pixmap_new(_graph_window->window, _pixmap_xsize, _pixmap_ysize, -1);
+  GdkWindow *window = gtk_widget_get_window(_graph_window);
+  _pixmap = gdk_pixmap_new(window, _pixmap_xsize, _pixmap_ysize, -1);
   // g_object_ref(_pixmap);   Should this be ref_sink?
   _pixmap_gc = gdk_gc_new(_pixmap);
   // g_object_ref(_pixmap_gc);    Should this be ref_sink?
@@ -392,8 +395,10 @@ graph_expose_callback(GtkWidget *widget, GdkEventExpose *event, gpointer data) {
   GtkStatsGraph *self = (GtkStatsGraph *)data;
 
   if (self->_pixmap != nullptr) {
-    gdk_draw_drawable(self->_graph_window->window,
-          self->_graph_window->style->fg_gc[0],
+    GdkWindow *window = gtk_widget_get_window(self->_graph_window);
+    GtkStyle *style = gtk_widget_get_style(self->_graph_window);
+    gdk_draw_drawable(window,
+          style->fg_gc[0],
           self->_pixmap, 0, 0, 0, 0,
           self->_pixmap_xsize, self->_pixmap_ysize);
   }

pandatool/src/gtk-stats/gtkStatsLabel.cxx

@@ -162,25 +162,28 @@ gboolean GtkStatsLabel::
 expose_event_callback(GtkWidget *widget, GdkEventExpose *event, gpointer data) {
   GtkStatsLabel *self = (GtkStatsLabel *)data;
 
-  GdkGC *gc = gdk_gc_new(widget->window);
+  GdkWindow *window = gtk_widget_get_window(widget);
+  GdkGC *gc = gdk_gc_new(window);
   gdk_gc_set_rgb_fg_color(gc, &self->_bg_color);
 
-  gdk_draw_rectangle(widget->window, gc, TRUE, 0, 0,
-         widget->allocation.width, widget->allocation.height);
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(widget, &allocation);
+
+  gdk_draw_rectangle(window, gc, TRUE, 0, 0, allocation.width, allocation.height);
 
   // Center the text within the rectangle.
   int width, height;
   pango_layout_get_pixel_size(self->_layout, &width, &height);
 
   gdk_gc_set_rgb_fg_color(gc, &self->_fg_color);
-  gdk_draw_layout(widget->window, gc,
-      (widget->allocation.width - width) / 2, 0,
+  gdk_draw_layout(window, gc,
+      (allocation.width - width) / 2, 0,
       self->_layout);
 
   // Now draw the highlight rectangle, if any.
   if (self->_highlight || self->_mouse_within) {
-    gdk_draw_rectangle(widget->window, gc, FALSE, 0, 0,
-           widget->allocation.width - 1, widget->allocation.height - 1);
+    gdk_draw_rectangle(window, gc, FALSE, 0, 0,
+           allocation.width - 1, allocation.height - 1);
   }
 
   g_object_unref(gc);

pandatool/src/gtk-stats/gtkStatsLabelStack.cxx

@@ -48,9 +48,12 @@ int GtkStatsLabelStack::
 get_label_y(int label_index, GtkWidget *target_widget) const {
   nassertr(label_index >= 0 && label_index < (int)_labels.size(), 0);
 
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(_widget, &allocation);
+
   // Assume all labels have the same height.
   int height = _labels[0]->get_height();
-  int start_y = _widget->allocation.height - height * label_index;
+  int start_y = allocation.height - height * label_index;
 
   int x, y;
   gtk_widget_translate_coordinates(_widget, target_widget,

pandatool/src/gtk-stats/gtkStatsMonitor.cxx

@@ -22,32 +22,12 @@
 #include "pStatCollectorDef.h"
 #include "indent.h"
 
-typedef void vc();
-
-GtkItemFactoryEntry GtkStatsMonitor::menu_entries[] = {
-  { (gchar *)"/Options", nullptr, nullptr, 0, (gchar *)"<Branch>" },
-  { (gchar *)"/Options/Units", nullptr, nullptr, 0, (gchar *)"<Branch>" },
-  { (gchar *)"/Options/Units/ms", nullptr, (vc *)&handle_menu_command, MI_time_ms, (gchar *)"<RadioItem>" },
-  { (gchar *)"/Options/Units/Hz", nullptr, (vc *)&handle_menu_command, MI_time_hz, (gchar *)"/Options/Units/ms" },
-  { (gchar *)"/Speed", nullptr, nullptr, 0, (gchar *)"<Branch>" },
-  { (gchar *)"/Speed/1", nullptr, (vc *)&handle_menu_command, MI_speed_1, (gchar *)"<RadioItem>" },
-  { (gchar *)"/Speed/2", nullptr, (vc *)&handle_menu_command, MI_speed_2, (gchar *)"/Speed/1" },
-  { (gchar *)"/Speed/3", nullptr, (vc *)&handle_menu_command, MI_speed_3, (gchar *)"/Speed/1" },
-  { (gchar *)"/Speed/6", nullptr, (vc *)&handle_menu_command, MI_speed_6, (gchar *)"/Speed/1" },
-  { (gchar *)"/Speed/12", nullptr, (vc *)&handle_menu_command, MI_speed_12, (gchar *)"/Speed/1" },
-  { (gchar *)"/Speed/sep", nullptr, nullptr, 0, (gchar *)"<Separator>" },
-  { (gchar *)"/Speed/pause", nullptr, (vc *)&handle_menu_command, MI_pause, (gchar *)"<CheckItem>" },
-};
-
-int GtkStatsMonitor::num_menu_entries = sizeof(menu_entries) / sizeof(GtkItemFactoryEntry);
-
 /**
  *
  */
 GtkStatsMonitor::
 GtkStatsMonitor(GtkStatsServer *server) : PStatMonitor(server) {
   _window = nullptr;
-  _item_factory = nullptr;
 
   // These will be filled in later when the menu is created.
   _time_units = 0;
@@ -160,8 +140,7 @@ new_collector(int collector_index) {
 void GtkStatsMonitor::
 new_thread(int thread_index) {
   GtkStatsChartMenu *chart_menu = new GtkStatsChartMenu(this, thread_index);
-  GtkWidget *menu_bar = gtk_item_factory_get_widget(_item_factory, "<PStats>");
-  chart_menu->add_to_menu_bar(menu_bar, _next_chart_index);
+  chart_menu->add_to_menu_bar(_menu_bar, _next_chart_index);
   ++_next_chart_index;
   _chart_menus.push_back(chart_menu);
 }
@@ -379,40 +358,27 @@ create_window() {
   gtk_window_set_default_size(GTK_WINDOW(_window), 500, 360);
 
   // Set up the menu.
-  GtkAccelGroup *accel_group = gtk_accel_group_new();
-  _item_factory =
-    gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<PStats>", accel_group);
-  gtk_item_factory_create_items(_item_factory, num_menu_entries, menu_entries,
-        this);
+   GtkAccelGroup *accel_group = gtk_accel_group_new();
   gtk_window_add_accel_group(GTK_WINDOW(_window), accel_group);
-  GtkWidget *menu_bar = gtk_item_factory_get_widget(_item_factory, "<PStats>");
+  _menu_bar = gtk_menu_bar_new();
   _next_chart_index = 2;
 
+  setup_options_menu();
+  setup_speed_menu();
   setup_frame_rate_label();
 
-  ChartMenus::iterator mi;
-  for (mi = _chart_menus.begin(); mi != _chart_menus.end(); ++mi) {
-    (*mi)->add_to_menu_bar(menu_bar, _next_chart_index);
+  for (GtkStatsChartMenu *chart_menu : _chart_menus) {
+    chart_menu->add_to_menu_bar(_menu_bar, _next_chart_index);
     ++_next_chart_index;
   }
 
   // Pack the menu into the window.
   GtkWidget *main_vbox = gtk_vbox_new(FALSE, 1);
   gtk_container_add(GTK_CONTAINER(_window), main_vbox);
-  gtk_box_pack_start(GTK_BOX(main_vbox), menu_bar, FALSE, TRUE, 0);
-
-  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(_item_factory, "/Speed/3")),
-         TRUE);
-  set_scroll_speed(3);
-
-  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(_item_factory, "/Options/Units/ms")),
-         TRUE);
-  set_time_units(PStatGraph::GBU_ms);
+  gtk_box_pack_start(GTK_BOX(main_vbox), _menu_bar, FALSE, TRUE, 0);
 
   gtk_widget_show_all(_window);
   gtk_widget_show(_window);
-
-  set_pause(false);
 }
 
 /**
@@ -462,6 +428,126 @@ window_destroy(GtkWidget *widget, gpointer data) {
   self->close();
 }
 
+
+/**
+ * Creates the "Options" pulldown menu.
+ */
+void GtkStatsMonitor::
+setup_options_menu() {
+  _options_menu = gtk_menu_new();
+
+  GtkWidget *item = gtk_menu_item_new_with_label("Options");
+  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), _options_menu);
+  gtk_menu_shell_append(GTK_MENU_SHELL(_menu_bar), item);
+
+  GtkWidget *units_menu = gtk_menu_new();
+  item = gtk_menu_item_new_with_label("Units");
+  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), units_menu);
+  gtk_menu_shell_append(GTK_MENU_SHELL(_options_menu), item);
+
+  item = gtk_radio_menu_item_new_with_label(nullptr, "ms");
+  gtk_menu_shell_append(GTK_MENU_SHELL(units_menu), item);
+  g_signal_connect(G_OBJECT(item), "activate",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+      self->set_time_units(PStatGraph::GBU_ms);
+    }), this);
+
+  item = gtk_radio_menu_item_new_with_label(
+    gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item)), "Hz");
+  gtk_menu_shell_append(GTK_MENU_SHELL(units_menu), item);
+  g_signal_connect(G_OBJECT(item), "activate",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+      self->set_time_units(PStatGraph::GBU_hz);
+    }), this);
+
+  set_time_units(PStatGraph::GBU_ms);
+}
+
+/**
+ * Creates the "Speed" pulldown menu.
+ */
+void GtkStatsMonitor::
+setup_speed_menu() {
+  _speed_menu = gtk_menu_new();
+
+  GtkWidget *item = gtk_menu_item_new_with_label("Speed");
+  gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), _speed_menu);
+  gtk_menu_shell_append(GTK_MENU_SHELL(_menu_bar), item);
+
+  GSList *group = nullptr;
+  item = gtk_radio_menu_item_new_with_label(group, "1");
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+  g_signal_connect(G_OBJECT(item), "toggled",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))) {
+        GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+        self->set_scroll_speed(1);
+      }
+    }), this);
+  group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
+
+  item = gtk_radio_menu_item_new_with_label(group, "2");
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+  g_signal_connect(G_OBJECT(item), "toggled",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))) {
+        GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+        self->set_scroll_speed(2);
+      }
+    }), this);
+  group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
+
+  item = gtk_radio_menu_item_new_with_label(group, "3");
+  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), TRUE);
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+  g_signal_connect(G_OBJECT(item), "toggled",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))) {
+        GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+        self->set_scroll_speed(3);
+      }
+    }), this);
+  group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
+
+  item = gtk_radio_menu_item_new_with_label(group, "6");
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+  g_signal_connect(G_OBJECT(item), "toggled",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))) {
+        GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+        self->set_scroll_speed(6);
+      }
+    }), this);
+  group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
+
+  item = gtk_radio_menu_item_new_with_label(group, "12");
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+  g_signal_connect(G_OBJECT(item), "toggled",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      if (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item))) {
+        GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+        self->set_scroll_speed(12);
+      }
+    }), this);
+  group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
+
+  item = gtk_separator_menu_item_new();
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+
+  item = gtk_check_menu_item_new_with_label("pause");
+  gtk_menu_shell_append(GTK_MENU_SHELL(_speed_menu), item);
+  g_signal_connect(G_OBJECT(item), "toggled",
+    G_CALLBACK(+[](GtkMenuItem *item, gpointer data) {
+      GtkStatsMonitor *self = (GtkStatsMonitor *)data;
+      self->set_pause(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(item)));
+    }), this);
+
+  set_scroll_speed(3);
+  set_pause(false);
+}
+
 /**
  * Creates the frame rate label on the right end of the menu bar.  This is
  * used as a text label to display the main thread's frame rate to the user,
@@ -470,59 +556,13 @@ window_destroy(GtkWidget *widget, gpointer data) {
  */
 void GtkStatsMonitor::
 setup_frame_rate_label() {
-  GtkWidget *menu_bar = gtk_item_factory_get_widget(_item_factory, "<PStats>");
-
   _frame_rate_menu_item = gtk_menu_item_new();
   _frame_rate_label = gtk_label_new("");
   gtk_container_add(GTK_CONTAINER(_frame_rate_menu_item), _frame_rate_label);
 
   gtk_widget_show(_frame_rate_menu_item);
   gtk_widget_show(_frame_rate_label);
-  gtk_menu_item_right_justify(GTK_MENU_ITEM(_frame_rate_menu_item));
-
-  gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), _frame_rate_menu_item);
-}
+  gtk_menu_item_set_right_justified(GTK_MENU_ITEM(_frame_rate_menu_item), TRUE);
 
-/**
- *
- */
-void GtkStatsMonitor::
-handle_menu_command(gpointer callback_data, guint menu_id, GtkWidget *widget) {
-  GtkStatsMonitor *self = (GtkStatsMonitor *)callback_data;
-  switch (menu_id) {
-  case MI_none:
-    break;
-
-  case MI_time_ms:
-    self->set_time_units(PStatGraph::GBU_ms);
-    break;
-
-  case MI_time_hz:
-    self->set_time_units(PStatGraph::GBU_hz);
-    break;
-
-  case MI_speed_1:
-    self->set_scroll_speed(1);
-    break;
-
-  case MI_speed_2:
-    self->set_scroll_speed(2);
-    break;
-
-  case MI_speed_3:
-    self->set_scroll_speed(3);
-    break;
-
-  case MI_speed_6:
-    self->set_scroll_speed(6);
-    break;
-
-  case MI_speed_12:
-    self->set_scroll_speed(12);
-    break;
-
-  case MI_pause:
-    self->set_pause(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)));
-    break;
-  }
+  gtk_menu_shell_append(GTK_MENU_SHELL(_menu_bar), _frame_rate_menu_item);
 }

pandatool/src/gtk-stats/gtkStatsMonitor.h

@@ -82,10 +82,10 @@ private:
   static gboolean window_delete_event(GtkWidget *widget, GdkEvent *event,
               gpointer data);
   static void window_destroy(GtkWidget *widget, gpointer data);
+  void setup_options_menu();
+  void setup_speed_menu();
   void setup_frame_rate_label();
 
-  static void handle_menu_command(gpointer callback_data, guint menu_id, GtkWidget *widget);
-
   typedef pset<GtkStatsGraph *> Graphs;
   Graphs _graphs;
 
@@ -96,7 +96,9 @@ private:
   Menus _menus;
 
   GtkWidget *_window;
-  GtkItemFactory *_item_factory;
+  GtkWidget *_menu_bar;
+  GtkWidget *_options_menu;
+  GtkWidget *_speed_menu;
   int _next_chart_index;
   GtkWidget *_frame_rate_menu_item;
   GtkWidget *_frame_rate_label;
@@ -105,9 +107,6 @@ private:
   double _scroll_speed;
   bool _pause;
 
-  static GtkItemFactoryEntry menu_entries[];
-  static int num_menu_entries;
-
   friend class GtkStatsGraph;
 };
 

pandatool/src/gtk-stats/gtkStatsPianoRoll.cxx

@@ -204,9 +204,11 @@ idle() {
  */
 void GtkStatsPianoRoll::
 additional_graph_window_paint() {
+  GdkWindow *window = gtk_widget_get_window(_graph_window);
+
   int num_user_guide_bars = get_num_user_guide_bars();
   for (int i = 0; i < num_user_guide_bars; i++) {
-    draw_guide_bar(_graph_window->window, get_user_guide_bar(i));
+    draw_guide_bar(window, get_user_guide_bar(i));
   }
 }
 
@@ -424,7 +426,8 @@ draw_guide_labels() {
  */
 void GtkStatsPianoRoll::
 draw_guide_label(const PStatGraph::GuideBar &bar) {
-  GdkGC *gc = gdk_gc_new(_scale_area->window);
+  GdkWindow *window = gtk_widget_get_window(_scale_area);
+  GdkGC *gc = gdk_gc_new(window);
 
   switch (bar._style) {
   case GBS_target:
@@ -467,9 +470,11 @@ draw_guide_label(const PStatGraph::GuideBar &bar) {
              x, 0,
              &x, &junk_y);
 
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(_scale_area, &allocation);
+
     int this_x = x - width / 2;
-    gdk_draw_layout(_scale_area->window, gc, this_x,
-        _scale_area->allocation.height - height, layout);
+    gdk_draw_layout(window, gc, this_x, allocation.height - height, layout);
   }
 
   g_object_unref(layout);

pandatool/src/gtk-stats/gtkStatsStripChart.cxx

@@ -255,10 +255,11 @@ copy_region(int start_x, int end_x, int dest_x) {
   _brush_origin += (dest_x - start_x);
   // SetBrushOrgEx(_bitmap_dc, _brush_origin, 0, NULL);
 
+  GdkWindow *window = gtk_widget_get_window(_graph_window);
   GdkRectangle rect = {
     dest_x, 0, end_x - start_x, get_ysize()
   };
-  gdk_window_invalidate_rect(_graph_window->window, &rect, FALSE);
+  gdk_window_invalidate_rect(window, &rect, FALSE);
 }
 
 /**
@@ -327,10 +328,11 @@ end_draw(int from_x, int to_x) {
     draw_guide_bar(_pixmap, from_x, to_x, get_guide_bar(i));
   }
 
+  GdkWindow *window = gtk_widget_get_window(_graph_window);
   GdkRectangle rect = {
     from_x, 0, to_x - from_x + 1, get_ysize()
   };
-  gdk_window_invalidate_rect(_graph_window->window, &rect, FALSE);
+  gdk_window_invalidate_rect(window, &rect, FALSE);
 }
 
 /**
@@ -339,9 +341,11 @@ end_draw(int from_x, int to_x) {
  */
 void GtkStatsStripChart::
 additional_graph_window_paint() {
+  GdkWindow *window = gtk_widget_get_window(_graph_window);
+
   int num_user_guide_bars = get_num_user_guide_bars();
   for (int i = 0; i < num_user_guide_bars; i++) {
-    draw_guide_bar(_graph_window->window, 0, get_xsize(), get_user_guide_bar(i));
+    draw_guide_bar(window, 0, get_xsize(), get_user_guide_bar(i));
   }
 }
 
@@ -558,7 +562,8 @@ draw_guide_labels() {
  */
 int GtkStatsStripChart::
 draw_guide_label(const PStatGraph::GuideBar &bar, int last_y) {
-  GdkGC *gc = gdk_gc_new(_scale_area->window);
+  GdkWindow *window = gtk_widget_get_window(_scale_area);
+  GdkGC *gc = gdk_gc_new(window);
 
   switch (bar._style) {
   case GBS_target:
@@ -603,7 +608,7 @@ draw_guide_label(const PStatGraph::GuideBar &bar, int last_y) {
 
     int this_y = y - height / 2;
     if (last_y < this_y || last_y > this_y + height) {
-      gdk_draw_layout(_scale_area->window, gc, 0, this_y, layout);
+      gdk_draw_layout(window, gc, 0, this_y, layout);
       last_y = this_y;
     }
   }