forked from Mirrors/openclonk
834 lines
18 KiB
C
834 lines
18 KiB
C
/*
|
|
* mape - C4 Landscape.txt editor
|
|
*
|
|
* Copyright (c) 2005-2009, Armin Burgmeier
|
|
*
|
|
* Distributed under the terms of the ISC license; see accompanying file
|
|
* "COPYING" for details.
|
|
*
|
|
* "Clonk" is a registered trademark of Matthes Bender, used with permission.
|
|
* See accompanying file "TRADEMARK" for details.
|
|
*
|
|
* To redistribute this file separately, substitute the full license texts
|
|
* for the above references.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <gtksourceview/gtksourceview.h>
|
|
#include <gtksourceview/gtksourcebuffer.h>
|
|
#include "mape/mapgen.h"
|
|
#include "mape/random.h"
|
|
#include "mape/preferences.h"
|
|
#include "mape/mattexview.h"
|
|
#include "mape/editview.h"
|
|
#include "mape/statusbar.h"
|
|
#include "mape/preview.h"
|
|
|
|
typedef struct _ThreadData ThreadData;
|
|
struct _ThreadData {
|
|
MapeEditView* view;
|
|
gchar* source;
|
|
MapeMapgenType type;
|
|
gchar* file_path;
|
|
MapeMaterialMap* mat_map;
|
|
MapeTextureMap* tex_map;
|
|
guint map_width;
|
|
guint map_height;
|
|
gdouble map_zoom;
|
|
gint64 start_time;
|
|
};
|
|
|
|
typedef struct _ThreadResult ThreadResult;
|
|
struct _ThreadResult {
|
|
MapeEditView* view;
|
|
GdkPixbuf* pixbuf;
|
|
GError* error;
|
|
guint idle_id;
|
|
gint64 start_time;
|
|
};
|
|
|
|
static void mape_edit_view_set_filename(MapeEditView* view,
|
|
const gchar* filename)
|
|
{
|
|
MapeMapgenType new_type;
|
|
GtkSourceBuffer* buf;
|
|
|
|
gchar* basename;
|
|
gchar* utf8_file;
|
|
gchar* utf8_file_casefold;
|
|
gchar* utf8_landscape_txt_casefold;
|
|
|
|
const gchar* lang_name;
|
|
const gchar* lang_filename;
|
|
GtkSourceLanguage* lang;
|
|
GtkSourceStyleScheme* style;
|
|
GtkWidget* error_dialog;
|
|
|
|
buf = GTK_SOURCE_BUFFER(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view) )
|
|
);
|
|
|
|
if (view->file_path != filename)
|
|
{
|
|
if(filename != NULL)
|
|
{
|
|
view->file_path = g_strdup(filename);
|
|
}
|
|
else
|
|
{
|
|
view->file_path = NULL;
|
|
}
|
|
}
|
|
|
|
if(filename != NULL)
|
|
{
|
|
basename = g_path_get_basename(filename);
|
|
|
|
/* Determine document type */
|
|
utf8_file = g_filename_to_utf8(
|
|
basename,
|
|
-1,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
g_free(basename);
|
|
|
|
if(utf8_file != NULL)
|
|
{
|
|
utf8_file_casefold = g_utf8_casefold(utf8_file, -1);
|
|
utf8_landscape_txt_casefold = g_utf8_casefold("landscape.txt", -1);
|
|
g_free(utf8_file);
|
|
|
|
if(g_utf8_collate(utf8_file_casefold, utf8_landscape_txt_casefold) == 0)
|
|
new_type = MAPE_MAPGEN_LANDSCAPE_TXT;
|
|
else
|
|
new_type = MAPE_MAPGEN_MAP_C;
|
|
g_free(utf8_file_casefold);
|
|
g_free(utf8_landscape_txt_casefold);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
new_type = MAPE_MAPGEN_MAP_C;
|
|
}
|
|
|
|
if(new_type != view->type)
|
|
{
|
|
view->type = new_type;
|
|
switch(view->type)
|
|
{
|
|
case MAPE_MAPGEN_LANDSCAPE_TXT:
|
|
lang_name = "c4landscape";
|
|
lang_filename = "Landscape.txt";
|
|
break;
|
|
case MAPE_MAPGEN_MAP_C:
|
|
lang_name = "c4mapscript";
|
|
lang_filename = "Map.c";
|
|
break;
|
|
default:
|
|
lang_name = NULL;
|
|
g_assert_not_reached();
|
|
break;
|
|
}
|
|
|
|
/* Set language according to document type */
|
|
lang = gtk_source_language_manager_get_language(
|
|
view->lang_manager,
|
|
lang_name
|
|
);
|
|
|
|
style = gtk_source_style_scheme_manager_get_scheme(
|
|
view->style_manager,
|
|
"mape"
|
|
);
|
|
|
|
if(lang == NULL || style == NULL)
|
|
{
|
|
/* TODO: Show location where we search in */
|
|
error_dialog = gtk_message_dialog_new(
|
|
NULL,
|
|
GTK_DIALOG_MODAL,
|
|
GTK_MESSAGE_ERROR,
|
|
GTK_BUTTONS_OK,
|
|
"Syntax Highlighting Not Available"
|
|
);
|
|
|
|
gtk_message_dialog_format_secondary_text(
|
|
GTK_MESSAGE_DIALOG(error_dialog),
|
|
"The syntax highlighting file for %s files "
|
|
"could not be located. Perhaps mape has not "
|
|
"been properly installed. Syntax "
|
|
"highlighting is disabled.",
|
|
lang_filename
|
|
);
|
|
|
|
gtk_window_set_title(GTK_WINDOW(error_dialog), "Mape");
|
|
|
|
gtk_dialog_run(GTK_DIALOG(error_dialog) );
|
|
gtk_widget_destroy(error_dialog);
|
|
}
|
|
else
|
|
{
|
|
gtk_source_buffer_set_language(buf, lang);
|
|
gtk_source_buffer_set_style_scheme(buf, style);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
mape_edit_view_thread_result_destroy_func(gpointer data)
|
|
{
|
|
ThreadResult* result = (ThreadResult*)data;
|
|
if(result->pixbuf != NULL) g_object_unref(G_OBJECT(result->pixbuf));
|
|
if(result->error != NULL) g_error_free(result->error);
|
|
/* Don't need to g_source_remove(result->idle_id) since this is
|
|
* only called when the idle handler is removed anyway. */
|
|
}
|
|
|
|
static void mape_edit_view_cb_changed(GtkTextBuffer* buffer,
|
|
gpointer user_data)
|
|
{
|
|
mape_edit_view_reload((MapeEditView*)user_data);
|
|
}
|
|
|
|
static void mape_edit_view_cb_update(GtkWidget* widget,
|
|
GdkEvent* event,
|
|
gpointer user_data)
|
|
{
|
|
mape_edit_view_reload((MapeEditView*)user_data);
|
|
}
|
|
|
|
static GdkPixbuf* mape_edit_view_render_map(const gchar* source,
|
|
MapeMapgenType type,
|
|
const gchar* file_path,
|
|
MapeMaterialMap* mat_map,
|
|
MapeTextureMap* tex_map,
|
|
guint map_width,
|
|
guint map_height,
|
|
gdouble map_zoom,
|
|
GError** error)
|
|
{
|
|
GdkPixbuf* pixbuf;
|
|
gchar* basename;
|
|
gchar* dirname;
|
|
gchar* scriptname;
|
|
const gchar* filename;
|
|
|
|
guint zoom_width;
|
|
guint zoom_height;
|
|
GdkPixbuf* zoombuf;
|
|
|
|
if(mat_map == NULL || tex_map == NULL)
|
|
{
|
|
g_set_error(
|
|
error,
|
|
g_quark_from_static_string("MAPE_EDIT_VIEW_ERROR"),
|
|
MAPE_EDIT_VIEW_ERROR_MISSING_MAPS,
|
|
"Material.ocg is not loaded"
|
|
);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
if(file_path != NULL)
|
|
{
|
|
basename = g_path_get_basename(file_path);
|
|
filename = basename;
|
|
|
|
dirname = g_path_get_dirname(file_path);
|
|
scriptname = g_build_filename(dirname, "Script.c", NULL);
|
|
g_free(dirname);
|
|
}
|
|
else
|
|
{
|
|
basename = NULL;
|
|
scriptname = NULL;
|
|
switch(type)
|
|
{
|
|
case MAPE_MAPGEN_LANDSCAPE_TXT:
|
|
filename = "Landscape.txt";
|
|
break;
|
|
case MAPE_MAPGEN_MAP_C:
|
|
filename = "Map.c";
|
|
break;
|
|
default:
|
|
filename = NULL;
|
|
g_assert_not_reached();
|
|
break;
|
|
}
|
|
}
|
|
|
|
pixbuf = mape_mapgen_render(
|
|
filename,
|
|
source,
|
|
type,
|
|
scriptname,
|
|
mat_map,
|
|
tex_map,
|
|
map_width,
|
|
map_height,
|
|
error
|
|
);
|
|
|
|
/* Zoom image to output size */
|
|
if(pixbuf != NULL)
|
|
{
|
|
map_width = gdk_pixbuf_get_width(pixbuf);
|
|
map_height = gdk_pixbuf_get_height(pixbuf);
|
|
|
|
zoom_width = (guint)(map_width * map_zoom + 0.5);
|
|
zoom_height = (guint)(map_height * map_zoom + 0.5);
|
|
if(map_width != zoom_width || map_height != zoom_height)
|
|
{
|
|
zoombuf = gdk_pixbuf_scale_simple(
|
|
pixbuf,
|
|
zoom_width,
|
|
zoom_height,
|
|
GDK_INTERP_BILINEAR
|
|
);
|
|
|
|
g_object_unref(pixbuf);
|
|
pixbuf = zoombuf;
|
|
}
|
|
}
|
|
|
|
g_free(basename);
|
|
return pixbuf;
|
|
}
|
|
|
|
static gboolean
|
|
mape_edit_view_thread_result(gpointer data_)
|
|
{
|
|
ThreadResult* result;
|
|
MapeEditView* view;
|
|
|
|
gint64 now;
|
|
gchar* time_text;
|
|
|
|
result = (ThreadResult*)data_;
|
|
view = result->view;
|
|
|
|
if(result->pixbuf == NULL)
|
|
{
|
|
g_assert(result->error != NULL);
|
|
|
|
mape_statusbar_set_compile(
|
|
view->statusbar,
|
|
result->error->message
|
|
);
|
|
}
|
|
else
|
|
{
|
|
now = g_get_monotonic_time();
|
|
g_assert(now >= result->start_time);
|
|
|
|
time_text = g_strdup_printf(
|
|
"Landscape rendered successfully (%.2fs)",
|
|
(now - result->start_time) / 1000000.
|
|
);
|
|
|
|
mape_statusbar_set_compile(view->statusbar, time_text);
|
|
g_free(time_text);
|
|
}
|
|
|
|
mape_pre_view_update(view->pre_view, result->pixbuf);
|
|
|
|
/* Finish thread */
|
|
g_thread_join(view->render_thread);
|
|
view->render_thread = NULL;
|
|
|
|
/* Do we have to render again (someone changed
|
|
the source while rendering)? */
|
|
if(view->rerender == TRUE)
|
|
mape_edit_view_reload(view);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gpointer mape_edit_view_thread_entry(gpointer data_)
|
|
{
|
|
ThreadData* data;
|
|
ThreadResult* result;
|
|
GError* error = NULL;
|
|
GdkPixbuf* res_buf;
|
|
|
|
data = (ThreadData*)data_;
|
|
|
|
res_buf = mape_edit_view_render_map(
|
|
data->source,
|
|
data->type,
|
|
data->file_path,
|
|
data->mat_map,
|
|
data->tex_map,
|
|
data->map_width,
|
|
data->map_height,
|
|
data->map_zoom,
|
|
&error
|
|
);
|
|
|
|
result = g_slice_new(ThreadResult);
|
|
result->view = data->view;
|
|
result->pixbuf = res_buf;
|
|
result->error = error;
|
|
result->start_time = data->start_time;
|
|
|
|
g_free(data->source);
|
|
g_free(data->file_path);
|
|
g_slice_free(ThreadData, data);
|
|
|
|
result->idle_id = g_idle_add_full(
|
|
G_PRIORITY_DEFAULT_IDLE,
|
|
mape_edit_view_thread_result,
|
|
result,
|
|
mape_edit_view_thread_result_destroy_func
|
|
);
|
|
|
|
/* Note that you can only use this securly with g_thread_join,
|
|
* otherwise the idle handler might already have been run */
|
|
return result;
|
|
}
|
|
|
|
MapeEditView* mape_edit_view_new(MapePreView* pre_view,
|
|
MapeStatusbar* statusbar,
|
|
GError** error)
|
|
{
|
|
MapeEditView* view;
|
|
GtkSourceBuffer* buf;
|
|
GPtrArray* search_dirs;
|
|
const gchar* const* data_dirs;
|
|
const gchar* const* dir;
|
|
|
|
view = malloc(sizeof(MapeEditView) );
|
|
view->pre_view = pre_view;
|
|
view->statusbar = statusbar;
|
|
view->file_path = NULL;
|
|
view->encoding = "UTF-8";
|
|
view->type = MAPE_MAPGEN_NONE;
|
|
view->render_thread = NULL;
|
|
view->rerender = FALSE;
|
|
view->fixed_seed = FALSE;
|
|
|
|
view->view = gtk_source_view_new();
|
|
buf = GTK_SOURCE_BUFFER(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view) )
|
|
);
|
|
|
|
g_signal_connect_after(
|
|
G_OBJECT(buf),
|
|
"changed",
|
|
G_CALLBACK(mape_edit_view_cb_changed),
|
|
view
|
|
);
|
|
|
|
g_signal_connect(
|
|
G_OBJECT(pre_view->event_box),
|
|
"button-press-event",
|
|
G_CALLBACK(mape_edit_view_cb_update),
|
|
view
|
|
);
|
|
|
|
view->font_desc = pango_font_description_new();
|
|
pango_font_description_set_family(view->font_desc, "monospace");
|
|
gtk_widget_modify_font(view->view, view->font_desc);
|
|
|
|
search_dirs = g_ptr_array_new();
|
|
#ifdef G_OS_WIN32
|
|
g_ptr_array_add(
|
|
search_dirs,
|
|
g_win32_get_package_installation_subdirectory(NULL, NULL, "mape-syntax")
|
|
);
|
|
#endif
|
|
|
|
g_ptr_array_add(
|
|
search_dirs,
|
|
g_build_filename(g_get_home_dir(), ".mape-syntax", NULL)
|
|
);
|
|
|
|
g_ptr_array_add(
|
|
search_dirs,
|
|
g_strdup("./mape-syntax")
|
|
);
|
|
|
|
g_ptr_array_add(
|
|
search_dirs,
|
|
g_strdup("./src/mape/mape-syntax")
|
|
);
|
|
|
|
data_dirs = g_get_system_data_dirs();
|
|
for(dir = data_dirs; *dir != NULL; ++ dir)
|
|
g_ptr_array_add(search_dirs, g_build_filename(*dir, "mape", NULL));
|
|
g_ptr_array_add(search_dirs, NULL);
|
|
|
|
view->lang_manager = gtk_source_language_manager_new();
|
|
gtk_source_language_manager_set_search_path(
|
|
view->lang_manager,
|
|
(gchar**)search_dirs->pdata
|
|
);
|
|
|
|
view->style_manager = gtk_source_style_scheme_manager_new();
|
|
gtk_source_style_scheme_manager_set_search_path(
|
|
view->style_manager,
|
|
(gchar**)search_dirs->pdata
|
|
);
|
|
|
|
g_ptr_array_foreach(search_dirs, (GFunc)g_free, NULL);
|
|
g_ptr_array_free(search_dirs, TRUE);
|
|
|
|
mape_edit_view_set_filename(view, NULL);
|
|
|
|
gtk_widget_show(view->view);
|
|
|
|
view->window = gtk_scrolled_window_new(NULL, NULL);
|
|
|
|
gtk_scrolled_window_set_policy(
|
|
GTK_SCROLLED_WINDOW(view->window),
|
|
GTK_POLICY_AUTOMATIC,
|
|
GTK_POLICY_AUTOMATIC
|
|
);
|
|
|
|
gtk_scrolled_window_set_shadow_type(
|
|
GTK_SCROLLED_WINDOW(view->window),
|
|
GTK_SHADOW_IN
|
|
);
|
|
|
|
gtk_container_add(
|
|
GTK_CONTAINER(view->window),
|
|
view->view
|
|
);
|
|
|
|
gtk_widget_show(view->window);
|
|
return view;
|
|
}
|
|
|
|
void mape_edit_view_destroy(MapeEditView* view)
|
|
{
|
|
gpointer data;
|
|
|
|
/* Wait for render thread to finish */
|
|
if(view->render_thread != NULL)
|
|
{
|
|
data = g_thread_join(view->render_thread);
|
|
view->render_thread = NULL;
|
|
|
|
/* Don't let idle handler run since edit_view is about to be destroyed */
|
|
g_assert(((ThreadResult*)data)->idle_id != 0);
|
|
g_source_remove(((ThreadResult*)data)->idle_id);
|
|
}
|
|
|
|
g_object_unref(G_OBJECT(view->lang_manager) );
|
|
g_object_unref(G_OBJECT(view->style_manager));
|
|
g_free(view->file_path);
|
|
free(view);
|
|
}
|
|
|
|
void mape_edit_view_clear(MapeEditView* view)
|
|
{
|
|
g_free(view->file_path);
|
|
view->file_path = NULL;
|
|
|
|
/* TODO: Undoable action dingsen */
|
|
/* (statische mape_edit_view_set_contents-Call?) */
|
|
gtk_text_buffer_set_text(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view)),
|
|
"",
|
|
0
|
|
);
|
|
|
|
gtk_text_buffer_set_modified(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view)),
|
|
FALSE
|
|
);
|
|
}
|
|
|
|
gboolean mape_edit_view_open(MapeEditView* view,
|
|
const gchar* filename,
|
|
GError** error)
|
|
{
|
|
gboolean result;
|
|
gchar* contents;
|
|
gchar* conv;
|
|
gchar* utf8_file;
|
|
gsize length;
|
|
|
|
result = g_file_get_contents(filename, &contents, &length, error);
|
|
if(result == FALSE) return FALSE;
|
|
|
|
/* Assume UTF-8 */
|
|
result = g_utf8_validate(contents, length, NULL);
|
|
|
|
if(result == FALSE)
|
|
{
|
|
/* No UTF-8, try LATIN1 */
|
|
conv = g_convert(
|
|
contents,
|
|
-1,
|
|
"UTF-8",
|
|
"LATIN1",
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
g_free(contents);
|
|
if(conv == NULL)
|
|
{
|
|
utf8_file = g_filename_to_utf8(
|
|
filename,
|
|
-1,
|
|
NULL,
|
|
NULL,
|
|
NULL
|
|
);
|
|
|
|
if(utf8_file == NULL)
|
|
utf8_file = g_strdup("<unknown file name>");
|
|
|
|
g_set_error(
|
|
error,
|
|
g_quark_from_static_string(
|
|
"MAPE_EDIT_VIEW_ERROR"
|
|
),
|
|
MAPE_EDIT_VIEW_ERROR_UNKNOWN_ENCODING,
|
|
"Could not read file %s: Either the encoding "
|
|
"is unknown or it is a binary file",
|
|
utf8_file
|
|
);
|
|
|
|
g_free(utf8_file);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Conversion succeeded */
|
|
contents = conv;
|
|
view->encoding = "LATIN1";
|
|
}
|
|
else
|
|
{
|
|
view->encoding = "UTF-8";
|
|
}
|
|
|
|
mape_edit_view_set_filename(view, filename);
|
|
|
|
/* TODO: Undoable action dingsen */
|
|
/* (statische mape_edit_view_set_contents-Call?) */
|
|
gtk_text_buffer_set_text(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view)),
|
|
contents,
|
|
length
|
|
);
|
|
|
|
g_free(contents);
|
|
|
|
gtk_text_buffer_set_modified(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view)),
|
|
FALSE
|
|
);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean mape_edit_view_save(MapeEditView* view,
|
|
const gchar* filename,
|
|
GError** error)
|
|
{
|
|
GtkTextBuffer* buffer;
|
|
GtkTextIter begin;
|
|
GtkTextIter end;
|
|
gchar* source;
|
|
gchar* conv;
|
|
gboolean result;
|
|
|
|
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view) );
|
|
gtk_text_buffer_get_start_iter(buffer, &begin);
|
|
gtk_text_buffer_get_end_iter(buffer, &end);
|
|
source = gtk_text_buffer_get_text(buffer, &begin, &end, TRUE);
|
|
|
|
conv = g_convert(
|
|
source,
|
|
-1,
|
|
view->encoding,
|
|
"UTF-8",
|
|
NULL,
|
|
NULL,
|
|
error
|
|
);
|
|
|
|
g_free(source);
|
|
if(conv == NULL) return FALSE;
|
|
|
|
result = g_file_set_contents(filename, conv, -1, error);
|
|
g_free(conv);
|
|
if(result == FALSE) return FALSE;
|
|
|
|
gtk_text_buffer_set_modified(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view)),
|
|
FALSE
|
|
);
|
|
|
|
mape_edit_view_set_filename(view, filename);
|
|
|
|
/* Rerender with new file path --
|
|
* different Script.c lookup for algo=script overlays */
|
|
mape_edit_view_reload(view);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
gboolean mape_edit_view_get_modified(MapeEditView* view)
|
|
{
|
|
return gtk_text_buffer_get_modified(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view->view))
|
|
);
|
|
}
|
|
|
|
void mape_edit_view_undo(MapeEditView* edit_view)
|
|
{
|
|
gtk_source_buffer_undo(
|
|
GTK_SOURCE_BUFFER(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(edit_view->view))
|
|
)
|
|
);
|
|
}
|
|
|
|
void mape_edit_view_redo(MapeEditView* edit_view)
|
|
{
|
|
gtk_source_buffer_redo(
|
|
GTK_SOURCE_BUFFER(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(edit_view->view))
|
|
)
|
|
);
|
|
}
|
|
|
|
void mape_edit_view_apply_preferences(MapeEditView* edit_view,
|
|
MapePreferences* preferences)
|
|
{
|
|
GtkSourceView* view;
|
|
GtkSourceBuffer* buffer;
|
|
GtkWrapMode wrap_mode;
|
|
|
|
view = GTK_SOURCE_VIEW(edit_view->view);
|
|
buffer = GTK_SOURCE_BUFFER(
|
|
gtk_text_view_get_buffer(GTK_TEXT_VIEW(view))
|
|
);
|
|
|
|
gtk_source_view_set_tab_width(
|
|
view,
|
|
preferences->tab_width
|
|
);
|
|
|
|
gtk_source_view_set_insert_spaces_instead_of_tabs(
|
|
view,
|
|
preferences->tab_to_spaces
|
|
);
|
|
|
|
gtk_source_view_set_auto_indent(
|
|
view,
|
|
preferences->auto_indentation
|
|
);
|
|
|
|
wrap_mode = GTK_WRAP_CHAR;
|
|
if(preferences->text_wrapping == FALSE)
|
|
wrap_mode = GTK_WRAP_NONE;
|
|
gtk_text_view_set_wrap_mode(
|
|
GTK_TEXT_VIEW(view),
|
|
wrap_mode
|
|
);
|
|
|
|
gtk_source_view_set_show_line_numbers(
|
|
view,
|
|
preferences->line_numbers
|
|
);
|
|
|
|
gtk_source_view_set_highlight_current_line(
|
|
view,
|
|
preferences->highlight_line
|
|
);
|
|
|
|
gtk_source_buffer_set_highlight_matching_brackets(
|
|
buffer,
|
|
preferences->bracket_matching
|
|
);
|
|
|
|
edit_view->fixed_seed = preferences->fixed_seed;
|
|
edit_view->random_seed = preferences->random_seed;
|
|
edit_view->map_width = preferences->map_width;
|
|
edit_view->map_height = preferences->map_height;
|
|
edit_view->map_zoom = preferences->map_zoom;
|
|
|
|
/* Rerender with new random settings */
|
|
mape_edit_view_reload(edit_view);
|
|
}
|
|
|
|
void mape_edit_view_reload(MapeEditView* edit_view)
|
|
{
|
|
GError* error = NULL;
|
|
ThreadData* data;
|
|
GtkTextBuffer* buffer;
|
|
GtkTextIter begin;
|
|
GtkTextIter end;
|
|
|
|
if(edit_view->render_thread == NULL)
|
|
{
|
|
data = g_slice_new(ThreadData);
|
|
|
|
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(edit_view->view) );
|
|
gtk_text_buffer_get_start_iter(buffer, &begin);
|
|
gtk_text_buffer_get_end_iter(buffer, &end);
|
|
|
|
/* TODO: We need to ref view so that it is guaranteed to be alive in the
|
|
* thread result handler */
|
|
data->view = edit_view;
|
|
data->source = gtk_text_buffer_get_text(buffer, &begin, &end, TRUE);
|
|
data->type = edit_view->type;
|
|
data->file_path = g_strdup(edit_view->file_path);
|
|
|
|
/* TODO: We need to ref these so noone can delete them while the thread
|
|
* uses them. */
|
|
data->mat_map = edit_view->pre_view->mat_tex->mat_map,
|
|
data->tex_map = edit_view->pre_view->mat_tex->tex_map,
|
|
|
|
data->map_width = edit_view->map_width;
|
|
data->map_height = edit_view->map_height;
|
|
data->map_zoom = edit_view->map_zoom;
|
|
data->start_time = g_get_monotonic_time();
|
|
|
|
if(edit_view->fixed_seed == TRUE)
|
|
mape_random_seed(edit_view->random_seed);
|
|
|
|
mape_statusbar_set_compile(
|
|
edit_view->statusbar,
|
|
"Rendering map..."
|
|
);
|
|
|
|
edit_view->rerender = FALSE;
|
|
|
|
edit_view->render_thread = g_thread_create(
|
|
mape_edit_view_thread_entry,
|
|
data,
|
|
TRUE,
|
|
&error
|
|
);
|
|
|
|
if(edit_view->render_thread == NULL)
|
|
{
|
|
mape_statusbar_set_compile(
|
|
edit_view->statusbar,
|
|
error->message
|
|
);
|
|
|
|
g_free(data->source);
|
|
g_slice_free(ThreadData, data);
|
|
|
|
g_error_free(error);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Rerender when thread finished */
|
|
edit_view->rerender = TRUE;
|
|
}
|
|
}
|
|
|