util.c

A GTK sound font editor. Sound font files are used to synthesize instruments from audio samples for

}

/* a callback for widgets (buttons, etc) within a "parent" widget used by
   util_waitfor_widget_action, sets "action" to the specified "value" */
void
util_widget_action (GtkWidget *cbwidg, gpointer value)
{
  GtkWidget *parent;

  parent = gtk_object_get_data (GTK_OBJECT (cbwidg), "parent");
  gtk_object_set_data (GTK_OBJECT (parent), "action", value);
}

GtkWidget *
util_create_pixmap (gchar ** xpmdata)
{
  GdkPixmap *pixmap;
  GdkBitmap *mask;

  pixmap_get (xpmdata, &pixmap, &mask);

  return (gtk_pixmap_new (pixmap, mask));
}

/* log_view - Display log view window */
void
log_view (gchar * title)
{
  GtkWidget *popdog;
  GtkWidget *hbox;
  GtkWidget *msgarea;
  GtkAdjustment *adj;
  GtkWidget *vscrollbar;
  GtkWidget *btn;

  if (log_viewactive) return;

  if (title) popdog = gtk_popdog_new (title);
  else popdog = gtk_popdog_new (_("Smurf log"));

  hbox = gtk_hbox_new (FALSE, 0);
  gtk_box_pack_start (GTK_BOX (GTK_POPDOG (popdog)->vbox), hbox, TRUE, TRUE, 0);
  gtk_widget_show (hbox);

  msgarea = gtk_text_new (NULL, NULL);
  gtk_widget_set_usize (msgarea, 400, 100);
  gtk_text_set_editable (GTK_TEXT (msgarea), FALSE);
  gtk_text_set_word_wrap (GTK_TEXT (msgarea), FALSE);
  gtk_text_insert (GTK_TEXT (msgarea), NULL, NULL, NULL, log_buf->str, -1);
  gtk_box_pack_start (GTK_BOX (hbox), msgarea, TRUE, TRUE, 0);
  gtk_widget_show (msgarea);

  adj = GTK_TEXT (msgarea)->vadj;	/* get the message area's vert adj */

  vscrollbar = gtk_vscrollbar_new (adj);
  gtk_box_pack_start (GTK_BOX (hbox), vscrollbar, FALSE, FALSE, 0);
  gtk_widget_show (vscrollbar);

  btn = gtk_button_new_with_label (_("OK"));
  gtk_signal_connect_object (GTK_OBJECT (btn), "clicked",
    (GtkSignalFunc) gtk_widget_destroy, GTK_OBJECT (popdog));
  gtk_box_pack_start (GTK_BOX (GTK_POPDOG (popdog)->action_area), btn,
    FALSE, FALSE, 0);
  gtk_widget_show (btn);

  gtk_signal_connect_object (GTK_OBJECT (popdog), "destroy",
    GTK_SIGNAL_FUNC (log_view_cb_destroy), NULL);

  gtk_widget_show (popdog);

  log_viewactive = TRUE;
  log_view_widg = NULL;
}

/* reset dialog active variables */
static void
log_view_cb_destroy (void)
{
  log_viewactive = FALSE;
  log_view_widg = NULL;
}

/* Logging function, returns FAIL to use as a return value in calling funcs */
gint
logit (gint lvl, gchar * fmt, ...)
{
  va_list args;
  gchar *s;
  gboolean syserr;

  syserr = (lvl & LogErrno) > 0;

  lvl &= LogLevelMask;

  if (lvl < 0 || lvl >= LogLast)
    return (FAIL);

  /* if a log group is active and this level exceeds group's highest.. */
  if (log_groups > 0 && log_grp_highest_lvl < lvl)
    log_grp_highest_lvl = lvl;	/* new highest level */

  if (syserr)
    s = g_strdup_printf ("%s: (errno = %d) %s", fmt, errno, g_strerror (errno));
  else s = g_strdup (fmt);

  va_start (args, fmt);
  log_vargs (s, args);
  va_end (args);

  g_free (s);

  /* if no log groups and log level is above log_poplevel, then popup log
     viewer */
  if (log_groups == 0 && lvl >= log_poplevel)
    log_view (NULL);

  return (FAIL);
}

void
log_vargs (const gchar * message, va_list args)
{
  gchar *s;

  if (!log_buf) log_buf = g_string_new (NULL);

  s = g_strdup_vprintf (message, args);
  log_buf = g_string_append (log_buf, s);
  log_buf = g_string_append (log_buf, "\n");
  g_free (s);

  if (log_buf->len > log_maxsize)
    {				/* log exceeded max size? */
      gint i = 0;
      gchar c;

      /* look for first line that satisfies max size */
      while ((c = log_buf->str[i]))
	{
	  i++;
	  if (c == '\n' && (log_buf->len - i) <= log_maxsize)
	    break;
	}
      g_string_erase (log_buf, 0, i);	/* erase old lines */
    }
}

void
log_message (const gchar * message, ...)
{
  va_list args;

  va_start (args, message);
  log_vargs (message, args);
  va_end (args);
}

/* starts an error group, which esentially waits until log_group_leave to pop up
   an error dialog and then only if an error occured at or above popup_lvl */
void
log_group_enter (gint popup_lvl)
{
  if (log_groups == 0)
    {
      log_grp_popup_lvl = popup_lvl;
      log_grp_highest_lvl = -1;	/* reset highest occured log level */
    }

  log_groups++;
}

/* leave the error group, popping dialog if an error of sufficient level
   occured (set by log_group_enter) */
void
log_group_leave (void)
{
  g_return_if_fail (log_groups <= 0);

  log_groups--;

  if (log_grp_highest_lvl == -1) return;

  if (log_grp_highest_lvl >= log_grp_popup_lvl)
    log_view (NULL);
}

gint
log_length (void)
{
  return (log_buf->len);
}

void
log_clear (void)
{
  log_buf = g_string_truncate (log_buf, 0);
}

gint
safe_fread (void *buf, gint count, FILE * fd)
{
  if (fread (buf, count, 1, fd) != 1)
    {				// size_t = count, nmemb = 1
      if (feof (fd))
	logit (LogFubar, _("EOF while attemping to read %d bytes"), count);
      else
	logit (LogFubar | LogErrno, _("File read failed"));
      return (FAIL);
    }
  return (OK);
}

gint
safe_fwrite (void *buf, gint count, FILE * fd)
{
  if (fwrite (buf, count, 1, fd) != 1)
    {
      logit (LogFubar | LogErrno, _("File write failed"));
      return (FAIL);
    }
  return (OK);
}

gint
safe_fseek (FILE * fd, long ofs, gint whence)
{
  if (fseek (fd, ofs, whence) == -1)
    return (logit (LogFubar | LogErrno, _("File seek failed with offset = %ld"
					  " and whence = %d"), ofs, whence));
  return (OK);
}

void *
safe_malloc (size_t size)
{
  void *ptr;

  if (!(ptr = malloc (size)))
    logit (LogFubar, _("Failed to allocate %d bytes"), (gint) size);
  return (ptr);
}

gchar *
str_crlf2lf (gchar * str)
{				/* convert '\r\n' to '\n' in str */
  gchar *newstr, *s;

  newstr = g_new (gchar, strlen (str) + 1);
  s = newstr;

  while (*str != '\0')
    {
      if (*str != '\r' || *(str + 1) != '\n')
	*(s++) = *str;
      str++;
    }
  *s = '\0';

  return (newstr);
}

gchar *
str_lf2crlf (gchar * str)
{				/* convert '\n' to '\r\n' in str */
  GString *gs;
  gchar *s;

  gs = g_string_sized_new (sizeof (str));

  while (*str != '\0')
    {
      if (*str != '\n')
	gs = g_string_append_c (gs, *str);
      else
	gs = g_string_append (gs, "\r\n");
      str++;
    }
  s = gs->str;
  g_string_free (gs, FALSE);	/* character segment is not free'd */

  return (s);
}

/* returns TRUE if "sub" is found in "str" */
gint
substrcmp (gchar * sub, gchar * str)
{
  gchar *s, *s2;

  if (!*sub)
    return (TRUE);		/* null string, matches */

  while (*str)
    {
      if (tolower (*str) == tolower (*sub))
	{
	  s = sub + 1;
	  s2 = str + 1;
	  while (*s && *s2)
	    {
	      if (tolower (*s) != tolower (*s2))
		break;
	      s++;
	      s2++;
	    }
	  if (!*s)
	    return (TRUE);
	}
      str++;
    }
  return (FALSE);
}