ViewVC Help

View File | Revision Log | Show Annotations | Download File | View Changeset | Root Listing

root/proj/RenegadeMapSelector/MapSelector.cpp

Comparing:
trunk/RenegadeMapSelector/MapSelector.cpp (file contents), Revision 89 by douglas, 2003-03-15T22:00:25-08:00 vs.
RenegadeMapSelector/MapSelector.cpp (file contents), Revision 368 by douglas, 2008-08-23T02:44:00-07:00

#	Line 96 | Line 96 | MapSelector::MapSelector()
96		GtkWidget* ok = gtk_button_new_from_stock(GTK_STOCK_OK);
97
98		g_signal_connect(G_OBJECT(ok), "clicked", G_CALLBACK(done), this);
99	+	GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
100
101		GtkWidget* cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
102
#	Line 144 | Line 145 | MapSelector::MapSelector()
145		gtk_widget_show(vertical);
146		gtk_widget_show(window);
147
148	+	// stuff
149	+	gtk_widget_grab_default(ok);
150	+	gtk_widget_grab_focus(ok);
151	+
152	+	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
153	+	available));
154	+
155	+	gtk_tree_selection_unselect_all(selection);
156	+
157		gtk_main();
158		}
159
#	Line 185 | Line 195 | void MapSelector::setupAvailable()
195		renderer, "text", 0, NULL);
196
197		gtk_tree_view_append_column(GTK_TREE_VIEW(available), column);
198	+
199	+	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
200	+	available));
201	+
202	+	gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
203	+	g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(changeAvailable
204	+	), this);
205		}
206
207		void MapSelector::setupSelected()
#	Line 207 | Line 224 | void MapSelector::setupSelected()
224		renderer, "text", 0, NULL);
225
226		gtk_tree_view_append_column(GTK_TREE_VIEW(selected), column);
227	+
228	+	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
229	+	selected));
230	+
231	+	gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
232	+	g_signal_connect(G_OBJECT(selection), "changed", G_CALLBACK(changeSelected),
233	+	this);
234		}
235
236		void destruct(GtkWidget* widget, MapSelector* data)
#	Line 223 | Line 247 | void done(GtkWidget* widget, MapSelector
247		if (!gtk_tree_model_get_iter_first(store, &itor))
248		{
249		message(GTK_WINDOW(data->window), "You need at least one map.",
250	<	"No Maps", GTK_MESSAGE_WARNING);
250	>	"No Maps", GTK_MESSAGE_INFO);
251		}
252		else
253		{
#	Line 248 | Line 272 | void done(GtkWidget* widget, MapSelector
272		}
273		}
274
275	+	void changeAvailable(GtkTreeSelection* selection, MapSelector* data)
276	+	{
277	+	if (gtk_tree_selection_count_selected_rows(selection) > 0)
278	+	{
279	+	gtk_widget_set_sensitive(data->add, true);
280	+	}
281	+	else
282	+	{
283	+	gtk_widget_set_sensitive(data->add, false);
284	+	}
285	+	}
286	+
287	+	void changeSelected(GtkTreeSelection* selection, MapSelector* data)
288	+	{
289	+	if (gtk_tree_selection_count_selected_rows(selection) > 0)
290	+	{
291	+	gtk_widget_set_sensitive(data->remove, true);
292	+
293	+	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(
294	+	data->selected));
295	+	GtkTreeIter first, last;
296	+
297	+	gtk_tree_model_get_iter_first(store, &first);
298	+	gtk_tree_model_iter_nth_child(store, &last, NULL,
299	+	gtk_tree_model_iter_n_children(store, NULL) - 1);
300	+
301	+	if (!gtk_tree_selection_iter_is_selected(selection, &first))
302	+	{
303	+	gtk_widget_set_sensitive(data->up, true);
304	+	}
305	+	else
306	+	{
307	+	gtk_widget_set_sensitive(data->up, false);
308	+	}
309	+
310	+	if (!gtk_tree_selection_iter_is_selected(selection, &last))
311	+	{
312	+	gtk_widget_set_sensitive(data->down, true);
313	+	}
314	+	else
315	+	{
316	+	gtk_widget_set_sensitive(data->down, false);
317	+	}
318	+	}
319	+	else
320	+	{
321	+	gtk_widget_set_sensitive(data->remove, false);
322	+	gtk_widget_set_sensitive(data->up, false);
323	+	gtk_widget_set_sensitive(data->down, false);
324	+	}
325	+	}
326	+
327		void mapAdd(GtkWidget* widget, MapSelector* data)
328		{
329	<	cout << "STUB: add\n\a" << flush;
329	>	GtkTreeSelection* additions = gtk_tree_view_get_selection(GTK_TREE_VIEW(
330	>	data->available));
331	>
332	>	if (debug) cerr << "additions = {\n";
333	>
334	>	data->counter = 0;
335	>	gtk_tree_selection_selected_foreach(additions, mapAddEach, data);
336	>
337	>	if (debug) cerr << "}\n";
338	>
339	>	gtk_tree_selection_unselect_all(additions);
340	>	}
341	>
342	>	void mapAddEach(GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter,
343	>	MapSelector* data)
344	>	{
345	>	if (debug)
346	>	{
347	>	char* number = gtk_tree_model_get_string_from_iter(model, iter);
348	>
349	>	cerr << "   [" << data->counter++ << "] = " << number << "\n";
350	>
351	>	g_free(number);
352	>	}
353	>
354	>	char* addition;
355	>
356	>	gtk_tree_model_get(model, iter, 0, &addition, -1);
357	>
358	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
359	>	);
360	>	GtkTreeIter itor;
361	>
362	>	gtk_list_store_append(GTK_LIST_STORE(store), &itor);
363	>	gtk_list_store_set(GTK_LIST_STORE(store), &itor, 0, addition, -1);
364	>
365	>	g_free(addition);
366		}
367
368		void mapRemove(GtkWidget* widget, MapSelector* data)
369		{
370	<	cout << "STUB: remove\n\a" << flush;
370	>	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
371	>	data->selected));
372	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
373	>	);
374	>	GList* removals = gtk_tree_selection_get_selected_rows(selection, &store);
375	>
376	>	if (debug) cerr << "removals = {\n";
377	>
378	>	removals = g_list_reverse(removals);
379	>	data->counter = g_list_length(removals) - 1;
380	>	g_list_foreach(removals, mapRemoveEach, data);
381	>
382	>	if (debug) cerr << "}\n";
383	>
384	>	g_list_free(removals);
385	>	gtk_tree_selection_unselect_all(selection);
386	>	}
387	>
388	>	void mapRemoveEach(GtkTreePath* path, MapSelector* data)
389	>	{
390	>	if (debug)
391	>	{
392	>	char* number = gtk_tree_path_to_string(path);
393	>
394	>	cerr << "   [" << data->counter-- << "] = " << number << "\n";
395	>
396	>	g_free(number);
397	>	}
398	>
399	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
400	>	);
401	>	GtkTreeIter itor;
402	>
403	>	gtk_tree_model_get_iter(store, &itor, path);
404	>	gtk_list_store_remove(GTK_LIST_STORE(store), &itor);
405		}
406
407		void mapUp(GtkWidget* widget, MapSelector* data)
408		{
409	<	cout << "STUB: up\n\a" << flush;
409	>	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
410	>	data->selected));
411	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
412	>	);
413	>	GList* ups = gtk_tree_selection_get_selected_rows(selection, &store);
414	>
415	>	if (debug) cerr << "ups = {\n";
416	>
417	>	data->counter = 0;
418	>	data->insert = 0;
419	>	g_list_foreach(ups, mapUpEach, data);
420	>
421	>	if (debug) cerr << "}\n";
422	>
423	>	g_list_free(ups);
424	>	}
425	>
426	>	void mapUpEach(GtkTreePath* path, MapSelector* data)
427	>	{
428	>	if (debug)
429	>	{
430	>	char* number = gtk_tree_path_to_string(path);
431	>
432	>	cerr << "   [" << data->counter++ << "] = " << number << "\n";
433	>
434	>	g_free(number);
435	>	}
436	>
437	>	if (data->insert == 0)
438	>	{
439	>	int* number = gtk_tree_path_get_indices(path);
440	>
441	>	data->insert = *number - 1;
442	>	}
443	>
444	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
445	>	);
446	>	GtkTreeIter itor;
447	>	char* up;
448	>
449	>	gtk_tree_model_get_iter(store, &itor, path);
450	>	gtk_tree_model_get(store, &itor, 0, &up, -1);
451	>	gtk_list_store_remove(GTK_LIST_STORE(store), &itor);
452	>	gtk_list_store_insert(GTK_LIST_STORE(store), &itor, data->insert++);
453	>	gtk_list_store_set(GTK_LIST_STORE(store), &itor, 0, up, -1);
454	>
455	>	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
456	>	data->selected));
457	>
458	>	gtk_tree_selection_select_iter(selection, &itor);
459	>	g_free(up);
460		}
461
462		void mapDown(GtkWidget* widget, MapSelector* data)
463		{
464	<	cout << "STUB: down\n\a" << flush;
464	>	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
465	>	data->selected));
466	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
467	>	);
468	>	GList* downs = gtk_tree_selection_get_selected_rows(selection, &store);
469	>
470	>	if (debug) cerr << "downs = {\n";
471	>
472	>	downs = g_list_reverse(downs);
473	>	data->counter = g_list_length(downs) - 1;
474	>	data->insert = 0;
475	>	g_list_foreach(downs, mapDownEach, data);
476	>
477	>	if (debug) cerr << "}\n";
478	>
479	>	g_list_free(downs);
480	>	}
481	>
482	>	void mapDownEach(GtkTreePath* path, MapSelector* data)
483	>	{
484	>	if (debug)
485	>	{
486	>	char* number = gtk_tree_path_to_string(path);
487	>
488	>	cerr << "   [" << data->counter-- << "] = " << number << "\n";
489	>
490	>	g_free(number);
491	>	}
492	>
493	>	if (data->insert == 0)
494	>	{
495	>	int* number = gtk_tree_path_get_indices(path);
496	>
497	>	data->insert = *number + 1;
498	>	}
499	>
500	>	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
501	>	);
502	>	GtkTreeIter itor;
503	>	char* down;
504	>
505	>	gtk_tree_model_get_iter(store, &itor, path);
506	>	gtk_tree_model_get(store, &itor, 0, &down, -1);
507	>	gtk_list_store_remove(GTK_LIST_STORE(store), &itor);
508	>	gtk_list_store_insert(GTK_LIST_STORE(store), &itor, data->insert--);
509	>	gtk_list_store_set(GTK_LIST_STORE(store), &itor, 0, down, -1);
510	>
511	>	GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(
512	>	data->selected));
513	>
514	>	gtk_tree_selection_select_iter(selection, &itor);
515	>	g_free(down);
516		}
517
518		#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines