Пример #1
0
/*
 * Shift entry up
 */
gboolean shift_entry_up()
{
	GtkTreePath *entry_path = NULL;
	GtkTreeView *entry_view = NULL;
	GtkTreeModel *entry_model = NULL;
	GtkTreeSelection *entry_selection = NULL;
	GtkTreeViewColumn *entry_column = NULL;
	GtkTreeIter entry_iter;
	book_data *book = NULL;
	section_data *section = NULL;
	entry_data *entry = NULL;
	guint entry_index = 0;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();

	// Get entry model and view
	entry_view = get_entry_view(book);
	entry_model = gtk_tree_view_get_model(entry_view);

	sn_trace0("Shifting entry up.");

	// Make sure we are not at the top
	gtk_tree_view_get_cursor
		(entry_view, &entry_path, &entry_column);
	if(entry_path != NULL) {
		if(gtk_tree_path_prev(entry_path)) {

			// Get the entry to move up
			entry_selection = gtk_tree_view_get_selection(entry_view);
			if(gtk_tree_selection_get_selected
				(entry_selection, &entry_model, &entry_iter)) {
				gtk_tree_model_get(entry_model, &entry_iter,
					ENTRY_ITEM, &entry, END_OF_LIST);

				// Move entry up
				if(entry != NULL) {
					entry_index = g_list_index(section->entry_list, entry);
					section->entry_list = g_list_remove(section->entry_list, entry);
					section->entry_list = g_list_insert
						(section->entry_list, entry, --entry_index);

					// Write book
					write_book(book, note_dir);
				}
			}
			// Populate entries
			populate_entries(book, section);
			gtk_tree_view_set_cursor
				(entry_view, entry_path, entry_column, FALSE);
		}
	gtk_tree_path_free(entry_path);
	}

	return TRUE;
} // Shift entry up
Пример #2
0
void
setup(void)
{
	WT_CONNECTION *conn;
	WT_SESSION *session;
	int ret;
	char config[512];

	if ((ret = system("rm -f WiredTiger* *.bf")) != 0)
		testutil_die(ret, "system cleanup call failed");

	/*
	 * This test doesn't test public Wired Tiger functionality, it still
	 * needs connection and session handles.
	 */

	/*
	 * Open configuration -- put command line configuration options at the
	 * end so they can override "standard" configuration.
	 */
	snprintf(config, sizeof(config),
	    "create,error_prefix=\"%s\",cache_size=%" PRIu32 "MB,%s",
	    g.progname, g.c_cache, g.config_open == NULL ? "" : g.config_open);

	testutil_check(wiredtiger_open(NULL, NULL, config, &conn));

	testutil_check(conn->open_session(conn, NULL, NULL, &session));

	g.wt_conn = conn;
	g.wt_session = session;
	populate_entries();
}
Пример #3
0
/**
 * Attempt to access PCI subsystem using Linux's sysfs interface.
 */
_pci_hidden int
pci_system_linux_sysfs_create( void )
{
    int err = 0;
    struct stat st;


    /* If the directory "/sys/bus/pci/devices" exists, then the PCI subsystem
     * can be accessed using this interface.
     */

    if ( stat( SYS_BUS_PCI, & st ) == 0 ) {
	pci_sys = calloc( 1, sizeof( struct pci_system ) );
	if ( pci_sys != NULL ) {
	    pci_sys->methods = & linux_sysfs_methods;
#ifdef HAVE_MTRR
	    pci_sys->mtrr_fd = open("/proc/mtrr", O_WRONLY | O_CLOEXEC);
#endif
	    err = populate_entries(pci_sys);
	}
	else {
	    err = ENOMEM;
	}
    }
    else {
	err = errno;
    }

    return err;
}
Пример #4
0
void on_action_entryDelete_activate(GtkAction *action, gpointer user_data)
{
  struct s_gui_data *gui_data = (struct s_gui_data *)user_data;
  GtkTreeSelection *selection;
  GtkTreeModel     *model;
  GtkTreeIter       iter;  
  selection = gtk_tree_view_get_selection(gui_data->treeviewEntries);
  if (gtk_tree_selection_get_selected(selection, &model, &iter))
  {
    gchar *path;    
    gtk_tree_model_get (model, &iter, COL_ENTRY_PATH, &path, -1);
    monconf_entry *entry = monconf_entry_get_by_path(gui_data->conf, path);
    
    GtkWidget *dialog;    
    dialog = gtk_message_dialog_new(GTK_WINDOW(gui_data->windowMain),
	      GTK_DIALOG_DESTROY_WITH_PARENT,
	      GTK_MESSAGE_QUESTION,
	      GTK_BUTTONS_YES_NO,
	      "Remove the entry '%s'?",path);
    gtk_window_set_title(GTK_WINDOW(dialog), "Remove Entry");
    if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_YES)
    {
      monconf_remove_entry(gui_data->conf, entry);
      populate_entries(gui_data);
    }
    gtk_widget_destroy(dialog);      
    g_free(path);
  }
}
Пример #5
0
static void test_slice_hash_table() {
  const test_entry test_entries[] = {
      {"key_0", "value_0"},   {"key_1", "value_1"},   {"key_2", "value_2"},
      {"key_3", "value_3"},   {"key_4", "value_4"},   {"key_5", "value_5"},
      {"key_6", "value_6"},   {"key_7", "value_7"},   {"key_8", "value_8"},
      {"key_9", "value_9"},   {"key_10", "value_10"}, {"key_11", "value_11"},
      {"key_12", "value_12"}, {"key_13", "value_13"}, {"key_14", "value_14"},
      {"key_15", "value_15"}, {"key_16", "value_16"}, {"key_17", "value_17"},
      {"key_18", "value_18"}, {"key_19", "value_19"}, {"key_20", "value_20"},
      {"key_21", "value_21"}, {"key_22", "value_22"}, {"key_23", "value_23"},
      {"key_24", "value_24"}, {"key_25", "value_25"}, {"key_26", "value_26"},
      {"key_27", "value_27"}, {"key_28", "value_28"}, {"key_29", "value_29"},
      {"key_30", "value_30"}, {"key_31", "value_31"}, {"key_32", "value_32"},
      {"key_33", "value_33"}, {"key_34", "value_34"}, {"key_35", "value_35"},
      {"key_36", "value_36"}, {"key_37", "value_37"}, {"key_38", "value_38"},
      {"key_39", "value_39"}, {"key_40", "value_40"}, {"key_41", "value_41"},
      {"key_42", "value_42"}, {"key_43", "value_43"}, {"key_44", "value_44"},
      {"key_45", "value_45"}, {"key_46", "value_46"}, {"key_47", "value_47"},
      {"key_48", "value_48"}, {"key_49", "value_49"}, {"key_50", "value_50"},
      {"key_51", "value_51"}, {"key_52", "value_52"}, {"key_53", "value_53"},
      {"key_54", "value_54"}, {"key_55", "value_55"}, {"key_56", "value_56"},
      {"key_57", "value_57"}, {"key_58", "value_58"}, {"key_59", "value_59"},
      {"key_60", "value_60"}, {"key_61", "value_61"}, {"key_62", "value_62"},
      {"key_63", "value_63"}, {"key_64", "value_64"}, {"key_65", "value_65"},
      {"key_66", "value_66"}, {"key_67", "value_67"}, {"key_68", "value_68"},
      {"key_69", "value_69"}, {"key_70", "value_70"}, {"key_71", "value_71"},
      {"key_72", "value_72"}, {"key_73", "value_73"}, {"key_74", "value_74"},
      {"key_75", "value_75"}, {"key_76", "value_76"}, {"key_77", "value_77"},
      {"key_78", "value_78"}, {"key_79", "value_79"}, {"key_80", "value_80"},
      {"key_81", "value_81"}, {"key_82", "value_82"}, {"key_83", "value_83"},
      {"key_84", "value_84"}, {"key_85", "value_85"}, {"key_86", "value_86"},
      {"key_87", "value_87"}, {"key_88", "value_88"}, {"key_89", "value_89"},
      {"key_90", "value_90"}, {"key_91", "value_91"}, {"key_92", "value_92"},
      {"key_93", "value_93"}, {"key_94", "value_94"}, {"key_95", "value_95"},
      {"key_96", "value_96"}, {"key_97", "value_97"}, {"key_98", "value_98"},
      {"key_99", "value_99"},
  };
  const size_t num_entries = GPR_ARRAY_SIZE(test_entries);
  // Construct table.
  grpc_slice_hash_table_entry* entries =
      gpr_zalloc(sizeof(*entries) * num_entries);
  populate_entries(test_entries, num_entries, entries);
  grpc_slice_hash_table* table =
      grpc_slice_hash_table_create(num_entries, entries, destroy_string);
  gpr_free(entries);
  // Check contents of table.
  check_values(test_entries, num_entries, table);
  check_non_existent_value("XX", table);
  // Clean up.
  grpc_exec_ctx exec_ctx = GRPC_EXEC_CTX_INIT;
  grpc_slice_hash_table_unref(&exec_ctx, table);
  grpc_exec_ctx_finish(&exec_ctx);
}
Пример #6
0
void on_action_entryDuplicate_activate(GtkAction *action, gpointer user_data)
{
  GtkTreeSelection *selection;
  GtkTreeModel     *model;
  GtkTreeIter       iter;  
  monconf_entry    *dupl_entry;
  struct s_gui_data *gui_data = (struct s_gui_data *)user_data;
  
  selection = gtk_tree_view_get_selection(gui_data->treeviewEntries);
  if (gtk_tree_selection_get_selected(selection, &model, &iter))
  {
    gchar *path;    
    gtk_tree_model_get (model, &iter, COL_ENTRY_PATH, &path, -1);
    monconf_entry *entry = monconf_entry_get_by_path(gui_data->conf, path);
    dupl_entry = monconf_entry_duplicate(gui_data->conf, entry);    
    populate_entries(gui_data);
  }
}
Пример #7
0
int main (int argc, char *argv[])
{ 
  char *cwd;
  char *glade_path;
  struct s_gui_data data;  
  config_args args;
  args.config_path = NULL;
  monconf_parse_cli_args(&args, argc, argv);  
    
  monconf_prepare_config_directory();
  monconf *conf = monconf_create();
  monconf_read_config(conf, args.config_path);
  monconf_load_available_actions(conf);
  data.rstart.active = 0;
  data.lstart.active = 0;
  
  gtk_init (&argc, &argv);
  
  data.builder = gtk_builder_new ();
  glade_path = monconf_resolve_path("ui-glade/monarqui_gui.glade");
  gtk_builder_add_from_file (data.builder, glade_path, NULL);  
  g_free(glade_path);
  data.builder = GTK_BUILDER(data.builder);
  data.windowMain = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowMain"));
  data.windowEntry = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowEntry"));
  data.windowConfig = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowConfig"));
  data.windowAction = GTK_WIDGET(gtk_builder_get_object (data.builder, "windowAction"));
  data.action_mainExit = GTK_ACTION(gtk_builder_get_object(data.builder, "action_mainExit"));
  data.action_configOpen = GTK_ACTION(gtk_builder_get_object(data.builder, "action_configOpen"));
  data.action_configClose = GTK_ACTION(gtk_builder_get_object(data.builder, "action_configClose"));
  data.action_startPause = GTK_ACTION(gtk_builder_get_object(data.builder, "action_startPause"));
  data.action_entryAdd = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryAdd"));
  data.action_entryModify = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryModify"));
  data.action_entryDuplicate = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryDuplicate"));
  data.action_entryDelete = GTK_ACTION(gtk_builder_get_object(data.builder, "action_entryDelete"));
  data.action_actionAdd = GTK_ACTION(gtk_builder_get_object(data.builder, "action_actionAdd"));
  data.action_actionModify = GTK_ACTION(gtk_builder_get_object(data.builder, "action_actionModify"));
  data.action_actionDelete = GTK_ACTION(gtk_builder_get_object(data.builder, "action_actionDelete"));
  data.action_saveConfig = GTK_ACTION(gtk_builder_get_object(data.builder, "action_saveConfig"));  
  data.action_toggleApplication = GTK_ACTION(gtk_builder_get_object(data.builder, "action_toggleApplication"));
  data.action_systrayPopup = GTK_ACTION(gtk_builder_get_object(data.builder, "action_systrayPopup"));
  data.image_startStop = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_startStop"));  
  data.systrayIcon = GTK_STATUS_ICON(gtk_builder_get_object(data.builder,"systrayIcon"));  
  data.args = &args;
  data.conf = conf;
  data.treeviewActions = GTK_TREE_VIEW(gtk_builder_get_object(data.builder,"treeviewActions"));
  data.treeviewEntries = GTK_TREE_VIEW(gtk_builder_get_object(data.builder,"treeviewEntries"));
  data.treeviewEntryActions = GTK_TREE_VIEW(gtk_builder_get_object(data.builder,"treeviewEntryActions"));
  data.listStoreActions = GTK_LIST_STORE(gtk_builder_get_object(data.builder,"listStoreActions"));  
  data.listStoreEntries = GTK_LIST_STORE(gtk_builder_get_object(data.builder,"listStoreEntries"));
  data.listStoreEntryActions = GTK_LIST_STORE(gtk_builder_get_object(data.builder,"listStoreEntryActions"));  
  
  data.image_started = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_started"));
  data.image_started_event = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_started_event"));
  data.image_stopped = GTK_IMAGE(gtk_builder_get_object(data.builder,"image_stopped"));
  data.logged_event = FALSE;
  data.textbufferLog = GTK_TEXT_BUFFER(gtk_builder_get_object(data.builder, "textbufferLog"));
  
  data.systrayMenu = GTK_MENU(gtk_menu_new());
  data.systrayMenuItem_startStop = GTK_MENU_ITEM(gtk_menu_item_new_with_label("Start"));
  data.systrayMenuItem_quit = GTK_MENU_ITEM(gtk_menu_item_new_with_label("Quit"));  
  
  
  gtk_menu_shell_append(GTK_MENU_SHELL(data.systrayMenu), GTK_WIDGET(data.systrayMenuItem_startStop));
  gtk_menu_shell_append(GTK_MENU_SHELL(data.systrayMenu), GTK_WIDGET(data.systrayMenuItem_quit));
    
  gtk_action_set_label(data.action_startPause, "Start");
  gtk_builder_connect_signals (data.builder, (gpointer)&data);    
     
  gtk_image_set_from_icon_name(data.image_startStop, ICON_NAME_START, GTK_ICON_SIZE_BUTTON);          
  gtk_status_icon_set_from_pixbuf(data.systrayIcon, gtk_image_get_pixbuf(data.image_stopped));
  populate_entries(&data);  
  populate_actions(&data);
  gtk_widget_show (data.windowMain);                
  gtk_main ();
  g_object_unref (G_OBJECT (data.builder));
  free(args.config_path);
  return 0;
}
Пример #8
0
void on_action_entrySave_activate(GtkAction *action, gpointer user_data)
{
  struct s_gui_data *gui_data = (struct s_gui_data *)user_data; 
  GList *list_item;
  monconf *conf = gui_data->conf;
  monconf_action_entry *action_entry;
  GtkTreeModel *model;
  GtkTreeIter iter;
  if(gui_data->curr_entry != NULL)
  {
    g_free(gui_data->curr_entry->file_name);
  }
  else
  {
    gui_data->curr_entry = monconf_new_entry(gui_data->conf);
  }
  monconf_entry_add_ignores_from_csv(gui_data->curr_entry, (char *)gtk_entry_get_text(GTK_ENTRY(gtk_builder_get_object(gui_data->builder,"entryIgnores"))));
  gui_data->curr_entry->file_name = g_strdup(gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(gtk_builder_get_object(gui_data->builder,"filechooserPath"))));
  gui_data->curr_entry->recursive = (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxRecursive"))->toggle_button)) ? TRUE : FALSE);
  gui_data->curr_entry->events = 
    (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxOnCreate"))->toggle_button)) ? MON_CREATE : 0)
    | (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxOnModify"))->toggle_button)) ? MON_MODIFY: 0)
    | (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxOnDelete"))->toggle_button)) ? MON_DELETE: 0)
    | (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxOnAttrib"))->toggle_button)) ? MON_ATTRIB: 0)
    | (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxOnMovedFrom"))->toggle_button)) ? MON_MOVED_FROM : 0)
    | (gtk_toggle_button_get_active(&(GTK_CHECK_BUTTON(gtk_builder_get_object(gui_data->builder,"checkboxOnMovedTo"))->toggle_button)) ? MON_MOVED_TO: 0);  
  
  short int valid;
  gboolean enabled, event_create, event_modify, event_delete, event_attribs, event_move_from, event_move_to;
  gchar *action_name, *globs;
  model = gtk_tree_view_get_model(gui_data->treeviewEntryActions);  
  valid = gtk_tree_model_get_iter_first(model, &iter);
  while(valid)
  {    
    gboolean move_next = TRUE;
    gtk_tree_model_get(model, &iter,
		       COL_ACTION_ENTRY_ENABLED, &enabled, 
		       COL_ACTION_ENTRY_NAME, &action_name,
		       COL_ACTION_ENTRY_GLOBS, &globs,
		       COL_ACTION_ENTRY_CREATE, &event_create,
		       COL_ACTION_ENTRY_MODIFY, &event_modify,
		       COL_ACTION_ENTRY_DELETE, &event_delete,
		       COL_ACTION_ENTRY_ATTRIBS, &event_attribs,
		       COL_ACTION_ENTRY_MOVED_FROM, &event_move_from,
		       COL_ACTION_ENTRY_MOVED_TO, &event_move_to,
		       -1);
    action_entry = monconf_action_entry_get_by_name(gui_data->curr_entry, action_name);
    if(!enabled)
    {
      if(action_entry)
      {	
	monconf_entry_remove_action_entry(gui_data->curr_entry, action_entry);	
	move_next=0;
      }
    }	
    else
    {
      if(!action_entry) 
      {
	action_entry = monconf_entry_new_action(gui_data->curr_entry);
	action_entry->action = monconf_action_get_by_name(conf, action_name);	
      }
      monconf_action_entry_add_globs_from_csv(action_entry, globs);
      action_entry->events =
	(event_create ? MON_CREATE : 0)
	| (event_modify ? MON_MODIFY: 0)
	| (event_delete ? MON_DELETE : 0)
	| (event_attribs ? MON_ATTRIB : 0)
	| (event_move_from ? MON_MOVED_FROM : 0)
	| (event_move_to ? MON_MOVED_TO : 0);		
    }    
    g_free(action_name);
    g_free(globs); 
    valid = gtk_tree_model_iter_next(model, &iter);
  }
  
  populate_entries(gui_data);  
}
Пример #9
0
/*
 * Move entry
 * Signal handler for "activate" move entry
 */
gboolean move_entry()
{
	FILE *fp = NULL;
	GtkWidget *msg_dialog = NULL;
	GtkWidget *section_dialog = NULL;
	GtkWidget *section_view = NULL;
	GtkTreeModel *section_model = NULL;
	GtkTreeSelection *section_selection = NULL;
	GtkTreeIter section_iter;
	gchar entry_display_name[MAX_NAME_LEN];
	gchar curr_entry_path[MAX_PATH_LEN];
	gchar move_entry_path[MAX_PATH_LEN];
	GList *entry_item = NULL;
	book_data *book = NULL;
	section_data *section = NULL;
	entry_data *entry = NULL;
	book_data *book_copy = NULL;
	section_data *section_copy = NULL;
	gint result;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();
	entry = get_current_entry_or_return_with_warning();

	// Create section view
	section_view = gtk_tree_view_new();

	// Create section dialog
	section_dialog = create_book_section_dialog(section_view,
		"Select the section to move the entry to...");

	// Init section view
	init_book_section_view(GTK_TREE_VIEW(section_view));

	// Create section entry model / store
	section_model = create_book_section_model(master);

	// Set section model on section view
	gtk_tree_view_set_model(GTK_TREE_VIEW(section_view),
		GTK_TREE_MODEL(section_model));
	if(section_model != NULL)
		g_object_unref(section_model);

	// Show and run view section dialog
	gtk_widget_show_all(section_dialog);
	result = gtk_dialog_run(GTK_DIALOG(section_dialog));

	switch (result) {
	case GTK_RESPONSE_ACCEPT:

		section_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(section_view));
		if(gtk_tree_selection_get_selected(section_selection,
				&section_model, &section_iter)) {

			gtk_tree_model_get(section_model, &section_iter, SECTION_ITEM,
				&section_copy, END_OF_LIST);

			if(section == NULL) {
				gtk_widget_destroy(section_dialog);
				return FALSE;
			}
		} else {
			gtk_widget_destroy(section_dialog);
			return FALSE;
		}

		book_copy = section_copy->parent_book;

		// Curr entry file path
		g_snprintf(curr_entry_path, sizeof(curr_entry_path),
			"%s%s%s%s%s%s%s.txt",
			note_dir, G_DIR_SEPARATOR_S,
			book->name, G_DIR_SEPARATOR_S,
			section->name, G_DIR_SEPARATOR_S,
			entry->name);

		// Move entry file path
		g_snprintf(move_entry_path, sizeof(move_entry_path),
			"%s%s%s%s%s%s%s.txt",
			note_dir, G_DIR_SEPARATOR_S,
			book_copy->name, G_DIR_SEPARATOR_S,
			section_copy->name, G_DIR_SEPARATOR_S,
			entry->name);

		// Set display name
		strncpy(entry_display_name, entry->name, MAX_NAME_LEN-5);
		if(strlen(entry_display_name) > 25)
			strcpy(entry_display_name+25, "...\0");

		// Check that new entry path is valid
		fp = fopen(move_entry_path, "wx");

		if (fp == NULL) {
			sn_warning("Unable to move entry [%s].", move_entry_path);

			msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_MODAL,
				GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
				"Unable to move entry \"%s\".", entry_display_name);
			gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
				"Please ensure the entry name doesn't aleady exist.");
			gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
			gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
			gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);
			result = gtk_dialog_run(GTK_DIALOG(msg_dialog));

			gtk_widget_destroy(msg_dialog);
			gtk_widget_destroy(section_dialog);
			return FALSE;
		}
		fclose(fp);

		// Remove file created by previous open
		result = remove(move_entry_path);

		sn_trace("Moving entry [%s] to [%s].", curr_entry_path, move_entry_path);

		// Move the entry file to the new path
		result = rename(curr_entry_path, move_entry_path);

		if(result == 0) {

			// Remove history
			remove_history();

			// Select next entry
			entry_item = g_list_find(section->entry_list, entry);
			entry_item = entry_item->next;
			if(entry_item != NULL)
				section->curr_entry = entry_item->data;
			else
				section->curr_entry = NULL;

			// Remove entry
			section->entry_list = g_list_remove(section->entry_list, entry);

			// Append entry
			section_copy->entry_list = g_list_append(section_copy->entry_list, entry);

			// Update entry
			entry->parent_section = section_copy;

			// Write book
			write_book(book, note_dir);

			// Update view
			populate_entries(book, section);
			
			gtk_widget_destroy(section_dialog);
			return TRUE;

		} else {
			gtk_widget_destroy(section_dialog);
			sn_warning("Unable to move entry [%s].", curr_entry_path);
			return FALSE;
		}
		gtk_widget_destroy(section_dialog);
		return FALSE;

	default:
		gtk_widget_destroy(section_dialog);
		return FALSE;

	} // End switch

	return FALSE;
} // Move entry
Пример #10
0
/*
 * Rename entry
 * Signal handler for "activate" rename entry
 */
gboolean rename_entry()
{
	FILE *fp = NULL;
	GtkWidget *name_dialog = NULL;
	GtkWidget *msg_dialog = NULL;
	GtkWidget *vbox = NULL;
	GtkWidget *hbox = NULL;
	GtkWidget *label = NULL;
	GtkWidget *name_entry = NULL;
	const gchar *entry_text = NULL;
	gchar old_entry_display_name[MAX_NAME_LEN];
	gchar new_entry_display_name[MAX_NAME_LEN];
	gchar new_entry_name[MAX_PATH_LEN];
	gchar old_entry_name[MAX_PATH_LEN];
	book_data *book = NULL;
	section_data *section = NULL;
	entry_data *entry = NULL;
	gchar *temp_string;
	gint result;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();
	entry = get_current_entry_or_return_with_warning();

	// Write current entry
	write_current_entry();

	// Create name dialog
	name_dialog = gtk_dialog_new_with_buttons(app_name, GTK_WINDOW(main_window),
			GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
			GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
			GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
	gtk_widget_set_size_request(name_dialog, SM_DLG_WIDTH, SM_DLG_HEIGHT);
	gtk_window_set_type_hint(GTK_WINDOW(name_dialog), GDK_WINDOW_TYPE_HINT_MENU);
	gtk_window_set_resizable(GTK_WINDOW(name_dialog), FALSE);

	label = gtk_label_new("Enter new entry name...");
	name_entry = gtk_entry_new();
	gtk_entry_set_max_length(GTK_ENTRY(name_entry), MAX_NAME_LEN-5);

	// Get auto name
	if(options.auto_name_entry == TRUE) {

		temp_string = g_malloc0(MAX_NAME_LEN);
		strdelchr(temp_string, get_auto_entry_name(get_text_view(book)), ILLEGAL_CHARS);
		temp_string[MAX_NAME_LEN-5] = 0;
		if(strcmp(temp_string, "") == 0)
			gtk_entry_set_text(GTK_ENTRY(name_entry), entry->name);
		else
			gtk_entry_set_text(GTK_ENTRY(name_entry), temp_string);
		g_free(temp_string);
	} else {

		gtk_entry_set_text(GTK_ENTRY(name_entry), entry->name);
	}

	vbox = gtk_dialog_get_content_area(GTK_DIALOG(name_dialog));

	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);

	hbox = gtk_hbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), name_entry, TRUE, TRUE, 5);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 5);

	gtk_entry_set_activates_default(GTK_ENTRY(name_entry), TRUE);
	gtk_dialog_set_default_response (GTK_DIALOG(name_dialog),GTK_RESPONSE_ACCEPT);
	gtk_widget_show_all(name_dialog);

	// Run dialog
	result = gtk_dialog_run(GTK_DIALOG(name_dialog));

	switch (result) {
	case GTK_RESPONSE_ACCEPT:

		entry_text = gtk_entry_get_text(GTK_ENTRY(name_entry));

		// Scan name for illegal characters
		temp_string = g_malloc0(MAX_NAME_LEN);
		strdelchr(temp_string, entry_text, ILLEGAL_CHARS);
		gtk_entry_set_text(GTK_ENTRY(name_entry), temp_string);
		g_free(temp_string);
		entry_text = gtk_entry_get_text(GTK_ENTRY(name_entry));

		// Old entry file
		g_snprintf(old_entry_name, sizeof(old_entry_name),
			"%s%s%s%s%s%s%s.txt",
			note_dir, G_DIR_SEPARATOR_S,
			book->name, G_DIR_SEPARATOR_S,
			section->name, G_DIR_SEPARATOR_S,
			entry->name);

		// New entry file
		g_snprintf(new_entry_name, sizeof(new_entry_name),
			"%s%s%s%s%s%s%s.txt",
			note_dir, G_DIR_SEPARATOR_S,
			book->name, G_DIR_SEPARATOR_S,
			section->name, G_DIR_SEPARATOR_S,
			entry_text);

		// Ignore rename if names match
		if(strcmp(entry->name, entry_text) == 0) {
			gtk_widget_destroy(name_dialog);
			return TRUE;
		}

		// Set display name
		strncpy(old_entry_display_name, entry->name, MAX_NAME_LEN-5);
		if(strlen(old_entry_display_name) > 25)
			strcpy(old_entry_display_name+25, "...\0");

		strncpy(new_entry_display_name, entry_text, MAX_NAME_LEN-5);
		if(strlen(new_entry_display_name) > 25)
			strcpy(new_entry_display_name+25, "...\0");

		// Check that new entry name is valid
		if(strlen(entry_text) < 1) {

			sn_warning("Unable to rename entry [%s] to [%s].",
				entry->name, entry_text);

			msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window),
				GTK_DIALOG_MODAL, GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
				"Unable to rename entry \"%s\" to \"%s\".",
				old_entry_display_name, new_entry_display_name);
			gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
				"Please ensure the entry name contains a valid character.");
			gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
			gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
			gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);
			result = gtk_dialog_run(GTK_DIALOG(msg_dialog));

			gtk_widget_destroy(name_dialog);
			gtk_widget_destroy(msg_dialog);
			return FALSE;
		}

		// Check that new entry name is valid
		fp = fopen(new_entry_name, "wx");
		if (fp == NULL) {
			sn_warning("Unable to rename entry [%s] to [%s].",
				entry->name, entry_text);

			msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_MODAL,
				GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
				"Unable to rename entry \"%s\" to \"%s\".",
				old_entry_display_name, new_entry_display_name);
			gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
				"Please ensure the entry name doesn't aleady exist.");
			gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
			gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
			gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);
			result = gtk_dialog_run(GTK_DIALOG(msg_dialog));

			gtk_widget_destroy(name_dialog);
			gtk_widget_destroy(msg_dialog);
			return FALSE;

		}
		fclose(fp);

		sn_trace("Renaming entry [%s] to [%s].", entry->name, entry_text);

		// Rename entry file
		result = rename(old_entry_name, new_entry_name);

		if(result == 0) {

			// Remove history
			remove_history();

			// Update entry
			strcpy(entry->name, entry_text);

			// Update book
			write_book(book, note_dir);

			// Update view
			populate_entries(book, section);
			on_entry_change(get_entry_view(book), book);

			gtk_widget_destroy(name_dialog);
			return TRUE;
		} else {
			sn_warning("Unable to rename entry [%s].", entry->name);
			gtk_widget_destroy(name_dialog);
			return FALSE;
		}

	default:
		gtk_widget_destroy(name_dialog);
		return FALSE;

	} // End switch

	return FALSE;
} // Rename entry
Пример #11
0
/*
 * Create entry
 * Signal handler for "activate" create entry
 */
gboolean create_entry()
{
	FILE *fp = NULL;
	gchar entry_name[MAX_NAME_LEN];
	gchar filename[MAX_PATH_LEN];
	GtkTreeModel *entry_model = NULL;
	GtkTreeView *entry_view = NULL;
	GtkTreeSelection *selection = NULL;
	GtkTreeIter tree_iter;
	GList *entry_item = NULL;
	GtkTreePath *tree_path = NULL;
	entry_data *curr_entry = NULL;
	book_data *book = NULL;
	section_data *section = NULL;
	entry_data *entry = NULL;
	gint cindex = 0;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();

	// Create new entry filename
	while (++cindex < MAX_TRIES) {
	
		// Create entry name
		g_snprintf(entry_name, sizeof(entry_name), "%s%d",
			default_entry_name, cindex);

		// Create entry text file
		g_snprintf(filename, sizeof(filename),
			"%s%s%s%s%s%s%s.txt",
			note_dir, G_DIR_SEPARATOR_S,
			book->name, G_DIR_SEPARATOR_S,
			section->name, G_DIR_SEPARATOR_S,
			entry_name);

		fp = fopen(filename, "wx");
		if (fp == NULL) {
			continue;
		}
		fclose(fp);
		break;
	}

	sn_trace("Creating entry text file [%s].", filename);

	// Create entry
	entry = g_new0(entry_data, NEW_INSTANCE);
	strcpy(entry->name, entry_name);
	entry->parent_section = section;

	// Get selected entry
	entry_view = get_entry_view(book);
	entry_model = gtk_tree_view_get_model(entry_view);
	selection = gtk_tree_view_get_selection(entry_view);

	// Update model
	if(gtk_tree_selection_get_selected(selection, &entry_model, &tree_iter)) {
		gtk_tree_model_get(entry_model, &tree_iter, ENTRY_ITEM, &curr_entry, END_OF_LIST);
		tree_path = gtk_tree_model_get_path(entry_model, &tree_iter);
		entry_item = g_list_find(section->entry_list, curr_entry);
		section->entry_list = g_list_insert_before(section->entry_list, entry_item, entry);
	} else {
		section->entry_list = g_list_append(section->entry_list, entry);
	}

	// Write book
	write_book(book, note_dir);

	// Update view
	populate_entries(book, section);
	if(tree_path != NULL)
		gtk_tree_selection_select_path(selection, tree_path);
	on_entry_change(entry_view, book);

	// Set text focus
	set_text_view_focus(get_text_view(book));

	// Name entry
	if(options.auto_name_entry == TRUE) {
		entry->need_rename = TRUE;
	} else {
		rename_entry();
	}

	return TRUE;
} // Create entry
Пример #12
0
/*
 * Delete entry
 * Signal handler for "activate" delete entry
 */
gboolean delete_entry()
{
	GtkWidget *msg_dialog;
	gchar filename[MAX_PATH_LEN];
	gchar entry_display_name[MAX_NAME_LEN];
	GList *entry_item = NULL;
	book_data *book = NULL;
	section_data *section = NULL;
	entry_data *entry = NULL;
	gint result;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();
	entry = get_current_entry_or_return_with_warning();

	// Set display name
	strncpy(entry_display_name, entry->name, MAX_NAME_LEN-5);
	if(strlen(entry_display_name) > 25)
		strcpy(entry_display_name+25, "...\0");

	// Confirm delete action
	msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_MODAL,
		GTK_MESSAGE_QUESTION, GTK_BUTTONS_YES_NO,
		"Are you sure you want to delete\n\"%s\"?", entry_display_name);
	gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
		"If you delete an entry, it is permanently lost.");
	gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
	gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
	gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);

	result = gtk_dialog_run(GTK_DIALOG(msg_dialog));
	switch (result) {
	case GTK_RESPONSE_YES:

		// Delete entry text file
		g_snprintf(filename, sizeof(filename),
			"%s%s%s%s%s%s%s.txt",
			note_dir, G_DIR_SEPARATOR_S,
			book->name, G_DIR_SEPARATOR_S,
			section->name, G_DIR_SEPARATOR_S,
			entry->name);

		sn_trace("Deleting entry [%s] in delete_entry().",
			filename);

		result = remove(filename);

		if (result == 0) {

			// Remove history
			remove_history();

			// Select next entry
			entry_item = g_list_find(section->entry_list, entry);
			entry_item = entry_item->next;
			if(entry_item != NULL)
				section->curr_entry = entry_item->data;
			else
				section->curr_entry = NULL;

			// Remove entry
			section->entry_list = g_list_remove(section->entry_list, entry);
			free_entry(entry);

			// Write book
			write_book(book, note_dir);

			// Update view
			populate_entries(book, section);
			gtk_widget_grab_focus(GTK_WIDGET(get_entry_view(book)));
			gtk_widget_destroy(msg_dialog);
			return TRUE;

		} else {
			sn_warning("Unable to delete entry [%s].", entry->name);
			gtk_widget_destroy(msg_dialog);
			return FALSE;
		}

	default:
		gtk_widget_destroy(msg_dialog);
		return FALSE;
	}
	return FALSE;
} // Delete entry
Пример #13
0
/*
 * Trash entry
 * Signal handler for "activate" trash entry
 */
gboolean trash_entry()
{
	FILE *fp = NULL;
	GtkWidget *msg_dialog = NULL;
	gchar entry_display_name[MAX_NAME_LEN];
	gchar curr_entry_path[MAX_PATH_LEN];
	gchar trash_entry_path[MAX_PATH_LEN];
	GList *entry_item = NULL;
	book_data *book = NULL;
	section_data *section = NULL;
	section_data *trash_section = NULL;
	entry_data *entry = NULL;
	gint result;

	// Assert master exists
	g_assert_nonnull(master);

	// Get currently selected
	book = get_current_book_or_return_with_warning();
	section = get_current_section_or_return_with_warning();
	entry = get_current_entry_or_return_with_warning();
	
	// Get trash section
	trash_section = book->trash_section;
	
	// Curr entry file path
	g_snprintf(curr_entry_path, sizeof(curr_entry_path),
		"%s%s%s%s%s%s%s.txt",
		note_dir, G_DIR_SEPARATOR_S,
		book->name, G_DIR_SEPARATOR_S,
		section->name, G_DIR_SEPARATOR_S,
		entry->name);

	// Trash entry file path
	g_snprintf(trash_entry_path, sizeof(trash_entry_path),
		"%s%s%s%s%s%s%s.txt",
		note_dir, G_DIR_SEPARATOR_S,
		book->name, G_DIR_SEPARATOR_S,
		trash_section_name, G_DIR_SEPARATOR_S,
		entry->name);

	// Set display name
	strncpy(entry_display_name, entry->name, MAX_NAME_LEN-5);
	if(strlen(entry_display_name) > 25)
		strcpy(entry_display_name+25, "...\0");

	// Check that new entry path is valid
	fp = fopen(trash_entry_path, "wx");

	if (fp == NULL) {
		sn_warning("Unable to trash entry [%s].", trash_entry_path);

		msg_dialog = gtk_message_dialog_new(GTK_WINDOW(main_window), GTK_DIALOG_MODAL,
			GTK_MESSAGE_WARNING, GTK_BUTTONS_OK,
			"Unable to trash entry \"%s\".", entry_display_name);
		gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(msg_dialog),
			"Please ensure the entry name doesn't aleady exist.");
		gtk_window_set_type_hint(GTK_WINDOW(msg_dialog), GDK_WINDOW_TYPE_HINT_MENU);
		gtk_window_set_resizable(GTK_WINDOW(msg_dialog), FALSE);
		gtk_window_set_title(GTK_WINDOW(msg_dialog), app_name);
		result = gtk_dialog_run(GTK_DIALOG(msg_dialog));

		gtk_widget_destroy(msg_dialog);
		return FALSE;
	}
	fclose(fp);

	// Remove file created by previous open
	result = remove(trash_entry_path);

	sn_trace("Trashing entry [%s] to [%s].", curr_entry_path, trash_entry_path);

	// Move the entry file to the new path
	result = rename(curr_entry_path, trash_entry_path);

	if(result == 0) {

		// Remove history
		remove_history();

		// Select next entry
		entry_item = g_list_find(section->entry_list, entry);
		entry_item = entry_item->next;
		if(entry_item != NULL)
			section->curr_entry = entry_item->data;
		else
			section->curr_entry = NULL;

		// Remove entry
		section->entry_list = g_list_remove(section->entry_list, entry);

		// Append entry
		trash_section->entry_list = g_list_append(trash_section->entry_list, entry);

		// Update entry
		entry->parent_section = trash_section;

		// Write book
		write_book(book, note_dir);

		// Update view
		populate_entries(book, section);

		return TRUE;

	} else {
		sn_warning("Unable to trash entry [%s].", curr_entry_path);
		return FALSE;
	}

	return FALSE;
} // Trash entry