Added an option to display seconds as hours, minutes and seconds

in the packet list, on this format: "1h 2m 3.456s".

svn path=/trunk/; revision=32683

4 files changed, 261 insertions, 153 deletions

diff --git a/epan/column-utils.c b/epan/column-utils.c
index be71c328b9..ba021ea978 100644
--- a/epan/column-utils.c
+++ b/epan/column-utils.c
@@ -613,8 +613,8 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
   tmp = localtime(&then);
   if (tmp != NULL) {
       switch(timestamp_get_precision()) {
-      case(TS_PREC_FIXED_SEC):
-      case(TS_PREC_AUTO_SEC):
+      case TS_PREC_FIXED_SEC:
+      case TS_PREC_AUTO_SEC:
           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d",
              tmp->tm_year + 1900,
              tmp->tm_mon + 1,
@@ -623,8 +623,8 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
              tmp->tm_min,
              tmp->tm_sec);
           break;
-      case(TS_PREC_FIXED_DSEC):
-      case(TS_PREC_AUTO_DSEC):
+      case TS_PREC_FIXED_DSEC:
+      case TS_PREC_AUTO_DSEC:
           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%01ld",
              tmp->tm_year + 1900,
              tmp->tm_mon + 1,
@@ -634,8 +634,8 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 100000000);
           break;
-      case(TS_PREC_FIXED_CSEC):
-      case(TS_PREC_AUTO_CSEC):
+      case TS_PREC_FIXED_CSEC:
+      case TS_PREC_AUTO_CSEC:
           g_snprintf(buf, COL_MAX_LEN,"%04d-%02d-%02d %02d:%02d:%02d.%02ld",
              tmp->tm_year + 1900,
              tmp->tm_mon + 1,
@@ -645,8 +645,8 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 10000000);
           break;
-      case(TS_PREC_FIXED_MSEC):
-      case(TS_PREC_AUTO_MSEC):
+      case TS_PREC_FIXED_MSEC:
+      case TS_PREC_AUTO_MSEC:
           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%03ld",
              tmp->tm_year + 1900,
              tmp->tm_mon + 1,
@@ -656,8 +656,8 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 1000000);
           break;
-      case(TS_PREC_FIXED_USEC):
-      case(TS_PREC_AUTO_USEC):
+      case TS_PREC_FIXED_USEC:
+      case TS_PREC_AUTO_USEC:
           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%06ld",
              tmp->tm_year + 1900,
              tmp->tm_mon + 1,
@@ -667,8 +667,8 @@ set_abs_date_time(const frame_data *fd, gchar *buf)
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 1000);
           break;
-      case(TS_PREC_FIXED_NSEC):
-      case(TS_PREC_AUTO_NSEC):
+      case TS_PREC_FIXED_NSEC:
+      case TS_PREC_AUTO_NSEC:
           g_snprintf(buf, COL_MAX_LEN, "%04d-%02d-%02d %02d:%02d:%02d.%09ld",
              tmp->tm_year + 1900,
              tmp->tm_mon + 1,
@@ -698,38 +698,38 @@ col_set_abs_date_time(const frame_data *fd, column_info *cinfo, const int col)
 }
 
 static gint
-set_rel_time(const frame_data *fd, gchar *buf)
+set_time_seconds(const nstime_t *ts, gchar *buf)
 {
   switch(timestamp_get_precision()) {
-      case(TS_PREC_FIXED_SEC):
-      case(TS_PREC_AUTO_SEC):
+      case TS_PREC_FIXED_SEC:
+      case TS_PREC_AUTO_SEC:
           display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->rel_ts.secs, fd->rel_ts.nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
+            (gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
           break;
-      case(TS_PREC_FIXED_DSEC):
-      case(TS_PREC_AUTO_DSEC):
+      case TS_PREC_FIXED_DSEC:
+      case TS_PREC_AUTO_DSEC:
           display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->rel_ts.secs, fd->rel_ts.nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
+            (gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
           break;
-      case(TS_PREC_FIXED_CSEC):
-      case(TS_PREC_AUTO_CSEC):
+      case TS_PREC_FIXED_CSEC:
+      case TS_PREC_AUTO_CSEC:
           display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->rel_ts.secs, fd->rel_ts.nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
+            (gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
           break;
-      case(TS_PREC_FIXED_MSEC):
-      case(TS_PREC_AUTO_MSEC):
+      case TS_PREC_FIXED_MSEC:
+      case TS_PREC_AUTO_MSEC:
           display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->rel_ts.secs, fd->rel_ts.nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
+            (gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
           break;
-      case(TS_PREC_FIXED_USEC):
-      case(TS_PREC_AUTO_USEC):
+      case TS_PREC_FIXED_USEC:
+      case TS_PREC_AUTO_USEC:
           display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->rel_ts.secs, fd->rel_ts.nsecs / 1000, TO_STR_TIME_RES_T_USECS);
+            (gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);
           break;
-      case(TS_PREC_FIXED_NSEC):
-      case(TS_PREC_AUTO_NSEC):
+      case TS_PREC_FIXED_NSEC:
+      case TS_PREC_AUTO_NSEC:
           display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->rel_ts.secs, fd->rel_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
+            (gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
           break;
       default:
           g_assert_not_reached();
@@ -737,113 +737,193 @@ set_rel_time(const frame_data *fd, gchar *buf)
   return 1;
 }
 
-static void
-col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
-{
-  if (set_rel_time(fd, cinfo->col_buf[col])) {
-      cinfo->col_expr.col_expr[col] = "frame.time_relative";
-      g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
-  }
-  cinfo->col_data[col] = cinfo->col_buf[col];
-}
-
 static gint
-set_delta_time(const frame_data *fd, gchar *buf)
+set_time_hour_min_sec(const nstime_t *ts, gchar *buf)
 {
   switch(timestamp_get_precision()) {
-      case(TS_PREC_FIXED_SEC):
-      case(TS_PREC_AUTO_SEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_cap_ts.secs, fd->del_cap_ts.nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
-          break;
-      case(TS_PREC_FIXED_DSEC):
-      case(TS_PREC_AUTO_DSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_cap_ts.secs, fd->del_cap_ts.nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
-          break;
-      case(TS_PREC_FIXED_CSEC):
-      case(TS_PREC_AUTO_CSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_cap_ts.secs, fd->del_cap_ts.nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
-          break;
-      case(TS_PREC_FIXED_MSEC):
-      case(TS_PREC_AUTO_MSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_cap_ts.secs, fd->del_cap_ts.nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
-          break;
-      case(TS_PREC_FIXED_USEC):
-      case(TS_PREC_AUTO_USEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_cap_ts.secs, fd->del_cap_ts.nsecs / 1000, TO_STR_TIME_RES_T_USECS);
-          break;
-      case(TS_PREC_FIXED_NSEC):
-      case(TS_PREC_AUTO_NSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_cap_ts.secs, fd->del_cap_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
-          break;
-      default:
-          g_assert_not_reached();
+  case TS_PREC_FIXED_SEC:
+  case TS_PREC_AUTO_SEC:
+    if (ts->secs >= (60*60)) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %dm %ds",
+		 (gint32) ts->secs / (60 * 60),
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60);
+    } else if (ts->secs >= 60) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %ds",
+		 (gint32) (ts->secs / 60),
+		 (gint32) ts->secs % 60);
+    } else {
+      g_snprintf(buf, COL_MAX_LEN,"%ds",
+		 (gint32) ts->secs);
+    }
+    break;
+  case TS_PREC_FIXED_DSEC:
+  case TS_PREC_AUTO_DSEC:
+    if (ts->secs >= (60*60)) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %dm %d.%01lds",
+		 (gint32) ts->secs / (60 * 60),
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 100000000);
+    } else if (ts->secs >= 60) {
+      g_snprintf(buf, COL_MAX_LEN,"%dm %d.%01lds",
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 100000000);
+    } else {
+      g_snprintf(buf, COL_MAX_LEN,"%d.%01lds",
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 100000000);
+    }
+    break;
+  case TS_PREC_FIXED_CSEC:
+  case TS_PREC_AUTO_CSEC:
+    if (ts->secs >= (60*60)) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %dm %d.%02lds",
+		 (gint32) ts->secs / (60 * 60),
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 10000000);
+    } else if (ts->secs >= 60) {
+      g_snprintf(buf, COL_MAX_LEN,"%dm %d.%02lds",
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 10000000);
+    } else {
+      g_snprintf(buf, COL_MAX_LEN,"%d.%02lds",
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 10000000);
+    }
+    break;
+  case TS_PREC_FIXED_MSEC:
+  case TS_PREC_AUTO_MSEC:
+    if (ts->secs >= (60*60)) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %dm %d.%03lds",
+		 (gint32) ts->secs / (60 * 60),
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 1000000);
+    } else if (ts->secs >= 60) {
+      g_snprintf(buf, COL_MAX_LEN,"%dm %d.%03lds",
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 1000000);
+    } else {
+      g_snprintf(buf, COL_MAX_LEN,"%d.%03lds",
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 1000000);
+    }
+    break;
+  case TS_PREC_FIXED_USEC:
+  case TS_PREC_AUTO_USEC:
+    if (ts->secs >= (60*60)) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %dm %d.%06lds",
+		 (gint32) ts->secs / (60 * 60),
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 1000);
+    } else if (ts->secs >= 60) {
+      g_snprintf(buf, COL_MAX_LEN,"%dm %d.%06lds",
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 1000);
+    } else {
+      g_snprintf(buf, COL_MAX_LEN,"%d.%06lds",
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs / 1000);
+    }
+    break;
+  case TS_PREC_FIXED_NSEC:
+  case TS_PREC_AUTO_NSEC:
+    if (ts->secs >= (60*60)) {
+      g_snprintf(buf, COL_MAX_LEN,"%dh %dm %d.%09lds",
+		 (gint32) ts->secs / (60 * 60),
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs);
+    } else if (ts->secs >= 60) {
+      g_snprintf(buf, COL_MAX_LEN,"%dm %d.%09lds",
+		 (gint32) (ts->secs / 60) % 60,
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs);
+    } else {
+      g_snprintf(buf, COL_MAX_LEN,"%d.%09lds",
+		 (gint32) ts->secs % 60,
+		 (long)ts->nsecs);
+    }
+    break;
+  default:
+    g_assert_not_reached();
   }
+
   return 1;
 }
 
 static void
-col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
+col_set_rel_time(const frame_data *fd, column_info *cinfo, const int col)
 {
-  if (set_delta_time(fd, cinfo->col_buf[col])) {
-      cinfo->col_expr.col_expr[col] = "frame.time_delta";
+  switch (timestamp_get_seconds_type()) {
+  case TS_SECONDS_DEFAULT:
+    if (set_time_seconds(&fd->rel_ts, cinfo->col_buf[col])) {
+      cinfo->col_expr.col_expr[col] = "frame.time_relative";
       g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
+    }
+    break;
+  case TS_SECONDS_HOUR_MIN_SEC:
+    if (set_time_hour_min_sec(&fd->rel_ts, cinfo->col_buf[col])) {
+      cinfo->col_expr.col_expr[col] = "frame.time_relative";
+      set_time_seconds(&fd->rel_ts, cinfo->col_expr.col_expr_val[col]);
+    }
+    break;
+  default:
+    g_assert_not_reached();
   }
   cinfo->col_data[col] = cinfo->col_buf[col];
 }
 
-static gint
-set_delta_time_dis(const frame_data *fd, gchar *buf)
+static void
+col_set_delta_time(const frame_data *fd, column_info *cinfo, const int col)
 {
-  switch(timestamp_get_precision()) {
-      case(TS_PREC_FIXED_SEC):
-      case(TS_PREC_AUTO_SEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_dis_ts.secs, fd->del_dis_ts.nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
-          break;
-      case(TS_PREC_FIXED_DSEC):
-      case(TS_PREC_AUTO_DSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_dis_ts.secs, fd->del_dis_ts.nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
-          break;
-      case(TS_PREC_FIXED_CSEC):
-      case(TS_PREC_AUTO_CSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_dis_ts.secs, fd->del_dis_ts.nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
-          break;
-      case(TS_PREC_FIXED_MSEC):
-      case(TS_PREC_AUTO_MSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_dis_ts.secs, fd->del_dis_ts.nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
-          break;
-      case(TS_PREC_FIXED_USEC):
-      case(TS_PREC_AUTO_USEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_dis_ts.secs, fd->del_dis_ts.nsecs / 1000, TO_STR_TIME_RES_T_USECS);
-          break;
-      case(TS_PREC_FIXED_NSEC):
-      case(TS_PREC_AUTO_NSEC):
-          display_signed_time(buf, COL_MAX_LEN,
-            (gint32) fd->del_dis_ts.secs, fd->del_dis_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
-          break;
-      default:
-          g_assert_not_reached();
+  switch (timestamp_get_seconds_type()) {
+  case TS_SECONDS_DEFAULT:
+    if (set_time_seconds(&fd->del_cap_ts, cinfo->col_buf[col])) {
+      cinfo->col_expr.col_expr[col] = "frame.time_delta";
+      g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
+    }
+    break;
+  case TS_SECONDS_HOUR_MIN_SEC:
+    if (set_time_hour_min_sec(&fd->del_cap_ts, cinfo->col_buf[col])) {
+      cinfo->col_expr.col_expr[col] = "frame.time_delta";
+      set_time_seconds(&fd->del_cap_ts, cinfo->col_expr.col_expr_val[col]);
+    }
+    break;
+  default:
+    g_assert_not_reached();
   }
-  return 1;
+
+  cinfo->col_data[col] = cinfo->col_buf[col];
 }
 
 static void
 col_set_delta_time_dis(const frame_data *fd, column_info *cinfo, const int col)
 {
-  if (set_delta_time_dis(fd, cinfo->col_buf[col])) {
-    cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
-    g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
+  switch (timestamp_get_seconds_type()) {
+  case TS_SECONDS_DEFAULT:
+    if (set_time_seconds(&fd->del_dis_ts, cinfo->col_buf[col])) {
+      cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
+      g_strlcpy(cinfo->col_expr.col_expr_val[col],cinfo->col_buf[col],COL_MAX_LEN);
+    }
+    break;
+  case TS_SECONDS_HOUR_MIN_SEC:
+    if (set_time_hour_min_sec(&fd->del_dis_ts, cinfo->col_buf[col])) {
+      cinfo->col_expr.col_expr[col] = "frame.time_delta_displayed";
+      set_time_seconds(&fd->del_dis_ts, cinfo->col_expr.col_expr_val[col]);
+    }
+    break;
+  default:
+    g_assert_not_reached();
   }
+
   cinfo->col_data[col] = cinfo->col_buf[col];
 }
 
@@ -857,47 +937,47 @@ set_abs_time(const frame_data *fd, gchar *buf)
   tmp = localtime(&then);
   if (tmp != NULL) {
       switch(timestamp_get_precision()) {
-      case(TS_PREC_FIXED_SEC):
-      case(TS_PREC_AUTO_SEC):
+      case TS_PREC_FIXED_SEC:
+      case TS_PREC_AUTO_SEC:
           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d",
              tmp->tm_hour,
              tmp->tm_min,
              tmp->tm_sec);
           break;
-      case(TS_PREC_FIXED_DSEC):
-      case(TS_PREC_AUTO_DSEC):
+      case TS_PREC_FIXED_DSEC:
+      case TS_PREC_AUTO_DSEC:
           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%01ld",
              tmp->tm_hour,
              tmp->tm_min,
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 100000000);
           break;
-      case(TS_PREC_FIXED_CSEC):
-      case(TS_PREC_AUTO_CSEC):
+      case TS_PREC_FIXED_CSEC:
+      case TS_PREC_AUTO_CSEC:
           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%02ld",
              tmp->tm_hour,
              tmp->tm_min,
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 10000000);
           break;
-      case(TS_PREC_FIXED_MSEC):
-      case(TS_PREC_AUTO_MSEC):
+      case TS_PREC_FIXED_MSEC:
+      case TS_PREC_AUTO_MSEC:
           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%03ld",
              tmp->tm_hour,
              tmp->tm_min,
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 1000000);
           break;
-      case(TS_PREC_FIXED_USEC):
-      case(TS_PREC_AUTO_USEC):
+      case TS_PREC_FIXED_USEC:
+      case TS_PREC_AUTO_USEC:
           g_snprintf(buf, COL_MAX_LEN,"%02d:%02d:%02d.%06ld",
              tmp->tm_hour,
              tmp->tm_min,
              tmp->tm_sec,
              (long)fd->abs_ts.nsecs / 1000);
           break;
-      case(TS_PREC_FIXED_NSEC):
-      case(TS_PREC_AUTO_NSEC):
+      case TS_PREC_FIXED_NSEC:
+      case TS_PREC_AUTO_NSEC:
           g_snprintf(buf, COL_MAX_LEN, "%02d:%02d:%02d.%09ld",
              tmp->tm_hour,
              tmp->tm_min,
@@ -928,33 +1008,33 @@ static gint
 set_epoch_time(const frame_data *fd, gchar *buf)
 {
   switch(timestamp_get_precision()) {
-      case(TS_PREC_FIXED_SEC):
-      case(TS_PREC_AUTO_SEC):
+      case TS_PREC_FIXED_SEC:
+      case TS_PREC_AUTO_SEC:
           display_epoch_time(buf, COL_MAX_LEN,
             fd->abs_ts.secs, fd->abs_ts.nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
           break;
-      case(TS_PREC_FIXED_DSEC):
-      case(TS_PREC_AUTO_DSEC):
+      case TS_PREC_FIXED_DSEC:
+      case TS_PREC_AUTO_DSEC:
           display_epoch_time(buf, COL_MAX_LEN,
             fd->abs_ts.secs, fd->abs_ts.nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
           break;
-      case(TS_PREC_FIXED_CSEC):
-      case(TS_PREC_AUTO_CSEC):
+      case TS_PREC_FIXED_CSEC:
+      case TS_PREC_AUTO_CSEC:
           display_epoch_time(buf, COL_MAX_LEN,
             fd->abs_ts.secs, fd->abs_ts.nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
           break;
-      case(TS_PREC_FIXED_MSEC):
-      case(TS_PREC_AUTO_MSEC):
+      case TS_PREC_FIXED_MSEC:
+      case TS_PREC_AUTO_MSEC:
           display_epoch_time(buf, COL_MAX_LEN,
             fd->abs_ts.secs, fd->abs_ts.nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
           break;
-      case(TS_PREC_FIXED_USEC):
-      case(TS_PREC_AUTO_USEC):
+      case TS_PREC_FIXED_USEC:
+      case TS_PREC_AUTO_USEC:
           display_epoch_time(buf, COL_MAX_LEN,
             fd->abs_ts.secs, fd->abs_ts.nsecs / 1000, TO_STR_TIME_RES_T_USECS);
           break;
-      case(TS_PREC_FIXED_NSEC):
-      case(TS_PREC_AUTO_NSEC):
+      case TS_PREC_FIXED_NSEC:
+      case TS_PREC_AUTO_NSEC:
           display_epoch_time(buf, COL_MAX_LEN,
             fd->abs_ts.secs, fd->abs_ts.nsecs, TO_STR_TIME_RES_T_NSECS);
           break;
@@ -1114,33 +1194,33 @@ col_set_time(column_info *cinfo, const gint el, const nstime_t *ts, char *fieldn
   for (col = cinfo->col_first[el]; col <= cinfo->col_last[el]; col++) {
     if (cinfo->fmt_matx[col][el]) {
       switch(timestamp_get_precision()) {
-    case(TS_PREC_FIXED_SEC):
-    case(TS_PREC_AUTO_SEC):
+    case TS_PREC_FIXED_SEC:
+    case TS_PREC_AUTO_SEC:
       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
         (gint32) ts->secs, ts->nsecs / 1000000000, TO_STR_TIME_RES_T_SECS);
       break;
-    case(TS_PREC_FIXED_DSEC):
-    case(TS_PREC_AUTO_DSEC):
+    case TS_PREC_FIXED_DSEC:
+    case TS_PREC_AUTO_DSEC:
       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
         (gint32) ts->secs, ts->nsecs / 100000000, TO_STR_TIME_RES_T_DSECS);
       break;
-    case(TS_PREC_FIXED_CSEC):
-    case(TS_PREC_AUTO_CSEC):
+    case TS_PREC_FIXED_CSEC:
+    case TS_PREC_AUTO_CSEC:
       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
         (gint32) ts->secs, ts->nsecs / 10000000, TO_STR_TIME_RES_T_CSECS);
       break;
-    case(TS_PREC_FIXED_MSEC):
-    case(TS_PREC_AUTO_MSEC):
+    case TS_PREC_FIXED_MSEC:
+    case TS_PREC_AUTO_MSEC:
       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
         (gint32) ts->secs, ts->nsecs / 1000000, TO_STR_TIME_RES_T_MSECS);
       break;
-    case(TS_PREC_FIXED_USEC):
-    case(TS_PREC_AUTO_USEC):
+    case TS_PREC_FIXED_USEC:
+    case TS_PREC_AUTO_USEC:
       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
         (gint32) ts->secs, ts->nsecs / 1000, TO_STR_TIME_RES_T_USECS);
       break;
-    case(TS_PREC_FIXED_NSEC):
-    case(TS_PREC_AUTO_NSEC):
+    case TS_PREC_FIXED_NSEC:
+    case TS_PREC_AUTO_NSEC:
       display_signed_time(cinfo->col_buf[col], COL_MAX_LEN,
         (gint32) ts->secs, ts->nsecs, TO_STR_TIME_RES_T_NSECS);
       break;
diff --git a/epan/libwireshark.def b/epan/libwireshark.def
index 3fbcf38b01..8604b58436 100644
--- a/epan/libwireshark.def
+++ b/epan/libwireshark.def
@@ -984,8 +984,10 @@ time_msecs_to_str
 time_secs_to_str
 timestamp_get_precision
 timestamp_get_type
+timestamp_get_seconds_type
 timestamp_set_precision
 timestamp_set_type
+timestamp_set_seconds_type
 trans2_cmd_vals                 DATA
 tree_is_expanded                DATA
 tvb_bytes_exist
diff --git a/epan/timestamp.c b/epan/timestamp.c
index a3d85b3c19..494e6df863 100644
--- a/epan/timestamp.c
+++ b/epan/timestamp.c
@@ -34,6 +34,8 @@ static ts_type timestamp_type = TS_NOT_SET;
 
 static int timestamp_precision = TS_PREC_AUTO_USEC;
 
+static ts_seconds_type timestamp_seconds_type = TS_SECONDS_NOT_SET;
+
 ts_type timestamp_get_type(void)
 {
 	return timestamp_type;
@@ -55,3 +57,13 @@ void timestamp_set_precision(int tsp)
 	timestamp_precision = tsp;
 }
 
+
+ts_seconds_type timestamp_get_seconds_type(void)
+{
+	return timestamp_seconds_type;
+}
+
+void timestamp_set_seconds_type(ts_seconds_type ts_t)
+{
+	timestamp_seconds_type = ts_t;
+}
diff --git a/epan/timestamp.h b/epan/timestamp.h
index bf45d3f8b6..bdc9ab0d62 100644
--- a/epan/timestamp.h
+++ b/epan/timestamp.h
@@ -48,7 +48,7 @@ typedef enum {
 	TS_PREC_FIXED_SEC,	/* recent and internal */
 	TS_PREC_FIXED_DSEC,	/* recent and internal */
 	TS_PREC_FIXED_CSEC,	/* recent and internal */
-	TS_PREC_FIXED_MSEC, /* recent and internal */
+	TS_PREC_FIXED_MSEC,	/* recent and internal */
 	TS_PREC_FIXED_USEC,	/* recent and internal */
 	TS_PREC_FIXED_NSEC,	/* recent and internal */
 	TS_PREC_AUTO_SEC,	/* internal */
@@ -59,10 +59,24 @@ typedef enum {
 	TS_PREC_AUTO_NSEC	/* internal */
 } ts_precision;
 
+typedef enum {
+	TS_SECONDS_DEFAULT,	/* recent */
+	TS_SECONDS_HOUR_MIN_SEC,/* recent */
+
+/*
+ * Special value used for the command-line setting in Wireshark, to indicate
+ * that no value has been set from the command line.
+ */
+	TS_SECONDS_NOT_SET
+} ts_seconds_type;
+
 extern ts_type timestamp_get_type(void);
 extern void timestamp_set_type(ts_type);
 
 extern int timestamp_get_precision(void);
 extern void timestamp_set_precision(int tsp);
 
+extern ts_seconds_type timestamp_get_seconds_type(void);
+extern void timestamp_set_seconds_type(ts_seconds_type);
+
 #endif /* timestamp.h */