diff -uN mindless-1.6/deck.c mindless-1.6-deckeditor/deck.c --- mindless-1.6/deck.c 2005-06-25 19:05:35.000000000 +0200 +++ mindless-1.6-deckeditor/deck.c 2005-09-19 19:49:05.000000000 +0200 @@ -64,6 +64,7 @@ name = cp; globalid = cardbase_find_globalid (db, name); if (globalid < 0) { + printf("Humm, there is a card I don't know (%s)\n", name); /* show error */ continue; } diff -uN mindless-1.6/deck_editor.c mindless-1.6-deckeditor/deck_editor.c --- mindless-1.6/deck_editor.c 1970-01-01 01:00:00.000000000 +0100 +++ mindless-1.6-deckeditor/deck_editor.c 2005-09-19 19:49:05.000000000 +0200 @@ -0,0 +1,779 @@ +#define _GNU_SOURCE + +#include +#include +#include +#include +#include + + +#include "cardbase.h" +#include "deck_editor.h" +#include "deck.h" +#include "game.h" /* game->cardbase */ +#include "cardart.h" +#include "dialogs.h" +#include "prefs.h" + +enum { + NAME_COLUMN, + MANA_COLUMN, + N_COLUMN +}; + +#define NUM_COLUMN 1 + + +GtkListStore *llist; +GtkListStore *rlist; + +GtkWidget *lpListView; +GtkWidget *rpListView; + +GtkWidget *card_image; + +GtkWidget *status_bar; + +GtkWidget *deck_infos_label_creatures_data, *deck_infos_label_instants_data; +GtkWidget *deck_infos_label_enchantments_data, *deck_infos_label_artifacts_data; +GtkWidget *deck_infos_label_artifact_creatures_data, *deck_infos_label_sorceries_data; +GtkWidget *deck_infos_label_lands_data; + +GtkWidget *label_manas_green, *label_manas_black, *label_manas_white, *label_manas_red, *label_manas_blue, *label_manas_colorless, *label_manas_total; + +struct game *game; + +const char *lowercase(char *my_text) +{ + char *text = strdup(my_text); + char *ptext = text; + + while ( *ptext != '\0' ) + { + *ptext = tolower(*ptext); + *ptext++; + } + + return text; +} + +void deck_editor(struct game *game) +{ + GtkWidget *pWindow; + GtkWidget *lpScrollbar, *rpScrollbar; + GtkTreeViewColumn *pColumn; + GtkCellRenderer *lpCellRenderer, *rpCellRenderer; + GtkWidget *cards_vbox, *deck_vbox, *main_hbox, *main_vbox, *buttons_hbox, *buttons2_hbox; + GtkWidget *filter_input; + GtkTreeSelection *lTreeSelection,*rTreeSelection; + GtkWidget *deck_tabs = gtk_notebook_new(); + + GtkWidget *add_button, *del_button, *reset_button; + GtkWidget *load_button, *save_button; + + llist = gtk_list_store_new(N_COLUMN, G_TYPE_STRING, G_TYPE_STRING); + rlist = gtk_list_store_new(N_COLUMN, G_TYPE_STRING, G_TYPE_INT); + + GtkWidget *lframe = gtk_frame_new("Available Cards :"); + GtkWidget *rframe = gtk_frame_new("Deck :"); + + status_bar = gtk_statusbar_new(); + + /* Creation des {v,h}box */ + main_hbox = gtk_hbox_new(0, 5); + main_vbox = gtk_vbox_new(0, 1); + cards_vbox = gtk_vbox_new(0, 2); + deck_vbox = gtk_vbox_new(0, 10); + buttons_hbox = gtk_hbox_new(0, 0); + buttons2_hbox = gtk_hbox_new(0, 0); + + /* Creation de l'input de recherche */ + filter_input = gtk_entry_new(); + g_signal_connect(G_OBJECT(filter_input), "changed", G_CALLBACK(make_list), (gpointer)gtk_entry_get_text(GTK_ENTRY(filter_input))); + + /* Creation de la fenetre principale */ + pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); + gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER_ON_PARENT); + + gtk_window_set_default_size(GTK_WINDOW(pWindow), 800, 600); + gtk_window_set_title(GTK_WINDOW(pWindow), "Deck editor"); + g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(close_deck_editor), NULL); + + + /* Details du deck */ + GtkWidget *deck_infos_frame = gtk_frame_new("Stats :"); + GtkWidget *deck_infos_label = gtk_label_new("Types"); + GtkWidget *deck_infos_table = gtk_table_new(7, 2, 1); + + GtkWidget *deck_infos_label_creatures = gtk_label_new("Creatures :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_creatures), 0, 1, 0, 1); + deck_infos_label_creatures_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_creatures_data), 1, 2, 0, 1); + + GtkWidget *deck_infos_label_artifact_creatures = gtk_label_new("Artifact-creatures :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_artifact_creatures), 0, 1, 1, 2); + deck_infos_label_artifact_creatures_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_artifact_creatures_data), 1, 2, 1, 2); + + GtkWidget *deck_infos_label_instants = gtk_label_new("Instants :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_instants), 0, 1, 2, 3); + deck_infos_label_instants_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_instants_data), 1, 2, 2, 3); + + GtkWidget *deck_infos_label_enchantments = gtk_label_new("Enchantments :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_enchantments), 0, 1, 3, 4); + deck_infos_label_enchantments_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_enchantments_data), 1, 2, 3, 4); + + GtkWidget *deck_infos_label_sorceries = gtk_label_new("Sorceries :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_sorceries), 0, 1, 4, 5); + deck_infos_label_sorceries_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_sorceries_data), 1, 2, 4, 5); + + GtkWidget *deck_infos_label_artifacts = gtk_label_new("Artifacts :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_artifacts), 0, 1, 5, 6); + deck_infos_label_artifacts_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_artifacts_data), 1, 2, 5, 6); + + GtkWidget *deck_infos_label_lands = gtk_label_new("Lands :"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_lands), 0, 1, 6, 7); + deck_infos_label_lands_data = gtk_label_new("--"); + gtk_table_attach_defaults(GTK_TABLE(deck_infos_table), GTK_WIDGET(deck_infos_label_lands_data), 1, 2, 6, 7); + + + gtk_notebook_insert_page(GTK_NOTEBOOK(deck_tabs), deck_infos_table, deck_infos_label, -1); + + /* Details des manas */ + GtkWidget *deck_manas_label = gtk_label_new("Manas"); + GtkWidget *deck_manas_vbox = gtk_vbox_new(1, 1); + gtk_notebook_insert_page(GTK_NOTEBOOK(deck_tabs), deck_manas_vbox, deck_manas_label, -1); + + label_manas_blue = gtk_label_new("Blue : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_blue); + + label_manas_red = gtk_label_new("Red : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_red); + + label_manas_green = gtk_label_new("Green : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_green); + + label_manas_white = gtk_label_new("White : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_white); + + label_manas_black = gtk_label_new("Black : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_black); + + label_manas_colorless = gtk_label_new("Colorless : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_colorless); + + label_manas_total = gtk_label_new("Total : --"); + gtk_box_pack_start_defaults(GTK_BOX(deck_manas_vbox), label_manas_total); + + + /* Sortable */ + gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(rlist), NAME_COLUMN, GTK_SORT_ASCENDING); + + /* creation de la vue */ + lpListView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(llist)); + + lTreeSelection = gtk_tree_view_get_selection (GTK_TREE_VIEW(lpListView)); + + g_signal_connect(G_OBJECT(lTreeSelection), "changed", G_CALLBACK(show_card_details), NULL); + // g_signal_connect(G_OBJECT(lpListView), "row-activated", G_CALLBACK(add_card_to_deck), (gpointer)gtk_tree_view_get_selection(GTK_TREE_VIEW(lpListView))); + + rpListView = gtk_tree_view_new(); + + rTreeSelection = gtk_tree_view_get_selection(GTK_TREE_VIEW(rpListView)); + g_signal_connect(G_OBJECT(rTreeSelection), "changed", G_CALLBACK(show_card_details), NULL); + + /* Buttons */ + add_button = gtk_button_new_from_stock(GTK_STOCK_ADD); + gtk_box_pack_start_defaults(GTK_BOX(buttons_hbox), GTK_WIDGET(add_button)); + g_signal_connect(G_OBJECT(add_button), "clicked", G_CALLBACK(add_card_to_deck), (gpointer)lTreeSelection); + del_button = gtk_button_new_from_stock(GTK_STOCK_REMOVE); + gtk_box_pack_start_defaults(GTK_BOX(buttons_hbox), GTK_WIDGET(del_button)); + g_signal_connect(G_OBJECT(del_button), "clicked", G_CALLBACK(remove_card_from_deck), (gpointer)rTreeSelection); + reset_button = gtk_button_new_from_stock(GTK_STOCK_DELETE); + gtk_box_pack_start_defaults(GTK_BOX(buttons_hbox), GTK_WIDGET(reset_button)); + g_signal_connect(G_OBJECT(reset_button), "clicked", G_CALLBACK(reset_deck), (gpointer)rTreeSelection); + + /* Buttons 2*/ + load_button = gtk_button_new_from_stock(GTK_STOCK_OPEN); + gtk_box_pack_start_defaults(GTK_BOX(buttons2_hbox), GTK_WIDGET(load_button)); + g_signal_connect(G_OBJECT(load_button), "clicked", G_CALLBACK(load_deck_from_file), NULL); + save_button = gtk_button_new_from_stock(GTK_STOCK_SAVE); + gtk_box_pack_start_defaults(GTK_BOX(buttons2_hbox), GTK_WIDGET(save_button)); + g_signal_connect(G_OBJECT(save_button), "clicked", G_CALLBACK(save_deck_to_file), NULL); + + /* liste des cartes dispos */ + make_list(NULL, NULL); + load_deck(NULL, NULL); + + gtk_widget_set_size_request(lpListView, 250, 0); + + /* creation de la premiere colonne */ + lpCellRenderer = gtk_cell_renderer_text_new(); + rpCellRenderer = gtk_cell_renderer_text_new(); + + pColumn = gtk_tree_view_column_new_with_attributes("Name", + lpCellRenderer, + "text", NAME_COLUMN, + NULL); + + /* ajout de la colonne */ + gtk_tree_view_append_column(GTK_TREE_VIEW(lpListView), pColumn); + + pColumn = gtk_tree_view_column_new_with_attributes("Name", + rpCellRenderer, + "text", NAME_COLUMN, + NULL); + + gtk_tree_view_append_column(GTK_TREE_VIEW(rpListView), pColumn); + + /* creation de la deuxieme colonne */ + lpCellRenderer = gtk_cell_renderer_text_new(); + rpCellRenderer = gtk_cell_renderer_text_new(); + + pColumn = gtk_tree_view_column_new_with_attributes("Cost", + lpCellRenderer, + "text", MANA_COLUMN, + NULL); + + /* ajout de la colonne */ + gtk_tree_view_append_column(GTK_TREE_VIEW(lpListView), pColumn); + + pColumn = gtk_tree_view_column_new_with_attributes("Count", + rpCellRenderer, + "text", MANA_COLUMN, + NULL); + + gtk_tree_view_append_column(GTK_TREE_VIEW(rpListView), pColumn); + + /* ajout de la vue a la fenetre */ + lpScrollbar = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(lpScrollbar), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + + gtk_container_add(GTK_CONTAINER(lpScrollbar), lpListView); + + rpScrollbar = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(rpScrollbar), + GTK_POLICY_AUTOMATIC, + GTK_POLICY_AUTOMATIC); + + + /* prevue de la carte */ + GtkWidget *card_frame = gtk_frame_new("Card Preview"); + GtkWidget *card_vbox = gtk_vbox_new(0, 5); + gtk_widget_set_size_request(card_vbox, 230, 200); + + card_image = gtk_image_new(); + gtk_widget_set_size_request(card_image, 200, 180); + + + + gtk_container_add(GTK_CONTAINER(card_frame), GTK_WIDGET(card_image)); + gtk_container_add(GTK_CONTAINER(deck_infos_frame), GTK_WIDGET(deck_tabs)); + gtk_box_pack_start(GTK_BOX(card_vbox), GTK_WIDGET(card_frame), 1, 1, 0); + gtk_box_pack_start(GTK_BOX(card_vbox), GTK_WIDGET(deck_infos_frame), 1, 1, 0); + + + + gtk_container_add(GTK_CONTAINER(rpScrollbar), rpListView); + + gtk_box_pack_start(GTK_BOX(cards_vbox), GTK_WIDGET(filter_input), 0, 0, 0); + gtk_box_pack_start(GTK_BOX(cards_vbox), GTK_WIDGET(lpScrollbar), 1, 1, 0); + gtk_box_pack_start(GTK_BOX(cards_vbox), GTK_WIDGET(buttons_hbox), 0, 0, 0); + gtk_box_pack_start(GTK_BOX(cards_vbox), GTK_WIDGET(buttons2_hbox), 0, 0, 0); + + gtk_box_pack_start(GTK_BOX(deck_vbox), GTK_WIDGET(rpScrollbar), 1, 1, 0); + + gtk_container_add(GTK_CONTAINER(lframe), cards_vbox); + gtk_container_add(GTK_CONTAINER(rframe), deck_vbox); + + GtkWidget *cards_paned = gtk_hpaned_new(); + + gtk_paned_add1(GTK_PANED(cards_paned), lframe); + gtk_paned_add2(GTK_PANED(cards_paned), rframe); + gtk_box_pack_start(GTK_BOX(main_hbox), cards_paned, 1, 1, 0); + gtk_box_pack_start(GTK_BOX(main_hbox), card_vbox, 0, 0, 0); + + + + + gtk_box_pack_start(GTK_BOX(main_vbox), main_hbox, 1, 1, 0); + gtk_box_pack_start(GTK_BOX(main_vbox), status_bar, 0, 1, 0); + + gtk_container_add(GTK_CONTAINER(pWindow), main_vbox); + + gtk_widget_show_all(pWindow); + +} + + +void make_list(GtkWidget *w, gpointer filter) +{ + struct cardinfo *card = NULL; + gint i; + + gtk_list_store_clear(llist); + + + if ( filter != NULL && strlen((gchar*)filter) > 1 ) + { + /* Insertion des elements */ + for(i = 0 ; i < game->cardbase->num_cards ; i++) + { + GtkTreeIter pIter; + + card = cardbase_get_card(game->cardbase, i); + + if ( card != NULL ) + { + if ( strstr(lowercase(card->name), (gchar*)(lowercase(filter))) != NULL ) + { + + gtk_list_store_append(llist, &pIter); + + /* Mise a jour des donnees */ + gtk_list_store_set(llist, &pIter, + NAME_COLUMN, card->name, + MANA_COLUMN, card->cost, + -1); + } + } + } + + } + else + { + GtkTreeIter pIter; + + gtk_list_store_append(llist, &pIter); + + /* Mise a jour des donnees */ + gtk_list_store_set(llist, &pIter, + NAME_COLUMN, "Please enter", + MANA_COLUMN, "a card name", + -1); + } + + gtk_tree_view_set_model(GTK_TREE_VIEW(lpListView), GTK_TREE_MODEL(llist)); +} + +void reset_deck(GtkWidget *w, gpointer data) +{ + gtk_list_store_clear(rlist); +} + + +void remove_card_from_deck(GtkWidget *w, gpointer data) +{ + GtkTreeIter iter; + GtkTreeModel *model; + gint count; + GtkTreeSelection *selection = (GtkTreeSelection*)data; + + if ( ! gtk_tree_selection_get_selected(selection, &model, &iter)) + return; + + gtk_tree_model_get(GTK_TREE_MODEL(rlist), &iter, NUM_COLUMN, &count, -1); + + if ( count > 1 ) + gtk_list_store_set(rlist, &iter, NUM_COLUMN, (count-1), -1); + else + gtk_list_store_remove(GTK_LIST_STORE(model), &iter); + + update_deck_list(); + update_stats(); + +} + +void add_card_to_deck(GtkWidget *w, gpointer data) +{ + GtkTreeIter pIter, iter, current; + GtkTreeModel *model; + gchar *name; + gboolean valid, exists=0; + int globalid; + + GtkTreeSelection *selection = (GtkTreeSelection*)data; + + struct cardinfo *card_info; + + if (gtk_tree_selection_get_selected (selection, &model, &iter)) + { + gtk_tree_model_get (model, &iter, NAME_COLUMN, &name, -1); + + + globalid = cardbase_find_globalid (game->cardbase, name); + + if ( globalid >= 0 && globalid < game->cardbase->num_cards ) + { + /* Get details of card */ + card_info = cardbase_get_card (game->cardbase, globalid); + + /* Check if card isn't yet in list */ + valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(rlist), ¤t); + + while ( valid ) + { + gchar *str_data; + gint int_data; + gtk_tree_model_get(GTK_TREE_MODEL(rlist), ¤t, NAME_COLUMN, &str_data, NUM_COLUMN, &int_data, -1); + + if ( strcmp(str_data, card_info->name) == 0 ) + { + g_free(str_data); + exists = 1; + break; + } + + g_free(str_data); + + valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(rlist), ¤t); + } + + /* We don't have such a card in our deck */ + if ( ! exists ) + { + gtk_list_store_append(rlist, &pIter); + gtk_list_store_set(rlist, &pIter, + NAME_COLUMN, card_info->name, + NUM_COLUMN, 1, + -1); + } + /* We already have the same card, so num++ */ + else + { + gint count; + gtk_tree_model_get(GTK_TREE_MODEL(rlist), ¤t, NUM_COLUMN, &count, -1); + gtk_list_store_set(rlist, ¤t, NUM_COLUMN, (count+1), -1); + } + } + } + + update_deck_list(); + update_stats(); + + +} + +void update_stats() +{ + struct cardinfo *card; + int creatures = 0, artifact_creatures = 0, sorceries = 0, instants = 0, enchantments = 0, others = 0, artifacts=0, total=0, lands=0; + int manas_blue=0, manas_red=0, manas_green=0, manas_white=0, manas_black=0, manas_nocolor=0, manas_total=0; + gboolean valid; + GtkTreeIter current; + gint globalid; + + if ( ! (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(rlist), ¤t)) ) + return; + + while ( valid ) + { + gint count; + gchar *name; + + gtk_tree_model_get(GTK_TREE_MODEL(rlist), ¤t, NAME_COLUMN, &name, NUM_COLUMN, &count, -1); + + /* Get card infos */ + globalid = cardbase_find_globalid(game->cardbase, name); + card = cardbase_get_card(game->cardbase, globalid); + + /* Statistics */ + if ( strncmp(card->cardtype, "Creature", 8) == 0 ) + creatures+=count; + else if ( strncmp(card->cardtype, "Artifact Creature", 17) == 0 ) + artifact_creatures+=count; + else if ( strstr(card->cardtype, "Sorcery" ) ) + sorceries+=count; + else if ( strstr(card->cardtype, "Instant") ) + instants+=count; + else if ( strstr(card->cardtype, "Enchant") ) + enchantments+=count; + else if ( strstr(card->cardtype, "Artifact") ) + artifacts+=count; + else if ( strstr(card->cardtype, "Land") || ( strstr(card->cardtype, "D,ON") ) ) + lands+=count; + else + others+=count; + + /* Manas */ + char *cost = card->cost; + while ( *cost != '\0' ) + { + switch ( *cost ) + { + case 'R': + manas_red += count; + break; + case 'W': + manas_white += count; + break; + case 'U': + manas_blue += count; + break; + case 'B': + manas_black += count; + break; + case 'G': + manas_green += count; + break; + case 'X': + manas_nocolor += count * 2; + break; + default: + manas_nocolor += count * (*cost - 48); + } + cost++; + } + + + /* cleanups */ + g_free(name); + + valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(rlist), ¤t); + } + + total = creatures+artifact_creatures+sorceries+instants+enchantments+others+lands; + + + char *stats; + + manas_total = manas_red + manas_white + manas_blue + manas_green + manas_black + manas_nocolor; + + asprintf(&stats, "Blue : %d (%d %%)", manas_blue, ((manas_blue * 100) / manas_total)); + gtk_label_set_label(GTK_LABEL(label_manas_blue), stats); + + asprintf(&stats, "Red : %d (%d %%)", manas_red, ((manas_red * 100) / manas_total)); + gtk_label_set_label(GTK_LABEL(label_manas_red), stats); + + asprintf(&stats, "Green : %d (%d %%)", manas_green, ((manas_green * 100) / manas_total)); + gtk_label_set_label(GTK_LABEL(label_manas_green), stats); + + asprintf(&stats, "White : %d (%d %%)", manas_white, ((manas_white * 100) / manas_total)); + gtk_label_set_label(GTK_LABEL(label_manas_white), stats); + + asprintf(&stats, "Black : %d (%d %%)", manas_black, ((manas_black * 100) / manas_total)); + gtk_label_set_label(GTK_LABEL(label_manas_black), stats); + + asprintf(&stats, "Colorless : %d (%d %%)", manas_nocolor, ((manas_nocolor * 100) / manas_total)); + gtk_label_set_label(GTK_LABEL(label_manas_colorless), stats); + + asprintf(&stats, "Total : %d (%0.2f / spell)", manas_total, (manas_total / (float)(total-lands))); + gtk_label_set_label(GTK_LABEL(label_manas_total), stats); + + + + /* Types */ + + asprintf(&stats, "Available cards : %d. Cards in Deck : %d.", game->cardbase->num_cards, total); + gtk_statusbar_push(GTK_STATUSBAR(status_bar), (guint)NULL, stats); + + asprintf(&stats, "%d (%d %%)", creatures, ((creatures * 100) / total )); + gtk_label_set_label(GTK_LABEL(deck_infos_label_creatures_data), stats); + + asprintf(&stats, "%d (%d %%)", artifact_creatures, ((artifact_creatures * 100) / total)); + gtk_label_set_label(GTK_LABEL(deck_infos_label_artifact_creatures_data), stats); + + asprintf(&stats, "%d (%d %%)", instants, ((instants * 100) / total)); + gtk_label_set_label(GTK_LABEL(deck_infos_label_instants_data), stats); + + asprintf(&stats, "%d (%d %%)", enchantments, ((enchantments * 100) / total)); + gtk_label_set_label(GTK_LABEL(deck_infos_label_enchantments_data), stats); + + asprintf(&stats, "%d (%d %%)", sorceries, ((sorceries * 100) / total)); + gtk_label_set_label(GTK_LABEL(deck_infos_label_sorceries_data), stats); + + asprintf(&stats, "%d (%d %%)", artifacts, ((artifacts * 100) / total)); + gtk_label_set_label(GTK_LABEL(deck_infos_label_artifacts_data), stats); + + asprintf(&stats, "%d (%d %%)", lands, ((lands * 100) / total)); + gtk_label_set_label(GTK_LABEL(deck_infos_label_lands_data), stats); + + free(stats); + +} + +void update_deck_list() +{ + gtk_tree_view_set_model(GTK_TREE_VIEW(rpListView), GTK_TREE_MODEL(rlist)); +} + +void load_deck(GtkWidget *w, gpointer data) +{ + int i=0,count=0; + int globalid; + struct deck *deck = game->player[game->local_player]->deck; + struct cardinfo *card; + + reset_deck(NULL, NULL); + + if ( data == NULL ) + { + if ( deck != NULL ) + while (i < deck->size) + { + globalid = deck->cardlist[i]; + if ( globalid >= 0 && globalid < game->cardbase->num_cards ) + { + count = 1; + while (deck->cardlist[i+count] == globalid) + count++; + + GtkTreeIter pIter; + gtk_list_store_append(rlist, &pIter); + + /* Get card infos */ + card = cardbase_get_card(game->cardbase, globalid); + + /* Ajout de la carte */ + gtk_list_store_set(rlist, &pIter, + NAME_COLUMN, card->name, + NUM_COLUMN, count, + -1); + + } + i+=count; + } + + } + + update_deck_list(); + update_stats(); + +} + +void save_deck_to_file(GtkWidget *w, gpointer data) +{ + GtkWidget *filesel = gtk_file_selection_new("Save deck to..."); + GtkFileSelection *fsp = GTK_FILE_SELECTION(filesel); + + g_signal_connect(G_OBJECT(fsp->cancel_button), "clicked", G_CALLBACK(save_deck_to_file_cancel), filesel); + g_signal_connect(G_OBJECT(fsp->ok_button), "clicked", G_CALLBACK(save_deck_to_file_ok), filesel); + + gtk_widget_show(filesel); + +} + +void save_deck_to_file_ok(GtkWidget *w, GtkWidget *dialog) +{ + struct deck *deck = game->player[game->local_player]->deck; + GtkTreeIter current; + deck_destroy(deck); + deck = deck_new(); + gboolean valid; + gint globalid; + const char *filename; + + filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)); + if ( filename == NULL ) + { + do_message_dialog("Please enter a file name"); + return; + } + + if ( ! (valid = gtk_tree_model_get_iter_first (GTK_TREE_MODEL(rlist), ¤t)) ) + return; + + while ( valid ) + { + gchar *name; + gint num; + + gtk_tree_model_get (GTK_TREE_MODEL(rlist), ¤t, NAME_COLUMN, &name, NUM_COLUMN, &num, -1); + globalid = cardbase_find_globalid(game->cardbase, name); + + if ( globalid >= 0 && globalid < game->cardbase->num_cards ) + deck_set_card(deck, deck->size, num, globalid); + + g_free(name); + + valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(rlist), ¤t); + } + + deck_write_file((char*)filename, deck, game->cardbase); + game->player[game->local_player]->deck = deck_read_file(filename, game->cardbase); + set_preference(game->prefs, "deck_name", filename); + + gtk_widget_destroy(dialog); +} + +void save_deck_to_file_cancel(GtkWidget *w, GtkWidget *dialog) +{ + gtk_widget_destroy(dialog); +} + +void load_deck_from_file(GtkWidget *w, gpointer data) +{ + GtkWidget *filesel = gtk_file_selection_new("Load deck from file..."); + GtkFileSelection *fsp = GTK_FILE_SELECTION(filesel); + + g_signal_connect(G_OBJECT(fsp->cancel_button), "clicked", G_CALLBACK(load_deck_from_file_cancel), filesel); + g_signal_connect(G_OBJECT(fsp->ok_button), "clicked", G_CALLBACK(load_deck_from_file_ok), filesel); + + gtk_widget_show(filesel); +} + +void load_deck_from_file_cancel(GtkWidget *w, GtkWidget *dialog) +{ + gtk_widget_destroy(dialog); +} + +void load_deck_from_file_ok(GtkWidget *w, GtkWidget *dialog) +{ + const char *filename = gtk_file_selection_get_filename (GTK_FILE_SELECTION (dialog)); + if ( filename == NULL ) + { + do_message_dialog("Please select a deck file !"); + return; + } + + game->player[game->local_player]->deck = deck_read_file(filename, game->cardbase); + + load_deck(w, NULL); + + set_preference(game->prefs, "deck_name", filename); + + gtk_widget_destroy(dialog); +} + +void show_card_details(GtkTreeSelection *selection, gpointer data) +{ + GtkTreeIter iter; + GtkTreeModel *model; + gchar *name; + struct cardinfo *card_info; + GdkPixbuf *image; + + if (gtk_tree_selection_get_selected (selection, &model, &iter)) + { + gtk_tree_model_get (model, &iter, NAME_COLUMN, &name, -1); + + + int globalid = cardbase_find_globalid (game->cardbase, name); + if ( globalid >= 0 ) + { + card_info = cardbase_get_card (game->cardbase, globalid); + + card_info->art = cardart_load_cardart3(card_info->name, card_info->expansion, FALSE); + + image = cardart_get_card_image(card_info); + if ( image != NULL ) + gtk_image_set_from_pixbuf(GTK_IMAGE(card_image), image); + + } + + g_object_unref(image); + g_free (name); + + } +} + +void close_deck_editor(GtkWidget *w, gpointer data) +{ + gtk_widget_destroy(w); +} diff -uN mindless-1.6/deck_editor.h mindless-1.6-deckeditor/deck_editor.h --- mindless-1.6/deck_editor.h 1970-01-01 01:00:00.000000000 +0100 +++ mindless-1.6-deckeditor/deck_editor.h 2005-09-19 19:49:05.000000000 +0200 @@ -0,0 +1,25 @@ +#ifndef _DECK_EDITOR_H +#define _DECK_EDITOR_H + +#include + +#include "game.h" + +void deck_editor(struct game *game); +void close_deck_editor(GtkWidget *w, gpointer data); +void make_list(GtkWidget *w, gpointer filter); +void load_deck(GtkWidget *w, gpointer filter); +void add_card_to_deck(GtkWidget *w, gpointer data); +void show_card_details(GtkTreeSelection *selection, gpointer filter); +void update_stats(); +void update_deck_list(); +void remove_card_from_deck(GtkWidget *w, gpointer data); +void reset_deck(GtkWidget *w, gpointer data); +void save_deck_to_file(GtkWidget *w, gpointer data); +void save_deck_to_file_ok(GtkWidget *w, GtkWidget *dialog); +void save_deck_to_file_cancel(GtkWidget *w, GtkWidget *dialog); +void load_deck_from_file(GtkWidget *w, gpointer data); +void load_deck_from_file_cancel(GtkWidget *w, GtkWidget *dialog); +void load_deck_from_file_ok(GtkWidget *w, GtkWidget *dialog); + +#endif /* _DECK_EDITOR_H */ diff -uN mindless-1.6/game.h mindless-1.6-deckeditor/game.h --- mindless-1.6/game.h 2005-06-28 06:34:16.000000000 +0200 +++ mindless-1.6-deckeditor/game.h 2005-09-19 19:49:05.000000000 +0200 @@ -1,3 +1,6 @@ +#ifndef _GAME_H +#define _GAME_H + #define UNTAP_PHASE 0 #define UPKEEP_PHASE 1 #define DRAW_PHASE 2 @@ -113,3 +116,5 @@ void game_load_expansions (struct game *game); #include "kplayer.h" + +#endif /* GAME_H */ Les sous-répertoires mindless-1.6/ICONS et mindless-1.6-deckeditor/ICONS sont identiques. diff -uN mindless-1.6/Makefile mindless-1.6-deckeditor/Makefile --- mindless-1.6/Makefile 2005-07-08 04:31:19.000000000 +0200 +++ mindless-1.6-deckeditor/Makefile 2005-09-19 19:49:52.000000000 +0200 @@ -9,7 +9,7 @@ OBJS= mindless.o deck.o zone.o playarea.o cardbase.o newgame.o \ game.o kplayer.o opponent.o dialogs.o prefs.o fgetline.o \ cardart.o proto-appr.o encrypt.o http_fetcher.o random.o \ - viewcard.o expansions.o sealed.o images.o + viewcard.o expansions.o sealed.o images.o deck_editor.o ICONS= ICONS/lifeset.svg ICONS/ping.svg ICONS/hand.svg \ ICONS/deck.svg ICONS/graveyard.svg ICONS/removed.svg \ @@ -74,3 +74,4 @@ sealed.o: sealed.c game.h deck.h dialogs.h cardbase.h expansions.h \ sealed.h random.h newgame.h images.o: images.c _images.c images.h +deck_editor.o: deck_editor.c deck_editor.h diff -uN mindless-1.6/mindless.c mindless-1.6-deckeditor/mindless.c --- mindless-1.6/mindless.c 2005-07-07 17:36:32.000000000 +0200 +++ mindless-1.6-deckeditor/mindless.c 2005-09-19 19:50:49.000000000 +0200 @@ -25,6 +25,8 @@ #include "random.h" #include "version.h" #include "images.h" +#include "deck_editor.h" + static void add_tools (GtkToolbar *toolbar); static void add_phase_button (GtkToolbar *, char *, char *, int, const char *); @@ -70,6 +72,7 @@ static void do_preferences (GtkWidget *w, gpointer data); static void do_set_name (GtkWidget *w, gpointer data); static void do_about_box (GtkWidget *w, gpointer data); +static void do_deck_editor (GtkWidget *w, gpointer data); static int set_name_callback (struct game *game, gpointer data, const char *text); static void do_view_card (GtkWidget *w, struct game *game); static int entry_box_key_pressed (GtkWidget *, GdkEventKey *, gpointer); @@ -96,8 +99,10 @@ { "/File/_New Game...", "", do_new_game, 0, MICON(M_NEW_ICON) }, { "/File/_Load Card Data...", "", do_load_cardbase, 0, MICON(GTK_STOCK_OPEN) }, { "/File/sep1", NULL, NULL, 0, "" }, - { "/File/_Disconnect", "", do_disconnect, 0, MICON(GTK_STOCK_STOP) }, + { "/File/D_eck Editor...", "", do_deck_editor, 0, MICON(GTK_STOCK_JUMP_TO) }, { "/File/sep2", NULL, NULL, 0, "" }, + { "/File/_Disconnect", "", do_disconnect, 0, MICON(GTK_STOCK_STOP) }, + { "/File/sep3", NULL, NULL, 0, "" }, { "/File/_Quit", "", do_exit, 0, MICON(GTK_STOCK_QUIT) }, { "/_Game", NULL, NULL, 0, "" }, @@ -465,6 +470,17 @@ new_game_dialog (game); } +static void do_deck_editor(GtkWidget *w, gpointer data) +{ + if (game->cardbase == NULL) + { + do_find_cardinfo_dialog(game); + return; + } + deck_editor(game); + +} + static void do_disconnect (GtkWidget *w, gpointer data) { int pid;