New upstream version 1.06.002

1 files changed, 225 insertions, 122 deletions

diff --git a/gtkgame.c b/gtkgame.c
index 8efccfe..2f032c4 100644
--- a/gtkgame.c
+++ b/gtkgame.c
@@ -16,7 +16,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  *
- * $Id: gtkgame.c,v 1.917 2017/11/07 22:29:56 plm Exp $
+ * $Id: gtkgame.c,v 1.924 2018/07/21 14:52:54 plm Exp $
  */
 
 #include "config.h"
@@ -890,15 +890,30 @@ ResignAnalysis(float arResign[NUM_ROLLOUT_OUTPUTS], int nResigned, evalsetup * p
     /* First column with text */
 
     pwLabel = gtk_label_new(_("Equity before resignation: "));
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pwLabel, GTK_ALIGN_START);
+    gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
     gtk_misc_set_alignment(GTK_MISC(pwLabel), 0, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 8, 2);
 
     pwLabel = gtk_label_new(_("Equity after resignation: "));
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pwLabel, GTK_ALIGN_START);
+    gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
     gtk_misc_set_alignment(GTK_MISC(pwLabel), 0, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 0, 1, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 8, 2);
 
     pwLabel = gtk_label_new(_("Difference: "));
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pwLabel, GTK_ALIGN_START);
+    gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
     gtk_misc_set_alignment(GTK_MISC(pwLabel), 0, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 0, 1, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 8, 2);
 
     /* Second column: equities/mwc */
@@ -911,7 +926,12 @@ ResignAnalysis(float arResign[NUM_ROLLOUT_OUTPUTS], int nResigned, evalsetup * p
         sprintf(sz, "%+6.3f", rBefore);
 
     pwLabel = gtk_label_new(sz);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pwLabel, GTK_ALIGN_END);
+    gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
     gtk_misc_set_alignment(GTK_MISC(pwLabel), 1, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 1, 2, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 8, 2);
 
 
@@ -921,7 +941,12 @@ ResignAnalysis(float arResign[NUM_ROLLOUT_OUTPUTS], int nResigned, evalsetup * p
         sprintf(sz, "%+6.3f", rAfter);
 
     pwLabel = gtk_label_new(sz);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pwLabel, GTK_ALIGN_END);
+    gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
     gtk_misc_set_alignment(GTK_MISC(pwLabel), 1, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 1, 2, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 8, 2);
 
 
@@ -931,10 +956,14 @@ ResignAnalysis(float arResign[NUM_ROLLOUT_OUTPUTS], int nResigned, evalsetup * p
         sprintf(sz, "%+6.3f", rAfter - rBefore);
 
     pwLabel = gtk_label_new(sz);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pwLabel, GTK_ALIGN_END);
+    gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
     gtk_misc_set_alignment(GTK_MISC(pwLabel), 1, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 1, 2, 2, 3, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 8, 2);
 
-
     return pwTable;
 
 }
@@ -1992,7 +2021,7 @@ static void
 EvalNoiseValueChanged(GtkAdjustment * padj, evalwidget * pew)
 {
 
-    gtk_widget_set_sensitive(pew->pwDeterministic, gtk_adjustment_get_value(padj) != 0.0f);
+    gtk_widget_set_sensitive(pew->pwDeterministic, gtk_adjustment_get_value(padj) != 0.0);
 
     EvalChanged(NULL, pew);
 
@@ -2506,7 +2535,7 @@ AddLevelSettings(GtkWidget * pwFrame, AnalysisDetails * pAnalDetails)
    }
 
 #define ADJUSTSKILLUPDATE(button,flag,string) \
-  if( gtk_adjustment_get_value ( paw->apadjSkill[(button)] ) != arSkillLevel[(flag)] ) \
+  if( gtk_adjustment_get_value ( paw->apadjSkill[(button)] ) != (gdouble)arSkillLevel[(flag)] ) \
   { \
      gchar buf[G_ASCII_DTOSTR_BUF_SIZE]; \
      sprintf(sz,  (string), g_ascii_formatd( buf, G_ASCII_DTOSTR_BUF_SIZE, \
@@ -2515,7 +2544,7 @@ AddLevelSettings(GtkWidget * pwFrame, AnalysisDetails * pAnalDetails)
   }
 
 #define ADJUSTLUCKUPDATE(button,flag,string) \
-  if( gtk_adjustment_get_value( paw->apadjLuck[(button)] ) != arLuckLevel[(flag)] ) \
+  if( gtk_adjustment_get_value( paw->apadjLuck[(button)] ) != (gdouble)arLuckLevel[(flag)] ) \
   { \
      gchar buf[G_ASCII_DTOSTR_BUF_SIZE]; \
      sprintf(sz,  (string), g_ascii_formatd( buf, G_ASCII_DTOSTR_BUF_SIZE, \
@@ -2713,7 +2742,12 @@ SetAnalysis(gpointer UNUSED(p), guint UNUSED(n), GtkWidget * UNUSED(pw))
         gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 0, 1, i, i + 1,
                          (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
         gtk_label_set_justify(GTK_LABEL(pwLabel), GTK_JUSTIFY_RIGHT);
+#if GTK_CHECK_VERSION(3,0,0)
+        gtk_widget_set_halign(pwLabel, GTK_ALIGN_START);
+        gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
         gtk_misc_set_alignment(GTK_MISC(pwLabel), 0, 0.5);
+#endif
     }
 
     for (i = 0; i < 3; i++) {
@@ -2737,7 +2771,12 @@ SetAnalysis(gpointer UNUSED(p), guint UNUSED(n), GtkWidget * UNUSED(pw))
         gtk_table_attach(GTK_TABLE(pwTable), pwLabel, 0, 1, i, i + 1,
                          (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0);
         gtk_label_set_justify(GTK_LABEL(pwLabel), GTK_JUSTIFY_RIGHT);
+#if GTK_CHECK_VERSION(3,0,0)
+        gtk_widget_set_halign(pwLabel, GTK_ALIGN_START);
+        gtk_widget_set_valign(pwLabel, GTK_ALIGN_CENTER);
+#else
         gtk_misc_set_alignment(GTK_MISC(pwLabel), 0, 0.5);
+#endif
     }
 
     for (i = 0; i < 4; i++) {
@@ -3351,7 +3390,7 @@ static GtkActionEntry actionEntries[] = {
      CMD_ACTION_CALLBACK_FROMID(CMD_ANALYSE_MATCH)},
 
     {"ClearAnalysisMenuAction", NULL, N_("Clear analysis"), NULL, NULL, G_CALLBACK(NULL)},
-    {"ClearAnalysisMoveAction", GTK_STOCK_CLEAR, N_("Move"), NULL, NULL,
+    {"ClearAnalysisMoveAction", GTK_STOCK_CLEAR, N_("noun|Move"), NULL, NULL,
      CMD_ACTION_CALLBACK_FROMID(CMD_ANALYSE_CLEAR_MOVE)},
     {"ClearAnalysisGameAction", GTK_STOCK_CLEAR, N_("_Game"), NULL, NULL,
      CMD_ACTION_CALLBACK_FROMID(CMD_ANALYSE_CLEAR_GAME)},
@@ -3362,7 +3401,7 @@ static GtkActionEntry actionEntries[] = {
     {"CMarkCubeMenuAction", NULL, N_("Cube"), NULL, NULL, G_CALLBACK(NULL)},
     {"CMarkCubeClearAction", NULL, N_("Clear"), NULL, NULL, CMD_ACTION_CALLBACK_FROMID(CMD_CMARK_CUBE_CLEAR)},
     {"CMarkCubeShowAction", NULL, N_("Show"), NULL, NULL, CMD_ACTION_CALLBACK_FROMID(CMD_CMARK_CUBE_SHOW)},
-    {"CMarkMoveMenuAction", NULL, N_("Move"), NULL, NULL, G_CALLBACK(NULL)},
+    {"CMarkMoveMenuAction", NULL, N_("noun|Move"), NULL, NULL, G_CALLBACK(NULL)},
     {"CMarkMoveClearAction", NULL, N_("Clear"), NULL, NULL, CMD_ACTION_CALLBACK_FROMID(CMD_CMARK_MOVE_CLEAR)},
     {"CMarkMoveShowAction", NULL, N_("Show"), NULL, NULL, CMD_ACTION_CALLBACK_FROMID(CMD_CMARK_MOVE_SHOW)},
     {"CMarkGameMenuAction", NULL, N_("Game"), NULL, NULL, G_CALLBACK(NULL)},
@@ -3885,7 +3924,12 @@ CreateMainWindow(void)
     pwGameBox = gtk_hbox_new(FALSE, 0);
 #endif
     gtk_box_pack_start(GTK_BOX(pwVbox), pwGameBox, TRUE, TRUE, 0);
-    gtk_box_pack_start(GTK_BOX(pwVbox), hpaned = gtk_hpaned_new(), TRUE, TRUE, 0);
+#if GTK_CHECK_VERSION(3,0,0)
+    hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
+#else
+    hpaned = gtk_hpaned_new();
+#endif
+    gtk_box_pack_start(GTK_BOX(pwVbox), hpaned, TRUE, TRUE, 0);
 
 #if GTK_CHECK_VERSION(3,0,0)
     pwPanelGameBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
@@ -3934,7 +3978,13 @@ CreateMainWindow(void)
     gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(pwStatus), FALSE);
     /* It's a bit naughty to access pwStatus->label, but its default alignment
      * is ugly, and GTK gives us no other way to change it. */
-    gtk_misc_set_alignment(GTK_MISC(get_statusbar_label(GTK_STATUSBAR(pwStatus))), 0.0f, 0.5f);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(get_statusbar_label(GTK_STATUSBAR(pwStatus)), GTK_ALIGN_START);
+    gtk_widget_set_valign(get_statusbar_label(GTK_STATUSBAR(pwStatus)), GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(get_statusbar_label(GTK_STATUSBAR(pwStatus))), 0, 0.5);
+#endif
+
     idOutput = gtk_statusbar_get_context_id(GTK_STATUSBAR(pwStatus), "gnubg output");
     idProgress = gtk_statusbar_get_context_id(GTK_STATUSBAR(pwStatus), "progress");
     g_signal_connect(G_OBJECT(pwStatus), "text-popped", G_CALLBACK(TextPopped), NULL);
@@ -4003,12 +4053,19 @@ CreateMainWindow(void)
     g_signal_connect(G_OBJECT(pwMain), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 }
 
+#if !defined(WIN32)
+static inline void my_g_object_unref(gpointer data, gpointer UNUSED(user_data))
+{
+    g_object_unref(data);
+}
+#endif
+
 static void
 gnubg_set_default_icon(void)
 {
     /* win32 uses the ico file for this */
     /* adapted from pidgin */
-#ifndef WIN32
+#if !defined(WIN32)
     GList *icons = NULL;
     GdkPixbuf *icon = NULL;
     char *ip;
@@ -4035,7 +4092,7 @@ gnubg_set_default_icon(void)
     }
     gtk_window_set_default_icon_list(icons);
 
-    g_list_foreach(icons, (GFunc) g_object_unref, NULL);
+    g_list_foreach(icons, my_g_object_unref, NULL);
     g_list_free(icons);
 #endif
 }
@@ -4324,7 +4381,6 @@ TutorHint(GtkWidget * pw, void *UNUSED(unused))
 
     gtk_widget_destroy(gtk_widget_get_toplevel(pw));
     UserCommand("hint");
-
 }
 
 static void
@@ -4367,7 +4423,11 @@ GtkTutor(char *sz)
 
     pwPrompt = gtk_label_new(sz);
 
+#if GTK_CHECK_VERSION(3,0,0)
+    g_object_set(pwPrompt, "margin", 8, NULL);
+#else
     gtk_misc_set_padding(GTK_MISC(pwPrompt), 8, 8);
+#endif
     gtk_label_set_justify(GTK_LABEL(pwPrompt), GTK_JUSTIFY_LEFT);
     gtk_label_set_line_wrap(GTK_LABEL(pwPrompt), TRUE);
     gtk_container_add(GTK_CONTAINER(DialogArea(pwTutorDialog, DA_MAIN)), pwPrompt);
@@ -4788,7 +4848,7 @@ typedef struct _rolloutpagegeneral {
     GtkAdjustment *padjSeed, *padjMinGames, *padjMaxError;
     GtkAdjustment *padjJsdMinGames, *padjJsdLimit;
     GtkWidget *arpwGeneral;
-    GtkWidget *pwMinGames, *pwMaxError;
+    GtkWidget *pwMinGames, *pwMaxError, *pwJsdLimit;
 } rolloutpagegeneral;
 
 typedef struct _rolloutwidget {
@@ -4938,7 +4998,6 @@ LateEvalToggled(GtkWidget * UNUSED(pw), rolloutwidget * prw)
 static void
 STDStopToggled(GtkWidget * UNUSED(pw), rolloutwidget * prw)
 {
-
     int do_std_stop = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prw->prwGeneral->pwDoSTDStop));
 
     gtk_widget_set_sensitive(GTK_WIDGET(prw->prwGeneral->pwAdjMinGames), do_std_stop);
@@ -4948,13 +5007,10 @@ STDStopToggled(GtkWidget * UNUSED(pw), rolloutwidget * prw)
 static void
 JsdStopToggled(GtkWidget * UNUSED(pw), rolloutwidget * prw)
 {
-
-    int do_jsd_stop = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prw->prwGeneral->pwJsdDoStop));
-
-    gtk_widget_set_sensitive(GTK_WIDGET(prw->prwGeneral->pwJsdAdjLimit), do_jsd_stop);
+   int do_jsd_stop = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(prw->prwGeneral->pwJsdDoStop));
 
     gtk_widget_set_sensitive(GTK_WIDGET(prw->prwGeneral->pwJsdAdjMinGames), do_jsd_stop);
-
+    gtk_widget_set_sensitive(GTK_WIDGET(prw->prwGeneral->pwJsdAdjLimit), do_jsd_stop);
 }
 
 static void
@@ -5025,8 +5081,8 @@ PlayersSameToggled(GtkWidget * UNUSED(pw), rolloutwidget * prw)
 static GtkWidget *
 RolloutPageGeneral(rolloutpagegeneral * prpw, rolloutwidget * prw)
 {
-    GtkWidget *pwPage, *pw, *pwv;
-    GtkWidget *pwHBox;
+    GtkWidget *pwPage;
+    GtkWidget *pwh, *pwv, *pwHBox;
     GtkWidget *pwTable, *pwFrame;
 
 #if GTK_CHECK_VERSION(3,0,0)
@@ -5036,93 +5092,100 @@ RolloutPageGeneral(rolloutpagegeneral * prpw, rolloutwidget * prw)
 #endif
     gtk_container_set_border_width(GTK_CONTAINER(pwPage), 8);
 
-    prpw->padjSeed = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.nSeed, 0, INT_MAX, 1, 1, 0));
-
+    prpw->padjSeed = GTK_ADJUSTMENT(gtk_adjustment_new((gdouble)prw->rcRollout.nSeed, 0, INT_MAX, 1, 1, 0));
     prpw->padjTrials = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.nTrials, 1, 1296 * 1296, 36, 36, 0));
+
 #if GTK_CHECK_VERSION(3,0,0)
-    pw = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    pwh = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
 #else
-    pw = gtk_hbox_new(FALSE, 0);
+    pwh = gtk_hbox_new(FALSE, 8);
 #endif
-    gtk_container_add(GTK_CONTAINER(pwPage), pw);
+    gtk_box_pack_start(GTK_BOX(pwPage), pwh, FALSE, FALSE, 0);
 
-    gtk_container_add(GTK_CONTAINER(pw), gtk_label_new(_("Seed:")));
-    gtk_container_add(GTK_CONTAINER(pw), gtk_spin_button_new(prpw->padjSeed, 1, 0));
+    gtk_box_pack_start(GTK_BOX(pwh), gtk_label_new(_("Seed:")), FALSE, FALSE, 4);
+    gtk_box_pack_start(GTK_BOX(pwh), gtk_spin_button_new(prpw->padjSeed, 1, 0), FALSE, FALSE, 4);
 
-    gtk_container_add(GTK_CONTAINER(pw), gtk_label_new(_("Trials:")));
-    gtk_container_add(GTK_CONTAINER(pw), gtk_spin_button_new(prpw->padjTrials, 36, 0));
+    gtk_box_pack_end(GTK_BOX(pwh), gtk_spin_button_new(prpw->padjTrials, 36, 0), FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwh), gtk_label_new(_("Trials:")), FALSE, FALSE, 4);
 
     pwFrame = gtk_frame_new(_("Truncation"));
-    gtk_container_add(GTK_CONTAINER(pwPage), pwFrame);
+    gtk_box_pack_start(GTK_BOX(pwPage), pwFrame, FALSE, FALSE, 0);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    pw = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
+    pwh = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
 #else
-    pw = gtk_hbox_new(FALSE, 8);
+    pwh = gtk_hbox_new(FALSE, 8);
 #endif
-    gtk_container_set_border_width(GTK_CONTAINER(pw), 8);
-    gtk_container_add(GTK_CONTAINER(pwFrame), pw);
+    gtk_container_set_border_width(GTK_CONTAINER(pwh), 8);
+    gtk_container_add(GTK_CONTAINER(pwFrame), pwh);
 
     prpw->pwDoTrunc = gtk_check_button_new_with_label(_("Truncate Rollouts"));
-    gtk_container_add(GTK_CONTAINER(pw), prpw->pwDoTrunc);
+    gtk_box_pack_start(GTK_BOX(pwh), prpw->pwDoTrunc, FALSE, FALSE, 4);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prpw->pwDoTrunc), prw->rcRollout.fDoTruncate);
     g_signal_connect(G_OBJECT(prpw->pwDoTrunc), "toggled", G_CALLBACK(TruncEnableToggled), prw);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwAdjTruncPlies  = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    prpw->pwAdjTruncPlies = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
     prpw->pwAdjTruncPlies = pwHBox = gtk_hbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pw), pwHBox);
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_label_new(_("Truncate at ply:")));
+    gtk_box_pack_end(GTK_BOX(pwh), pwHBox, FALSE, FALSE, 4);
 
     prpw->padjTruncPlies = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.nTruncate, 0, 1000, 1, 1, 0));
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_spin_button_new(prpw->padjTruncPlies, 1, 0));
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_spin_button_new(prpw->padjTruncPlies, 1, 0), FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_label_new(_("Truncate at ply:")), FALSE, FALSE, 4);
 
 
     pwFrame = gtk_frame_new(_("Evaluation for later plies"));
-    gtk_container_add(GTK_CONTAINER(pwPage), pwFrame);
+    gtk_box_pack_start(GTK_BOX(pwPage), pwFrame, FALSE, FALSE, 0);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    pw = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
+    pwh = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
 #else
-    pw = gtk_hbox_new(FALSE, 8);
+    pwh = gtk_hbox_new(FALSE, 8);
 #endif
-    gtk_container_set_border_width(GTK_CONTAINER(pw), 8);
-    gtk_container_add(GTK_CONTAINER(pwFrame), pw);
+    gtk_container_set_border_width(GTK_CONTAINER(pwh), 8);
+    gtk_container_add(GTK_CONTAINER(pwFrame), pwh);
 
     prpw->pwDoLate = gtk_check_button_new_with_label(_("Enable separate evaluations "));
-    gtk_container_add(GTK_CONTAINER(pw), prpw->pwDoLate);
+    gtk_box_pack_start(GTK_BOX(pwh), prpw->pwDoLate, FALSE, FALSE, 4);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prw->prwGeneral->pwDoLate), prw->rcRollout.fLateEvals);
     g_signal_connect(G_OBJECT(prw->prwGeneral->pwDoLate), "toggled", G_CALLBACK(LateEvalToggled), prw);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwAdjLatePlies  = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    prpw->pwAdjLatePlies = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
     prpw->pwAdjLatePlies = pwHBox = gtk_hbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pw), pwHBox);
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_label_new(_("Change eval after ply:")));
+    gtk_box_pack_end(GTK_BOX(pwh), pwHBox, FALSE, FALSE, 4);
 
     prpw->padjLatePlies = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.nLate, 0, 1000, 1, 1, 0));
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_spin_button_new(prpw->padjLatePlies, 1, 0));
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_spin_button_new(prpw->padjLatePlies, 1, 0), FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_label_new(_("Change eval after ply:")), FALSE, FALSE, 4);
 
+    
     pwFrame = gtk_frame_new(_("Stop when result is accurate"));
-    gtk_container_add(GTK_CONTAINER(pwPage), pwFrame);
+    gtk_box_pack_start(GTK_BOX(pwPage), pwFrame, FALSE, FALSE, 0);
 
-    /* an hbox for the pane */
+    /* an hbox for the frame */
 #if GTK_CHECK_VERSION(3,0,0)
-    pw = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
+    pwh = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
 #else
-    pw = gtk_hbox_new(FALSE, 8);
+    pwh = gtk_hbox_new(FALSE, 8);
 #endif
-    gtk_container_set_border_width(GTK_CONTAINER(pw), 8);
-    gtk_container_add(GTK_CONTAINER(pwFrame), pw);
+    gtk_container_set_border_width(GTK_CONTAINER(pwh), 8);
+    gtk_container_add(GTK_CONTAINER(pwFrame), pwh);
 
-    prpw->pwDoSTDStop = gtk_check_button_new_with_label(_("Stop when STD is small enough "));
-    gtk_container_add(GTK_CONTAINER(pw), prpw->pwDoSTDStop);
+    prpw->pwDoSTDStop = gtk_check_button_new_with_label(_("Stop when SE is small enough "));
+    gtk_box_pack_start(GTK_BOX(pwh), prpw->pwDoSTDStop, FALSE, FALSE, 4);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prw->prwGeneral->pwDoSTDStop), prw->rcRollout.fStopOnSTD);
     g_signal_connect(G_OBJECT(prw->prwGeneral->pwDoSTDStop), "toggled", G_CALLBACK(STDStopToggled), prw);
+    gtk_widget_set_tooltip_text(prpw->pwDoSTDStop,
+        _("Standard Error (SE) of the candidate play equity is a measure of "
+           "the accuracy of the current rollout result. "
+          "If the rollout were to be continued indefinitely, its result would "
+          "have about 95% chances to be in an interval of +/-2 SE around the "
+          "current result."));
 
     /* a vbox for the adjusters */
 #if GTK_CHECK_VERSION(3,0,0)
@@ -5130,61 +5193,56 @@ RolloutPageGeneral(rolloutpagegeneral * prpw, rolloutwidget * prw)
 #else
     pwv = gtk_vbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pw), pwv);
+    gtk_box_pack_end(GTK_BOX(pwh), pwv, FALSE, FALSE, 4);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwAdjMinGames  = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    prpw->pwAdjMinGames = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
     prpw->pwAdjMinGames = pwHBox = gtk_hbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pwv), pwHBox);
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_label_new(_("Minimum Trials:")));
+    gtk_box_pack_start(GTK_BOX(pwv), pwHBox, TRUE, TRUE, 0);
 
     prpw->padjMinGames = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.nMinimumGames, 1, 1296 * 1296, 36, 36, 0));
-
     prpw->pwMinGames = gtk_spin_button_new(prpw->padjMinGames, 1, 0);
-
-    gtk_container_add(GTK_CONTAINER(pwHBox), prpw->pwMinGames);
+    gtk_box_pack_end(GTK_BOX(pwHBox), prpw->pwMinGames, FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_label_new(_("Minimum Trials:")), FALSE, FALSE, 4);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwAdjMaxError  = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    prpw->pwAdjMaxError = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
     prpw->pwAdjMaxError = pwHBox = gtk_hbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pwv), pwHBox);
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_label_new(_("Equity Standard Deviation:")));
+    gtk_box_pack_end(GTK_BOX(pwv), pwHBox, TRUE, TRUE, 0);
 
     prpw->padjMaxError = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.rStdLimit, 0, 1, .0001, .0001, 0));
-
     prpw->pwMaxError = gtk_spin_button_new(prpw->padjMaxError, .0001, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), prpw->pwMaxError, FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_label_new(_("Equity SE threshold:")), FALSE, FALSE, 4);
 
-    gtk_container_add(GTK_CONTAINER(pwHBox), prpw->pwMaxError);
 
-
-    pwFrame = gtk_frame_new(_("Stop Rollouts of multiple moves based on JSD"));
-    gtk_container_add(GTK_CONTAINER(pwPage), pwFrame);
+    pwFrame = gtk_frame_new(_("Stop when result is clear"));
+    gtk_box_pack_start(GTK_BOX(pwPage), pwFrame, FALSE, FALSE, 0);
 
     /* an hbox for the frame */
 #if GTK_CHECK_VERSION(3,0,0)
-    pw = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
+    pwh = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
 #else
-    pw = gtk_hbox_new(FALSE, 8);
+    pwh = gtk_hbox_new(FALSE, 8);
 #endif
-    gtk_container_set_border_width(GTK_CONTAINER(pw), 8);
-    gtk_container_add(GTK_CONTAINER(pwFrame), pw);
+    gtk_container_set_border_width(GTK_CONTAINER(pwh), 8);
+    gtk_container_add(GTK_CONTAINER(pwFrame), pwh);
 
-    /* a vbox for the check boxes */
-#if GTK_CHECK_VERSION(3,0,0)
-    pwv = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
-#else
-    pwv = gtk_vbox_new(FALSE, 0);
-#endif
-    gtk_container_add(GTK_CONTAINER(pw), pwv);
-
-    prpw->pwJsdDoStop = gtk_check_button_new_with_label(_("Enable Stop on JSD"));
-    gtk_container_add(GTK_CONTAINER(pwv), prpw->pwJsdDoStop);
+    prpw->pwJsdDoStop = gtk_check_button_new_with_label(_("Stop when JSD margin is high enough"));
+    gtk_box_pack_start(GTK_BOX(pwh), prpw->pwJsdDoStop, FALSE, FALSE, 4);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prw->prwGeneral->pwJsdDoStop), prw->rcRollout.fStopOnJsd);
     g_signal_connect(G_OBJECT(prw->prwGeneral->pwJsdDoStop), "toggled", G_CALLBACK(JsdStopToggled), prw);
+    gtk_widget_set_tooltip_text(prpw->pwJsdDoStop,
+        _("The number of Joint Standard Deviations (JSD) between "
+          "the current favourite and another candidate decision is a "
+          "measure of how unlikely continuing the rollout is to "
+          "change the current result. "
+          "A candidate trailing by 2.33 JSD has about 1% chance to "
+          "end as winner if the rollout were to be continued indefinitely."));
 
     /* a vbox for the adjusters */
 #if GTK_CHECK_VERSION(3,0,0)
@@ -5192,56 +5250,54 @@ RolloutPageGeneral(rolloutpagegeneral * prpw, rolloutwidget * prw)
 #else
     pwv = gtk_vbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pw), pwv);
+    gtk_box_pack_end(GTK_BOX(pwh), pwv, FALSE, FALSE, 4);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwJsdAdjMinGames  = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    prpw->pwJsdAdjMinGames = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
     prpw->pwJsdAdjMinGames = pwHBox = gtk_hbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pwv), pwHBox);
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_label_new(_("Minimum Trials:")));
+    gtk_box_pack_start(GTK_BOX(pwv), pwHBox, TRUE, TRUE, 0);
 
     prpw->padjJsdMinGames =
         GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.nMinimumJsdGames, 1, 1296 * 1296, 36, 36, 0));
-
     prpw->pwJsdMinGames = gtk_spin_button_new(prpw->padjJsdMinGames, 1, 0);
-
-    gtk_container_add(GTK_CONTAINER(pwHBox), prpw->pwJsdMinGames);
+    gtk_box_pack_end(GTK_BOX(pwHBox), prpw->pwJsdMinGames, FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_label_new(_("Minimum Trials:")), FALSE, FALSE, 4);
 
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwJsdAdjLimit  = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
+    prpw->pwJsdAdjLimit = pwHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
 #else
     prpw->pwJsdAdjLimit = pwHBox = gtk_hbox_new(FALSE, 0);
 #endif
-    gtk_container_add(GTK_CONTAINER(pwv), pwHBox);
-    gtk_container_add(GTK_CONTAINER(pwHBox), gtk_label_new(_("JSDs from best choice")));
-
+    gtk_box_pack_end(GTK_BOX(pwv), pwHBox, TRUE, TRUE, 0);
+    
     prpw->padjJsdLimit = GTK_ADJUSTMENT(gtk_adjustment_new(prw->rcRollout.rJsdLimit, 0, 8, .0001, .0001, 0));
+    prpw->pwJsdLimit = gtk_spin_button_new(prpw->padjJsdLimit, .0001, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), prpw->pwJsdLimit, FALSE, FALSE, 4);
+    gtk_box_pack_end(GTK_BOX(pwHBox), gtk_label_new(_("JSD threshold:")), FALSE, FALSE, 4);
 
-    prpw->pwJsdAdjLimit = gtk_spin_button_new(prpw->padjJsdLimit, .0001, 4);
-
-    gtk_container_add(GTK_CONTAINER(pwHBox), prpw->pwJsdAdjLimit);
 
     pwFrame = gtk_frame_new(_("Bearoff Truncation"));
-    gtk_container_add(GTK_CONTAINER(pwPage), pwFrame);
+    gtk_box_pack_start(GTK_BOX(pwPage), pwFrame, FALSE, FALSE, 0);
+    
 #if GTK_CHECK_VERSION(3,0,0)
-    prpw->pwTruncBearoffOpts = pw = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
+    prpw->pwTruncBearoffOpts = pwv = gtk_box_new(GTK_ORIENTATION_VERTICAL, 8);
 #else
-    prpw->pwTruncBearoffOpts = pw = gtk_vbox_new(FALSE, 8);
+    prpw->pwTruncBearoffOpts = pwv = gtk_vbox_new(FALSE, 8);
 #endif
-    gtk_container_set_border_width(GTK_CONTAINER(pw), 8);
-    gtk_container_add(GTK_CONTAINER(pwFrame), pw);
+    gtk_container_set_border_width(GTK_CONTAINER(pwv), 8);
+    gtk_container_add(GTK_CONTAINER(pwFrame), pwv);
 
     prpw->pwTruncBearoff2 =
-        gtk_check_button_new_with_label(_("Truncate cubeless (and cubeful money) at exact bearoff database"));
+        gtk_check_button_new_with_label(_("Truncate cubeless and cubeful money at exact bearoff database"));
 
-    gtk_container_add(GTK_CONTAINER(pw), prpw->pwTruncBearoff2);
+    gtk_box_pack_start(GTK_BOX(pwv), prpw->pwTruncBearoff2, FALSE, FALSE, 0);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prpw->pwTruncBearoff2), prw->rcRollout.fTruncBearoff2);
 
     prpw->pwTruncBearoffOS = gtk_check_button_new_with_label(_("Truncate cubeless at one-sided bearoff database"));
 
-    gtk_container_add(GTK_CONTAINER(pw), prpw->pwTruncBearoffOS);
+    gtk_box_pack_start(GTK_BOX(pwv), prpw->pwTruncBearoffOS, FALSE, FALSE, 0);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prpw->pwTruncBearoffOS), prw->rcRollout.fTruncBearoffOS);
 
 
@@ -5256,9 +5312,16 @@ RolloutPageGeneral(rolloutpagegeneral * prpw, rolloutwidget * prw)
     g_signal_connect(G_OBJECT(prpw->pwCubeful), "toggled", G_CALLBACK(CubefulToggled), prw);
 
 
-    prpw->pwVarRedn = gtk_check_button_new_with_label(_("Variance reduction"));
+    prpw->pwVarRedn = gtk_check_button_new_with_label(_("Use variance reduction"));
     gtk_table_attach(GTK_TABLE(pwTable), prpw->pwVarRedn, 1, 2, 0, 1, GTK_FILL, GTK_FILL, 2, 2);
     gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(prpw->pwVarRedn), prw->rcRollout.fVarRedn);
+    gtk_widget_set_tooltip_text(prpw->pwVarRedn,
+        _("Variance Reduction is a procedure used to considerably increase "
+          "the accuracy of rollout results. "
+          "It has a significant cost for 0-ply rollouts "
+          "(but is still valuable on an accuracy per elapsed-time basis) "
+          "and is almost free for higher plies. "
+          "It is recommended to enable this option."));
 
     prpw->pwRotate = gtk_check_button_new_with_label(_("Use quasi-random dice"));
     gtk_table_attach(GTK_TABLE(pwTable), prpw->pwRotate, 0, 1, 1, 2, GTK_FILL, GTK_FILL, 2, 2);
@@ -5405,7 +5468,7 @@ SetRollouts(gpointer UNUSED(p), guint UNUSED(n), GtkWidget * UNUSED(pwIgnore))
 #else
         pwVBox = gtk_vbox_new(FALSE, 0);
 #endif
-        gtk_notebook_append_page(GTK_NOTEBOOK(rw.RolloutNotebook), pwVBox, gtk_label_new(_("Play settings")));
+        gtk_notebook_append_page(GTK_NOTEBOOK(rw.RolloutNotebook), pwVBox, gtk_label_new(_("Play Settings")));
 
         pwTable = gtk_table_new(3, 2, FALSE);
         gtk_box_pack_start(GTK_BOX(pwVBox), pwTable, FALSE, FALSE, 0);
@@ -5422,7 +5485,7 @@ SetRollouts(gpointer UNUSED(p), guint UNUSED(n), GtkWidget * UNUSED(pwIgnore))
         gtk_table_attach(GTK_TABLE(pwTable), gtk_widget_get_parent(rw.analysisDetails[3]->pwSettingWidgets), 1, 2, 1, 2,
                          (GtkAttachOptions) 0, (GtkAttachOptions) 0, 4, 4);
         rw.prpwTrunc->pmf = NULL;
-        rw.analysisDetails[4] = RolloutPage(rw.prpwTrunc, _("Truncation Pt."), FALSE, NULL);
+        rw.analysisDetails[4] = RolloutPage(rw.prpwTrunc, _("Truncation Point"), FALSE, NULL);
         gtk_table_attach(GTK_TABLE(pwTable), gtk_widget_get_parent(rw.analysisDetails[4]->pwSettingWidgets), 0, 1, 2, 3,
                          (GtkAttachOptions) 0, (GtkAttachOptions) 0, 4, 4);
 
@@ -5432,12 +5495,12 @@ SetRollouts(gpointer UNUSED(p), guint UNUSED(n), GtkWidget * UNUSED(pwIgnore))
         g_signal_connect(G_OBJECT(RPGeneral.pwPlayersAreSame), "toggled", G_CALLBACK(PlayersSameToggled), &rw);
 
         RPGeneral.pwCubeEqualChequer =
-            gtk_check_button_new_with_label(_("Cube decisions use same settings as Chequer play"));
+            gtk_check_button_new_with_label(_("Cube decisions use same settings as chequer play"));
         gtk_box_pack_start(GTK_BOX(pwVBox), RPGeneral.pwCubeEqualChequer, FALSE, FALSE, 0);
         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(RPGeneral.pwCubeEqualChequer), rw.fCubeEqualChequer);
         g_signal_connect(G_OBJECT(RPGeneral.pwCubeEqualChequer), "toggled", G_CALLBACK(CubeEqCheqToggled), &rw);
 
-        RPGeneral.pwTruncEqualPlayer0 = gtk_check_button_new_with_label(_("Use player0 setting for truncation point"));
+        RPGeneral.pwTruncEqualPlayer0 = gtk_check_button_new_with_label(_("Use player 0 setting for truncation point"));
         gtk_box_pack_start(GTK_BOX(pwVBox), RPGeneral.pwTruncEqualPlayer0, FALSE, FALSE, 0);
         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(RPGeneral.pwTruncEqualPlayer0), rw.fTruncEqualPlayer0);
         g_signal_connect(G_OBJECT(RPGeneral.pwTruncEqualPlayer0), "toggled", G_CALLBACK(TruncEqualPlayer0Toggled), &rw);
@@ -5758,7 +5821,12 @@ GTKResignHint(float UNUSED(arOutput[]), float rEqBefore, float rEqAfter, cubeinf
     gtk_table_attach(GTK_TABLE(pwTable), pw =
                      gtk_label_new(fMWC ? _("MWC before resignation") : _("Equity before resignation")), 0, 1, 0, 1,
                      GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 4, 0);
-    gtk_misc_set_alignment(GTK_MISC(pw), 0, 0.5);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pw, GTK_ALIGN_START);
+    gtk_widget_set_valign(pw, GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(pw), 0.0, 0.5);
+#endif
 
     if (fMWC)
         sprintf(sz, "%6.2f%%", 100.0 * (eq2mwc(-rEqBefore, pci)));
@@ -5767,14 +5835,24 @@ GTKResignHint(float UNUSED(arOutput[]), float rEqBefore, float rEqAfter, cubeinf
 
     gtk_table_attach(GTK_TABLE(pwTable), pw = gtk_label_new(sz),
                      1, 2, 0, 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 4, 0);
-    gtk_misc_set_alignment(GTK_MISC(pw), 1, 0.5);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pw, GTK_ALIGN_END);
+    gtk_widget_set_valign(pw, GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(pw), 1.0, 0.5);
+#endif
 
     /* equity after resignation */
 
     gtk_table_attach(GTK_TABLE(pwTable), pw =
                      gtk_label_new(fMWC ? _("MWC after resignation") : _("Equity after resignation")), 0, 1, 1, 2,
                      GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 4, 0);
-    gtk_misc_set_alignment(GTK_MISC(pw), 0, 0.5);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pw, GTK_ALIGN_START);
+    gtk_widget_set_valign(pw, GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(pw), 0.0, 0.5);
+#endif
 
     if (fMWC)
         sprintf(sz, "%6.2f%%", 100.0 * eq2mwc(-rEqAfter, pci));
@@ -5783,7 +5861,12 @@ GTKResignHint(float UNUSED(arOutput[]), float rEqBefore, float rEqAfter, cubeinf
 
     gtk_table_attach(GTK_TABLE(pwTable), pw = gtk_label_new(sz),
                      1, 2, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 4, 0);
-    gtk_misc_set_alignment(GTK_MISC(pw), 1, 0.5);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pw, GTK_ALIGN_END);
+    gtk_widget_set_valign(pw, GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(pw), 1.0, 0.5);
+#endif
 
     if (-rEqAfter >= -rEqBefore)
         pch = _("You should accept the resignation!");
@@ -6033,7 +6116,11 @@ GTKShowVersion(void)
     fn = g_build_filename(getPkgDataDir(), "pixmaps", "gnubg-big.png", NULL);
     image = gtk_image_new_from_file(fn);
     g_free(fn);
+#if GTK_CHECK_VERSION(3,0,0)
+    g_object_set(image, "margin", 8, NULL);
+#else
     gtk_misc_set_padding(GTK_MISC(image), 8, 8);
+#endif
     gtk_box_pack_start(GTK_BOX(DialogArea(pwDialog, DA_MAIN)), image, FALSE, FALSE, 0);
 
     /* Buttons on right side */
@@ -6380,7 +6467,13 @@ GTKHelp(char *sz)
 
     g_signal_connect_swapped(pw, "response", G_CALLBACK(gtk_widget_destroy), pw);
 
-    gtk_container_add(GTK_CONTAINER(DialogArea(pw, DA_MAIN)), pwPaned = gtk_vpaned_new());
+#if GTK_CHECK_VERSION(3,0,0)
+    pwPaned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
+#else
+    pwPaned = gtk_vpaned_new();
+#endif
+
+    gtk_container_add(GTK_CONTAINER(DialogArea(pw, DA_MAIN)), pwPaned);
 
     gtk_paned_pack1(GTK_PANED(pwPaned), pwScrolled = gtk_scrolled_window_new(NULL, NULL), TRUE, FALSE);
     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(pwScrolled), GTK_SHADOW_IN);
@@ -6518,12 +6611,17 @@ enable_menu(GtkWidget * pw, int f)
         gtk_widget_set_sensitive(pw, f);
 }
 
+static inline void my_enable_menu(gpointer data, gpointer user_data)
+{
+     enable_menu((GtkWidget *)data, GPOINTER_TO_INT(user_data));
+}
+
 static void
 enable_sub_menu(GtkWidget * pw, int f)
 {
 
     GtkMenuShell *pms = GTK_MENU_SHELL(pw);
-    g_list_foreach(gtk_container_get_children(GTK_CONTAINER(pms)), (GFunc) enable_menu, GINT_TO_POINTER(f));
+    g_list_foreach(gtk_container_get_children(GTK_CONTAINER(pms)), my_enable_menu, GINT_TO_POINTER(f));
 }
 
 /* A global setting has changed; update entry in Settings menu if necessary. */
@@ -7349,7 +7447,12 @@ AddToTable(GtkWidget * pwTable, char *str, int x, int y)
 {
     GtkWidget *pw = gtk_label_new(str);
     /* Right align */
-    gtk_misc_set_alignment(GTK_MISC(pw), 1, .5);
+#if GTK_CHECK_VERSION(3,0,0)
+    gtk_widget_set_halign(pw, GTK_ALIGN_END);
+    gtk_widget_set_valign(pw, GTK_ALIGN_CENTER);
+#else
+    gtk_misc_set_alignment(GTK_MISC(pw), 1.0, 0.5);
+#endif
     gtk_table_attach(GTK_TABLE(pwTable), pw, x, x + 1, y, y + 1, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
 }
 
@@ -7438,7 +7541,7 @@ CalibrationOK(GtkWidget * pw, GtkWidget * ppw)
     GtkAdjustment *padj = gtk_spin_button_get_adjustment(GTK_SPIN_BUTTON(ppw));
 
     if (gtk_widget_is_sensitive(ppw)) {
-        if (gtk_adjustment_get_value(padj) != rEvalsPerSec) {
+        if (gtk_adjustment_get_value(padj) != (gdouble)rEvalsPerSec) {
             sprintf(sz, "set calibration %.0f", gtk_adjustment_get_value(padj));
             UserCommand(sz);
         }