st-handler.c

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

}

STCategoryBag *
st_handler_get_stock_category (STHandler *handler, const char *name)
{
  GetStockCategoryInfo info = { name, NULL };

  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);
  g_return_val_if_fail(name != NULL, NULL);

  g_node_traverse(handler->priv->stock_categories,
		  G_PRE_ORDER,
		  G_TRAVERSE_ALL,
		  -1,
		  st_handler_get_stock_category_cb,
		  &info);

  return info.category_bag;
}

static gboolean
st_handler_get_stock_category_cb (GNode *node, gpointer data)
{
  if (node->data)
    {
      GetStockCategoryInfo *info = data;
      STCategoryBag *bag = node->data;
      
      if (ST_CATEGORY_BAG_IS(bag, info->name))
	{
	  info->category_bag = bag;
	  return TRUE;		/* abort */
	}
    }

  return FALSE;			/* continue */
}

/*
 * If no category is selected, select the __main category (if there is
 * no __main category, abort).
 */
void
st_handler_select_category (STHandler *handler)
{
  STCategoryBag *category_bag = NULL;

  g_return_if_fail(ST_IS_HANDLER(handler));

  category_bag = st_handler_get_selected_category(handler);
  if (category_bag)
    g_object_unref(category_bag); /* we're done */
  else
    {
      category_bag = st_handler_get_stock_category(handler, ST_CATEGORY_BAG_MAIN);

      g_assert(category_bag != NULL);
      SG_SET_FLAGS(category_bag->flags, ST_CATEGORY_BAG_SELECTED);
    }
}

STCategoryBag *
st_handler_get_selected_category (STHandler *handler)
{
  STCategoryBag *selected_category = NULL;

  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  st_category_store_foreach(handler->priv->categories,
			    st_handler_get_selected_category_cb,
			    &selected_category);
  
  return selected_category;
}

static gboolean
st_handler_get_selected_category_cb (STCategoryStore *store,
				     STCategoryBag *bag,
				     STCategoryBag *parent,
				     gpointer data)
{
  if (bag->flags & ST_CATEGORY_BAG_SELECTED)
    {
      STCategoryBag **selected = data;

      *selected = g_object_ref(bag);
      return TRUE;		/* stop */
    }
  else
    return FALSE;		/* continue */
}

gboolean
st_handler_event_is_bound (STHandler *handler, STHandlerEvent event)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), FALSE);
  g_return_val_if_fail(event >= 0 && event < ST_HANDLER_N_EVENTS, FALSE);

  return handler->priv->callbacks[event].cb != NULL;
}

gboolean
st_handler_is_dummy (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), FALSE);

  return handler->priv->dummy;
}

const char *
st_handler_get_name (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  return handler->priv->name;
}

const char *
st_handler_get_label (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  return handler->priv->label;
}

const char *
st_handler_get_description (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  return handler->priv->description;
}

const char *
st_handler_get_home (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  return handler->priv->home;
}

GdkPixbuf *
st_handler_get_pixbuf (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  return handler->priv->pixbuf;
}

unsigned int
st_handler_get_flags (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), 0);

  return handler->priv->flags;
}

int
st_handler_get_stream_version (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), 0);

  return handler->priv->stream_version;
}

void
st_handler_set_paned_position (STHandler *handler, int paned_position)
{
  g_return_if_fail(ST_IS_HANDLER(handler));

  handler->priv->paned_position = paned_position;
}

int
st_handler_get_paned_position (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), -1);

  return handler->priv->paned_position;
}

GSList *
st_handler_get_fields (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), NULL);

  return handler->priv->fields;
}

int
st_handler_count_fields (STHandler *handler, unsigned int flags)
{
  int count = 0;
  GSList *l;

  SG_LIST_FOREACH(l, handler->priv->fields)
    if (st_handler_field_get_flags(l->data) & flags)
      count++;

  return count;
}

void
st_handler_set_fields_sort_index (STHandler *handler, int sort_index)
{
  g_return_if_fail(ST_IS_HANDLER(handler));

  handler->priv->fields_sort_index = sort_index;
}

int
st_handler_get_fields_sort_index (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), -1);

  return handler->priv->fields_sort_index;
}

void
st_handler_set_fields_sort_order (STHandler *handler, int sort_order)
{
  g_return_if_fail(ST_IS_HANDLER(handler));

  handler->priv->fields_sort_order = sort_order;
}

int
st_handler_get_fields_sort_order (STHandler *handler)
{
  g_return_val_if_fail(ST_IS_HANDLER(handler), -1);

  return handler->priv->fields_sort_order;
}

/*** events ******************************************************************/

gboolean
st_handler_event_reload (STHandler *handler,
			 STCategory *category,
			 GNode **categories,
			 GList **streams,
			 GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_RELOAD];
  STHandlerReloadCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(category, categories, streams, callback->data, err);
}

gboolean
st_handler_event_reload_multiple (STHandler *handler,
				  GNode **categories,
				  GHashTable **streams,
				  GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_RELOAD_MULTIPLE];
  STHandlerReloadMultipleCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(categories, streams, callback->data, err);
}

STCategory *
st_handler_event_category_new (STHandler *handler)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_CATEGORY_NEW];
  STCategoryNewCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, NULL);
  return cb(callback->data);
}

void
st_handler_event_category_free (STHandler *handler, STCategory *category)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_CATEGORY_FREE];
  STCategoryFreeCallback cb = callback->cb;

  g_return_if_fail(cb != NULL);
  cb(category, callback->data);
}

STStream *
st_handler_event_stream_new (STHandler *handler)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_NEW];
  STStreamNewCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, NULL);
  return cb(callback->data);
}

void
st_handler_event_stream_field_get (STHandler *handler,
				   STStream *stream,
				   STHandlerField *field,
				   GValue *value)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_FIELD_GET];
  STStreamFieldGetCallback cb = callback->cb;

  g_return_if_fail(cb != NULL);
  cb(stream, field, value, callback->data);
}

void
st_handler_event_stream_field_set (STHandler *handler,
				   STStream *stream,
				   STHandlerField *field,
				   const GValue *value)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_FIELD_SET];
  STStreamFieldSetCallback cb = callback->cb;

  g_return_if_fail(cb != NULL);
  cb(stream, field, value, callback->data);
}

void
st_handler_event_stream_stock_field_get (STHandler *handler,
					 STStream *stream,
					 STHandlerStockField stock_field,
					 GValue *value)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_STOCK_FIELD_GET];
  STStreamStockFieldGetCallback cb = callback->cb;

  g_return_if_fail(cb != NULL);
  cb(stream, stock_field, value, callback->data);
}

gboolean
st_handler_event_stream_modify (STHandler *handler,
				STStream *stream,
				GSList *fields,
				GSList *values,
				GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_MODIFY];
  STStreamModifyCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(stream, fields, values, callback->data, err);
}

gboolean
st_handler_event_stream_delete (STHandler *handler,
				STStream *stream,
				GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_DELETE];
  STStreamDeleteCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(stream, callback->data, err);
}

void
st_handler_event_stream_free (STHandler *handler, STStream *stream)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_FREE];
  STStreamFreeCallback cb = callback->cb;

  g_return_if_fail(cb != NULL);
  cb(stream, callback->data);
}

gboolean
st_handler_event_stream_resolve (STHandler *handler,
				 STStream *stream,
				 GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_RESOLVE];
  STStreamResolveCallback cb = callback->cb;
  
  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(stream, callback->data, err);
}

gboolean
st_handler_event_stream_tune_in (STHandler *handler,
				 STStream *stream,
				 GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_TUNE_IN];
  STStreamTuneInCallback cb = callback->cb;
  
  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(stream, callback->data, err);
}

gboolean
st_handler_event_stream_tune_in_multiple (STHandler *handler,
					  GSList *streams,
					  GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_TUNE_IN_MULTIPLE];
  STStreamTuneInMultipleCallback cb = callback->cb;
  
  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(streams, callback->data, err);
}

gboolean
st_handler_event_stream_record (STHandler *handler,
				STStream *stream,
				GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_RECORD];
  STStreamRecordCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(stream, callback->data, err);
}

gboolean
st_handler_event_stream_browse (STHandler *handler,
				STStream *stream,
				GError **err)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_STREAM_BROWSE];
  STStreamBrowseCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, FALSE);
  return cb(stream, callback->data, err);
}

gpointer
st_handler_event_thread_begin (STHandler *handler)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_THREAD_BEGIN];
  STThreadBeginCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, NULL);
  return cb(callback->data);
}

void
st_handler_event_thread_end (STHandler *handler, gpointer thread_data)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_THREAD_END];
  STThreadEndCallback cb = callback->cb;

  g_return_if_fail(cb != NULL);
  cb(thread_data, callback->data);
}

GtkWidget *
st_handler_event_preferences_widget_new (STHandler *handler)
{
  STHandlerCallback *callback = &handler->priv->callbacks[ST_HANDLER_EVENT_PREFERENCES_WIDGET_NEW];
  STHandlerPreferencesWidgetNewCallback cb = callback->cb;

  g_return_val_if_fail(cb != NULL, NULL);
  return cb(callback->data);
}