st-stream-view.c

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

  st_handler_field_set_user_visible(field, gtk_tree_view_column_get_visible(GTK_TREE_VIEW_COLUMN(object)));
}

static void
st_stream_view_column_notify_width_h (GObject *object,
				      GParamSpec *pspec,
				      gpointer data)
{
  STHandlerField *field = st_stream_view_column_get_field(GTK_TREE_VIEW_COLUMN(object));
  st_handler_field_set_width(field, gtk_tree_view_column_get_width(GTK_TREE_VIEW_COLUMN(object)));
}

static void
st_stream_view_column_hide_activate_h (GtkMenuItem *item, gpointer data)
{
  GtkTreeViewColumn *column = data;

  gtk_tree_view_column_set_visible(column, FALSE);
}

static void
st_stream_view_column_show_all_activate_h (GtkMenuItem *item, gpointer data)
{
  STStreamView *view = data;
  GtkTreeViewColumn *column;
  int i = N_VISIBLE_STOCK_COLUMNS;

  while ((column = gtk_tree_view_get_column(GTK_TREE_VIEW(view), i++)))
    gtk_tree_view_column_set_visible(column, TRUE);
}

static void
st_stream_view_column_stream_columns_activate_h (GtkMenuItem *item, gpointer data)
{
  st_shell_present_stream_columns(st_shell);
}

static void
st_stream_view_selection_changed_h (GtkTreeSelection *selection,
				    gpointer user_data)
{
  STStreamView *view = user_data;
  
  g_signal_emit(view, stream_view_signals[SELECTION_CHANGED], 0);
}

static void
st_stream_view_columns_changed_h (GtkTreeView *view, gpointer user_data)
{
  GtkTreeViewColumn *column;
  int i = N_VISIBLE_STOCK_COLUMNS;
  int pos = 0;
  
  while ((column = gtk_tree_view_get_column(view, i++)))
    {
      STHandlerField *field = st_stream_view_column_get_field(column);
      st_handler_field_set_position(field, pos++);
    }
}

static void
st_stream_view_destroy_h (GtkObject *object, gpointer user_data)
{
  g_signal_handlers_disconnect_by_func(object, st_stream_view_columns_changed_h, NULL);
}

static void
st_stream_view_order_columns (STStreamView *view)
{
  GList *columns;
  GList *l;

  g_return_if_fail(ST_IS_STREAM_VIEW(view));

  columns = gtk_tree_view_get_columns(GTK_TREE_VIEW(view));
  SG_LIST_FOREACH(l, g_list_nth(columns, N_VISIBLE_STOCK_COLUMNS))
    {
      GtkTreeViewColumn *column = l->data;
      STHandlerField *field;
      int position;

      field = st_stream_view_column_get_field(column);
      position = st_handler_field_get_position(field);

      if (position != -1)
	{
	  GtkTreeViewColumn *after;

	  after = gtk_tree_view_get_column(GTK_TREE_VIEW(view), position + N_VISIBLE_STOCK_COLUMNS - 1);
	  if (after != column)
	    gtk_tree_view_move_column_after(GTK_TREE_VIEW(view), column, after);
	}
    }
  g_list_free(columns);
}

GtkWidget *
st_stream_view_new (STHandler *handler)
{
  return g_object_new(ST_TYPE_STREAM_VIEW,
		      "handler", handler,
		      NULL);
}

STHandler *
st_stream_view_get_handler (STStreamView *view)
{
  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), NULL);

  return view->priv->handler;
}

void
st_stream_view_update_sensitivity (STStreamView *view)
{
  g_return_if_fail(ST_IS_STREAM_VIEW(view));

  if (view->priv->menu_items)
    st_stream_menu_items_update_sensitivity(view->priv->menu_items);
}

/*
 * Select the iter belonging to stream BAG, and let that trigger the
 * emission of a selection-changed signal.
 */
void
st_stream_view_select_stream (STStreamView *view, STStreamBag *bag)
{
  GtkTreeSelection *selection;

  g_return_if_fail(ST_IS_STREAM_VIEW(view));
  g_return_if_fail(ST_IS_STREAM_BAG(bag));

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));

  gtk_tree_selection_unselect_all(selection);
  gtk_tree_selection_select_iter(selection, &bag->iter);
}

void
st_stream_view_present_stream (STStreamView *view, STStreamBag *bag)
{
  GtkTreeModel *model;
  GtkTreePath *path;
  
  g_return_if_fail(ST_IS_STREAM_VIEW(view));
  g_return_if_fail(ST_IS_STREAM_BAG(bag));

  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
  path = gtk_tree_model_get_path(model, &bag->iter);
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(view), path, NULL, FALSE, 0, 0);
  gtk_tree_path_free(path);
}

gboolean
st_stream_view_can_select_previous (STStreamView *view)
{
  GtkTreeIter iter;
  gboolean can = FALSE;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), FALSE);

  if (st_stream_view_get_first_selection(view, &iter))
    {
      GtkTreeModel *model;
      
      model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
      can = sgtk_tree_model_iter_prev(model, &iter);
    }

  return can;
}

void
st_stream_view_select_previous (STStreamView *view)
{
  GtkTreeModel *model;
  GtkTreeSelection *selection;
  GtkTreeIter iter;
  GtkTreePath *path;
  gboolean status;
  
  g_return_if_fail(ST_IS_STREAM_VIEW(view));
  g_return_if_fail(st_stream_view_can_select_previous(view));
  
  status = st_stream_view_get_first_selection(view, &iter);
  g_return_if_fail(status == TRUE);

  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
  path = gtk_tree_model_get_path(model, &iter);
  status = gtk_tree_path_prev(path);
  g_return_if_fail(status == TRUE);

  status = gtk_tree_model_get_iter(model, &iter, path);
  g_return_if_fail(status == TRUE);

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  gtk_tree_selection_unselect_all(selection);
  gtk_tree_selection_select_iter(selection, &iter);
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(view), path, NULL, FALSE, 0, 0);

  gtk_tree_path_free(path);
}

gboolean
st_stream_view_can_select_next (STStreamView *view)
{
  GtkTreeModel *model;
  GtkTreeIter iter;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), FALSE);

  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));

  return st_stream_view_get_first_selection(view, &iter)
    && gtk_tree_model_iter_next(model, &iter);
}

void
st_stream_view_select_next (STStreamView *view)
{
  GtkTreeModel *model;
  GtkTreeSelection *selection;
  GtkTreeIter iter;
  GtkTreePath *path;
  gboolean status;

  g_return_if_fail(ST_IS_STREAM_VIEW(view));
  g_return_if_fail(st_stream_view_can_select_next(view));
  
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));

  status = st_stream_view_get_first_selection(view, &iter);
  g_return_if_fail(status == TRUE);
  status = gtk_tree_model_iter_next(model, &iter);
  g_return_if_fail(status == TRUE);

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  gtk_tree_selection_unselect_all(selection);
  gtk_tree_selection_select_iter(selection, &iter);

  path = gtk_tree_model_get_path(model, &iter);
  gtk_tree_view_scroll_to_cell(GTK_TREE_VIEW(view), path, NULL, FALSE, 0, 0);
  gtk_tree_path_free(path);
}

static gboolean
st_stream_view_get_first_selection (STStreamView *view, GtkTreeIter *iter)
{
  GtkTreeSelection *selection;
  GtkTreeModel *model;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), FALSE);
  g_return_val_if_fail(iter != NULL, FALSE);

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));

  if (model)
    {
      GList *paths;
      
      paths = gtk_tree_selection_get_selected_rows(selection, NULL);
      if (paths)
	{
	  GtkTreePath *path = paths->data;
	  gboolean status;
	  
	  status = gtk_tree_model_get_iter(model, iter, path);
	  g_return_val_if_fail(status == TRUE, FALSE);

	  g_list_foreach(paths, (GFunc) gtk_tree_path_free, NULL);
	  g_list_free(paths);

	  return TRUE;
	}
    }

  return FALSE;
}

/*
 * This owns ITEMS. The caller must not free it.
 */
void
st_stream_view_set_menu_items (STStreamView *view, STStreamMenuItems *items)
{
  g_return_if_fail(ST_IS_STREAM_VIEW(view));
  g_return_if_fail(view->priv->menu_items == NULL);
  g_return_if_fail(items != NULL);

  view->priv->menu = gtk_menu_new();
  view->priv->menu_items = items;
  
  st_stream_menu_items_insert_into_shell(view->priv->menu_items, GTK_MENU_SHELL(view->priv->menu), 0);
  sgtk_widget_set_popup_menu(GTK_WIDGET(view), GTK_MENU(view->priv->menu));
}

void
st_stream_view_set_store (STStreamView *view, STStreamStore *store)
{
  g_return_if_fail(ST_IS_STREAM_VIEW(view));
  
  gtk_tree_view_set_model(GTK_TREE_VIEW(view), GTK_TREE_MODEL(store));

  g_signal_emit(view, stream_view_signals[SELECTION_CHANGED], 0);
}

GSList *
st_stream_view_get_selected_streams (STStreamView *view)
{
  GtkTreeModel *model;
  GSList *selected_streams = NULL;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), NULL);

  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
  if (model)
    {
      GtkTreeSelection *selection;
      GList *paths;
      
      selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
      paths = gtk_tree_selection_get_selected_rows(selection, NULL);
      if (paths)
	{
	  GList *l;

	  SG_LIST_FOREACH(l, paths)
	    {
	      GtkTreePath *path = l->data;
	      GtkTreeIter iter;
	      gboolean status;
	      STStreamBag *bag;
	  
	      status = gtk_tree_model_get_iter(model, &iter, path);
	      g_return_val_if_fail(status == TRUE, NULL);

	      gtk_tree_model_get(model, &iter, ST_STREAM_STORE_COLUMN_BAG, &bag, -1);
	      selected_streams = g_slist_append(selected_streams, bag);

	      gtk_tree_path_free(path);
	    }

	  g_list_free(paths);
	}
    }

  return selected_streams;
}

gboolean
st_stream_view_has_selected_streams (STStreamView *view)
{
  GSList *selected_streams;
  gboolean has;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), FALSE);

  selected_streams = st_stream_view_get_selected_streams(view);
  has = selected_streams != NULL;
  sg_objects_free(selected_streams);

  return has;
}

void
st_stream_view_select_all (STStreamView *view)
{
  GtkTreeSelection *selection;

  g_return_if_fail(ST_IS_STREAM_VIEW(view));

  selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
  gtk_tree_selection_select_all(selection);
}

static gboolean
st_stream_view_model_iter_move (GtkTreeModel *model,
				GtkTreeIter *iter,
				sGtkDirection direction,
				gboolean wrap_around,
				gboolean *edge_hit)
{
  gboolean valid;

  g_return_val_if_fail(GTK_IS_TREE_MODEL(model), FALSE);
  g_return_val_if_fail(iter != NULL, FALSE);

  valid = sgtk_tree_model_iter_move(model, iter, direction);
  if (! valid && wrap_around)
    {
      if (edge_hit)
	*edge_hit = TRUE;

      switch (direction)
	{
	case SGTK_PREVIOUS:
	  valid = sgtk_tree_model_get_iter_last(model, iter);
	  break;
	  
	case SGTK_NEXT:
	  valid = gtk_tree_model_get_iter_first(model, iter);
	  break;
	  
	default:
	  g_return_val_if_reached(FALSE);
	}
    }

  return valid;
}

gboolean
st_stream_view_find (STStreamView *view,
		     sGtkDirection direction,
		     const char *token,
		     gboolean case_sensitive,
		     gboolean wrap_around)
{
  GtkTreeModel *model;
  gboolean found = FALSE;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), FALSE);
  g_return_val_if_fail(token != NULL, FALSE);

  model = gtk_tree_view_get_model(GTK_TREE_VIEW(view));
  if (model)
    {
      GSList *selected_streams;
      gboolean valid;
      GtkTreeIter iter;
      gboolean edge_hit = FALSE;

      selected_streams = st_stream_view_get_selected_streams(view);
      if (selected_streams)
	{
	  GSList *last = g_slist_last(selected_streams);
	  STStreamBag *bag = last->data;

	  iter = bag->iter;
	  valid = st_stream_view_model_iter_move(model, &iter, direction, wrap_around, &edge_hit);

	  sg_objects_free(selected_streams);
	}
      else
	valid = gtk_tree_model_get_iter_first(model, &iter);

      while (valid)
	{
	  STStreamBag *bag;

	  gtk_tree_model_get(model, &iter, ST_STREAM_STORE_COLUMN_BAG, &bag, -1);
	  found = st_stream_bag_matches(bag, token, case_sensitive);
	  if (found)
	    {
	      st_stream_view_select_stream(view, bag);
	      st_stream_view_present_stream(view, bag);
	    }
	  g_object_unref(bag);

	  if (found)
	    break;

	  valid = st_stream_view_model_iter_move(model, &iter, direction, wrap_around && ! edge_hit, &edge_hit);
	}
    }

  return found;
}

GSList *
st_stream_view_get_columns (STStreamView *view)
{
  GSList *columns = NULL;
  int i = N_VISIBLE_STOCK_COLUMNS;
  GtkTreeViewColumn *column;

  g_return_val_if_fail(ST_IS_STREAM_VIEW(view), NULL);

  while ((column = gtk_tree_view_get_column(GTK_TREE_VIEW(view), i++)))
    columns = g_slist_append(columns, column);

  return columns;
}

STHandlerField *
st_stream_view_column_get_field (GtkTreeViewColumn *column)
{
  g_return_val_if_fail(GTK_IS_TREE_VIEW_COLUMN(column), NULL);

  return g_object_get_data(G_OBJECT(column), "field");
}