?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sourceview: Move preferences in plugins/sourceview
[anjuta.git] / plugins / sourceview / sourceview-io.c
blob3c749f14a6ab1cfbc9ab9750331aad5e9341ecdc
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
2 /*
3 * anjuta-trunk
4 * Copyright (C) Johannes Schmid 2008 <jhs@gnome.org>
5 *
6 * anjuta-trunk is free software: you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * anjuta-trunk is distributed in the hope that it will be useful, but
12 * WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 * See the GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License along
17 * with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "sourceview-io.h"
21 #include "sourceview-private.h"
22 #include <libanjuta/interfaces/ianjuta-editor.h>
23 #include <libanjuta/anjuta-convert.h>
24 #include <libanjuta/anjuta-encodings.h>
25
26 #define READ_SIZE 4096
27 #define RATE_LIMIT 5000 /* Use a big rate limit to avoid duplicates */
28 #define TIMEOUT 5
29
30 enum
31 {
32 SAVE_STATUS,
33 SAVE_FINISHED,
34 OPEN_STATUS,
35 OPEN_FINISHED,
36 OPEN_FAILED,
37 SAVE_FAILED,
38 FILE_DELETED,
39
40 LAST_SIGNAL
41 };
42
43 #define IO_ERROR_QUARK g_quark_from_string ("SourceviewIO-Error")
44
45 static guint io_signals[LAST_SIGNAL] = { 0 };
46
47 G_DEFINE_TYPE (SourceviewIO, sourceview_io, G_TYPE_OBJECT);
48
49 static void
50 sourceview_io_init (SourceviewIO *object)
51 {
52 object->file = NULL;
53 object->filename = NULL;
54 object->read_buffer = NULL;
55 object->write_buffer = NULL;
56 object->cancel = g_cancellable_new();
57 object->monitor = NULL;
58 object->last_encoding = NULL;
59 object->bytes_read = 0;
60 }
61
62 static void
63 sourceview_io_finalize (GObject *object)
64 {
65 SourceviewIO* sio = SOURCEVIEW_IO(object);
66 if (sio->file)
67 g_object_unref (sio->file);
68 g_free(sio->filename);
69 g_free(sio->read_buffer);
70 g_free(sio->write_buffer);
71 g_object_unref (sio->cancel);
72 if (sio->monitor_idle > 0)
73 g_source_remove (sio->monitor_idle);
74 if (sio->monitor)
75 g_object_unref (sio->monitor);
76
77 G_OBJECT_CLASS (sourceview_io_parent_class)->finalize (object);
78 }
79
80 static void
81 sourceview_io_class_init (SourceviewIOClass *klass)
82 {
83 GObjectClass* object_class = G_OBJECT_CLASS (klass);
84
85 object_class->finalize = sourceview_io_finalize;
86
87 klass->changed = NULL;
88 klass->deleted = NULL;
89 klass->save_finished = NULL;
90 klass->open_finished = NULL;
91 klass->open_failed = NULL;
92 klass->save_failed = NULL;
93
94 io_signals[SAVE_STATUS] =
95 g_signal_new ("changed",
96 G_OBJECT_CLASS_TYPE (klass),
97 0,
98 G_STRUCT_OFFSET (SourceviewIOClass, changed),
99 NULL, NULL,
100 g_cclosure_marshal_VOID__VOID,
101 G_TYPE_NONE, 0,
102 NULL);
103
104 io_signals[SAVE_FINISHED] =
105 g_signal_new ("save-finished",
106 G_OBJECT_CLASS_TYPE (klass),
107 0,
108 G_STRUCT_OFFSET (SourceviewIOClass, save_finished),
109 NULL, NULL,
110 g_cclosure_marshal_VOID__VOID,
111 G_TYPE_NONE, 0,
112 NULL);
113
114 io_signals[OPEN_FINISHED] =
115 g_signal_new ("open-finished",
116 G_OBJECT_CLASS_TYPE (klass),
117 0,
118 G_STRUCT_OFFSET (SourceviewIOClass, open_finished),
119 NULL, NULL,
120 g_cclosure_marshal_VOID__VOID,
121 G_TYPE_NONE, 0,
122 NULL);
123
124 io_signals[OPEN_FAILED] =
125 g_signal_new ("open-failed",
126 G_OBJECT_CLASS_TYPE (klass),
127 0,
128 G_STRUCT_OFFSET (SourceviewIOClass, open_failed),
129 NULL, NULL,
130 g_cclosure_marshal_VOID__POINTER,
131 G_TYPE_NONE, 1,
132 G_TYPE_POINTER);
133
134 io_signals[SAVE_FAILED] =
135 g_signal_new ("save-failed",
136 G_OBJECT_CLASS_TYPE (klass),
137 0,
138 G_STRUCT_OFFSET (SourceviewIOClass, save_failed),
139 NULL, NULL,
140 g_cclosure_marshal_VOID__POINTER,
141 G_TYPE_NONE, 1,
142 G_TYPE_POINTER);
143
144 io_signals[FILE_DELETED] =
145 g_signal_new ("deleted",
146 G_OBJECT_CLASS_TYPE (klass),
147 0,
148 G_STRUCT_OFFSET (SourceviewIOClass, deleted),
149 NULL, NULL,
150 g_cclosure_marshal_VOID__VOID,
151 G_TYPE_NONE, 0,
152 NULL);
153 }
154
155 static void on_file_changed (GFileMonitor* monitor,
156 GFile* file,
157 GFile* other_file,
158 GFileMonitorEvent event_type,
159 gpointer data)
160 {
161 SourceviewIO* sio = SOURCEVIEW_IO(data);
162
163 switch (event_type)
164 {
165 case G_FILE_MONITOR_EVENT_CREATED:
166 case G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT:
167 g_signal_emit_by_name (sio, "changed");
168 break;
169 case G_FILE_MONITOR_EVENT_DELETED:
170 g_signal_emit_by_name (sio, "deleted");
171 break;
172 default:
173 break;
174 }
175 }
176
177 static gboolean
178 setup_monitor_idle(gpointer data)
179 {
180 SourceviewIO* sio = SOURCEVIEW_IO(data);
181 sio->monitor_idle = 0;
182 if (sio->monitor != NULL)
183 g_object_unref (sio->monitor);
184 sio->monitor = g_file_monitor_file (sio->file,
185 G_FILE_MONITOR_NONE,
186 NULL,
187 NULL);
188 if (sio->monitor)
189 {
190 g_signal_connect (sio->monitor, "changed",
191 G_CALLBACK(on_file_changed), sio);
192 g_file_monitor_set_rate_limit (sio->monitor, RATE_LIMIT);
193 }
194 return FALSE;
195 }
196
197 static void
198 setup_monitor(SourceviewIO* sio)
199 {
200 if (sio->monitor_idle > 0)
201 g_source_remove (sio->monitor_idle);
202
203 sio->monitor_idle = g_timeout_add_seconds (TIMEOUT,
204 setup_monitor_idle,
205 sio);
206 }
207
208 static void
209 cancel_monitor (SourceviewIO* sio)
210 {
211 if (sio->monitor != NULL)
212 g_object_unref (sio->monitor);
213 sio->monitor = NULL;
214 }
215
216 static void
217 set_display_name (SourceviewIO* sio)
218 {
219 GFileInfo* file_info = g_file_query_info (sio->file,
220 G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
221 G_FILE_QUERY_INFO_NONE,
222 NULL,
223 NULL);
224 if (file_info)
225 {
226 g_free (sio->filename);
227 sio->filename = g_strdup(g_file_info_get_display_name (file_info));
228 }
229 else
230 {
231 g_free (sio->filename);
232 sio->filename = NULL;
233 }
234 g_object_unref (file_info);
235 }
236
237 static void
238 on_save_finished (GObject* file, GAsyncResult* result, gpointer data)
239 {
240 SourceviewIO* sio = SOURCEVIEW_IO(data);
241 AnjutaShell* shell = ANJUTA_PLUGIN (sio->sv->priv->plugin)->shell;
242 GError* err = NULL;
243 g_file_replace_contents_finish (G_FILE (file),
244 result,
245 NULL,
246 &err);
247 g_free (sio->write_buffer);
248 sio->write_buffer = NULL;
249 if (err)
250 {
251 g_signal_emit_by_name (sio, "save-failed", err);
252 g_error_free (err);
253 }
254 else
255 {
256 set_display_name (sio);
257 setup_monitor (sio);
258 g_signal_emit_by_name (sio, "save-finished");
259 }
260 g_object_unref (sio);
261 anjuta_shell_saving_pop (shell);
262 }
263
264 void
265 sourceview_io_save (SourceviewIO* sio)
266 {
267 if (!sio->file)
268 {
269 GError* error = NULL;
270 g_set_error (&error, IO_ERROR_QUARK, 0,
271 _("Could not save file because filename not yet specified"));
272 g_signal_emit_by_name (sio, "save-failed", error);
273 g_error_free(error);
274 }
275 else
276 sourceview_io_save_as (sio, sio->file);
277 }
278
279 void
280 sourceview_io_save_as (SourceviewIO* sio, GFile* file)
281 {
282 AnjutaShell* shell = ANJUTA_PLUGIN (sio->sv->priv->plugin)->shell;
283 gboolean backup = TRUE;
284 gsize len;
285
286 g_return_if_fail (file != NULL);
287
288 cancel_monitor (sio);
289
290 backup = g_settings_get_boolean (sio->sv->priv->settings,
291 "backup");
292
293 if (sio->last_encoding == NULL)
294 {
295 sio->write_buffer = ianjuta_editor_get_text_all (IANJUTA_EDITOR(sio->sv),
296 NULL);
297 len = strlen (sio->write_buffer);
298 }
299 else
300 {
301 GError* err = NULL;
302 gchar* buffer_text = ianjuta_editor_get_text_all (IANJUTA_EDITOR(sio->sv),
303 NULL);
304 sio->write_buffer = anjuta_convert_from_utf8 (buffer_text,
305 -1,
306 sio->last_encoding,
307 &len,
308 &err);
309 g_free (buffer_text);
310 if (err != NULL)
311 {
312 g_signal_emit_by_name (sio, "save-failed", err);
313 g_error_free(err);
314 return;
315 }
316 }
317 g_cancellable_reset (sio->cancel);
318 g_file_replace_contents_async (file,
319 sio->write_buffer,
320 len,
321 NULL,
322 backup,
323 G_FILE_CREATE_NONE,
324 sio->cancel,
325 on_save_finished,
326 sio);
327 anjuta_shell_saving_push (shell);
328
329 if (sio->file != file)
330 {
331 if (sio->file)
332 g_object_unref (sio->file);
333 sio->file = file;
334 g_object_ref (file);
335 }
336 g_object_ref (sio);
337 }
338
339 static void insert_text_in_document(SourceviewIO* sio, const gchar* text, gsize len)
340 {
341 GtkSourceBuffer* document = GTK_SOURCE_BUFFER (sio->sv->priv->document);
342 gtk_source_buffer_begin_not_undoable_action (GTK_SOURCE_BUFFER (sio->sv->priv->document));
343
344 /* Insert text in the buffer */
345 gtk_text_buffer_set_text (GTK_TEXT_BUFFER (document),
346 text,
347 len);
348
349 gtk_text_buffer_set_modified (GTK_TEXT_BUFFER (document),
350 FALSE);
351
352 gtk_source_buffer_end_not_undoable_action (document);
353 }
354
355 static gboolean
356 append_buffer (SourceviewIO* sio, gsize size)
357 {
358 /* Text is utf-8 - good */
359 if (g_utf8_validate (sio->read_buffer, size, NULL))
360 {
361 insert_text_in_document (sio, sio->read_buffer, size);
362 }
363 else
364 {
365 /* Text is not utf-8 */
366 GError *conv_error = NULL;
367 gchar *converted_text = NULL;
368 gsize new_len = size;
369 const AnjutaEncoding* enc = NULL;
370
371 converted_text = anjuta_convert_to_utf8 (sio->read_buffer,
372 size,
373 &enc,
374 &new_len,
375 &conv_error);
376 if (converted_text == NULL)
377 {
378 /* Last chance, let's try 8859-15 */
379 enc = anjuta_encoding_get_from_charset( "ISO-8859-15");
380 conv_error = NULL;
381 converted_text = anjuta_convert_to_utf8 (sio->read_buffer,
382 size,
383 &enc,
384 &new_len,
385 &conv_error);
386 }
387 if (converted_text == NULL)
388 {
389 g_return_val_if_fail (conv_error != NULL, FALSE);
390
391 g_signal_emit_by_name (sio, "open-failed", conv_error);
392 g_error_free (conv_error);
393 g_cancellable_cancel (sio->cancel);
394 return FALSE;
395 }
396 sio->last_encoding = enc;
397 insert_text_in_document (sio, converted_text, new_len);
398 g_free (converted_text);
399 }
400 return TRUE;
401 }
402
403 static void
404 on_read_finished (GObject* input, GAsyncResult* result, gpointer data)
405 {
406 SourceviewIO* sio = SOURCEVIEW_IO(data);
407 GInputStream* input_stream = G_INPUT_STREAM(input);
408 gsize current_bytes = 0;
409 GError* err = NULL;
410
411 current_bytes = g_input_stream_read_finish (input_stream, result, &err);
412 if (err)
413 {
414 g_signal_emit_by_name (sio, "open-failed", err);
415 g_error_free (err);
416 g_object_unref (input_stream);
417 g_free (sio->read_buffer);
418 sio->read_buffer = NULL;
419 sio->bytes_read = 0;
420 return;
421 }
422
423 sio->bytes_read += current_bytes;
424 if (current_bytes != 0)
425 {
426 sio->read_buffer = g_realloc (sio->read_buffer, sio->bytes_read + READ_SIZE);
427 g_input_stream_read_async (G_INPUT_STREAM (input_stream),
428 sio->read_buffer + sio->bytes_read,
429 READ_SIZE,
430 G_PRIORITY_LOW,
431 sio->cancel,
432 on_read_finished,
433 sio);
434 return;
435 }
436 else
437 {
438 if (append_buffer (sio, sio->bytes_read))
439 g_signal_emit_by_name (sio, "open-finished");
440 sio->bytes_read = 0;
441 g_object_unref (input_stream);
442 setup_monitor (sio);
443 g_free (sio->read_buffer);
444 sio->read_buffer = NULL;
445 }
446 }
447
448 void
449 sourceview_io_open (SourceviewIO* sio, GFile* file)
450 {
451 GFileInputStream* input_stream;
452 GError* err = NULL;
453
454 g_return_if_fail (file != NULL);
455
456 if (sio->file)
457 g_object_unref (sio->file);
458 sio->file = file;
459 g_object_ref (sio->file);
460 set_display_name(sio);
461
462 input_stream = g_file_read (file, NULL, &err);
463 if (!input_stream)
464 {
465 g_signal_emit_by_name (sio, "open-failed", err);
466 g_error_free (err);
467 return;
468 }
469 sio->read_buffer = g_realloc (sio->read_buffer, READ_SIZE);
470 g_input_stream_read_async (G_INPUT_STREAM (input_stream),
471 sio->read_buffer,
472 READ_SIZE,
473 G_PRIORITY_LOW,
474 sio->cancel,
475 on_read_finished,
476 sio);
477 }
478
479 GFile*
480 sourceview_io_get_file (SourceviewIO* sio)
481 {
482 if (sio->file)
483 g_object_ref (sio->file);
484 return sio->file;
485 }
486
487 void
488 sourceview_io_cancel (SourceviewIO* sio)
489 {
490 g_cancellable_cancel (sio->cancel);
491 }
492
493 const gchar*
494 sourceview_io_get_filename (SourceviewIO* sio)
495 {
496 static gint new_file_count = 1;
497 if (sio->filename == NULL) /* new file */
498 {
499 sio->filename = g_strdup_printf (_("New file %d"), new_file_count++);
500 }
501 return sio->filename;
502 }
503
504 void
505 sourceview_io_set_filename (SourceviewIO* sio, const gchar* filename)
506 {
507 g_free (sio->filename);
508 sio->filename = g_strdup(filename);
509 }
510
511 gchar*
512 sourceview_io_get_mime_type (SourceviewIO* sio)
513 {
514 GFileInfo* file_info;
515
516 if (!sio->file)
517 return NULL;
518
519 file_info = g_file_query_info (sio->file,
520 G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
521 G_FILE_QUERY_INFO_NONE,
522 NULL,
523 NULL);
524 if (file_info)
525 {
526 gchar* mime_type = g_strdup (g_file_info_get_content_type (file_info));
527 g_object_unref (file_info);
528 return mime_type;
529 }
530 else
531 return NULL;
532
533 }
534
535 gboolean
536 sourceview_io_get_read_only (SourceviewIO* sio)
537 {
538 GFileInfo* file_info;
539 gboolean retval;
540
541 if (!sio->file)
542 return FALSE;
543
544 file_info = g_file_query_info (sio->file,
545 G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
546 G_FILE_QUERY_INFO_NONE,
547 NULL,
548 NULL);
549 if (!file_info)
550 return FALSE;
551
552 retval = !g_file_info_get_attribute_boolean (file_info,
553 G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
554 g_object_unref (file_info);
555 return retval;
556 }
557
558 SourceviewIO*
559 sourceview_io_new (Sourceview* sv)
560 {
561 SourceviewIO* sio = SOURCEVIEW_IO(g_object_new (SOURCEVIEW_TYPE_IO, NULL));
562 sio->sv = sv;
563 return sio;
564 }
anjuta mirror