trunk/RenegadeMapSelector/MapSelector.cpp

// Renegade Map Selector
//
// Douglas Thrift
//
// MapSelector.cpp

#include "MapSelector.h"

#ifndef _WIN32

MapSelector::MapSelector()
{
        window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

        gtk_window_set_title(GTK_WINDOW(window), "Renegade Map Selector");
        gtk_window_set_resizable(GTK_WINDOW(window), false);
        g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(destruct),
                this);

        GtkWidget* vertical = gtk_vbox_new(false, 0);
        GtkWidget* horizontal = gtk_hbox_new(false, 9);
        GtkWidget* left = gtk_frame_new("Available Maps");

        gtk_frame_set_label_align(GTK_FRAME(left), 0.5, 0.5);
        gtk_container_set_border_width(GTK_CONTAINER(left), 6);

        GtkWidget* leftScroll = gtk_scrolled_window_new(NULL, NULL);
        
        gtk_container_set_border_width(GTK_CONTAINER(leftScroll), 6);
        gtk_widget_set_size_request(leftScroll, 150, 200);
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(leftScroll),
                GTK_SHADOW_IN);

        available = gtk_tree_view_new();

        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(available), false);
        setupAvailable();

        GtkWidget* center = gtk_vbox_new(true, 0);
        GtkWidget* top = gtk_vbutton_box_new();

        gtk_button_box_set_layout(GTK_BUTTON_BOX(top), GTK_BUTTONBOX_START);
        gtk_box_set_spacing(GTK_BOX(top), 9);
        gtk_container_set_border_width(GTK_CONTAINER(top), 6);

        add = gtk_button_new_with_mnemonic("_Add");

        g_signal_connect(G_OBJECT(add), "clicked", G_CALLBACK(mapAdd), this);
        gtk_widget_set_sensitive(add, false);

        remove = gtk_button_new_with_mnemonic("_Remove");

        g_signal_connect(G_OBJECT(remove), "clicked", G_CALLBACK(mapRemove), this);
        gtk_widget_set_sensitive(remove, false);

        GtkWidget* middle = gtk_vbutton_box_new();

        gtk_button_box_set_layout(GTK_BUTTON_BOX(middle), GTK_BUTTONBOX_END);
        gtk_box_set_spacing(GTK_BOX(middle), 9);
        gtk_container_set_border_width(GTK_CONTAINER(middle), 6);

        up = gtk_button_new_with_mnemonic("_Up");

        g_signal_connect(G_OBJECT(up), "clicked", G_CALLBACK(mapUp), this);
        gtk_widget_set_sensitive(up, false);

        down = gtk_button_new_with_mnemonic("_Down");

        g_signal_connect(G_OBJECT(down), "clicked", G_CALLBACK(mapDown), this);
        gtk_widget_set_sensitive(down, false);

        GtkWidget* right = gtk_frame_new("Selected Maps");

        gtk_frame_set_label_align(GTK_FRAME(right), 0.5, 0.5);
        gtk_container_set_border_width(GTK_CONTAINER(right), 6);

        GtkWidget* rightScroll = gtk_scrolled_window_new(NULL, NULL);

        gtk_container_set_border_width(GTK_CONTAINER(rightScroll), 6);
        gtk_widget_set_size_request(rightScroll, 150, 200);
        gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(rightScroll),
                GTK_SHADOW_IN);

        selected = gtk_tree_view_new();

        gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(selected), false);
        setupSelected();

        GtkWidget* separator = gtk_hseparator_new();
        GtkWidget* bottom = gtk_hbutton_box_new();

        gtk_button_box_set_layout(GTK_BUTTON_BOX(bottom), GTK_BUTTONBOX_END);
        gtk_box_set_spacing(GTK_BOX(bottom), 9);
        gtk_container_set_border_width(GTK_CONTAINER(bottom), 6);

        GtkWidget* ok = gtk_button_new_from_stock(GTK_STOCK_OK);

        g_signal_connect(G_OBJECT(ok), "clicked", G_CALLBACK(done), this);

        GtkWidget* cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);

        g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(destruct), this);

        // pack
        gtk_container_add(GTK_CONTAINER(vertical), horizontal);
        gtk_container_add(GTK_CONTAINER(horizontal), left);
        gtk_container_add(GTK_CONTAINER(left), leftScroll);
        gtk_container_add(GTK_CONTAINER(leftScroll), available);
        gtk_container_add(GTK_CONTAINER(horizontal), center);
        gtk_container_add(GTK_CONTAINER(center), top);
        gtk_container_add(GTK_CONTAINER(top), add);
        gtk_container_add(GTK_CONTAINER(top), remove);
        gtk_container_add(GTK_CONTAINER(center), middle);
        gtk_container_add(GTK_CONTAINER(middle), up);
        gtk_container_add(GTK_CONTAINER(middle), down);
        gtk_container_add(GTK_CONTAINER(horizontal), right);
        gtk_container_add(GTK_CONTAINER(right), rightScroll);
        gtk_container_add(GTK_CONTAINER(rightScroll), selected);
        gtk_container_add(GTK_CONTAINER(vertical), separator);
        gtk_container_add(GTK_CONTAINER(bottom), ok);
        gtk_container_add(GTK_CONTAINER(bottom), cancel);
        gtk_container_add(GTK_CONTAINER(vertical), bottom);
        gtk_container_add(GTK_CONTAINER(window), vertical);

        // show
        gtk_widget_show(available);
        gtk_widget_show(leftScroll);
        gtk_widget_show(left);
        gtk_widget_show(add);
        gtk_widget_show(remove);
        gtk_widget_show(top);
        gtk_widget_show(up);
        gtk_widget_show(down);
        gtk_widget_show(middle);
        gtk_widget_show(center);
        gtk_widget_show(selected);
        gtk_widget_show(rightScroll);
        gtk_widget_show(right);
        gtk_widget_show(horizontal);
        gtk_widget_show(separator);
        gtk_widget_show(ok);
        gtk_widget_show(cancel);
        gtk_widget_show(bottom);
        gtk_widget_show(vertical);
        gtk_widget_show(window);

        gtk_main();
}

void MapSelector::setupAvailable()
{
        GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);

        char* directory = new char[MAXPATHLEN + 1];
        getcwd(directory, MAXPATHLEN + 1);
        if (debug) cerr << "directory = " << directory << "\n";

        char* data = new char[strlen(directory) + 6];
        sprintf(data, "%s/data", directory);
        delete [] directory;
        if (debug) cerr << "data = " << data << "\n";

        DIR* dir = opendir(data);
        delete [] data;

        GtkTreeIter itor;
        dirent* file;
        while ((file = readdir(dir)) != NULL)
        {
                string name = file->d_name;

                if (name.rfind(".mix") == name.length() - 4)
                {
                        gtk_list_store_append(store, &itor);
                        gtk_list_store_set(store, &itor, 0, name.c_str(), -1);
                }
        }

        closedir(dir);

        gtk_tree_view_set_model(GTK_TREE_VIEW(available), GTK_TREE_MODEL(store));

        GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
        GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(NULL,
                renderer, "text", 0, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(available), column);
}

void MapSelector::setupSelected()
{
        GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);

        vector<string> maps = config->getMaps();

        GtkTreeIter itor;
        for (unsigned index = 0; index < maps.size(); index++)
        {
                gtk_list_store_append(store, &itor);
                gtk_list_store_set(store, &itor, 0, maps[index].c_str(), -1);
        }

        gtk_tree_view_set_model(GTK_TREE_VIEW(selected), GTK_TREE_MODEL(store));

        GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
        GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(NULL,
                renderer, "text", 0, NULL);

        gtk_tree_view_append_column(GTK_TREE_VIEW(selected), column);
}

void destruct(GtkWidget* widget, MapSelector* data)
{
        gtk_main_quit();
}

void done(GtkWidget* widget, MapSelector* data)
{
        GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
                );
        
        GtkTreeIter itor;
        if (!gtk_tree_model_get_iter_first(store, &itor))
        {
                message(GTK_WINDOW(data->window), "You need at least one map.",
                        "No Maps", GTK_MESSAGE_INFO);
        }
        else
        {
                vector<string> maps;

                do
                {
                        char* name;

                        gtk_tree_model_get(store, &itor, 0, &name, -1);
                        maps.push_back(name);

                        g_free(name);
                }
                while (gtk_tree_model_iter_next(store, &itor));

                config->setMaps(maps);
                
                config->save();

                gtk_main_quit();
        }
}

void mapAdd(GtkWidget* widget, MapSelector* data)
{
        cout << "STUB: add\n\a" << flush;
}

void mapRemove(GtkWidget* widget, MapSelector* data)
{
        cout << "STUB: remove\n\a" << flush;
}

void mapUp(GtkWidget* widget, MapSelector* data)
{
        cout << "STUB: up\n\a" << flush;
}

void mapDown(GtkWidget* widget, MapSelector* data)
{
        cout << "STUB: down\n\a" << flush;
}

#endif
Revision:	92
Committed:	2003-03-15T22:23:04-08:00 (22 years, 3 months ago) by douglas
File size:	7505 byte(s)
Log Message:	Oops again and changed clean in GNUmakefile.
#	User	Rev	Content
1	douglas	86	// Renegade Map Selector
2			//
3			// Douglas Thrift
4			//
5			// MapSelector.cpp
6
7	douglas	87	#include "MapSelector.h"
8
9	douglas	86	#ifndef _WIN32
10
11			MapSelector::MapSelector()
12			{
13			window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
14
15			gtk_window_set_title(GTK_WINDOW(window), "Renegade Map Selector");
16			gtk_window_set_resizable(GTK_WINDOW(window), false);
17			g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(destruct),
18	douglas	87	this);
19	douglas	86
20			GtkWidget* vertical = gtk_vbox_new(false, 0);
21			GtkWidget* horizontal = gtk_hbox_new(false, 9);
22			GtkWidget* left = gtk_frame_new("Available Maps");
23
24			gtk_frame_set_label_align(GTK_FRAME(left), 0.5, 0.5);
25			gtk_container_set_border_width(GTK_CONTAINER(left), 6);
26
27	douglas	88	GtkWidget* leftScroll = gtk_scrolled_window_new(NULL, NULL);
28
29			gtk_container_set_border_width(GTK_CONTAINER(leftScroll), 6);
30			gtk_widget_set_size_request(leftScroll, 150, 200);
31			gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(leftScroll),
32			GTK_SHADOW_IN);
33
34			available = gtk_tree_view_new();
35
36			gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(available), false);
37			setupAvailable();
38
39	douglas	86	GtkWidget* center = gtk_vbox_new(true, 0);
40			GtkWidget* top = gtk_vbutton_box_new();
41
42			gtk_button_box_set_layout(GTK_BUTTON_BOX(top), GTK_BUTTONBOX_START);
43			gtk_box_set_spacing(GTK_BOX(top), 9);
44			gtk_container_set_border_width(GTK_CONTAINER(top), 6);
45
46			add = gtk_button_new_with_mnemonic("_Add");
47
48	douglas	87	g_signal_connect(G_OBJECT(add), "clicked", G_CALLBACK(mapAdd), this);
49	douglas	86	gtk_widget_set_sensitive(add, false);
50
51			remove = gtk_button_new_with_mnemonic("_Remove");
52
53	douglas	87	g_signal_connect(G_OBJECT(remove), "clicked", G_CALLBACK(mapRemove), this);
54	douglas	86	gtk_widget_set_sensitive(remove, false);
55
56			GtkWidget* middle = gtk_vbutton_box_new();
57
58			gtk_button_box_set_layout(GTK_BUTTON_BOX(middle), GTK_BUTTONBOX_END);
59			gtk_box_set_spacing(GTK_BOX(middle), 9);
60			gtk_container_set_border_width(GTK_CONTAINER(middle), 6);
61
62			up = gtk_button_new_with_mnemonic("_Up");
63
64	douglas	87	g_signal_connect(G_OBJECT(up), "clicked", G_CALLBACK(mapUp), this);
65	douglas	86	gtk_widget_set_sensitive(up, false);
66
67			down = gtk_button_new_with_mnemonic("_Down");
68
69	douglas	87	g_signal_connect(G_OBJECT(down), "clicked", G_CALLBACK(mapDown), this);
70	douglas	86	gtk_widget_set_sensitive(down, false);
71
72			GtkWidget* right = gtk_frame_new("Selected Maps");
73
74			gtk_frame_set_label_align(GTK_FRAME(right), 0.5, 0.5);
75			gtk_container_set_border_width(GTK_CONTAINER(right), 6);
76
77	douglas	88	GtkWidget* rightScroll = gtk_scrolled_window_new(NULL, NULL);
78
79			gtk_container_set_border_width(GTK_CONTAINER(rightScroll), 6);
80			gtk_widget_set_size_request(rightScroll, 150, 200);
81			gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(rightScroll),
82			GTK_SHADOW_IN);
83
84			selected = gtk_tree_view_new();
85
86			gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(selected), false);
87			setupSelected();
88
89	douglas	86	GtkWidget* separator = gtk_hseparator_new();
90			GtkWidget* bottom = gtk_hbutton_box_new();
91
92			gtk_button_box_set_layout(GTK_BUTTON_BOX(bottom), GTK_BUTTONBOX_END);
93			gtk_box_set_spacing(GTK_BOX(bottom), 9);
94			gtk_container_set_border_width(GTK_CONTAINER(bottom), 6);
95
96			GtkWidget* ok = gtk_button_new_from_stock(GTK_STOCK_OK);
97
98	douglas	87	g_signal_connect(G_OBJECT(ok), "clicked", G_CALLBACK(done), this);
99	douglas	86
100			GtkWidget* cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
101
102	douglas	87	g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(destruct), this);
103	douglas	86
104			// pack
105			gtk_container_add(GTK_CONTAINER(vertical), horizontal);
106			gtk_container_add(GTK_CONTAINER(horizontal), left);
107	douglas	88	gtk_container_add(GTK_CONTAINER(left), leftScroll);
108			gtk_container_add(GTK_CONTAINER(leftScroll), available);
109	douglas	86	gtk_container_add(GTK_CONTAINER(horizontal), center);
110			gtk_container_add(GTK_CONTAINER(center), top);
111			gtk_container_add(GTK_CONTAINER(top), add);
112			gtk_container_add(GTK_CONTAINER(top), remove);
113			gtk_container_add(GTK_CONTAINER(center), middle);
114			gtk_container_add(GTK_CONTAINER(middle), up);
115			gtk_container_add(GTK_CONTAINER(middle), down);
116			gtk_container_add(GTK_CONTAINER(horizontal), right);
117	douglas	88	gtk_container_add(GTK_CONTAINER(right), rightScroll);
118			gtk_container_add(GTK_CONTAINER(rightScroll), selected);
119	douglas	86	gtk_container_add(GTK_CONTAINER(vertical), separator);
120			gtk_container_add(GTK_CONTAINER(bottom), ok);
121			gtk_container_add(GTK_CONTAINER(bottom), cancel);
122			gtk_container_add(GTK_CONTAINER(vertical), bottom);
123			gtk_container_add(GTK_CONTAINER(window), vertical);
124
125			// show
126	douglas	88	gtk_widget_show(available);
127			gtk_widget_show(leftScroll);
128	douglas	86	gtk_widget_show(left);
129			gtk_widget_show(add);
130			gtk_widget_show(remove);
131			gtk_widget_show(top);
132			gtk_widget_show(up);
133			gtk_widget_show(down);
134			gtk_widget_show(middle);
135			gtk_widget_show(center);
136	douglas	88	gtk_widget_show(selected);
137			gtk_widget_show(rightScroll);
138	douglas	86	gtk_widget_show(right);
139			gtk_widget_show(horizontal);
140			gtk_widget_show(separator);
141			gtk_widget_show(ok);
142			gtk_widget_show(cancel);
143			gtk_widget_show(bottom);
144			gtk_widget_show(vertical);
145			gtk_widget_show(window);
146
147			gtk_main();
148			}
149
150	douglas	88	void MapSelector::setupAvailable()
151			{
152			GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
153
154			char* directory = new char[MAXPATHLEN + 1];
155			getcwd(directory, MAXPATHLEN + 1);
156			if (debug) cerr << "directory = " << directory << "\n";
157
158			char* data = new char[strlen(directory) + 6];
159			sprintf(data, "%s/data", directory);
160			delete [] directory;
161			if (debug) cerr << "data = " << data << "\n";
162
163			DIR* dir = opendir(data);
164			delete [] data;
165
166			GtkTreeIter itor;
167			dirent* file;
168			while ((file = readdir(dir)) != NULL)
169			{
170			string name = file->d_name;
171
172			if (name.rfind(".mix") == name.length() - 4)
173			{
174			gtk_list_store_append(store, &itor);
175			gtk_list_store_set(store, &itor, 0, name.c_str(), -1);
176			}
177			}
178
179			closedir(dir);
180
181			gtk_tree_view_set_model(GTK_TREE_VIEW(available), GTK_TREE_MODEL(store));
182
183			GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
184			GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(NULL,
185			renderer, "text", 0, NULL);
186
187			gtk_tree_view_append_column(GTK_TREE_VIEW(available), column);
188			}
189
190			void MapSelector::setupSelected()
191			{
192	douglas	89	GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);
193
194			vector<string> maps = config->getMaps();
195
196			GtkTreeIter itor;
197			for (unsigned index = 0; index < maps.size(); index++)
198			{
199			gtk_list_store_append(store, &itor);
200			gtk_list_store_set(store, &itor, 0, maps[index].c_str(), -1);
201			}
202
203			gtk_tree_view_set_model(GTK_TREE_VIEW(selected), GTK_TREE_MODEL(store));
204
205			GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
206			GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(NULL,
207			renderer, "text", 0, NULL);
208
209			gtk_tree_view_append_column(GTK_TREE_VIEW(selected), column);
210	douglas	88	}
211
212			void destruct(GtkWidget* widget, MapSelector* data)
213			{
214			gtk_main_quit();
215			}
216
217			void done(GtkWidget* widget, MapSelector* data)
218			{
219	douglas	89	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
220			);
221
222			GtkTreeIter itor;
223			if (!gtk_tree_model_get_iter_first(store, &itor))
224	douglas	88	{
225			message(GTK_WINDOW(data->window), "You need at least one map.",
226	douglas	92	"No Maps", GTK_MESSAGE_INFO);
227	douglas	88	}
228			else
229			{
230	douglas	89	vector<string> maps;
231	douglas	88
232	douglas	89	do
233			{
234			char* name;
235
236			gtk_tree_model_get(store, &itor, 0, &name, -1);
237			maps.push_back(name);
238
239			g_free(name);
240			}
241			while (gtk_tree_model_iter_next(store, &itor));
242
243			config->setMaps(maps);
244
245	douglas	88	config->save();
246
247			gtk_main_quit();
248			}
249			}
250
251			void mapAdd(GtkWidget* widget, MapSelector* data)
252			{
253			cout << "STUB: add\n\a" << flush;
254			}
255
256			void mapRemove(GtkWidget* widget, MapSelector* data)
257			{
258			cout << "STUB: remove\n\a" << flush;
259			}
260
261			void mapUp(GtkWidget* widget, MapSelector* data)
262			{
263			cout << "STUB: up\n\a" << flush;
264			}
265
266			void mapDown(GtkWidget* widget, MapSelector* data)
267			{
268			cout << "STUB: down\n\a" << flush;
269			}
270
271	douglas	86	#endif