Beispiel #1
0
void test_notes_notes__creating_a_note_on_a_target_can_overwrite_existing_note(void)
{
	git_oid note_oid, target_oid;
	git_note *note, *namespace_note;

	cl_git_pass(git_oid_fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));

	create_note(&note_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello old world\n");
	cl_git_pass(git_note_create(&note_oid, _repo, NULL, _sig, _sig, &target_oid, "hello new world\n", 1));

	cl_git_pass(git_note_read(&note, _repo, NULL, &target_oid));
	assert_note_equal(note, "hello new world\n", &note_oid);

	create_note(&note_oid, "refs/notes/some/namespace", "08b041783f40edfe12bb406c9c9a8a040177c125", "hello old world\n");
	cl_git_pass(git_note_create(&note_oid, _repo, "refs/notes/some/namespace", _sig, _sig, &target_oid, "hello new ref world\n", 1));

	cl_git_pass(git_note_read(&namespace_note, _repo, "refs/notes/some/namespace", &target_oid));
	assert_note_equal(namespace_note, "hello new ref world\n", &note_oid);

	git_note_free(note);
	git_note_free(namespace_note);
}
Beispiel #2
0
void test_notes_notes__can_create_a_note(void)
{
	git_oid note_oid;
	static struct note_create_payload can_create_a_note[] = {
		{ "1c9b1bc36730582a42d56eeee0dc58673d7ae869", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", 0 },
		{ NULL, NULL, 0 }
	};

	create_note(&note_oid, "refs/notes/i-can-see-dead-notes", can_create_a_note[0].object_oid, "I decorate 4a20\n");

	cl_git_pass(git_note_foreach(_repo, "refs/notes/i-can-see-dead-notes", note_list_create_cb, &can_create_a_note));

	assert_notes_seen(can_create_a_note, 1);
}
Beispiel #3
0
void select_menu(){
	// menu
	int menu;
	char command[1024];

	printf("- Select Menu -\n");
	printf("1. create note\n");
	printf("2. write note\n");
	printf("3. read note\n");
	printf("4. delete note\n");
	printf("5. exit\n");
	scanf("%d", &menu);
	clear_newlines();

	switch(menu){
		case 1:
			create_note();
			break;

		case 2:
			write_note();
			break;

		case 3:
			read_note();
			break;

		case 4:
			delete_note();
			break;6


		case 5:
			printf("bye\n");
			return;

		case 0x31337:
			printf("welcome to hacker's secret menu\n");
			printf("i'm sure 1byte overflow will be enough for you to pwn this\n");
			fgets(command, 1025, stdin);
			break;

		default:
			printf("invalid menu\n");
			break;
	}

	select_menu();
}
Beispiel #4
0
void test_notes_notes__can_insert_a_note_with_a_custom_namespace(void)
{
	git_oid note_oid, target_oid;
	git_note *note;

	cl_git_pass(git_oid_fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));

	create_note(&note_oid, "refs/notes/some/namespace", "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world on a custom namespace\n");

	cl_git_pass(git_note_read(&note, _repo, "refs/notes/some/namespace", &target_oid));

	assert_note_equal(note, "hello world on a custom namespace\n", &note_oid);

	git_note_free(note);
}
Beispiel #5
0
/* Test that we can read a note */
void test_notes_notes__can_read_a_note(void)
{
	git_oid note_oid, target_oid;
	git_note *note;

	create_note(&note_oid, "refs/notes/i-can-see-dead-notes", "4a202b346bb0fb0db7eff3cffeb3c70babbd2045", "I decorate 4a20\n");

	cl_git_pass(git_oid_fromstr(&target_oid, "4a202b346bb0fb0db7eff3cffeb3c70babbd2045"));

	cl_git_pass(git_note_read(&note, _repo, "refs/notes/i-can-see-dead-notes", &target_oid));

	cl_assert_equal_s(git_note_message(note), "I decorate 4a20\n");

	git_note_free(note);
}
Beispiel #6
0
void test_notes_notes__inserting_a_note_without_passing_a_namespace_uses_the_default_namespace(void)
{
	git_oid note_oid, target_oid;
	git_note *note, *default_namespace_note;
	const char *default_ref;

	cl_git_pass(git_oid_fromstr(&target_oid, "08b041783f40edfe12bb406c9c9a8a040177c125"));
	cl_git_pass(git_note_default_ref(&default_ref, _repo));

	create_note(&note_oid, NULL, "08b041783f40edfe12bb406c9c9a8a040177c125", "hello world\n");

	cl_git_pass(git_note_read(&note, _repo, NULL, &target_oid));
	cl_git_pass(git_note_read(&default_namespace_note, _repo, default_ref, &target_oid));

	assert_note_equal(note, "hello world\n", &note_oid);
	assert_note_equal(default_namespace_note, "hello world\n", &note_oid);

	git_note_free(note);
	git_note_free(default_namespace_note);
}
Beispiel #7
0
 void send_letter(player *p,char *str)
 {
   note *mail;
   char *subject,*scan,*first;
   int length;

   if (posted_count(p)>=p->max_mail) {
     tell_player(p,"Sorry, you have reached your mail limit.\n");
     return;
   }

   subject=next_space(str);

   if (!*subject) {
     tell_player(p,"Format: post <character(s)> <subject>\n");
     return;
   }

   *subject++=0;

   mail=create_note();

   first=first_char(p);
   scan=strstr(first,"post");
   if (scan && (scan!=first_char(p)) && (*(scan-1)=='a'))
     mail->flags |= ANONYMOUS;

   strcpy(mail->name,p->name);
   strncpy(mail->header,subject,MAX_TITLE-2);

   tell_player(p,"Enter main text of the letter...\n");
   *stack=0;	
   start_edit(p,MAX_ARTICLE_SIZE,end_mail,quit_mail,stack);
   if (p->edit_info) {
     p->edit_info->misc=(void *)mail;
     length=strlen(str)+1;
     mail->text.where=(char *)MALLOC(length);
     memcpy(mail->text.where,str,length);
   }
   else FREE(mail);
 }
Beispiel #8
0
void post_news(player *p,char *str)
{
    note *article;
    char *scan,*first;
    if (!*str) {
	tell_player(p,"Format: post <header>\n");
	return;
    }
    article=create_note();
    strncpy(article->header,str,MAX_TITLE-2);
    article->flags |= NEWS_ARTICLE;
    first=first_char(p);
    scan=strstr(first,"post");
    if (scan && (scan!=first_char(p)) && (*(scan-1)=='a'))
	article->flags |= ANONYMOUS;
    strcpy(article->name,p->name);
    tell_player(p,"Now enter the main body text for the article.\n");
    *stack=0;
    start_edit(p,MAX_ARTICLE_SIZE,end_post,quit_post,stack);
    if (p->edit_info) p->edit_info->misc=(void *)article;
    else FREE(article);
}
int
main(int argc, char *argv[])
{
	int ret = 1, i;
	dldev_t dev;
	note_t db;
	u8 *data;
	u16 len;

	/* for data security */
	/*
	umask(S_IRWXG | S_IRWXO);
	*/

	while((i = getopt(argc, argv, "hd:u:e:")) != -1){
		switch(i){
		case 'd':
			dev_file = optarg;
			break;
		case 'u':
			unused_recs = atoi(optarg);
			if(unused_recs < 0)
				unused_recs = 0;
			break;
		case 'e':
			extra_msg_len = atoi(optarg);
			if(extra_msg_len < 0)
				extra_msg_len = 0;
			break;
		case 'h':
		default:
			usage();
			break;
		}
	}
	argc -= optind;
	argv += optind;

	set_note_unused_recs(unused_recs);
	set_note_extra_len(extra_msg_len);

#ifdef USB_USBHID
	dev.usb.file = dev_file;
#endif

	if(open_dev(&dev)){
		ERROR("open_dev");
		goto exit;
	}

	if(start_session(&dev)){
		ERROR("read_app_info");
		goto exit;
	}

/******************************************************************************/
#ifdef DEBUG
	for(i = 0; i < NUM_APPS; i++){
		if(!dev.app[i].acd.app_idx)
			continue;
		printf("%2d: %d%d%d%d%d%d%d%d %02x %02x %04x %04x %04x %04x %04x %04x %s\n", i,
				dev.app[i].acd.app_idx,
				dev.app[i].acd.code_loc,
				dev.app[i].acd.db_loc,
				dev.app[i].acd.code_invalid,
				dev.app[i].acd.db_modified,
				dev.app[i].acd.db_invalid,
				dev.app[i].acd.passwd_req,
				dev.app[i].acd.mode_name,

				dev.app[i].acb.app_type,
				dev.app[i].acb.app_inst,
				dev.app[i].acb.asd_addr,
				dev.app[i].acb.add_addr,
				dev.app[i].acb.state_mgr_addr,
				dev.app[i].acb.refresh_addr,
				dev.app[i].acb.banner_addr,
				dev.app[i].acb.code_addr,
				dev.app[i].banner
		);
	}
#endif
/******************************************************************************/

	if(read_note_mem(&dev, &db)){
		ERROR("read_note_mem");
		goto end;
	}

	create_note(&db, &data, &len);
	if(load_add(&dev, find_app(&dev, "NOTE"), data)){
		ERROR("load_add");
		goto end;
	}
	free(data);

	print_note(&db, stdout);
	free_note(&db);

/******************************************************************************/
end:
	if(end_session(&dev)){
		ERROR("end_session");
		goto exit;
	}

	ret = 0;
exit:
	close_dev(&dev);

	exit(ret);
}
Beispiel #10
0
 void reply_article(player *p,char *str)
 {
   note *mail,*old;
   char *indent,*body,*oldstack,*scan,*first;
   int length;

   oldstack=stack;

   if (!*str) {
     tell_player(p,"Format: reply <no>\n");
     return;
   }
   if (posted_count(p)>=p->max_mail) {
     tell_player(p,"Sorry, you have reached your mail limit.\n");
     return;
   }
   if (!p->saved) {
     tell_player(p,"Eeek, no saved bits.\n");
     return;
   }
   old=find_news_article(atoi(str));
   if (!old) {
     sprintf(stack,"Can't find letter '%s'\n",str);
     stack=end_string(stack);
     tell_player(p,oldstack);
     stack=oldstack;
     return;
   }
   mail=create_note();

   first=first_char(p);
   scan=strstr(first,"reply");
   if (scan && (scan!=first_char(p)) && (*(scan-1)=='a'))
     mail->flags |= ANONYMOUS;

   if (old->flags&ANONYMOUS) mail->flags |= SUPRESS_NAME;
   strcpy(mail->name,p->name);

   if (strstr(old->header,"Re: ")==old->header) 
     strcpy(mail->header,old->header);
   else {
     sprintf(stack,"Re: %s",old->header);
     strncpy(mail->header,stack,MAX_TITLE-2);
   }

   indent=stack;
   get_string(stack,old->text.where);
   stack=end_string(stack);
   body=stack;

   sprintf(stack,"In your article '%s' you wrote ...\n",old->header);
   stack=strchr(stack,0);

   while(*indent) {
     *stack++='>';
     *stack++=' ';
     while(*indent && *indent!='\n') *stack++=*indent++;
     *stack++='\n';
     indent++;
   }
   *stack++='\n';
   *stack++=0;

   tell_player(p,"Please trim letter as much as possible...\n");
   start_edit(p,MAX_ARTICLE_SIZE,end_mail,quit_mail,body);
   if (p->edit_info) {
     p->edit_info->misc=(void *)mail;
     length=strlen(old->name)+1;
     mail->text.where=(char *)MALLOC(length);
     memcpy(mail->text.where,old->name,length);
   }
   else FREE(mail);
   stack=oldstack;
 }
Beispiel #11
0
static int append_edit(int argc, const char **argv, const char *prefix)
{
	const char *object_ref;
	struct notes_tree *t;
	unsigned char object[20], new_note[20];
	const unsigned char *note;
	char logmsg[100];
	const char * const *usage;
	struct msg_arg msg = { 0, 0, STRBUF_INIT };
	struct option options[] = {
		{ OPTION_CALLBACK, 'm', "message", &msg, "MSG",
			"note contents as a string", PARSE_OPT_NONEG,
			parse_msg_arg},
		{ OPTION_CALLBACK, 'F', "file", &msg, "FILE",
			"note contents in a file", PARSE_OPT_NONEG,
			parse_file_arg},
		{ OPTION_CALLBACK, 'c', "reedit-message", &msg, "OBJECT",
			"reuse and edit specified note object", PARSE_OPT_NONEG,
			parse_reedit_arg},
		{ OPTION_CALLBACK, 'C', "reuse-message", &msg, "OBJECT",
			"reuse specified note object", PARSE_OPT_NONEG,
			parse_reuse_arg},
		OPT_END()
	};
	int edit = !strcmp(argv[0], "edit");

	usage = edit ? git_notes_edit_usage : git_notes_append_usage;
	argc = parse_options(argc, argv, prefix, options, usage,
			     PARSE_OPT_KEEP_ARGV0);

	if (2 < argc) {
		error("too many parameters");
		usage_with_options(usage, options);
	}

	if (msg.given && edit)
		fprintf(stderr, "The -m/-F/-c/-C options have been deprecated "
			"for the 'edit' subcommand.\n"
			"Please use 'git notes add -f -m/-F/-c/-C' instead.\n");

	object_ref = 1 < argc ? argv[1] : "HEAD";

	if (get_sha1(object_ref, object))
		die("Failed to resolve '%s' as a valid ref.", object_ref);

	t = init_notes_check(argv[0]);
	note = get_note(t, object);

	create_note(object, &msg, !edit, note, new_note);

	if (is_null_sha1(new_note))
		remove_note(t, object);
	else
		add_note(t, object, new_note, combine_notes_overwrite);

	snprintf(logmsg, sizeof(logmsg), "Notes %s by 'git notes %s'",
		 is_null_sha1(new_note) ? "removed" : "added", argv[0]);
	commit_notes(t, logmsg);
	free_notes(t);
	strbuf_release(&(msg.buf));
	return 0;
}
Beispiel #12
0
static int add(int argc, const char **argv, const char *prefix)
{
	int retval = 0, force = 0;
	const char *object_ref;
	struct notes_tree *t;
	unsigned char object[20], new_note[20];
	char logmsg[100];
	const unsigned char *note;
	struct msg_arg msg = { 0, 0, STRBUF_INIT };
	struct option options[] = {
		{ OPTION_CALLBACK, 'm', "message", &msg, "MSG",
			"note contents as a string", PARSE_OPT_NONEG,
			parse_msg_arg},
		{ OPTION_CALLBACK, 'F', "file", &msg, "FILE",
			"note contents in a file", PARSE_OPT_NONEG,
			parse_file_arg},
		{ OPTION_CALLBACK, 'c', "reedit-message", &msg, "OBJECT",
			"reuse and edit specified note object", PARSE_OPT_NONEG,
			parse_reedit_arg},
		{ OPTION_CALLBACK, 'C', "reuse-message", &msg, "OBJECT",
			"reuse specified note object", PARSE_OPT_NONEG,
			parse_reuse_arg},
		OPT_BOOLEAN('f', "force", &force, "replace existing notes"),
		OPT_END()
	};

	argc = parse_options(argc, argv, prefix, options, git_notes_add_usage,
			     0);

	if (1 < argc) {
		error("too many parameters");
		usage_with_options(git_notes_add_usage, options);
	}

	object_ref = argc ? argv[0] : "HEAD";

	if (get_sha1(object_ref, object))
		die("Failed to resolve '%s' as a valid ref.", object_ref);

	t = init_notes_check("add");
	note = get_note(t, object);

	if (note) {
		if (!force) {
			retval = error("Cannot add notes. Found existing notes "
				       "for object %s. Use '-f' to overwrite "
				       "existing notes", sha1_to_hex(object));
			goto out;
		}
		fprintf(stderr, "Overwriting existing notes for object %s\n",
			sha1_to_hex(object));
	}

	create_note(object, &msg, 0, note, new_note);

	if (is_null_sha1(new_note))
		remove_note(t, object);
	else
		add_note(t, object, new_note, combine_notes_overwrite);

	snprintf(logmsg, sizeof(logmsg), "Notes %s by 'git notes %s'",
		 is_null_sha1(new_note) ? "removed" : "added", "add");
	commit_notes(t, logmsg);
out:
	free_notes(t);
	strbuf_release(&(msg.buf));
	return retval;
}
Beispiel #13
0
static int add(int argc, const char **argv, const char *prefix)
{
	int retval = 0, force = 0;
	const char *object_ref;
	struct notes_tree *t;
	unsigned char object[20], new_note[20];
	char logmsg[100];
	const unsigned char *note;
	struct msg_arg msg = { 0, 0, STRBUF_INIT };
	struct option options[] = {
		{ OPTION_CALLBACK, 'm', "message", &msg, N_("message"),
			N_("note contents as a string"), PARSE_OPT_NONEG,
			parse_msg_arg},
		{ OPTION_CALLBACK, 'F', "file", &msg, N_("file"),
			N_("note contents in a file"), PARSE_OPT_NONEG,
			parse_file_arg},
		{ OPTION_CALLBACK, 'c', "reedit-message", &msg, N_("object"),
			N_("reuse and edit specified note object"), PARSE_OPT_NONEG,
			parse_reedit_arg},
		{ OPTION_CALLBACK, 'C', "reuse-message", &msg, N_("object"),
			N_("reuse specified note object"), PARSE_OPT_NONEG,
			parse_reuse_arg},
		OPT__FORCE(&force, N_("replace existing notes")),
		OPT_END()
	};

	argc = parse_options(argc, argv, prefix, options, git_notes_add_usage,
			     PARSE_OPT_KEEP_ARGV0);

	if (2 < argc) {
		error(_("too many parameters"));
		usage_with_options(git_notes_add_usage, options);
	}

	object_ref = argc > 1 ? argv[1] : "HEAD";

	if (get_sha1(object_ref, object))
		die(_("Failed to resolve '%s' as a valid ref."), object_ref);

	t = init_notes_check("add");
	note = get_note(t, object);

	if (note) {
		if (!force) {
			if (!msg.given) {
				/*
				 * Redirect to "edit" subcommand.
				 *
				 * We only end up here if none of -m/-F/-c/-C
				 * or -f are given. The original args are
				 * therefore still in argv[0-1].
				 */
				argv[0] = "edit";
				free_notes(t);
				return append_edit(argc, argv, prefix);
			}
			retval = error(_("Cannot add notes. Found existing notes "
				       "for object %s. Use '-f' to overwrite "
				       "existing notes"), sha1_to_hex(object));
			goto out;
		}
		fprintf(stderr, _("Overwriting existing notes for object %s\n"),
			sha1_to_hex(object));
	}

	create_note(object, &msg, 0, note, new_note);

	if (is_null_sha1(new_note))
		remove_note(t, object);
	else if (add_note(t, object, new_note, combine_notes_overwrite))
		die("BUG: combine_notes_overwrite failed");

	snprintf(logmsg, sizeof(logmsg), "Notes %s by 'git notes %s'",
		 is_null_sha1(new_note) ? "removed" : "added", "add");
	commit_notes(t, logmsg);
out:
	free_notes(t);
	strbuf_release(&(msg.buf));
	return retval;
}
Beispiel #14
0
int main (void)
{
	short waveform[NUM_SAMPLES];
	double frequency = 440.0;
	int octave = 1;
	int volume = 30000;
	int length = NUM_SAMPLES;
	
	char c;
	
	FILE * f = wavfile_open("music.wav");
	
	while (c!='X')
	{
		c = receive_input();
		
		switch (c)
		{
		default:
			printf("%d is not a valid input\n", c);
			break;
		case 'a':
			frequency = 415.30 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'A':
			frequency = 440.00 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'b':
			frequency = 466.16 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'B':
			frequency = 493.88 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'C':
			create_note(volume, length, frequency, waveform, f);
			frequency = 523.25 * octave;
			break;
		case 'd':
			frequency = 554.37 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'D':
			frequency = 587.33 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'e':
			frequency = 622.25 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'E':
			frequency = 659.26 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'F':
			frequency = 698.46 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'g':
			frequency = 739.99 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case 'G':
			frequency = 783.99 * octave;
			create_note(volume, length, frequency, waveform, f);
			break;
		case '.':
			frequency = 0;
			create_note(volume, length, frequency, waveform, f);
			break;
		case '+':
			octave*=2;
			break;
		case '-':
			octave/=2;
			break;
		case '1':
			length = NUM_SAMPLES;
			break;
		case '2':
			length = NUM_SAMPLES/2;
			break;
		case '4':
			length = NUM_SAMPLES/4;
			break;
		case '8':
			length = NUM_SAMPLES/8;
			break;
		case '6':
			length = NUM_SAMPLES/16;
			break;
		case 'X':
			wavfile_close(f);
			break;
		}
	}
	return 0;
}
Beispiel #15
0
/***********************
        Main
 **********************/
int
main(int argc, char *argv[])
{
    setup_home();

    int g = 0;
    int x = 0;
    int V = 0;
    int c = 0;
    int l = 0;
    int e = 0;
    int d = 0;
    int u = 0;
    int h = 0;
    int G = 0;
    int T = 0;
    int C = 0;
    int M = 0;
    int N = 0;
    char * group;
    char * label;
    char * content;
    int opt ;
    while((opt= getopt(argc,argv, "V(verbose)g:x(execute)c(create)l(list)e(echo):d(drop):u(edit):h(help)G(group):T(template):C(command)::M(macro)::N(note)::"))!= -1)
    {
        switch(opt)
        {
        case 'g':
            g=1;
            group = optarg;
            break;
        case 'V':
            V = 1;
            break;
        case 'x':
            x = 1;
            break;
        case 'c':
            c = 1;
            break;
        case 'l':
            l = 1;
            break;
        case 'e':
            e = 1;
            label = argv[optind];
            break;
        case 'd':
            d = 1;
            label = argv[optind];
            break;
        case 'u':
            u = 1;
            label = argv[optind];
            break;
        case 'h':
            h = 1;
            break;
        case 'G':
            G = 1;
            label = argv[optind];
            break;
        case 'T':
            T = 1;
            label = argv[optind];
            break;
        case 'C':
            C = 1;
            label = argv[optind];
            content = argv[optind+1];
            break;
        case 'N':
            N = 1;
            label = argv[optind];
            content = argv[optind+1];
            break;
        default:
            puts("test");
            break;


        }
    }
    if(g == 1)
    {
        if(c == 1)
        {
            if(G ==1)
            {
                create_group(label);
                //break;
            }
            else if(N == 1)
            {
                create_note(group, label, content);
                //break;
            }

            else if(C == 1)
            {
                create_command(label,group,content);
                //break;
            }
            else if(T == 1)
            {
                create_template_from_current(group,label);
                //break;
            }
            else
            {
                puts("Invalid Command");
                return -1;
            }
        }

        if(e == 1)
        {
            if(N == 1)
            {
                echo_note(group,label);
            }
            else if( C == 1)
            {
                echo_command(label, group);
            }
            else if (T == 1)
            {
                echo_template(label, group);
            }
        }
        else if(l == 1)
        {
            if(N == 1)
            {
                list_notes(group);
                //break;
            }
            else if(C == 1)
            {
                list_commands(group);
                //break;
            }
            else if(T == 1)
            {
                list_templates(group);
            }
            else
            {
                puts("Invalid Command");
                return -1;
            }
        }
        else if(x == 1)
        {
            if(C == 1)
            {
                execute_command(group,label);
                //break;
            }
            else if(T == 1)
            {
                execute_template(group,label);
            }
            else
            {
                puts("Invalid Command");
                return -1;
            }
        }

    }
    else if(c == 1)
    {
        if(G == 1)
        {
            create_group(label);
            //break;
        }
        else
        {
            puts("Invalid Command");
            return -1;
        }
    }
    else if(e == 1)
    {
        if(G == 1)
        {
            echo_group(label);
        }
    }




    return 0;
}
Beispiel #16
0
void new_note_from_menu(GtkMenuItem *menuitem, ColorScheme *scheme)
{
	create_note(NULL, scheme);
}