st-config-load.c

来自「linux下网络收音机的源码」· C语言 代码 · 共 1,003 行 · 第 1/2 页

	      st_settings.proxy_type = g_value_get_int(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_PROXY_URL:
	      {
		const char *proxy_url;
		char *server = NULL;
		int port = 0;
		
		proxy_url = g_value_get_string(&info.statement->value);
		if (proxy_url)
		  {
		    const char *protocol;
		    const char *portstr;

		    /* skip protocol */

		    protocol = strstr(proxy_url, "://");
		    if (protocol)
		      proxy_url = protocol + 3;

		    /* extract port */

		    portstr = strrchr(proxy_url, ':');
		    if (portstr)
		      {
			server = g_strndup(proxy_url, portstr - proxy_url);
			port = atoi(portstr + 1);
		      }
		    else
		      server = g_strdup(proxy_url);
		  }

		g_free(st_settings.proxy_server);
		st_settings.proxy_server = server;
		st_settings.proxy_port = port;

		break;
	      }

	    case STATEMENT_OPTIONS_PROXY_SERVER:
	      g_free(st_settings.proxy_server);
	      st_settings.proxy_server = g_value_dup_string(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_PROXY_PORT:
	      st_settings.proxy_port = g_value_get_int(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_PROXY_AUTH_ENABLED:
	      st_settings.proxy_auth_enabled = g_value_get_boolean(&info.statement->value);
	      break;
	      
	    case STATEMENT_OPTIONS_PROXY_AUTH_NAME:
	      g_free(st_settings.proxy_auth_name);
	      st_settings.proxy_auth_name = g_value_dup_string(&info.statement->value);
	      break;
	      
	    case STATEMENT_OPTIONS_PROXY_AUTH_PASSWORD:
	      g_free(st_settings.proxy_auth_password);
	      st_settings.proxy_auth_password = g_value_dup_string(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_VIEW_MENUBAR:
	    case STATEMENT_OPTIONS_TOOLBAR_THEME:
	    case STATEMENT_OPTIONS_GALEON_THEMES_ENABLED:
	    case STATEMENT_OPTIONS_GALEON_THEMES_SYSTEM_DIR:
	    case STATEMENT_OPTIONS_GALEON_THEMES_USER_DIR:
	    case STATEMENT_HANDLER_SELECTED_CATEGORY:
	    case STATEMENT_HANDLER_SELECTED_STREAM:
	    case STATEMENT_HANDLER_EXPANDED_CATEGORIES:
	    case STATEMENT_HANDLER_SELECTED_STREAMS:
	    case STATEMENT_OPTIONS_SAVE_AUTOMATIC:
	    case STATEMENT_OPTIONS_SELECTED_PREFERENCES_PAGE:
	      g_scanner_warn(info.parser->scanner, _("obsolete statement, ignored"));
	      break;

	    case STATEMENT_OPTIONS_SELECTED_HANDLER:
	      g_free(st_settings.selected_handler_name);
	      st_settings.selected_handler_name = g_value_dup_string(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_ALWAYS_REFRESH: /* deprecated */
	    case STATEMENT_OPTIONS_ALWAYS_RELOAD:
	      st_settings.always_reload = g_value_get_boolean(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_FIND_TOKEN:
	      g_free(st_settings.find_token);
	      st_settings.find_token = g_value_dup_string(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_FIND_CASE_SENSITIVE:
	      st_settings.find_case_sensitive = g_value_get_boolean(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_FIND_WRAP_AROUND:
	      st_settings.find_wrap_around = g_value_get_boolean(&info.statement->value);
	      break;

	    case STATEMENT_OPTIONS_MUSIC_DIR:
	      g_free(st_settings.music_dir);
	      st_settings.music_dir = g_value_dup_string(&info.statement->value);
	      break;

	    case STATEMENT_ACTION:
	      g_free(info.action);
	      info.action = g_value_dup_string(&info.statement->value);
	      if (! info.action)
		g_scanner_warn(info.parser->scanner, _("action name missing"));
	      break;

	    case STATEMENT_ACTION_COMMAND:
	      st_config_load_command(&info);
	      break;

	    case STATEMENT_ACTION_PROGRAM:
	      st_config_load_program(&info);
	      break;
	      
	    case STATEMENT_HANDLER:
	      st_config_load_handler_begin(&info);
	      break;
	      
	    case STATEMENT_HANDLER_FIELDS_SORT_INDEX:
	      if (info.handler)
		{
		  int sort_index = g_value_get_int(&info.statement->value);
		  
		  if (! st_handler_is_dummy(info.handler) && sort_index > st_handler_count_fields(info.handler, ST_HANDLER_FIELD_VISIBLE))
		    g_scanner_warn(info.parser->scanner, _("index too big, ignored"));
		  else
		    st_handler_set_fields_sort_index(info.handler, sort_index);
		}
	      break;
	      
	    case STATEMENT_HANDLER_FIELDS_SORT_ORDER:
	      if (info.handler)
		st_handler_set_fields_sort_order(info.handler, g_value_get_int(&info.statement->value));
	      break;
	      
	    case STATEMENT_HANDLER_PANED_POSITION:
	      if (info.handler)
		st_handler_set_paned_position(info.handler, g_value_get_int(&info.statement->value));
	      break;

	    case STATEMENT_HANDLER_FIELD:
	      st_config_load_handler_field_begin(&info);
	      break;

	    case STATEMENT_HANDLER_FIELD_VISIBLE:
	      if (info.handler_field)
		st_handler_field_set_user_visible(info.handler_field, g_value_get_boolean(&info.statement->value));
	      break;

	    case STATEMENT_HANDLER_FIELD_WIDTH:
	      if (info.handler_field)
		st_handler_field_set_width(info.handler_field, g_value_get_int(&info.statement->value));
	      break;

	    case STATEMENT_HANDLER_FIELD_POSITION:
	      if (info.handler_field)
		st_handler_field_set_position(info.handler_field, g_value_get_int(&info.statement->value));
	      break;

	    case STATEMENT_HANDLER_KEY:
	      st_config_load_handler_key_begin(&info);
	      break;
	    }
	}
      else if (G_IS_VALUE(&info.statement->value))
	{
	  switch (SG_PARSER_SCOPE(info.parser))
	    {
	    case STATEMENT_OPTIONS_FIND_HISTORY:
	      st_config_load_find_history(&info);
	      break;

	    case STATEMENT_HANDLER_FIELDS_WIDTH:
	      st_config_load_handler_field_width(&info);
	      break;
	      
	    case STATEMENT_HANDLER_EXPANDED_CATEGORIES:
	    case STATEMENT_HANDLER_SELECTED_STREAMS:
	      /* obsolete */
	      break;

	    case STATEMENT_HANDLER_KEY:
	      st_config_load_handler_key_value(&info);
	      break;

	    default:
	      g_scanner_warn(info.parser->scanner, _("unexpected value"));
	    }
	}

      sg_parser_statement_evaluate(info.statement);
      sg_parser_statement_free(info.statement);
    }
  
  sg_parser_free(info.parser);
  g_free(info.action);
  st_handlers_reorder(info.handlers);
  g_free(info.handler_config_key);
  if (info.handler_config_values)
    g_value_array_free(info.handler_config_values);
  
  return TRUE;
}

static void
st_config_load_find_history (LoadInfo *info)
{
  if (! G_VALUE_HOLDS_STRING(&info->statement->value))
    {
      g_scanner_warn(info->parser->scanner, _("expected string value"));
      return;
    }

  if (g_slist_length(st_settings.find_history) < ST_SETTINGS_FIND_HISTORY_MAX_LENGTH)
    st_settings.find_history = g_slist_append(st_settings.find_history, g_value_dup_string(&info->statement->value));
  else
    g_scanner_warn(info->parser->scanner, _("too many find history tokens"));
}

static void
st_config_load_handler_begin (LoadInfo *info)
{
  const char *name;

  name = g_value_get_string(&info->statement->value);
  if (name)
    {
      info->handler = st_handlers_find_by_name(name);
  
      if (info->handler)
	info->handler_field_iter = st_handler_get_fields(info->handler);
      else
	{
	  info->handler = st_handler_new_dummy(name);
	  g_scanner_warn(info->parser->scanner, _("%s: no such handler"), name);
	}

      info->handlers = g_slist_append(info->handlers, info->handler);
    }
  else
    {
      info->handler = NULL;
      g_scanner_warn(info->parser->scanner, _("handler name missing"));
    }
}

static void
st_config_load_handler_end (LoadInfo *info)
{
  info->handler = NULL;
  info->handler_field_iter = NULL;
  info->handler_field = NULL;
}

static void
st_config_load_handler_field_begin (LoadInfo *info)
{
  if (! info->handler)
    return;
  
  if (st_handler_is_dummy(info->handler))
    {
      info->handler_field = st_handler_field_new_dummy();
      st_handler_add_field(info->handler, info->handler_field);
    }
  else
    {
      while (info->handler_field_iter)
	{
	  STHandlerField *field = info->handler_field_iter->data;
      
	  if (ST_HANDLER_FIELD_IS_VISIBLE(field))
	    break;
      
	  info->handler_field_iter = info->handler_field_iter->next;
	}
		  
      if (info->handler_field_iter)
	info->handler_field = info->handler_field_iter->data;
      else
	{
	  info->handler_field = NULL;
	  g_scanner_warn(info->parser->scanner, _("too many fields"));
	}
    }
}

static void
st_config_load_handler_field_end (LoadInfo *info)
{
  if (info->handler_field_iter)
    info->handler_field_iter = info->handler_field_iter->next;
  /* otherwise it's a dummy handler, or there has been a "too many fields" error -> nop */
}

static void
st_config_load_command (LoadInfo *info)
{
  if (! info->action)
    return;

  st_action_associate(info->action, g_value_get_string(&info->statement->value));
}

static void
st_config_load_program (LoadInfo *info)
{
  const char *command;
  char *new_command;

  if (! info->action)
    return;

  command = g_value_get_string(&info->statement->value);
  new_command = st_action_convert_old_style_command(command);

  st_action_associate(info->action, new_command);
  g_free(new_command);
}

static void
st_config_load_handler_field_width (LoadInfo *info)
{
  STHandlerField *field = NULL;

  if (! info->handler)
    return;

  if (! G_VALUE_HOLDS_INT(&info->statement->value))
    {
      g_scanner_warn(info->parser->scanner, _("expected integer value"));
      return;
    }

  if (st_handler_is_dummy(info->handler))
    {
      field = st_handler_field_new_dummy();
      st_handler_add_field(info->handler, field);
    }
  else
    while (info->handler_field_iter)
      {
	field = info->handler_field_iter->data;

	info->handler_field_iter = info->handler_field_iter->next;
	
	if (ST_HANDLER_FIELD_IS_VISIBLE(field))
	  break;
	else
	  field = NULL;
      }
  
  if (field)
    st_handler_field_set_width(field, g_value_get_int(&info->statement->value));
  else
    g_scanner_warn(info->parser->scanner, _("too many fields"));
}

static void
st_config_load_handler_key_begin (LoadInfo *info)
{
  if (! info->handler)
    return;

  if (st_handler_is_dummy(info->handler))
    {
      g_free(info->handler_config_key);
      info->handler_config_key = g_value_dup_string(&info->statement->value);
    }
  else
    {
      info->handler_config_pspec = st_handler_config_lookup(info->handler, g_value_get_string(&info->statement->value));
      if (! info->handler_config_pspec)
	{
	  g_scanner_warn(info->parser->scanner, _("unknown configuration key"));
	  return;
	}
    }
  
  if (info->handler_config_values)
    g_value_array_free(info->handler_config_values);
  info->handler_config_values = g_value_array_new(0);
}

static void
st_config_load_handler_key_value (LoadInfo *info)
{
  if (! info->handler)
    return;

  g_value_array_append(info->handler_config_values, &info->statement->value);
}

static void
st_config_load_handler_key_end (LoadInfo *info)
{
  GParamSpec *pspec;

  if (! info->handler)
    return;

  if (st_handler_is_dummy(info->handler))
    {
      if (info->handler_config_values->n_values == 0
	  || info->handler_config_values->n_values > 1)
	pspec = g_param_spec_value_array(info->handler_config_key,
					 NULL,
					 NULL,
					 NULL,
					 G_PARAM_READWRITE);
      else
	{
	  GValue *value = g_value_array_get_nth(info->handler_config_values, 0);

	  /* keep in sync with st_handler_config_register() */
	  if (G_VALUE_HOLDS_BOOLEAN(value))
	    pspec = g_param_spec_boolean(info->handler_config_key,
					 NULL,
					 NULL,
					 FALSE,
					 G_PARAM_READWRITE);
	  else if (G_VALUE_HOLDS_INT(value))
	    pspec = g_param_spec_int(info->handler_config_key,
				     NULL,
				     NULL,
				     G_MININT,
				     G_MAXINT,
				     0,
				     G_PARAM_READWRITE);
	  else if (G_VALUE_HOLDS_UINT(value))
	    pspec = g_param_spec_uint(info->handler_config_key,
				      NULL,
				      NULL,
				      0,
				      G_MAXUINT,
				      0,
				      G_PARAM_READWRITE);
	  else if (G_VALUE_HOLDS_DOUBLE(value))
	    pspec = g_param_spec_double(info->handler_config_key,
					NULL,
					NULL,
					G_MINDOUBLE,
					G_MAXDOUBLE,
					0,
					G_PARAM_READWRITE);
	  else if (G_VALUE_HOLDS_STRING(value))
	    pspec = g_param_spec_string(info->handler_config_key,
					NULL,
					NULL,
					NULL,
					G_PARAM_READWRITE);
	  else
	    {
	      g_scanner_warn(info->parser->scanner, _("invalid value type"));
	      return;
	    }
	}

      st_handler_config_register(info->handler, pspec);
    }
  else
    {
      pspec = info->handler_config_pspec;
      if (! pspec)
	return;
    }

  if (G_PARAM_SPEC_VALUE_TYPE(pspec) == G_TYPE_VALUE_ARRAY)
    {
      GValue value = { 0, };

      g_value_init(&value, G_TYPE_VALUE_ARRAY);
      g_value_set_boxed(&value, info->handler_config_values);
      st_handler_config_set_value(info->handler, g_param_spec_get_name(pspec), &value);
      g_value_unset(&value);
    }
  else
    {
      GValue *value;

      if (info->handler_config_values->n_values != 1)
	{
	  g_scanner_warn(info->parser->scanner, _("wrong number of values"));
	  return;
	}
      
      value = g_value_array_get_nth(info->handler_config_values, 0);
      
      if (G_VALUE_HOLDS(value, G_PARAM_SPEC_VALUE_TYPE(pspec)))
	st_handler_config_set_value(info->handler, g_param_spec_get_name(pspec), value);
      else
	g_scanner_warn(info->parser->scanner, _("invalid value type"));
    }
}