Example #1
0
File: inc.c Project: Tux/claws-mail
gint inc_account_mail(MainWindow *mainwin, PrefsAccount *account)
{
	gint new_msgs;

	if (inc_lock_count) return 0;

	if (account->receive_in_progress) return 0;

	if (prefs_common.work_offline && 
	    !inc_offline_should_override(TRUE,
		_("Claws Mail needs network access in order "
		  "to get mails.")))
		return 0;

	inc_autocheck_timer_remove();
	main_window_lock(mainwin);

	new_msgs = inc_account_mail_real(mainwin, account);

	inc_update_stats(new_msgs);
	inc_finished(mainwin, new_msgs > 0, FALSE);
	main_window_unlock(mainwin);
	inc_autocheck_timer_set();

	return new_msgs;
}
Example #2
0
void inc_mail(MainWindow *mainwin, gboolean notify)
{
	gint new_msgs = 0;
	gint account_new_msgs = 0;

	if (inc_lock_count) return;

	if (prefs_common.work_offline && 
	    !inc_offline_should_override(TRUE,
		_("Claws Mail needs network access in order "
		  "to get mails.")))
		return;

	inc_lock();
	inc_autocheck_timer_remove();
	main_window_lock(mainwin);

	if (prefs_common.use_extinc && prefs_common.extinc_cmd) {
		/* external incorporating program */
		if (execute_command_line(prefs_common.extinc_cmd, FALSE) < 0) {
			main_window_unlock(mainwin);
			inc_autocheck_timer_set();
			inc_unlock();
			return;
		}
	} else {
		account_new_msgs = inc_account_mail_real(mainwin, cur_account);
		if (account_new_msgs > 0)
			new_msgs += account_new_msgs;
	}

	inc_update_stats(new_msgs);
	inc_finished(mainwin, new_msgs > 0, FALSE);
	main_window_unlock(mainwin);
 	inc_notify_cmd(new_msgs, notify);
	inc_autocheck_timer_set();
	inc_unlock();
}
Example #3
0
void inc_all_account_mail(MainWindow *mainwin, gboolean autocheck,
			  gboolean notify)
{
	GList *list, *queue_list = NULL;
	IncProgressDialog *inc_dialog;
	gint new_msgs = 0;
	gint account_new_msgs = 0;
	
	if (prefs_common.work_offline && 
	    !inc_offline_should_override( (autocheck == FALSE),
		_("Claws Mail needs network access in order "
		  "to get mails.")))
		return;

	if (inc_lock_count) return;

	inc_autocheck_timer_remove();
	main_window_lock(mainwin);

	list = account_get_list();
	if (!list) {
		inc_update_stats(new_msgs);
		inc_finished(mainwin, new_msgs > 0, autocheck);
		main_window_unlock(mainwin);
 		inc_notify_cmd(new_msgs, notify);
		inc_autocheck_timer_set();
		return;
	}

	if (prefs_common.use_extinc && prefs_common.extinc_cmd) {
		/* external incorporating program */
		if (execute_command_line(prefs_common.extinc_cmd, FALSE) < 0) {
			log_error(LOG_PROTOCOL, _("%s failed\n"), prefs_common.extinc_cmd);
			
			main_window_unlock(mainwin);
			inc_autocheck_timer_set();
			return;
		}
	}
	
	/* check local folders */
	account_new_msgs = inc_all_spool();
	if (account_new_msgs > 0)
		new_msgs += account_new_msgs;

	/* check IMAP4 / News folders */
	for (list = account_get_list(); list != NULL; list = list->next) {
		PrefsAccount *account = list->data;
		if ((account->protocol == A_IMAP4 ||
		     account->protocol == A_NNTP) && account->recv_at_getall) {
			new_msgs += folderview_check_new(FOLDER(account->folder));
		}
	}

	/* check POP3 accounts */
	for (list = account_get_list(); list != NULL; list = list->next) {
		IncSession *session;
		PrefsAccount *account = list->data;

		if (account->recv_at_getall) {
			session = inc_session_new(account);
			if (session)
				queue_list = g_list_append(queue_list, session);
		}
	}

	if (queue_list) {
		inc_dialog = inc_progress_dialog_create(autocheck);
		inc_dialog->queue_list = queue_list;
		inc_dialog->mainwin = mainwin;
		inc_progress_dialog_set_list(inc_dialog);

		toolbar_main_set_sensitive(mainwin);
		main_window_set_menu_sensitive(mainwin);
		new_msgs += inc_start(inc_dialog);
	}

	inc_update_stats(new_msgs);
	inc_finished(mainwin, new_msgs > 0, autocheck);
	main_window_unlock(mainwin);
 	inc_notify_cmd(new_msgs, notify);
	inc_autocheck_timer_set();
}
Example #4
0
int main(int argc, char *argv[]){

	char *ep;
	u_long temp, trials;
	struct state *gp;
	struct state game;
	
	/* structures to hold the stats */
	struct stats b_before;
	struct stats b_after;
	struct stats b_both;
	struct stats m_card, m_dice;
	
	struct stats game_stats;	

	struct card deck[DECKS*CARDS*SUITS];

	int i;
	int card_index = 0;
	float outcome; 
	int die_total;

	gp = &game;

	if (argc != 2)
		usage();

	temp = strtoul(argv[1], &ep, 10);
	if (*argv[1] == '\0'|| *ep != '\0'){
		fprintf(stderr, "%s - not a number\n", argv[1]);
		usage();
	}

	if (argv[1][0] == '-'){
		fprintf(stderr, "%s - no negative numbers\n", argv[1]);
		usage();
	}
	
	if (( errno == ERANGE && temp == ULONG_MAX ) && (temp > 1)){
		fprintf(stderr, "%s - value out of range\n", argv[1]);
		usage();
	}
	trials = temp;

	/* seed the random number generator */
	srand(time(NULL));
	
	/* initialize the deck */
	init_deck(deck);
	
	/* shuffle the cards */
	shuffle(deck);

	/* initialize the statistics structs */
	init_stats(&b_before);
	init_stats(&b_after);
	init_stats(&b_both);
	init_stats(&m_card);
	init_stats(&m_dice);
	init_stats(&game_stats);

	/* run the simulations */
	for (i = 0 ; i < trials ; i++){
		
		/* initialize the game */
		game.die_1 = rand()%6 + 1;
		game.die_2 = rand()%6 + 1;
		die_total = game.die_1 + game.die_2;

		game.before_card = deck[card_index];
		game.after_card = deck[card_index+1];
		card_index+=2;		

		/* beat before */
		if (die_total == 12)
			outcome = 4.0; 
		else if ( die_total > game.before_card.value )
			outcome = 1.0;
		else if ( die_total < game.before_card.value )
			outcome = -1.0;
		else
			outcome = 0.0;							
		inc_update_stats(&b_before, outcome, i+1);
 		inc_update_stats(&game_stats, outcome, i+1);
		
		/* beat after */
		if (die_total == 12)
			outcome = 4.0; 
		else if ( die_total > game.after_card.value )
			outcome = 1.0;
		else if ( die_total < game.after_card.value )
			outcome = -1.0;
		else
			outcome = 0.0;

		inc_update_stats(&b_after, outcome, i+1);
		inc_update_stats(&game_stats, outcome, i+1);
		
		/* beat both */
		if (die_total == 12)
			outcome = 6.0;

		else if ( (die_total > game.after_card.value) &&
		    (die_total > game.before_card.value) )
			outcome = 3.0;
		else if ( (die_total == game.after_card.value) &&
			(die_total == game.before_card.value))
			outcome = 0.0;	
		else
			outcome = -1.0;

		inc_update_stats(&b_both, outcome, i+1);
		inc_update_stats(&game_stats, outcome, i+1);
		
		/* match card */
		outcome = match_card(gp);
		inc_update_stats(&m_card, outcome, i+1);
		inc_update_stats(&game_stats, outcome, i+1);
		
		/* match dice */
		outcome = match_dice(gp);
		inc_update_stats(&m_dice, outcome, i+1);
 		inc_update_stats(&game_stats, outcome, i+1);

		if(card_index > (DECKS*SUITS*CARDS - 52)){
			card_index = 0;
			shuffle(deck);
		}

	}

	/* finalize the standard deviations */	
	b_before.stddev = sqrt(b_before.stddev/(trials-1));
	b_after.stddev = sqrt(b_after.stddev/(trials-1));
	b_both.stddev = sqrt(b_both.stddev/(trials-1));
	m_card.stddev = sqrt(m_card.stddev/(trials-1));
	m_dice.stddev = sqrt(m_dice.stddev/(trials-1));
	game_stats.stddev = sqrt(game_stats.stddev/(trials-1));

	/* Print the statistics of the each game's square */
	printf("Beat Before:\n");
	print_stats(&b_before);	
	printf("Beat After:\n");
	print_stats(&b_after);	
	printf("Beat Both:\n");
	print_stats(&b_both);	
	printf("Match Card:\n");
	print_stats(&m_card);	
	printf("Match Dice:\n");
	print_stats(&m_dice);	
	
	/* Print the game's overall EV */
	printf("Game Statistics:\n");
	print_stats(&game_stats);	

	return 0;

}