示例#1
0
static int
release_user_entry(GtkTreeView *view) {
  GtkTreePath *path;
  GtkTreeIter iter;
  GtkTreeModel *model;

  model = gtk_tree_view_get_model(view);
  
  if (!model)
    return -EINVAL;

  path=gtk_tree_path_new_first ();
  g_assert(path);

  if (gtk_tree_model_get_iter(model,&iter,path)) {
    while(gtk_list_store_remove(GTK_LIST_STORE(model), &iter))
      dbg_out("Remove OK\n");
  }
  gtk_tree_path_free (path);

  return 0;
}
示例#2
0
static void
dialog_pref_select_page (PrefState *state, gchar const *page)
{
	page_search_t pst = {NULL, NULL};

	if (page == NULL)
		page = "Tools";

	pst.page = _(page);
	gtk_tree_model_foreach (GTK_TREE_MODEL (state->store),
				(GtkTreeModelForeachFunc) dialog_pref_select_page_search,
				&pst);

	if (pst.path == NULL)
		pst.path = gtk_tree_path_new_first ();

	if (pst.path != NULL) {
		gtk_tree_view_set_cursor (state->view, pst.path, NULL, FALSE);
		gtk_tree_view_expand_row (state->view, pst.path, TRUE);
		gtk_tree_path_free (pst.path);
	}
}
static gboolean
individual_view_drag_motion_cb (GtkWidget *widget,
    GdkDragContext *context,
    gint x,
    gint y,
    guint time_)
{
  EmpathyIndividualView *view = EMPATHY_INDIVIDUAL_VIEW (widget);
  GdkAtom target;

  target = gtk_drag_dest_find_target (GTK_WIDGET (view), context, NULL);

  if (target == gdk_atom_intern_static_string ("text/x-persona-id"))
    {
      GtkTreePath *path;

      /* FIXME: It doesn't make sense for us to highlight a specific row or
       * position to drop a Persona in, so just highlight the entire widget.
       * Since I can't find a way to do this, just highlight the first possible
       * position in the tree. */
      gdk_drag_status (context, gdk_drag_context_get_suggested_action (context),
          time_);

      path = gtk_tree_path_new_first ();
      gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (view), path,
          GTK_TREE_VIEW_DROP_BEFORE);
      gtk_tree_path_free (path);

      return TRUE;
    }

  /* Unknown or unhandled drag target */
  gdk_drag_status (context, GDK_ACTION_DEFAULT, time_);
  gtk_tree_view_set_drag_dest_row (GTK_TREE_VIEW (view), NULL, 0);

  return FALSE;
}
示例#4
0
static GtkTreePath *
_dtm_get_path (GtkTreeModel *tree_model,
	       GtkTreeIter  *iter)
{
  GtkTreePath *result;
  int index = 0;

  if (!NODE_DIAGRAM(iter) && !NODE_LAYER(iter) && !NODE_OBJECT(iter)) {
    /* the root path */
    return gtk_tree_path_new_first ();
  }

  result = gtk_tree_path_new ();

  if (NODE_DIAGRAM(iter)) {
    GList *list = dia_open_diagrams();
    gtk_tree_path_append_index (result, g_list_index (list, NODE_DIAGRAM(iter)));
  }
  if (NODE_LAYER(iter)) {
    g_return_val_if_fail (NODE_DIAGRAM(iter) == layer_get_parent_diagram (NODE_LAYER(iter)), NULL);
    index = data_layer_get_index (NODE_DIAGRAM(iter), NODE_LAYER(iter));
    if (index >= 0)
      gtk_tree_path_append_index (result, index);
  }
  if (index >= 0 && NODE_OBJECT(iter)) {
    g_return_val_if_fail (NODE_LAYER(iter) == dia_object_get_parent_layer (NODE_OBJECT(iter)), NULL);
    index = layer_object_get_index (NODE_LAYER(iter), NODE_OBJECT(iter));
    if (index >= 0)
      gtk_tree_path_append_index (result, index);
  }

  if (index < 0) {
    gtk_tree_path_free (result);
    return NULL;
  }
  return result;
}
示例#5
0
void FormAccount_UpDown(FormAccount* fa, unsigned int updown)
{
    GtkTreePath* path;
    GtkTreeModel* model;
    GtkTreeIter iter;


    gtk_tree_view_get_cursor(GTK_TREE_VIEW(fa->ListViewAccount), &path, NULL);

    if (path == NULL)
    {
        path = gtk_tree_path_new_first();
    }
    else
    {
        switch (updown)
        {
        case 2:
            gtk_tree_path_next(path);
            model = gtk_tree_view_get_model(GTK_TREE_VIEW(fa->ListViewAccount));

            if (gtk_tree_model_get_iter(model, &iter, path) == FALSE)
            {
                gtk_tree_path_prev(path);
            }

            break;
        case 1:
            gtk_tree_path_prev(path);
            break;
        }
    }

    gtk_tree_view_set_cursor_on_cell(GTK_TREE_VIEW(fa->ListViewAccount),
                                     path, NULL, NULL, FALSE);
    gtk_tree_path_free(path);
}
示例#6
0
static GtkTreePath *get_next_bus (GtkTreeModel *tm, GtkTreePath *tpSelBus)
  {
  int row_type ;
  int icRootChildren = -1 ;
  GtkTreePath *tp = NULL ;
  int idxChild = 0 ;
  GtkTreeIter itr ;

  if (1 != gtk_tree_path_get_depth (tpSelBus))
    return NULL ;

  icRootChildren = gtk_tree_model_iter_n_children (tm, NULL) ;

  tp = gtk_tree_path_new_first () ;
  while (gtk_tree_path_compare (tp, tpSelBus) <= 0 && idxChild < icRootChildren)
    if (gtk_tree_model_get_iter (tm, &itr, tp))
      {
      gtk_tree_path_next (tp) ;
      idxChild++ ;
      }
    else
      break ;

  while (idxChild < icRootChildren)
    {
    if (gtk_tree_model_get_iter (tm, &itr, tp))
      {
      gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ;
      if (ROW_TYPE_BUS & row_type)
        return tp ;
      }
    if (++idxChild < icRootChildren)
      gtk_tree_path_next (tp) ;
    }
  gtk_tree_path_free (tp) ;
  return NULL ;
  }
示例#7
0
文件: tasks_utils.c 项目: rosedu/osmo
gint
tsk_get_tasks_num (guint32 julian, gboolean check_only, gboolean show_done, gint hidden_category, GUI *appGUI)
{
	GtkTreeModel *model = NULL;
	GtkTreePath *path;
	GtkTreeIter iter;
	guint32 tsk_julian;
	gchar *buf;
	gint tasks = 0;
	gint done;

	model = GTK_TREE_MODEL (appGUI->tsk->tasks_list_store);
	g_return_val_if_fail (model != NULL, 0);

	path = gtk_tree_path_new_first ();

	while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {

		gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_DATE_JULIAN, &tsk_julian,
		                                  TA_COLUMN_CATEGORY, &buf,
		                                  TA_COLUMN_DONE, &done, -1);

		if (tsk_julian == julian && (show_done || !done) && tsk_get_category_state (buf, hidden_category, appGUI)) {
			tasks++;
		}

		g_free (buf);
		if (check_only && tasks) break;
		gtk_tree_path_next (path);

	}

	gtk_tree_path_free (path);

	return tasks;
}
static GtkTreePath *
dspy_introspection_model_get_path (GtkTreeModel *model,
                                   GtkTreeIter  *iter)
{
  DspyIntrospectionModel *self = (DspyIntrospectionModel *)model;
  GtkTreePath *path;
  DspyNode *node;

  LOG_DEBUG (G_STRFUNC);

  g_assert (DSPY_IS_INTROSPECTION_MODEL (self));
  g_assert (iter != NULL);

  node = iter->user_data;

  g_assert (node != NULL);
  g_assert (node->any.parent != NULL);

  path = gtk_tree_path_new_first ();

  g_assert (gtk_tree_path_get_depth (path) == 1);

  for (; node->any.parent != NULL; node = node->any.parent)
    {
      gint pos = 0;

      for (const GList *list = &node->any.link; list->prev; list = list->prev)
        pos++;

      gtk_tree_path_prepend_index (path, pos);
    }

  gtk_tree_path_up (path);

  return g_steal_pointer (&path);
}
示例#9
0
static void
panel_addto_search_entry_changed (GtkWidget        *entry,
				  PanelAddtoDialog *dialog)
{
	GtkTreeModel *model;
	char         *new_text;
	GtkTreeIter   iter;
	GtkTreePath  *path;

	new_text = g_strdup (gtk_entry_get_text (GTK_ENTRY (dialog->search_entry)));
	g_strchomp (new_text);

	if (dialog->search_text &&
	    g_utf8_collate (new_text, dialog->search_text) == 0) {
		g_free (new_text);
		return;
	}

	if (dialog->search_text)
		g_free (dialog->search_text);
	dialog->search_text = new_text;

	model = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tree_view));
	gtk_tree_model_filter_refilter (GTK_TREE_MODEL_FILTER (model));

	path = gtk_tree_path_new_first ();
	if (gtk_tree_model_get_iter (model, &iter, path)) {
		GtkTreeSelection *selection;

		gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->tree_view),
					      path, NULL, FALSE, 0, 0);
		selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->tree_view));
		gtk_tree_selection_select_path (selection, path);
	}
	gtk_tree_path_free (path);
}
/*!
* Event-handler for editing the suggestion.
*/
void 
AP_UnixDialog_Spell::onSuggestionChanged ()
{
	UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::onSuggestionChanged()\n"));
	const gchar * modtext = gtk_entry_get_text(GTK_ENTRY(m_eChange));
	UT_ASSERT(modtext);

	GtkTreeIter iter;
	GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvSuggestions));
	GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions));
	GtkTreePath *first = gtk_tree_path_new_first ();
	if (gtk_tree_model_get_iter (model, &iter, first))
	{
		gtk_tree_path_free (first);
		do
		{
			gchar *label = NULL;
			gtk_tree_model_get (model, &iter, COLUMN_SUGGESTION, &label, -1);
			if (g_ascii_strncasecmp (modtext, label, strlen (modtext)) == 0)
			{
				GtkTreePath *path = gtk_tree_model_get_path (model, &iter);
				g_signal_handler_block(G_OBJECT(selection), m_listHandlerID);
				gtk_tree_selection_select_path (selection, path);
				g_signal_handler_unblock(G_OBJECT(selection), m_listHandlerID);
				gtk_tree_path_free (path);
				return;			
			}
		}
	   	while (gtk_tree_model_iter_next (model, &iter));
	}
	else
	{
		gtk_tree_path_free (first);
		gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions)));
	}
}
示例#11
0
文件: plugins.c 项目: eskil/gdivelog
void plugins_show_window(PluginType plugin_type)
{
  gchar *heading;

  GtkTreeViewColumn *column;
  switch(plugin_type) {
    case PLUGIN_TYPE_IMPORT :
      heading=g_strdup((gchar *)_("Import Plugins"));
      plugins_liststore=plugins_import_liststore;
      break;
    case PLUGIN_TYPE_EXPORT :
      heading=g_strdup((gchar *)_("Export Plugins"));
      plugins_liststore=plugins_export_liststore;
      break;
    case PLUGIN_TYPE_DOWNLOAD :
      heading=g_strdup((gchar *)_("Download Plugins"));
      plugins_liststore=plugins_download_liststore;
      break;
    case PLUGIN_TYPE_GENERAL :
      heading=g_strdup((gchar *)_("General Plugins"));
      plugins_liststore=plugins_general_liststore;
      break;
    }
  plugins_window=GTK_WIDGET(create_plugins_window());
  column=gtk_tree_view_column_new_with_attributes(heading,gtk_cell_renderer_text_new(),"text",PLUGIN_COL_DESCRIPTION,NULL);
  g_free(heading);
  widget_plugins_list=GTK_WIDGET(lookup_widget(GTK_WIDGET(plugins_window),"pluginslist"));
  gtk_tree_view_append_column(GTK_TREE_VIEW(widget_plugins_list),column);
  gtk_tree_view_column_set_sort_column_id(column, PLUGIN_COL_DESCRIPTION);
  gtk_tree_view_set_model(GTK_TREE_VIEW(widget_plugins_list),GTK_TREE_MODEL(plugins_liststore));
  gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget_plugins_list),gtk_tree_path_new_first(),NULL,FALSE);
  gtk_window_set_transient_for(GTK_WINDOW(plugins_window),GTK_WINDOW(main_window));
  gtk_widget_show(plugins_window);
  if(!gtk_tree_model_iter_n_children(GTK_TREE_MODEL(plugins_liststore),NULL))
    gtk_widget_set_sensitive(GTK_WIDGET(lookup_widget(GTK_WIDGET(plugins_window),"plugins_ok_btn")),FALSE);
}
static void
wp_remove_wallpaper (GtkWidget *widget,
                     AppearanceData *data)
{
  MateWPItem *item;
  GtkTreeIter iter;
  GtkTreePath *path;

  item = get_selected_item (data, &iter);

  if (item)
  {
    item->deleted = TRUE;

    if (gtk_list_store_remove (GTK_LIST_STORE (data->wp_model), &iter))
      path = gtk_tree_model_get_path (data->wp_model, &iter);
    else
      path = gtk_tree_path_new_first ();

    gtk_icon_view_select_path (data->wp_view, path);
    gtk_icon_view_set_cursor (data->wp_view, path, NULL, FALSE);
    gtk_tree_path_free (path);
  }
}
/**
 * autoar_gtk_chooser_advanced_new:
 * @default_format: an #AutoarFormat
 * @default_filter: an #AutoarFilter
 *
 * Create a #GtkGrid with two lists. One list shows all available formats,
 * and the other list shows all available filters.
 *
 * Returns: (transfer full): a new #GtkGrid widget
 **/
GtkWidget*
autoar_gtk_chooser_advanced_new (AutoarFormat default_format,
                                 AutoarFilter default_filter)
{
  GtkWidget *advanced_widget;
  GtkGrid *advanced;

  GtkTreeModel *format_model;
  GtkWidget *format_widget;
  GtkTreeView *format;
  GtkTreeSelection *format_selection;
  GtkCellRenderer *format_renderer;
  GtkTreePath *format_path;

  GtkTreeModel *filter_model;
  GtkWidget *filter_widget;
  GtkTreeView *filter;
  GtkTreeSelection *filter_selection;
  GtkCellRenderer *filter_renderer;
  GtkTreePath *filter_path;

  GtkWidget *description_widget;
  GtkLabel *description;

  advanced_widget = gtk_grid_new ();
  advanced = GTK_GRID (advanced_widget);
  gtk_grid_set_row_spacing (advanced, 5);
  gtk_grid_set_column_spacing (advanced, 5);
  gtk_grid_set_column_homogeneous (advanced, TRUE);

  format_model = advanced_format_store ();
  format_widget = gtk_tree_view_new_with_model (format_model);
  format = GTK_TREE_VIEW (format_widget);
  format_selection = gtk_tree_view_get_selection (format);
  format_renderer = gtk_cell_renderer_text_new ();
  gtk_tree_selection_set_mode (format_selection, GTK_SELECTION_SINGLE);
  gtk_tree_view_insert_column_with_attributes (format, -1, _("Format"),
                                               format_renderer, "text",
                                               ADVANCED_FORMAT_COL_DESCRIPTION,
                                               NULL);
  if (autoar_format_is_valid (default_format)) {
    GtkTreeIter iter;
    gboolean valid;
    format_path = NULL;
    for (valid = gtk_tree_model_get_iter_first (format_model, &iter);
         valid;
         valid = gtk_tree_model_iter_next (format_model, &iter)) {
      int get_format;
      gtk_tree_model_get (format_model, &iter,
                          ADVANCED_FORMAT_COL_FORMAT, &get_format, -1);
      if (default_format == get_format) {
        format_path = gtk_tree_model_get_path (format_model, &iter);
        break;
      }
    }
    if (format_path == NULL)
      format_path = gtk_tree_path_new_first ();
  } else {
    format_path = gtk_tree_path_new_first ();
  }
  gtk_tree_view_set_cursor (format, format_path, NULL, FALSE);
  gtk_tree_path_free (format_path);
  gtk_grid_attach (advanced, format_widget, 0, 0, 1, 1);
  g_object_unref (format_model);

  filter_model = advanced_filter_store ();
  filter_widget = gtk_tree_view_new_with_model (filter_model);
  filter = GTK_TREE_VIEW (filter_widget);
  filter_selection = gtk_tree_view_get_selection (filter);
  filter_renderer = gtk_cell_renderer_text_new ();
  gtk_tree_selection_set_mode (filter_selection, GTK_SELECTION_SINGLE);
  gtk_tree_view_insert_column_with_attributes (filter, -1, _("Filter"),
                                               filter_renderer, "text",
                                               ADVANCED_FILTER_COL_DESCRIPTION,
                                               NULL);
  if (autoar_filter_is_valid (default_filter)) {
    GtkTreeIter iter;
    gboolean valid;
    filter_path = NULL;
    for (valid = gtk_tree_model_get_iter_first (filter_model, &iter);
         valid;
         valid = gtk_tree_model_iter_next (filter_model, &iter)) {
      int get_filter;
      gtk_tree_model_get (filter_model, &iter,
                          ADVANCED_FILTER_COL_FILTER, &get_filter, -1);
      if (default_filter == get_filter) {
        filter_path = gtk_tree_model_get_path (filter_model, &iter);
        break;
      }
    }
    if (filter_path == NULL)
      filter_path = gtk_tree_path_new_first ();
  } else {
    filter_path = gtk_tree_path_new_first ();
  }
  gtk_tree_view_set_cursor (filter, filter_path, NULL, FALSE);
  gtk_tree_path_free (filter_path);
  gtk_grid_attach (advanced, filter_widget, 1, 0, 1, 1);
  g_object_unref (filter_model);

  description_widget = gtk_label_new (NULL);
  description = GTK_LABEL (description_widget);
  gtk_label_set_justify (description, GTK_JUSTIFY_CENTER);
  gtk_grid_attach (advanced, description_widget, 0, 1, 2, 1);

  g_signal_connect (format_widget, "cursor-changed",
                    G_CALLBACK (advanced_update_description_cb), advanced);
  g_signal_connect (filter_widget, "cursor-changed",
                    G_CALLBACK (advanced_update_description_cb), advanced);

  /* Run the callback now to set the initial text on the label */
  advanced_update_description_cb (NULL, advanced_widget);

  return advanced_widget;
}
示例#14
0
bool
sc_navigate_index(girara_session_t* session, girara_argument_t* argument,
                  girara_event_t* UNUSED(event), unsigned int UNUSED(t))
{
  g_return_val_if_fail(session != NULL, false);
  g_return_val_if_fail(session->global.data != NULL, false);
  zathura_t* zathura = session->global.data;
  g_return_val_if_fail(argument != NULL, false);
  g_return_val_if_fail(zathura->document != NULL, false);

  if(zathura->ui.index == NULL) {
    return false;
  }

  GtkTreeView *tree_view = gtk_container_get_children(GTK_CONTAINER(zathura->ui.index))->data;
  GtkTreePath *path;

  gtk_tree_view_get_cursor(tree_view, &path, NULL);
  if (path == NULL) {
    return false;
  }

  GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
  GtkTreeIter   iter;
  GtkTreeIter   child_iter;

  gboolean is_valid_path = TRUE;

  switch(argument->n) {
    case TOP:
      /* go to the first node */
      gtk_tree_path_free(path);
      path = gtk_tree_path_new_first();
      break;
    case BOTTOM:
      /* go to the last visiible node */
      gtk_tree_path_free(path);
      path = gtk_tree_path_new_from_indices(gtk_tree_model_iter_n_children(model, NULL) - 1, -1);
      gtk_tree_model_get_iter(model, &iter, path);
      while (gtk_tree_model_iter_has_child(model, &iter) == TRUE &&
          gtk_tree_view_row_expanded(tree_view, path) == TRUE) {
          gtk_tree_path_append_index(path, gtk_tree_model_iter_n_children(model, &iter) - 1);
      }
      break;
    case UP:
      if (gtk_tree_path_prev(path) == FALSE) {
        /* For some reason gtk_tree_path_up returns TRUE although we're not
         * moving anywhere. */
        is_valid_path = gtk_tree_path_up(path) && (gtk_tree_path_get_depth(path) > 0);
      } else { /* row above */
        while (gtk_tree_view_row_expanded(tree_view, path)) {
          gtk_tree_model_get_iter(model, &iter, path);
          /* select last child */
          gtk_tree_model_iter_nth_child(model, &child_iter, &iter,
                                        gtk_tree_model_iter_n_children(model, &iter)-1);
          gtk_tree_path_free(path);
          path = gtk_tree_model_get_path(model, &child_iter);
        }
      }
      break;
    case COLLAPSE:
      if (gtk_tree_view_collapse_row(tree_view, path) == FALSE
          && gtk_tree_path_get_depth(path) > 1) {
        gtk_tree_path_up(path);
        gtk_tree_view_collapse_row(tree_view, path);
      }
      break;
    case DOWN:
      if (gtk_tree_view_row_expanded(tree_view, path) == TRUE) {
        gtk_tree_path_down(path);
      } else {
        do {
          gtk_tree_model_get_iter(model, &iter, path);
          if (gtk_tree_model_iter_next(model, &iter)) {
            gtk_tree_path_free(path);
            path = gtk_tree_model_get_path(model, &iter);
            break;
          }
        } while((is_valid_path = (gtk_tree_path_get_depth(path) > 1))
                && gtk_tree_path_up(path));
      }
      break;
    case EXPAND:
      if (gtk_tree_view_expand_row(tree_view, path, FALSE)) {
        gtk_tree_path_down(path);
      }
      break;
    case EXPAND_ALL:
      gtk_tree_view_expand_all(tree_view);
      break;
    case COLLAPSE_ALL:
      gtk_tree_view_collapse_all(tree_view);
      gtk_tree_path_free(path);
      path = gtk_tree_path_new_first();
      gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE);
      break;
    case TOGGLE:
      gtk_tree_model_get_iter(model, &iter, path);
      if (gtk_tree_model_iter_has_child(model, &iter) == TRUE) {
        if (gtk_tree_view_row_expanded(tree_view, path) == TRUE) {
          gtk_tree_view_collapse_row(tree_view, path);
        } else {
          gtk_tree_view_expand_row(tree_view, path, FALSE);
        }
        break;
      }
    case SELECT:
      cb_index_row_activated(tree_view, path, NULL, zathura);
      gtk_tree_path_free(path);
      return false;
  }

  if (is_valid_path == TRUE) {
    gtk_tree_view_set_cursor(tree_view, path, NULL, FALSE);
  }

  gtk_tree_path_free(path);

  return false;
}
示例#15
0
bool
sc_toggle_index(girara_session_t* session, girara_argument_t* UNUSED(argument),
                girara_event_t* UNUSED(event), unsigned int UNUSED(t))
{
  g_return_val_if_fail(session != NULL, false);
  g_return_val_if_fail(session->global.data != NULL, false);
  zathura_t* zathura = session->global.data;
  if (zathura->document == NULL) {
    return false;
  }

  girara_tree_node_t* document_index = NULL;
  GtkWidget* treeview                = NULL;
  GtkTreeModel* model                = NULL;
  GtkCellRenderer* renderer          = NULL;
  GtkCellRenderer* renderer2         = NULL;

  if (zathura->ui.index == NULL) {
    /* create new index widget */
    zathura->ui.index = gtk_scrolled_window_new(NULL, NULL);

    if (zathura->ui.index == NULL) {
      goto error_ret;
    }

    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(zathura->ui.index),
                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

    /* create index */
    document_index = zathura_document_index_generate(zathura->document, NULL);
    if (document_index == NULL) {
      girara_notify(session, GIRARA_WARNING, _("This document does not contain any index"));
      goto error_free;
    }

    model = GTK_TREE_MODEL(gtk_tree_store_new(3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER));
    if (model == NULL) {
      goto error_free;
    }

    treeview = gtk_tree_view_new_with_model(model);
    if (treeview == NULL) {
      goto error_free;
    }

    gtk_style_context_add_class(gtk_widget_get_style_context(treeview),
        "indexmode");

    g_object_unref(model);

    renderer = gtk_cell_renderer_text_new();
    if (renderer == NULL) {
      goto error_free;
    }

    renderer2 = gtk_cell_renderer_text_new();
    if (renderer2 == NULL) {
      goto error_free;
    }

    document_index_build(model, NULL, document_index);
    girara_node_free(document_index);

    /* setup widget */
    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 0, "Title", renderer, "markup", 0, NULL);
    gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW (treeview), 1, "Target", renderer2, "text", 1, NULL);

    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
    g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL);
    g_object_set(G_OBJECT(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 0)), "expand", TRUE, NULL);
    gtk_tree_view_column_set_alignment(gtk_tree_view_get_column(GTK_TREE_VIEW(treeview), 1), 1.0f);
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(treeview), gtk_tree_path_new_first(), NULL, FALSE);
    g_signal_connect(G_OBJECT(treeview), "row-activated", G_CALLBACK(cb_index_row_activated), zathura);

    gtk_container_add(GTK_CONTAINER(zathura->ui.index), treeview);
    gtk_widget_show(treeview);
  }

  if (gtk_widget_get_visible(GTK_WIDGET(zathura->ui.index))) {
    girara_set_view(session, zathura->ui.page_widget);
    gtk_widget_hide(GTK_WIDGET(zathura->ui.index));
    girara_mode_set(zathura->ui.session, zathura->modes.normal);

    /* refresh view */
    refresh_view(zathura);
  } else {
    /* save current position to the jumplist */
    zathura_jumplist_add(zathura);

    girara_set_view(session, zathura->ui.index);
    gtk_widget_show(GTK_WIDGET(zathura->ui.index));
    girara_mode_set(zathura->ui.session, zathura->modes.index);
  }

  return false;

error_free:

  if (zathura->ui.index != NULL) {
    g_object_ref_sink(zathura->ui.index);
    zathura->ui.index = NULL;
  }

  if (document_index != NULL) {
    girara_node_free(document_index);
  }

error_ret:

  return false;
}
示例#16
0
/* Create a new dir tree view */
GtkWidget* ptk_dir_tree_view_new( PtkFileBrowser* browser,
                                  gboolean show_hidden )
{
    GtkTreeView * dir_tree_view;
    GtkTreeViewColumn* col;
    GtkCellRenderer* renderer;
    GtkTreeModel* model;
    GtkTreeSelection* tree_sel;
    GtkTreePath* tree_path;
    GtkTreeModel* filter;

    dir_tree_view = GTK_TREE_VIEW( gtk_tree_view_new () );
    gtk_tree_view_set_headers_visible( dir_tree_view, FALSE );
#if GTK_CHECK_VERSION(2, 10, 0)
    gtk_tree_view_set_enable_tree_lines(dir_tree_view, TRUE);
#endif
    /*
    FIXME: Temporarily disable drag & drop since it doesn't work right now.
    gtk_tree_view_enable_model_drag_dest ( dir_tree_view,
                                           drag_targets,
                                           sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
                                           GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );

    gtk_tree_view_enable_model_drag_source ( dir_tree_view,
                                             ( GDK_CONTROL_MASK | GDK_BUTTON1_MASK | GDK_BUTTON3_MASK ),
                                             drag_targets,
                                             sizeof( drag_targets ) / sizeof( GtkTargetEntry ),
                                             GDK_ACTION_DEFAULT | GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK );
    */

    col = gtk_tree_view_column_new ();

    renderer = ( GtkCellRenderer* ) ptk_file_icon_renderer_new();
    gtk_tree_view_column_pack_start( col, renderer, FALSE );
    gtk_tree_view_column_set_attributes( col, renderer, "pixbuf", COL_DIR_TREE_ICON,
                                         "info", COL_DIR_TREE_INFO, NULL );
    renderer = gtk_cell_renderer_text_new();
    gtk_tree_view_column_pack_start( col, renderer, TRUE );
    gtk_tree_view_column_set_attributes( col, renderer, "text", COL_DIR_TREE_DISP_NAME, NULL );

    gtk_tree_view_append_column ( dir_tree_view, col );

    tree_sel = gtk_tree_view_get_selection( dir_tree_view );
    gtk_tree_selection_set_select_function( tree_sel, sel_func, NULL, NULL );

    if ( G_UNLIKELY( !dir_tree_view_data ) )
        dir_tree_view_data = g_quark_from_static_string( "show_hidden" );
    g_object_set_qdata( G_OBJECT( dir_tree_view ),
                        dir_tree_view_data, ( gpointer ) show_hidden );
    model = get_dir_tree_model();
    filter = gtk_tree_model_filter_new( model, NULL );
    g_object_unref( G_OBJECT( model ) );
    gtk_tree_model_filter_set_visible_func( GTK_TREE_MODEL_FILTER( filter ),
                                            filter_func, dir_tree_view, NULL );
    gtk_tree_view_set_model( dir_tree_view, filter );
    g_object_unref( G_OBJECT( filter ) );

    g_signal_connect ( dir_tree_view, "row-expanded",
                       G_CALLBACK ( on_dir_tree_view_row_expanded ),
                       model );

    g_signal_connect_data ( dir_tree_view, "row-collapsed",
                            G_CALLBACK ( on_dir_tree_view_row_collapsed ),
                            model, NULL, G_CONNECT_AFTER );

    g_signal_connect ( dir_tree_view, "button-press-event",
                       G_CALLBACK ( on_dir_tree_view_button_press ),
                       browser );

    g_signal_connect ( dir_tree_view, "key-press-event",
                       G_CALLBACK ( on_dir_tree_view_key_press ),
                       NULL );

    tree_path = gtk_tree_path_new_first();
    gtk_tree_view_expand_row( dir_tree_view, tree_path, FALSE );
    gtk_tree_path_free( tree_path );

    g_signal_connect( dir_tree_view, "destroy", G_CALLBACK(on_destroy), NULL );
    return GTK_WIDGET( dir_tree_view );
}
示例#17
0
/** Create widget for select question in single question form.
 *
 * This will also register the corresponding setter function.
 *
 * @param fe cdebconf frontend
 * @param question handled question
 * @param question_box the container for question widgets
 * @param model model for the possible choices
 * @return the created widget, NULL if something went wrong
 * @see focus_path()
 */
static int create_select_list(struct frontend * fe, struct question * question,
                              GtkWidget * question_box, GtkTreeModel * model)
{
    GtkTreePath * path = NULL;
    GtkWidget * view;
    GtkWidget * scroll;
    GtkWidget * frame;

    /* check NULL! */
    view = gtk_tree_view_new_with_model(model);

    gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view),
                                      FALSE /* no headers */);
    gtk_tree_view_set_enable_search(GTK_TREE_VIEW(view),
                                    TRUE /* enable typeahead */);
    gtk_tree_view_set_search_column(GTK_TREE_VIEW(view),
                                    CHOICE_MODEL_TRANSLATED_VALUE);
    gtk_tree_selection_set_mode(
        gtk_tree_view_get_selection(GTK_TREE_VIEW(view)),
        GTK_SELECTION_BROWSE);

    if (!IS_SPECIAL_QUESTION(question)) {
        hide_expanders(GTK_TREE_VIEW(view));
    }

    insert_choice_column(fe, GTK_TREE_VIEW(view));

    g_signal_connect_swapped(G_OBJECT(view), "row-activated",
                             G_CALLBACK(cdebconf_gtk_set_answer_ok), fe);

    if (should_expand_all(question->tag)) {
        gtk_tree_view_expand_all(GTK_TREE_VIEW(view));
    }

    path = cdebconf_gtk_choice_model_get_first_selected(model);
    /* Select first row if there is no other default */
    if (NULL == path) {
        path = gtk_tree_path_new_first();
    } else {
        /* Only expand path when there was a previous selection. */
        gtk_tree_view_expand_to_path(GTK_TREE_VIEW(view), path);
    }
    gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), path,
                             NULL /* don't focus a particular column */,
                             FALSE /* don't start editing */);
    /* We need to focus the row *after* the widget realization, see #340007. */
    g_signal_connect_after(view, "expose-event", G_CALLBACK(focus_path), path);
    /* path will be free'd in focus_path() */

    scroll = gtk_scrolled_window_new(NULL /* create horizontal adjustement */,
                                     NULL /* create vertical adjustement */);
    gtk_container_add(GTK_CONTAINER(scroll), view);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    frame = gtk_frame_new(NULL);
    gtk_container_add(GTK_CONTAINER(frame), scroll);

    cdebconf_gtk_add_common_layout(fe, question, question_box, frame);

    gtk_widget_grab_focus(view);

    cdebconf_gtk_register_setter(fe, SETTER_FUNCTION(set_value_from_select),
                                 question, view);

    return DC_OK;
}
示例#18
0
// part_browser_create
//
// Creates a new part browser. This is only called once per schematic window.
GtkWidget *
part_browser_create (SchematicView *schematic_view)
{
	Browser *br;
	GtkBuilder *gui;
	GError *perror = NULL;
	char *msg;
	GtkWidget *w, *view;
	GtkCellRenderer *cell_text;
	GtkTreeViewColumn *cell_column;
	static GtkTargetEntry dnd_types[] =
		{ { "x-application/oregano-part", 0, DRAG_PART_INFO } };

	static int dnd_num_types = sizeof (dnd_types) / sizeof (dnd_types[0]);
	GtkTreePath *path;

	if ((gui = gtk_builder_new ()) == NULL) {
		oregano_error (_("Could not create part browser"));
		return NULL;
	} 
	else 
		gtk_builder_set_translation_domain (gui, NULL);

	br = g_new0 (Browser, 1);
	br->preview = NULL;
	br->schematic_view = schematic_view;
	br->hidden = FALSE;

	schematic_view_set_browser (schematic_view, br);

	if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/part-browser.ui", 
	    &perror) <= 0) {
		msg = perror->message;
		oregano_error_with_title (_("Could not create part browser"), msg);
		g_error_free (perror);
		return NULL;
	}

	view = GTK_WIDGET (gtk_builder_get_object (gui, "viewport1"));
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), 
	    GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

	gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (view),
	                                            115);
	
	w = goo_canvas_new ();
	gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (w));
	
	br->canvas = w;

	g_signal_connect (w, "realize", (GCallback) preview_realized, br);

	//gtk_widget_set_size_request (w, PREVIEW_WIDTH,
	//	PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT);
	goo_canvas_set_bounds (GOO_CANVAS (w), 0, 0, PREVIEW_WIDTH,
		(PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT));

	br->description = GOO_CANVAS_TEXT (goo_canvas_text_new (
	           goo_canvas_get_root_item (GOO_CANVAS (br->canvas)), 
	           "", 0.0, PREVIEW_HEIGHT - 9.0, 100.0, GOO_CANVAS_ANCHOR_NORTH_WEST,
	           "font", "sans 9", 
	           NULL));  

	// Set up dnd. 
	g_signal_connect (G_OBJECT (br->canvas), "drag_data_get",
		G_CALLBACK (drag_data_get), br);

	gtk_drag_source_set (br->canvas, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
		dnd_types, dnd_num_types, GDK_ACTION_MOVE);

	br->filter_entry = GTK_ENTRY (gtk_builder_get_object (gui, "part_search"));

	g_signal_connect (G_OBJECT (br->filter_entry), "changed",
		G_CALLBACK (part_search_change), br);
	g_signal_connect (G_OBJECT (br->filter_entry), "activate",
		G_CALLBACK (part_search_activate), br);

	// Buttons. 
	w = GTK_WIDGET (gtk_builder_get_object (gui, "place_button"));
	g_signal_connect (G_OBJECT (w), "clicked",
		G_CALLBACK (place_cmd), br);

	// Update the libraries option menu 
	br->library = g_list_nth_data (oregano.libraries, 0);
	part_browser_setup_libs (br, gui);

	// Parts list. 
	w = GTK_WIDGET (gtk_builder_get_object (gui, "parts_list"));
	br->list = w;

	// Create the List Model for TreeView, this is a Real model 
	br->real_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
	cell_text = gtk_cell_renderer_text_new ();
	cell_column = gtk_tree_view_column_new_with_attributes (
		"", cell_text, 
	    "text", 0,
	    NULL);

	// Create the sort model for the items, this sort the real model 
	br->sort_model = gtk_tree_model_sort_new_with_model (
		GTK_TREE_MODEL (br->real_model));

	gtk_tree_sortable_set_sort_column_id (
		GTK_TREE_SORTABLE (br->sort_model),
		0, GTK_SORT_ASCENDING);

	// Create the filter sorted model. This filter items based on user
	//   request for fast item search 
	br->filter_model = gtk_tree_model_filter_new (br->sort_model, NULL);
	gtk_tree_model_filter_set_visible_func (
		GTK_TREE_MODEL_FILTER (br->filter_model),
		part_list_filter_func, br, NULL);

	// If we have TreeFilter use it, if not, just use sorting model only 
	if (br->filter_model)
		gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->filter_model);
	else
		gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->sort_model);

	gtk_tree_view_append_column (GTK_TREE_VIEW (w), cell_column);
	update_list (br);

	// Set up TreeView dnd.
	g_signal_connect (G_OBJECT (w), "drag_data_get",
		G_CALLBACK (drag_data_get), br);

	gtk_drag_source_set (w, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
		dnd_types, dnd_num_types, GDK_ACTION_MOVE);

	g_signal_connect (G_OBJECT (w), "cursor_changed", 
		G_CALLBACK (select_row), br);
	g_signal_connect (G_OBJECT (w), "row_activated", 
	    G_CALLBACK (part_selected), br);

	br->viewport = GTK_WIDGET (gtk_builder_get_object (gui, 
	    "part_browser_vbox"));

	path = gtk_tree_path_new_first ();
	gtk_tree_view_set_cursor (GTK_TREE_VIEW (w), path, NULL, FALSE);
	gtk_tree_path_free (path);

	gtk_widget_unparent (br->viewport);
	return br->viewport;
}
示例#19
0
static void
change_root_to( ASFileBrowserRootSelFrame *data, ASFileBrowserRoot root )	
{
	char *new_root = NULL ;
	int i ;
	GtkTreeModel *old_model ;

	if( root != root_Other )
	{
		/* disable other text controls */			
	}		   
	switch( root ) 
	{
		case root_PrivateAfterStep : 
			new_root = mystrdup(Session->ashome );
		    break ;					   
		case root_SharedAfterStep  :
			new_root = mystrdup(Session->asshare );
		    break ;					   
		case root_Home :
			new_root = mystrdup(getenv("HOME"));
		    break ;					   
		case root_UsrShare :
			new_root = mystrdup("/usr/share");
		    break ;					   
		case root_UsrLocalShare :
			new_root = mystrdup("/usr/local/share");
		    break ;					   
		case root_Root :
#ifdef __CYGWIN__
			new_root = mystrdup("/cygdrive");
#else
			new_root = mystrdup("/");
#endif
		    break ;					   
		case root_Other :
		    break ;			
	}	 
	
	if( root != root_Root ) 
		data->last_nonroot_root = root ; 


	old_model = asgtk_dir_tree_get_model( ASGTK_DIR_TREE(data->target_dirlist) );
	for( i = 0 ; i < root_StandardRoots ; ++i ) 
		if( data->root_models[i] == old_model ) 
		{
			if( data->root_paths[i] )
				gtk_tree_path_free( data->root_paths[i] );
			data->root_paths[i]	= asgtk_dir_tree_get_curr_path( ASGTK_DIR_TREE(data->target_dirlist) );				   
			break;
		}	 
	g_object_unref( old_model );
	if( root < root_StandardRoots )
	{	
		GtkTreeModel *new_model ;
		asgtk_dir_tree_set_root( ASGTK_DIR_TREE(data->target_dirlist), new_root, data->root_models[root] );
		new_model = asgtk_dir_tree_get_model( ASGTK_DIR_TREE(data->target_dirlist) );
		if( data->root_models[root] != new_model )
		{
			if( data->root_models[root]	)
				g_object_unref( data->root_models[root] );
			data->root_models[root] = new_model ; 
		}else
	  		 g_object_unref( new_model );	 
		if( data->root_paths[root] == NULL ) 
			data->root_paths[root] = gtk_tree_path_new_first ();
		asgtk_dir_tree_restore_curr_path( ASGTK_DIR_TREE(data->target_dirlist), data->root_paths[root] );				   
	}else
		asgtk_dir_tree_set_root( ASGTK_DIR_TREE(data->target_dirlist), new_root, NULL );

	if( new_root ) 
		free( new_root ); 
}
示例#20
0
void
xml_tree_model_add_file (	xmlTreeModel	*model,
							gchar			*filename)
{
	g_return_if_fail (XML_IS_TREE_MODEL(model));
	g_return_if_fail (filename != NULL);

	GtkTreeIter   		iter;
	xsltStylesheetPtr 	xsldoc;
	xmlDocPtr			xmldoc = NULL;
	xmlNodePtr			cur;

    model->parser = xmlCreateURLParserCtxt (filename,
											XML_PARSE_RECOVER);// | 
											//XML_PARSE_DTDVALID);

	g_return_if_fail(model->parser != NULL);
            
    int record_info	= 1;
	xmlSetFeature(model->parser, "gather line info", &record_info);	

	xmlParseDocument(model->parser);

	glong bytes = xmlByteConsumed(model->parser);
		
 	model->valid = (model->parser->valid == 0) ? FALSE : TRUE;

	xmldoc = model->parser->myDoc;

	g_return_if_fail (xmldoc != NULL);

	model->offset = get_offset(xmldoc, filename);

	gint i;
	xmlParserNodeInfoPtr node;

	for(i = 0; i < model->parser->node_seq.length; ++i) {
		node = &model->parser->node_seq.buffer[i];
		model->nodeinfo = g_list_append(model->nodeinfo, node);
	}
	
	model->nodeinfo = g_list_sort(model->nodeinfo, compare_node_func);
	
	cur = xmlDocGetRootElement(xmldoc);

    if ((IS_XSLT_ELEM(cur)) &&
		((IS_XSLT_NAME(cur, "stylesheet")) ||
		(IS_XSLT_NAME(cur, "transform")))) {
		xsldoc = xsltParseStylesheetDoc(xmldoc);
	} else {
		xsldoc = NULL;
	}

	if(model->xsldoc != NULL) {
		xsltFreeStylesheet(model->xsldoc);
		model->xmldoc = NULL;
	}
	
	if(model->xmldoc)
		xmlFreeDoc(model->xmldoc);

	model->xmldoc = xmldoc;
	model->xsldoc = xsldoc;
	model->filename = filename;
	model->stamp = g_random_int();  /* Random int to check whether an iter belongs to our model */

	gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &iter);
	gtk_tree_model_row_changed(GTK_TREE_MODEL(model),gtk_tree_path_new_first(), &iter);
	
	g_signal_emit(model, xml_tree_model_signals[XML_TREE_MODEL_CHANGED],0,NULL);
	
    //xmlFreeParserCtxt(model->parser);
}
示例#21
0
文件: resv_info.c 项目: lipari/slurm
static void _update_info_resv(List info_list,
			      GtkTreeView *tree_view)
{
	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
	static GtkTreeModel *last_model = NULL;
	reserve_info_t *resv_ptr = NULL;
	char *name = NULL;
	ListIterator itr = NULL;
	sview_resv_info_t *sview_resv_info = NULL;

	set_for_update(model, SORTID_UPDATED);

	itr = list_iterator_create(info_list);
	while ((sview_resv_info = (sview_resv_info_t*) list_next(itr))) {
		resv_ptr = sview_resv_info->resv_ptr;

		/* This means the tree_store changed (added new column
		   or something). */
		if (last_model != model)
			sview_resv_info->iter_set = false;

		if (sview_resv_info->iter_set) {
			gtk_tree_model_get(model, &sview_resv_info->iter_ptr,
					   SORTID_NAME, &name, -1);
			if (strcmp(name, resv_ptr->name)) { /* Bad pointer */
				sview_resv_info->iter_set = false;
				//g_print("bad resv iter pointer\n");
			}
			g_free(name);
		}
		if (sview_resv_info->iter_set) {
			_update_resv_record(sview_resv_info,
					    GTK_TREE_STORE(model));
		} else {
			GtkTreePath *path = gtk_tree_path_new_first();

			/* get the iter, or find out the list is empty
			 * goto add */
			if (gtk_tree_model_get_iter(
				    model, &sview_resv_info->iter_ptr, path)) {
				do {
					/* search for the jobid and
					   check to see if it is in
					   the list */
					gtk_tree_model_get(
						model,
						&sview_resv_info->iter_ptr,
						SORTID_NAME,
						&name, -1);
					if (!strcmp(name, resv_ptr->name)) {
						/* update with new info */
						g_free(name);
						_update_resv_record(
							sview_resv_info,
							GTK_TREE_STORE(model));
						sview_resv_info->iter_set = 1;
						break;
					}
					g_free(name);
				} while (gtk_tree_model_iter_next(
						 model,
						 &sview_resv_info->iter_ptr));
			}

			if (!sview_resv_info->iter_set) {
				_append_resv_record(sview_resv_info,
						    GTK_TREE_STORE(model));
				sview_resv_info->iter_set = true;
			}
			gtk_tree_path_free(path);
		}
	}
	list_iterator_destroy(itr);

	/* remove all old reservations */
	remove_old(model, SORTID_UPDATED);
	last_model = model;
}
示例#22
0
static void _update_info_block(List block_list,
			       GtkTreeView *tree_view)
{
	ListIterator itr;
	sview_block_info_t *block_ptr = NULL;
	GtkTreePath *path = gtk_tree_path_new_first();
	GtkTreeModel *model = gtk_tree_view_get_model(tree_view);
	GtkTreeIter iter;
	char *name = NULL;
	char *host = NULL;
	int line = 0;

	if (!block_list) {
		g_print("No block_list given");
		return;
	}

	/* get the iter, or find out the list is empty goto add */
	if (gtk_tree_model_get_iter(model, &iter, path)) {
		/* make sure all the partitions are still here */
		while (1) {
			gtk_tree_store_set(GTK_TREE_STORE(model), &iter,
					   SORTID_UPDATED, 0, -1);
			if (!gtk_tree_model_iter_next(model, &iter)) {
				break;
			}
		}
	}


 	/* Report the BG Blocks */

	itr = list_iterator_create(block_list);
	while ((block_ptr = (sview_block_info_t*) list_next(itr))) {
		if (block_ptr->cnode_cnt == 0)
			block_ptr->cnode_cnt = block_ptr->size;
		if (!block_ptr->slurm_part_name)
			block_ptr->slurm_part_name = xstrdup("no part");

		/* get the iter, or find out the list is empty goto add */
		if (!gtk_tree_model_get_iter(model, &iter, path)) {
			goto adding;
		}
		line = 0;
		while (1) {
			/* search for the jobid and check to see if
			   it is in the list */
			gtk_tree_model_get(model, &iter, SORTID_BLOCK,
					   &name, -1);
			if (!strcmp(name, block_ptr->bg_block_name)) {
				/* update with new info */
				g_free(name);
				_update_block_record(block_ptr,
						     GTK_TREE_STORE(model),
						     &iter);
				goto found;
			}
			g_free(name);

			line++;
			if (!gtk_tree_model_iter_next(model, &iter)) {
				break;
			}
		}
	adding:
		_append_block_record(block_ptr, GTK_TREE_STORE(model),
				     &iter, line);
	found:
		;
	}

	list_iterator_destroy(itr);
	if (host)
		free(host);

	gtk_tree_path_free(path);
	/* remove all old blocks */
	remove_old(model, SORTID_UPDATED);
}
示例#23
0
static void DialogToBusLayout (bus_layout_D *dialog, BUS_LAYOUT *bus_layout)
  {
  GtkTreeModel *tm = gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->tview)) ;
  int Nix ;
  int icTopLevel = gtk_tree_model_iter_n_children (tm, NULL), icCells = -1 ;
  GtkTreePath *tp = NULL, *tpCells = NULL ;
  GtkTreeIter itr ;
  int Nix1, idxCell = -1 ;
  int row_type ;
  EXP_ARRAY *cell_list = NULL ;
  BUS *bus ;

  // destroy all buses before adding the new ones
  for (Nix = bus_layout->buses->icUsed - 1 ; Nix > -1 ; Nix--)
    {
    exp_array_free (exp_array_index_1d (bus_layout->buses, BUS, Nix).cell_indices) ;
    g_free (exp_array_index_1d (bus_layout->buses, BUS, Nix).pszName) ;
    }
  exp_array_remove_vals (bus_layout->buses, 1, 0, bus_layout->buses->icUsed) ;

  // Since we've destroyed all buses, no cells are members of any bus any longer
  for (Nix = 0 ; Nix < bus_layout->inputs->icUsed ; Nix++)
    exp_array_index_1d (bus_layout->inputs, BUS_LAYOUT_CELL, Nix).bIsInBus = FALSE ;
  for (Nix = 0 ; Nix < bus_layout->outputs->icUsed ; Nix++)
    exp_array_index_1d (bus_layout->outputs, BUS_LAYOUT_CELL, Nix).bIsInBus = FALSE ;

  if (icTopLevel > 0)
    {
    tp = gtk_tree_path_new_first () ;
    for (Nix = 0 ; Nix < icTopLevel ; Nix++, gtk_tree_path_next (tp))
      {
      if (gtk_tree_model_get_iter (tm, &itr, tp))
        {
        gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type, -1) ;
        if (ROW_TYPE_BUS & row_type)
          {
          exp_array_1d_insert_vals (bus_layout->buses, NULL, 1, -1) ;
          bus = &(exp_array_index_1d (bus_layout->buses, BUS, bus_layout->buses->icUsed - 1)) ;
          gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_NAME, &(bus->pszName), -1) ;
          if (ROW_TYPE_INPUT & row_type)
            {
            bus->bus_function = QCAD_CELL_INPUT ;
            cell_list = bus_layout->inputs ;
            }
          else
            {
            bus->bus_function = QCAD_CELL_OUTPUT ;
            cell_list = bus_layout->outputs ;
            }
          bus->cell_indices = exp_array_new (sizeof (int), 1) ;
          if ((icCells = gtk_tree_model_iter_n_children (tm, &itr)) > 0)
            {
            gtk_tree_path_down (tpCells = gtk_tree_path_copy (tp)) ;

            for (Nix1 = 0 ; Nix1 < icCells ; Nix1++, gtk_tree_path_next (tpCells))
              if (gtk_tree_model_get_iter (tm, &itr, tpCells))
                {
                gtk_tree_model_get (tm, &itr, BUS_LAYOUT_MODEL_COLUMN_INDEX, &idxCell, -1) ;
                exp_array_1d_insert_vals (bus->cell_indices, &idxCell, 1, -1) ;
                // Flag this cell in the master cell list as a member of some bus
                exp_array_index_1d (cell_list, BUS_LAYOUT_CELL, idxCell).bIsInBus = TRUE ;
                }
            gtk_tree_path_free (tpCells) ;
            }
          }
        }
      }
    gtk_tree_path_free (tp) ;
    }
  }
示例#24
0
gint
export_contacts_to_file(gchar *filename, gboolean header, GUI *appGUI) {

GtkTreePath *sort_path, *filter_path, *path;
gint i, j, a, b, c, e, n, m, max_field, exported;
gchar *text;
GtkTreeIter iter;
FILE *filehandle;
guint32 date;
gchar tmpbuf[BUFFER_SIZE];
gchar tmp_buffer_1[BUFFER_SIZE], tmp_buffer_2[BUFFER_SIZE];

    exported = 0;

    if (utl_gui_check_overwrite_file (filename, appGUI->cnt->export_window, appGUI) != 0) {
        return -1;
    }

    for(max_field = CONTACTS_NUM_COLUMNS-1; max_field >= 0; --max_field) {
        if(config.export_fields[max_field] == '+') break;
    }
    if (max_field == -1) {
        max_field = CONTACTS_NUM_COLUMNS-1;
    }

    filehandle = g_fopen (filename, "w");
    if(filehandle) {

        if (config.export_format == EXPORT_TO_XHTML) {
            fprintf(filehandle, "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n");
            fprintf(filehandle, "<html xmlns=\"http://www.w3.org/1999/xhtml\">\n");
            fprintf(filehandle, "<head>\n");
            fprintf(filehandle, "\t<title>Contact List</title>\n");
            fprintf(filehandle, "\t<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\" />\n");
            fprintf(filehandle, "\t<meta name=\"generator\" content=\"OSMO - http://clay.ll.pl/osmo\" />\n");
            fprintf(filehandle, "\t<style type=\"text/css\">\n");
            fprintf(filehandle, "\t\tbody { color:black; background-color:white; }\n");
            fprintf(filehandle, "\t\ta { color:#0000ff; }\n");
            fprintf(filehandle, "\t\ta:visited { color:#000055; }\n");
            fprintf(filehandle, "\t\ttable { border-collapse:collapse; }\n");
            fprintf(filehandle, "\t\ttr.header { background-color:#c0c0c0; }\n");
            fprintf(filehandle, "\t\ttr.evenrow { background-color:#f0f0f0; }\n");
            fprintf(filehandle, "\t\ttr.oddrow { background-color:#fafafa; }\n");
            fprintf(filehandle, "\t\tth, td { border:1px solid #555555; padding:3px; }\n");
            fprintf(filehandle, "\t</style>\n");
            fprintf(filehandle, "</head>\n\n");
            fprintf(filehandle, "<body>\n\n");
            fprintf(filehandle, "<h1>Contact List</h1>\n\n");

            fprintf(filehandle, "<table>\n");

            fprintf(filehandle, "<tr class=\"header\">\n");

            for(i=0; i < CONTACTS_NUM_COLUMNS; i++) {
                if(config.export_fields[i] == '+') {
                    fprintf(filehandle, "\t<th>");

                    if (appGUI->cnt->contact_fields_tags_name[i*2] != NULL) {
                        for(a=b=0; a < strlen(appGUI->cnt->contact_fields_tags_name[i*2]); a++) {
                            if(appGUI->cnt->contact_fields_tags_name[i*2][a] == ' ') {
                                tmpbuf[b] = '\0';
                                strcat(tmpbuf, "&nbsp;");
                                b += 6;
                            } else {
                                tmpbuf[b++] = appGUI->cnt->contact_fields_tags_name[i*2][a];
                            }
                        }
                        tmpbuf[b] = '\0';
                        fprintf(filehandle, "%s", tmpbuf);
                    }

                    fprintf(filehandle, "</th>\n");
                }
            }

            fprintf(filehandle, "</tr>\n\n");
        }

        j = 0;
        sort_path = gtk_tree_path_new_first ();

        while (gtk_tree_model_get_iter (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, sort_path) == TRUE) {

            if (sort_path != NULL) {

                filter_path = gtk_tree_model_sort_convert_path_to_child_path (GTK_TREE_MODEL_SORT(appGUI->cnt->contacts_sort), sort_path);

                if (filter_path != NULL) {

                    path = gtk_tree_model_filter_convert_path_to_child_path (GTK_TREE_MODEL_FILTER(appGUI->cnt->contacts_filter), filter_path);

                    if (path != NULL) {

                        gtk_tree_model_get_iter (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, path);

                        if (config.export_format == EXPORT_TO_XHTML) {
                            if(j & 1) {
                                fprintf(filehandle, "<tr class=\"evenrow\">\n");
                            } else {
                                fprintf(filehandle, "<tr class=\"oddrow\">\n");
                            }
                        } else if (config.export_format == EXPORT_TO_CSV && header == TRUE && j == 0) {

                            for(i=n=0; i < CONTACTS_NUM_COLUMNS; i++) {
                                if (i != COLUMN_PHOTO && i != COLUMN_ID && config.export_fields[i] == '+') {
                                    n++;
                                }
                            }
                            for(i=m=0; i < CONTACTS_NUM_COLUMNS; i++) {
                                if (i != COLUMN_PHOTO && i != COLUMN_ID && config.export_fields[i] == '+') {
                                    fprintf(filehandle, "%s", appGUI->cnt->contact_fields_tags_name[i*2]);
                                    if (m != n-1) {
                                        fprintf(filehandle, ",");
                                    }
                                    m++;
                                }
                            }
                            fprintf(filehandle, "\n");
                        }

                        for(i=0; i < CONTACTS_NUM_COLUMNS; i++) {

                            if(config.export_fields[i] == '+') {

                                if (i == COLUMN_BIRTH_DAY_DATE || i == COLUMN_NAME_DAY_DATE) {
                                    gtk_tree_model_get (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, i, &date, -1);
                                    if (date == 0) {
                                        text = NULL;
                                    } else {
                                        if (i == COLUMN_BIRTH_DAY_DATE) {
                                            text = g_strdup((const gchar *)julian_to_str(date, DATE_FULL, config.override_locale_settings));
                                        } else {
                                            text = g_strdup((const gchar *)julian_to_str(date, DATE_NAME_DAY, config.override_locale_settings));
                                        }
                                    }
                                } else {
                                    gtk_tree_model_get (GTK_TREE_MODEL(appGUI->cnt->contacts_list_store), &iter, i, &text, -1);
                                }

                                if (config.export_format == EXPORT_TO_XHTML) {
                                    fprintf(filehandle, "\t<td>");

                                    if (text != NULL) {

                                        for(a=b=0; a < strlen(text); a++) {
                                            if(text[a] == ' ') {
                                                tmpbuf[b] = '\0';
                                                strcat(tmpbuf, "&nbsp;");
                                                b += 6;
                                            } else {
                                                tmpbuf[b++] = text[a];
                                            }
                                        }
                                        tmpbuf[b] = '\0';

                                        switch (i) {
                                            case COLUMN_EMAIL_1:
                                            case COLUMN_EMAIL_2:
                                            case COLUMN_EMAIL_3:
                                            case COLUMN_EMAIL_4:
                                                fprintf(filehandle, "<a href=\"mailto:%s\">%s</a>", tmpbuf, tmpbuf);
                                                break;
                                            case COLUMN_WWW_1:
                                            case COLUMN_WWW_2:
                                            case COLUMN_WWW_3:
                                            case COLUMN_WWW_4:
                                            case COLUMN_BLOG:
                                                fprintf(filehandle, "<a href=\"%s\">%s</a>", tmpbuf, tmpbuf);
                                                break;
                                            default:
                                                fprintf(filehandle, "%s", tmpbuf);
                                        }
                                        g_free(text);
                                    }

                                    fprintf(filehandle, "</td>\n");

                                } else {
                                    /* CSV */

                                    if (text != NULL) {

                                        /* 1 */

                                        for(a = b = e = 0; a < strlen(text); a++) {
                                            if(text[a]=='"') {
                                                b = 1;
                                            }
                                            if(text[a]=='\n') {
                                                e = 1;              /* found new line */
                                            }
                                        }

                                        c = a = 0;

                                        if (b) {
                                            tmp_buffer_1[c++] = '"';
                                        }

                                        do {
                                            if(text[a]=='"') {
                                                tmp_buffer_1[c++] = '"';
                                            }
                                            tmp_buffer_1[c++] = text[a];
                                            a++;
                                        } while (text[a]!='\0');

                                        if(b) {
                                            tmp_buffer_1[c++] = '"';
                                        }
                                        tmp_buffer_1[c] = '\0';

                                        /* 2 */

                                        for(a = b = 0; a < strlen(tmp_buffer_1); a++) {
                                            if(tmp_buffer_1[a]==',') {
                                                b = 1;
                                            }
                                        }

                                        c = a = 0;

                                        if (b) {
                                            tmp_buffer_2[c++] = '"';
                                        }

                                        do {
                                            tmp_buffer_2[c++] = tmp_buffer_1[a];
                                            a++;
                                        } while (tmp_buffer_1[a]!='\0');

                                        if (b) {
                                            tmp_buffer_2[c++] = '"';
                                        }
                                        tmp_buffer_2[c] = '\0';

                                        if (e) {
                                            fprintf(filehandle, "\"%s\"", tmp_buffer_2);
                                        } else {
                                            fprintf(filehandle, "%s", tmp_buffer_2);
                                        }

                                        g_free(text);
                                    }

                                    if (i != max_field) {
                                        fprintf(filehandle, ",");
                                    }

                                }

                            }
                        }

                        if (config.export_format == EXPORT_TO_XHTML) {
                            fprintf(filehandle, "</tr>\n\n");
                        } else {
                            /* CSV */
                            fprintf(filehandle, "\n");
                        }

                        j++;
                        exported++;
                        gtk_tree_path_free(path);

                    }

                    gtk_tree_path_free(filter_path);
                }

            }

            gtk_tree_path_next (sort_path);
        }

        if (config.export_format == EXPORT_TO_XHTML) {
            fprintf(filehandle, "</table>\n");

            fprintf(filehandle, "</body>\n");
            fprintf(filehandle, "</html>\n");
        }

        fclose(filehandle);

    } else {

        utl_gui_create_dialog(GTK_MESSAGE_ERROR, _("Cannot create file."), GTK_WINDOW(appGUI->cnt->export_window));
        return -1;
    }

    return exported;
}
void 
AP_UnixDialog_Spell::_updateWindow (void)
{             
	GtkTextBuffer * buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(m_txWrong));
	GtkTextIter iter2;

	// Empty buffer
	gtk_text_buffer_set_text(buffer, "", -1);

	const UT_UCSChar *p;
	UT_sint32 iLength;
	// insert start of sentence
	p = m_pWordIterator->getPreWord(iLength);
	if (0 < iLength)
	{
		gchar * preword = (gchar*) _convertToMB(p, iLength);
		gtk_text_buffer_set_text(buffer, preword, -1);
		FREEP(preword);
	}

	// insert misspelled word (in highlight color)
	p = m_pWordIterator->getCurrentWord(iLength);
	gchar * word = (gchar*) _convertToMB(p, iLength);
	GtkTextTag * txt_tag = gtk_text_buffer_create_tag(buffer, NULL, "foreground-gdk", &m_highlight, NULL); 
	gtk_text_buffer_get_end_iter(buffer, &iter2);
	gtk_text_buffer_insert_with_tags(buffer, &iter2, word, -1, txt_tag, NULL);
	// word is freed at the end of the method...
	
	// insert end of sentence
	p = m_pWordIterator->getPostWord(iLength);
	if (0 < iLength)
	{
		gchar * postword = (gchar*) _convertToMB(p, iLength);
		gtk_text_buffer_get_end_iter(buffer, &iter2);
		gtk_text_buffer_insert(buffer, &iter2, postword, -1);
		FREEP(postword);
	}
	else
	{
		// Insert space to make gtk_text_buffer understand that it
		// really should highlight the selected word. This is a
		// workaround for bug 5459. It really should be fixed in GTK.
		gtk_text_buffer_get_end_iter(buffer, &iter2);
		gtk_text_buffer_insert(buffer, &iter2, " ", -1);
	}
	// TODO: set scroll position so misspelled word is centered


	GtkTreeModel *model = gtk_tree_view_get_model (GTK_TREE_VIEW (m_lvSuggestions));
	
	// Detach model for faster updates
	g_object_ref (G_OBJECT (model));	
	gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), NULL);
	gtk_list_store_clear (GTK_LIST_STORE (model));	
     
	GtkTreeSelection *selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (m_lvSuggestions));

	UT_DEBUGMSG (("ROB: AP_UnixDialog_Spell::_updateWindow() itemcount=%d\n", m_Suggestions->getItemCount ()));
	if (m_Suggestions->getItemCount () == 0) {

		GtkTreeIter iter;
		gtk_tree_selection_set_mode (selection, GTK_SELECTION_NONE);

		const XAP_StringSet * pSS = m_pApp->getStringSet();
		UT_UTF8String s;
		pSS->getValueUTF8(AP_STRING_ID_DLG_Spell_NoSuggestions,s);

		gtk_list_store_append (GTK_LIST_STORE (model), &iter);
		gtk_list_store_set (GTK_LIST_STORE (model), &iter, 
							COLUMN_SUGGESTION, s.utf8_str (),  
							COLUMN_NUMBER, -1,
							-1);

		g_signal_handler_block(G_OBJECT(m_eChange), m_replaceHandlerID);
		gtk_entry_set_text(GTK_ENTRY(m_eChange), word);
		g_signal_handler_unblock(G_OBJECT(m_eChange), m_replaceHandlerID);      
	} 
	else
	{

		GtkTreeIter iter;
		gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);

		gchar * suggest = NULL;   
		for (UT_sint32 i = 0; i < m_Suggestions->getItemCount(); i++)
		{
			suggest = (gchar*) _convertToMB((UT_UCSChar*)m_Suggestions->getNthItem(i));
			gtk_list_store_append (GTK_LIST_STORE (model), &iter);
			gtk_list_store_set (GTK_LIST_STORE (model), &iter, 
								COLUMN_SUGGESTION, suggest,  
								COLUMN_NUMBER, i,
								-1);
		}
		// put the first suggestion in the entry
		suggest = (gchar*) _convertToMB((UT_UCSChar*)m_Suggestions->getNthItem(0));
		g_signal_handler_block(G_OBJECT(m_eChange), m_replaceHandlerID);
		gtk_entry_set_text(GTK_ENTRY(m_eChange), suggest);
		g_signal_handler_unblock(G_OBJECT(m_eChange), m_replaceHandlerID);      
	}

	gtk_tree_view_set_model (GTK_TREE_VIEW (m_lvSuggestions), model);
	g_object_unref (G_OBJECT (model));	

	// select first
	if (m_Suggestions->getItemCount () > 0) {
		GtkTreePath *path = gtk_tree_path_new_first ();
		gtk_tree_selection_select_path (selection, path);
		gtk_tree_path_free (path);
	}

	FREEP (word);
}
示例#26
0
static void
combobox_changed (GtkComboBox    *combobox,
		  PanelRunDialog *dialog)
{
	char *text;
	char *start;
	char *msg;

	text = g_strdup (panel_run_dialog_get_combo_text (dialog));

	start = text;
	while (*start != '\0' && g_ascii_isspace (*start))
		start++;

	/* update item name to use for dnd */
	if (!dialog->use_program_list) {
		if (dialog->desktop_path) {
			g_free (dialog->desktop_path);
			dialog->desktop_path = NULL;
		}
		if (dialog->item_name) {
			g_free (dialog->item_name);
			dialog->item_name = NULL;
		}
	}

	/* desensitize run button if no text entered */
	if (!start || !start [0]) {
		g_free (text);

		gtk_widget_set_sensitive (dialog->run_button, FALSE);
		gtk_drag_source_unset (dialog->run_dialog);

		if (panel_profile_get_enable_program_list ())
			gtk_label_set_text (GTK_LABEL (dialog->program_label),
					    _("Select an application to view its description."));

		panel_run_dialog_set_default_icon (dialog, FALSE);

		if (dialog->find_command_idle_id) {
			g_source_remove (dialog->find_command_idle_id);
			dialog->find_command_idle_id = 0;
		}

		if (panel_profile_get_enable_program_list ()) {
			GtkTreeIter  iter;
			GtkTreePath *path;

			gtk_tree_model_foreach (GTK_TREE_MODEL (dialog->program_list_store),
						panel_run_dialog_make_all_list_visible,
						NULL);

			path = gtk_tree_path_new_first ();
			if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)),
						     &iter, path))
				gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list),
							      path, NULL,
							      FALSE, 0, 0);
			gtk_tree_path_free (path);
		}

		return;
	}

	gtk_widget_set_sensitive (dialog->run_button, TRUE);
	gtk_drag_source_set (dialog->run_dialog,
			     GDK_BUTTON1_MASK,
			     NULL, 0,
			     GDK_ACTION_COPY);
	gtk_drag_source_add_uri_targets (dialog->run_dialog);

	if (panel_profile_get_enable_program_list () &&
	    !dialog->use_program_list) {
		msg = g_strdup_printf (_("Will run command: '%s'"),
				       start);
		gtk_label_set_text (GTK_LABEL (dialog->program_label), msg);
		g_free (msg);
	}

	/* look up icon for the command */
	if (panel_profile_get_enable_program_list () &&
	    !dialog->use_program_list &&
	    !dialog->find_command_idle_id)
		dialog->find_command_idle_id =
			g_idle_add_full (G_PRIORITY_LOW,
					 (GSourceFunc) panel_run_dialog_find_command_idle,
					 dialog, NULL);

	g_free (text);
}
示例#27
0
/**
 * Function called first when try to print the  list
 * initialize the variables and calculate the number of pages
 *
 * \param operation	GtkPrintOperation
 * \param context	GtkPrintContext
 * \param null
 *
 * \return FALSE
 * */
gboolean print_tree_view_list_begin ( GtkPrintOperation *operation,
                        GtkPrintContext *context,
                        gpointer data )
{
    GtkTreeView *tree_view = ( GtkTreeView * ) data;
    gint size_line;
    gdouble lines_per_page_double;
    gint nbre_pages;

    devel_debug (NULL);

    /* we need to calculate the number of pages */
    cr = gtk_print_context_get_cairo_context ( context );

    /* get the size of the title */
    if ( title_string && strlen ( title_string ) )
        size_title = print_tree_view_list_get_title_size ( );
    else
        size_title = 0;

    /* get the size of a row */
    size_row = pango_font_description_get_size ( gsb_data_print_config_get_font_transactions () ) / PANGO_SCALE;
    size_line = size_row + gsb_data_print_config_get_draw_lines ( );

    /* get the size of the titles of columns */
    if ( gsb_data_print_config_get_draw_columns_name () )
    {
        nbre_lines_col_title = print_tree_view_list_get_columns_title_nbre_lines ( tree_view );
        size_columns_title = print_tree_view_list_get_columns_title_size ( nbre_lines_col_title );
    }
    else
        size_columns_title = 0;

    /* the heigh of a page decrease size_columns_title */
    page_height = gtk_print_context_get_height ( context );

    /* get total lines to print */
    total_lines_to_print = 0;
    total_lines_to_print = print_tree_view_list_set_rows_to_print ( tree_view );

    /* how much transactions we can show in a page : */
    lines_per_page_double = page_height / size_line;
    /* on enlève les lignes des titres des colonnes */
    lines_per_page_double -= nbre_lines_col_title;

    if ( !size_title ) /* no title */
    {
        nbre_pages = ceil ( total_lines_to_print / lines_per_page_double );
        lines_in_first_page = floor ( lines_per_page_double );
    }
    else
    {
        gint first_page_height;

        first_page_height = page_height - size_title;

        lines_in_first_page = floor ( first_page_height / size_line ) - nbre_lines_col_title;
        nbre_pages = 1 + ceil (  ( total_lines_to_print - lines_in_first_page ) /
                                    lines_per_page_double );
    }

    /* set the number of page */
    gtk_print_operation_set_n_pages ( GTK_PRINT_OPERATION ( operation ), nbre_pages );
    /* save the nb of rows per page */
    lines_per_page = floor ( lines_per_page_double );

    /* calculate the size and position of the columns */
    page_width = gtk_print_context_get_width ( context );
    print_tree_view_list_calculate_columns_width ( tree_view, page_width );

    if ( tree_path_to_print )
        gtk_tree_path_free ( tree_path_to_print );
    tree_path_to_print = gtk_tree_path_new_first ( );
    total_lines_printed = 0;
    current_row_to_print = 0;

    return FALSE;
}
示例#28
0
static gboolean
panel_run_dialog_find_command_idle (PanelRunDialog *dialog)
{
	GtkTreeIter   iter;
	GtkTreeModel *model;
	GtkTreePath  *path;
	char         *text;
	GIcon        *found_icon;
	char         *found_name;
	gboolean      fuzzy;

	model = GTK_TREE_MODEL (dialog->program_list_store);
	path = gtk_tree_path_new_first ();

	if (!path || !gtk_tree_model_get_iter (model, &iter, path)) {
		if (path)
			gtk_tree_path_free (path);

		panel_run_dialog_set_icon (dialog, NULL, FALSE);

		dialog->find_command_idle_id = 0;
		return FALSE;
	}

	text = g_strdup (panel_run_dialog_get_combo_text (dialog));
	found_icon = NULL;
	found_name = NULL;
	fuzzy = FALSE;

	do {
		char *exec = NULL;
		GIcon *icon = NULL;
		char *name = NULL;
		char *comment = NULL;

		gtk_tree_model_get (model, &iter,
				    COLUMN_EXEC,      &exec,
				    COLUMN_GICON,     &icon,
				    COLUMN_NAME,      &name,
				    COLUMN_COMMENT,   &comment,
				    -1);

		if (!fuzzy && exec && icon &&
		    fuzzy_command_match (text, exec, &fuzzy)) {
			g_clear_object (&found_icon);
			g_free (found_name);

			found_icon = g_object_ref (icon);
			found_name = g_strdup (name);

			gtk_list_store_set (dialog->program_list_store,
					    &iter,
					    COLUMN_VISIBLE, TRUE,
					    -1);
		} else if (panel_g_utf8_strstrcase (exec, text) != NULL ||
			   panel_g_utf8_strstrcase (name, text) != NULL ||
			   panel_g_utf8_strstrcase (comment, text) != NULL) {
			gtk_list_store_set (dialog->program_list_store,
					    &iter,
					    COLUMN_VISIBLE, TRUE,
					    -1);
		} else {
			gtk_list_store_set (dialog->program_list_store,
					    &iter,
					    COLUMN_VISIBLE, FALSE,
					    -1);
		}

		g_free (exec);
		g_object_unref (icon);
		g_free (name);
		g_free (comment);

        } while (gtk_tree_model_iter_next (model, &iter));

	if (gtk_tree_model_get_iter (gtk_tree_view_get_model (GTK_TREE_VIEW (dialog->program_list)),
				     &iter, path))
		gtk_tree_view_scroll_to_cell (GTK_TREE_VIEW (dialog->program_list),
					      path, NULL, FALSE, 0, 0);

	gtk_tree_path_free (path);

	panel_run_dialog_set_icon (dialog, found_icon, FALSE);
	//FIXME update dialog->program_label

	g_clear_object (&found_icon);
	g_free (text);

	g_free (dialog->item_name);
	dialog->item_name = found_name;

	dialog->find_command_idle_id = 0;
	return FALSE;
}
示例#29
0
void
so__dlg_preferences_construct_cb (GtkWidget  *dialog,
				  GthBrowser *browser,
				  GtkBuilder *dialog_builder)
{
	BrowserData      *data;
	GtkWidget        *notebook;
	GtkWidget        *page;
	GtkListStore     *model;
	GArray           *pixbuf_saver_types;
	int               i;
	GtkTreeSelection *treeselection;
	GtkTreePath      *path;
	GtkWidget        *label;

	data = g_new0 (BrowserData, 1);
	data->builder = _gtk_builder_new_from_file ("save-options-preferences.ui", "pixbuf_savers");

	notebook = _gtk_builder_get_widget (dialog_builder, "notebook");

	page = _gtk_builder_get_widget (data->builder, "preferences_page");
	gtk_widget_show (page);

	model = (GtkListStore *) gtk_builder_get_object (data->builder, "file_type_liststore");
	pixbuf_saver_types = gth_main_get_type_set ("pixbuf-saver");
	for (i = 0; (pixbuf_saver_types != NULL) && (i < pixbuf_saver_types->len); i++) {
		GthPixbufSaver *pixbuf_saver;
		GtkTreeIter     iter;
		GtkWidget      *options;

		pixbuf_saver = g_object_new (g_array_index (pixbuf_saver_types, GType, i), NULL);

		gtk_list_store_append (model, &iter);
		gtk_list_store_set (model, &iter,
				    FILE_TYPE_COLUMN_N, i,
				    FILE_TYPE_COLUMN_OBJ, pixbuf_saver,
				    FILE_TYPE_COLUMN_DISPLAY_NAME, gth_pixbuf_saver_get_display_name (pixbuf_saver),
				    -1);

		options = gth_pixbuf_saver_get_control (pixbuf_saver);
		gtk_widget_show (options);
		gtk_notebook_append_page (GTK_NOTEBOOK (_gtk_builder_get_widget (data->builder, "options_notebook")), options, NULL);

		data->pixbuf_saver = g_list_prepend (data->pixbuf_saver, pixbuf_saver);
	}

	treeselection = gtk_tree_view_get_selection (GTK_TREE_VIEW (_gtk_builder_get_widget (data->builder, "file_type_treeview")));
	gtk_tree_selection_set_mode (treeselection, GTK_SELECTION_BROWSE);
	g_signal_connect (treeselection,
			  "changed",
			  G_CALLBACK (treeselection_changed_cb),
			  dialog);

	label = gtk_label_new (_("Saving"));
	gtk_widget_show (label);

	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), page, label);
	g_object_set_data_full (G_OBJECT (dialog), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);

	path = gtk_tree_path_new_first ();
	gtk_tree_selection_select_path (treeselection, path);
	gtk_tree_path_free (path);
}
示例#30
0
void
cal_print_get_events (gchar *buffer, guint32 julian, GUI *appGUI)
{
	GtkTreePath *path;
	GtkTreeIter iter;
	GtkTreeModel *model;
	GSList *lnode;
	struct note *a;
	gint i;

	gchar *wbuf1, *wbuf2;
	gchar buf1[BUFFER_SIZE], buf2[BUFFER_SIZE];
	GDate *date, *sdate;
	gint age, syear;
	guint32 tsk_julian;
	gint time;
	gint max_event_length;
	GRegex *reg;

	buffer[0] = '\0';
	max_event_length = (config.cal_print_event_length + 2 > BUFFER_SIZE) ? BUFFER_SIZE : config.cal_print_event_length + 2;


#ifdef TASKS_ENABLED

	/* tasks */
	if (config.cal_print_tasks) {

		model = GTK_TREE_MODEL (appGUI->tsk->tasks_list_store);
		g_return_if_fail (model != NULL);

		path = gtk_tree_path_new_first ();

		while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {
			gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_DATE_JULIAN, &tsk_julian, TA_COLUMN_CATEGORY, &wbuf1, -1);

			if (tsk_julian == julian && tasks_category_get_state (wbuf1, STATE_CALENDAR, appGUI) == TRUE) {
				gtk_tree_model_get (model, &iter, TA_COLUMN_DUE_TIME, &time, TA_COLUMN_SUMMARY, &wbuf2, -1);

				if (time >= 0) {
					g_snprintf (buf1, max_event_length, "\n[%02d:%02d] %s", time / 3600, time / 60 % 60, wbuf2);
				} else {
					g_snprintf (buf1, max_event_length, "\n%s", wbuf2);
				}

				g_strlcat (buffer, buf1, BUFFER_SIZE);
				g_free (wbuf2);
			}

			g_free (wbuf1);
			gtk_tree_path_next (path);
		}

		gtk_tree_path_free (path);

	}

#endif  /* TASKS_ENABLED */

#ifdef CONTACTS_ENABLED

	/* birthdays */
	if (config.cal_print_birthdays) {

		model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store);
		g_return_if_fail (model != NULL);

		date = g_date_new ();
		g_return_if_fail (date != NULL);

		sdate = g_date_new_julian (julian);
		g_return_if_fail (sdate != NULL);

		syear = g_date_get_year (sdate);
		path = gtk_tree_path_new_first ();

		while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {
			gtk_tree_model_get (model, &iter, COLUMN_BIRTH_DAY_DATE, &tsk_julian, -1);

			if (g_date_valid_julian (tsk_julian)) {
				g_date_set_julian (date, tsk_julian);
				age = syear - g_date_get_year (date);

				if (age >= 0) {

					if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == FALSE) {
						g_date_subtract_days (date, 1);
					}
					g_date_set_year (date, syear);

					if (g_date_compare (date, sdate) == 0) {

						gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1);
						utl_name_strcat (wbuf1, wbuf2, buf2);

						g_snprintf (buf1, max_event_length, "\n%s (%d)", buf2, age);
						g_strlcat (buffer, buf1, BUFFER_SIZE);
					}
				}
			}
			gtk_tree_path_next (path);
		}

		gtk_tree_path_free (path);
		g_date_free (sdate);
		g_date_free (date);

	}

	/* name days */
	if (config.cal_print_namedays) {

		model = GTK_TREE_MODEL (appGUI->cnt->contacts_list_store);
		g_return_if_fail (model != NULL);

		date = NULL;
		date = g_date_new ();
		g_return_if_fail (date != NULL);

		sdate = NULL;
		sdate = g_date_new_julian (julian);
		g_return_if_fail (sdate != NULL);

		syear = g_date_get_year (sdate);
		path = gtk_tree_path_new_first ();

		while (gtk_tree_model_get_iter (model, &iter, path) == TRUE) {
			gtk_tree_model_get (model, &iter, COLUMN_NAME_DAY_DATE, &tsk_julian, -1);

			if (g_date_valid_julian (tsk_julian)) {
				g_date_set_julian (date, tsk_julian);

				if (g_date_valid_dmy (g_date_get_day (date), g_date_get_month (date), syear) == TRUE) {
					g_date_set_year (date, syear);

					if (g_date_compare (date, sdate) == 0) {

						gtk_tree_model_get (model, &iter, COLUMN_FIRST_NAME, &wbuf1, COLUMN_LAST_NAME, &wbuf2, -1);
						utl_name_strcat (wbuf1, wbuf2, buf1);

						g_snprintf (buf2, max_event_length, "\n%s (%s)", buf1, _("Name day"));
						g_strlcat (buffer, buf2, BUFFER_SIZE);
					}
				}
			}
			gtk_tree_path_next (path);
		}

		gtk_tree_path_free (path);
		g_date_free (sdate);
		g_date_free (date);

	}

#endif  /* CONTACTS_ENABLED */

	/* day note */
	if (config.cal_print_day_notes) {

		if (appGUI->cal->notes_list != NULL) {

			wbuf1 = NULL;
			reg = g_regex_new ("\n", 0, 0, NULL);

			for (i = 0, lnode = appGUI->cal->notes_list; lnode != NULL; lnode = lnode->next, i++) {
				a = g_slist_nth_data (appGUI->cal->notes_list, i);

				if (a->date == julian) {
					wbuf1 = g_regex_replace_literal (reg, a->note, -1, 0, " ", 0, NULL);
					break;
				}
			}

			g_regex_unref (reg);
		}

		if (wbuf1 != NULL) {
			g_strstrip (wbuf1);
			g_snprintf (buf1, max_event_length, "\n%s", wbuf1);
			g_strlcat (buffer, buf1, BUFFER_SIZE);
			g_free (wbuf1);
		}

	}

#ifdef HAVE_LIBICAL

	/* ical */
	if (config.cal_print_ical) {


	}

#endif  /* HAVE_LIBICAL */

	g_strstrip (buffer);

}