geany  1.38
About: Geany is a text editor (using GTK2) with basic features of an integrated development environment (syntax highlighting, code folding, symbol name auto-completion, ...). F: office T: editor programming GTK+ IDE
  Fossies Dox: geany-1.38.tar.bz2  ("unofficial" and yet experimental doxygen-generated source code documentation)  
classbuilder.c
Go to the documentation of this file.
1/*
2 * classbuilder.c - this file is part of Geany, a fast and lightweight IDE
3 *
4 * Copyright 2007 The Geany contributors
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * 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, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
19 */
20
21/* Class Builder - creates source files containing a new class interface and definition. */
22
23#ifdef HAVE_CONFIG_H
24# include "config.h"
25#endif
26
27#include "geanyplugin.h"
28
29GeanyData *geany_data;
30
31
32PLUGIN_VERSION_CHECK(GEANY_API_VERSION)
33
34PLUGIN_SET_INFO(_("Class Builder"), _("Creates source files for new class types."), VERSION,
35 "Alexander Rodin, Ondrej Donek, the Geany developer team")
36
37
38static GtkWidget *main_menu_item = NULL;
39
40
41enum
42{
43 GEANY_CLASS_TYPE_CPP,
44 GEANY_CLASS_TYPE_GTK,
45 GEANY_CLASS_TYPE_PHP
46};
47
48typedef struct _ClassInfo ClassInfo;
49
50struct _ClassInfo
51{
52 gint type;
53 gchar *namespace;
54 gchar *namespace_up;
55 gchar *namespace_low;
56 gchar *class_name;
57 gchar *class_name_up;
58 gchar *class_name_low;
59 gchar *base_name;
60 gchar *base_gtype;
61 gchar *header;
62 gchar *header_guard;
63 gchar *base_include;
64 gchar *base_decl;
65 gchar *constructor_decl;
66 gchar *destructor_decl;
67 gchar *source;
68 gchar *constructor_impl;
69 gchar *destructor_impl;
70 gchar *gtk_destructor_registration;
71 /* These are needed only for PHP classes */
72 gchar *namespace_decl;
73 gchar *implements_decl;
74 gchar *abstract_decl;
75 gchar *singleton_impl;
76};
77
78typedef struct _CreateClassDialog
79{
80 gint class_type;
81 GtkWidget *dialog;
82 GtkWidget *class_name_entry;
83 GtkWidget *header_entry;
84 GtkWidget *source_entry;
85 GtkWidget *base_name_entry;
86 GtkWidget *base_header_entry;
87 GtkWidget *base_header_global_box;
88 GtkWidget *base_gtype_entry;
89 GtkWidget *create_constructor_box;
90 GtkWidget *create_destructor_box;
91 GtkWidget *gtk_constructor_type_entry;
92 /* These are needed only for PHP classes */
93 GtkWidget *class_namespace_entry;
94 GtkWidget *class_implements_entry;
95 GtkWidget *create_isabstract_box;
96 GtkWidget *create_issingleton_box;
97} CreateClassDialog;
98
99
100/* TODO make these templates configurable */
101static const gchar templates_cpp_class_header[] = "{fileheader}\n\n\
102#ifndef {header_guard}\n\
103#define {header_guard}\n\
104{base_include}\n\
105class {class_name}{base_decl}\n\
106{\n\
107 public:\n\
108 {constructor_decl}\
109 {destructor_decl}\
110 \n\
111 private:\n\
112 /* add your private declarations */\n\
113};\n\
114\n\
115#endif /* {header_guard} */ \n\
116";
117
118static const gchar templates_cpp_class_source[] = "{fileheader}\n\n\
119#include \"{header}\"\n\
120\n\
121{constructor_impl}\n\
122{destructor_impl}\n\
123";
124
125static const gchar templates_gtk_class_header[] = "{fileheader}\n\n\
126#ifndef {header_guard}_\n\
127#define {header_guard}_ 1\n\
128{base_include}\n\
129G_BEGIN_DECLS\n\
130\n\n\
131#define {namespace_up}TYPE_{class_name_up} ({namespace_low}{class_name_low}_get_type ())\n\
132#define {namespace_up}{class_name_up}(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), {namespace_up}TYPE_{class_name_up}, {namespace}{class_name}))\n\
133#define {namespace_up}{class_name_up}_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), {namespace_up}TYPE_{class_name_up}, {namespace}{class_name}Class))\n\
134#define {namespace_up}IS_{class_name_up}(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), {namespace_up}TYPE_{class_name_up}))\n\
135#define {namespace_up}IS_{class_name_up}_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), {namespace_up}TYPE_{class_name_up}))\n\
136#define {namespace_up}{class_name_up}_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), {namespace_up}TYPE_{class_name_up}, {namespace}{class_name}Class))\n\
137\n\
138typedef struct {namespace}{class_name}_ {namespace}{class_name};\n\
139typedef struct {namespace}{class_name}Class_ {namespace}{class_name}Class;\n\
140typedef struct {namespace}{class_name}Private_ {namespace}{class_name}Private;\n\
141\n\
142struct {namespace}{class_name}_\n\
143{\n\
144 {base_name} parent;\n\
145 /* add your public declarations here */\n\
146 {namespace}{class_name}Private *priv;\n\
147};\n\
148\n\
149struct {namespace}{class_name}Class_\n\
150{\n\
151 {base_name}Class parent_class;\n\
152};\n\
153\n\n\
154GType {namespace_low}{class_name_low}_get_type (void);\n\n\
155{constructor_decl}\
156\n\n\
157G_END_DECLS\n\
158\n\
159#endif /* {header_guard}_ */\n\
160";
161
162static const gchar templates_gtk_class_source[] = "{fileheader}\n\
163#include \"{header}\"\n\
164\n\
165struct {namespace}{class_name}Private_\n\
166{\n\
167 /* add your private declarations here */\n\
168 gpointer delete_me;\n\
169};\n\
170\n\
171{destructor_decl}\
172\n\
173G_DEFINE_TYPE ({namespace}{class_name}, {namespace_low}{class_name_low}, {base_gtype})\n\
174\n\n\
175static void\n\
176{namespace_low}{class_name_low}_class_init ({namespace}{class_name}Class *klass)\n\
177{\n\
178 {gtk_destructor_registration}\n\
179 g_type_class_add_private ((gpointer)klass, sizeof ({namespace}{class_name}Private));\n\
180}\n\
181\n\
182{destructor_impl}\n\
183\n\
184static void\n\
185{namespace_low}{class_name_low}_init ({namespace}{class_name} *self)\n\
186{\n\
187 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, {namespace_up}TYPE_{class_name_up}, {namespace}{class_name}Private);\n\
188}\n\
189\n\
190{constructor_impl}\n\
191";
192
193static const gchar templates_php_class_source[] = "<?php\n\
194{fileheader}\n\
195{namespace_decl}\n\
196{base_include}\n\
197{abstract_decl}class {class_name}{base_decl}{implements_decl}\n{\n\
198{singleton_impl}\
199{constructor_impl}\
200{destructor_impl}\n\
201 // ...\n\n\
202}\n\
203";
204
205
206static void cc_dlg_on_set_sensitive_toggled(GtkWidget *toggle_button, GtkWidget *target_widget);
207static void cc_dlg_on_class_name_entry_changed(GtkWidget *entry, CreateClassDialog *cc_dlg);
208static void cc_dlg_on_class_namespace_entry_changed(GtkWidget *entry, CreateClassDialog *cc_dlg);
209static void cc_dlg_on_base_name_entry_changed(GtkWidget *entry, CreateClassDialog *cc_dlg);
210static gboolean create_class(CreateClassDialog *cc_dlg);
211
212
213/* The list must be ended with NULL as an extra check that arg_count is correct. */
214static void
215free_pointers(gsize arg_count, ...)
216{
217 va_list a;
218 gsize i;
219 gpointer ptr;
220
221 va_start(a, arg_count);
222 for (i = 0; i < arg_count; i++)
223 {
224 ptr = va_arg(a, gpointer);
225 g_free(ptr);
226 }
227 ptr = va_arg(a, gpointer);
228 if (ptr)
229 g_warning("Wrong arg_count!");
230 va_end(a);
231}
232
233
234static gchar*
235get_template_class_header(ClassInfo *class_info)
236{
237 gchar *fileheader = NULL;
238 GString *template = NULL;
239
240 switch (class_info->type)
241 {
242 case GEANY_CLASS_TYPE_CPP:
243 fileheader = templates_get_template_fileheader(GEANY_FILETYPES_CPP, class_info->header);
244 template = g_string_new(templates_cpp_class_header);
245 utils_string_replace_all(template, "{fileheader}", fileheader);
246 utils_string_replace_all(template, "{header_guard}", class_info->header_guard);
247 utils_string_replace_all(template, "{base_include}", class_info->base_include);
248 utils_string_replace_all(template, "{class_name}", class_info->class_name);
249 utils_string_replace_all(template, "{base_decl}", class_info->base_decl);
250 utils_string_replace_all(template, "{constructor_decl}",
251 class_info->constructor_decl);
252 utils_string_replace_all(template, "{destructor_decl}",
253 class_info->destructor_decl);
254 break;
255
256 case GEANY_CLASS_TYPE_GTK:
257 fileheader = templates_get_template_fileheader(GEANY_FILETYPES_C, class_info->header);
258 template = g_string_new(templates_gtk_class_header);
259 utils_string_replace_all(template, "{fileheader}", fileheader);
260 utils_string_replace_all(template, "{header_guard}", class_info->header_guard);
261 utils_string_replace_all(template, "{base_include}", class_info->base_include);
262 utils_string_replace_all(template, "{namespace}", class_info->namespace);
263 utils_string_replace_all(template, "{namespace_up}", class_info->namespace_up);
264 utils_string_replace_all(template, "{namespace_low}", class_info->namespace_low);
265 utils_string_replace_all(template, "{class_name}", class_info->class_name);
266 utils_string_replace_all(template, "{class_name_up}", class_info->class_name_up);
267 utils_string_replace_all(template, "{class_name_low}", class_info->class_name_low);
268 utils_string_replace_all(template, "{base_name}", class_info->base_name);
269 utils_string_replace_all(template, "{constructor_decl}",
270 class_info->constructor_decl);
271 break;
272 }
273
274 g_free(fileheader);
275
276 if (template)
277 return g_string_free(template, FALSE);
278 else
279 return NULL;
280}
281
282
283static gchar*
284get_template_class_source(ClassInfo *class_info)
285{
286 gchar *fileheader = NULL;
287 GString *template = NULL;
288
289 switch (class_info->type)
290 {
291 case GEANY_CLASS_TYPE_CPP:
292 fileheader = templates_get_template_fileheader(GEANY_FILETYPES_CPP, class_info->source);
293 template = g_string_new(templates_cpp_class_source);
294 utils_string_replace_all(template, "{fileheader}", fileheader);
295 utils_string_replace_all(template, "{header}", class_info->header);
296 utils_string_replace_all(template, "{class_name}", class_info->class_name);
297 utils_string_replace_all(template, "{base_include}", class_info->base_include);
298 utils_string_replace_all(template, "{base_name}", class_info->base_name);
299 utils_string_replace_all(template, "{constructor_impl}",
300 class_info->constructor_impl);
301 utils_string_replace_all(template, "{destructor_impl}",
302 class_info->destructor_impl);
303 break;
304
305 case GEANY_CLASS_TYPE_GTK:
306 fileheader = templates_get_template_fileheader(GEANY_FILETYPES_C, class_info->source);
307 template = g_string_new(templates_gtk_class_source);
308 utils_string_replace_all(template, "{fileheader}", fileheader);
309 utils_string_replace_all(template, "{header}", class_info->header);
310 utils_string_replace_all(template, "{namespace}", class_info->namespace);
311 utils_string_replace_all(template, "{namespace_up}", class_info->namespace_up);
312 utils_string_replace_all(template, "{namespace_low}", class_info->namespace_low);
313 utils_string_replace_all(template, "{class_name}", class_info->class_name);
314 utils_string_replace_all(template, "{class_name_up}", class_info->class_name_up);
315 utils_string_replace_all(template, "{class_name_low}", class_info->class_name_low);
316 utils_string_replace_all(template, "{base_name}", class_info->base_name);
317 utils_string_replace_all(template, "{base_gtype}", class_info->base_gtype);
318 utils_string_replace_all(template, "{destructor_decl}", class_info->destructor_decl);
319 utils_string_replace_all(template, "{constructor_impl}",
320 class_info->constructor_impl);
321 utils_string_replace_all(template, "{destructor_impl}",
322 class_info->destructor_impl);
323 utils_string_replace_all(template, "{gtk_destructor_registration}",
324 class_info->gtk_destructor_registration);
325 break;
326
327 case GEANY_CLASS_TYPE_PHP:
328 fileheader = templates_get_template_fileheader(GEANY_FILETYPES_PHP, class_info->source);
329 template = g_string_new(templates_php_class_source);
330 utils_string_replace_all(template, "{fileheader}", fileheader);
331 utils_string_replace_all(template, "{namespace_decl}", class_info->namespace_decl);
332 utils_string_replace_all(template, "{base_include}", class_info->base_include);
333 utils_string_replace_all(template, "{abstract_decl}", class_info->abstract_decl);
334 utils_string_replace_all(template, "{class_name}", class_info->class_name);
335 utils_string_replace_all(template, "{base_decl}", class_info->base_decl);
336 utils_string_replace_all(template, "{implements_decl}", class_info->implements_decl);
337 utils_string_replace_all(template, "{constructor_impl}", class_info->constructor_impl);
338 utils_string_replace_all(template, "{destructor_impl}", class_info->destructor_impl);
339 utils_string_replace_all(template, "{singleton_impl}", class_info->singleton_impl);
340 break;
341 }
342
343 g_free(fileheader);
344
345 if (template)
346 return g_string_free(template, FALSE);
347 else
348 return NULL;
349}
350
351/* Creates a new option label, indented on the left */
352static GtkWidget *cc_option_label_new(const gchar *text)
353{
354 GtkWidget *align;
355 GtkWidget *label;
356
357 align = gtk_alignment_new(0.0, 0.5, 1.0, 1.0);
358 gtk_alignment_set_padding(GTK_ALIGNMENT(align), 0, 0, 12, 0);
359
360 label = gtk_label_new(text);
361 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
362 gtk_container_add(GTK_CONTAINER(align), label);
363
364 return align;
365}
366
367/* Attaches a new section label at the specified table row, optionally
368 * padded at the top, and returns the new label. */
369static GtkWidget *cc_table_attach_section_label(GtkWidget *table, const gchar *text,
370 guint row, gboolean top_padding)
371{
372 gchar *markup;
373 GtkWidget *label, *align;
374
375 label = gtk_label_new(NULL);
376 markup = g_markup_printf_escaped("<b>%s</b>", text);
377 gtk_label_set_markup(GTK_LABEL(label), markup);
378 g_free(markup);
379 gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
380
381 align = gtk_alignment_new(0.0, 0.5, 1.0, 1.0);
382 if (top_padding)
383 gtk_alignment_set_padding(GTK_ALIGNMENT(align), 6, 0, 0, 0);
384 gtk_container_add(GTK_CONTAINER(align), label);
385
386 gtk_table_attach(GTK_TABLE(table), align,
387 0, 2, row, row+1,
388 GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
389
390 return label;
391}
392
393/* Attach a new option label at the specified table row and returns
394 * the label */
395static GtkWidget *cc_table_attach_option_label(GtkWidget *table, const gchar *text, guint row)
396{
397 GtkWidget *opt_label = cc_option_label_new(text);
398 gtk_table_attach(GTK_TABLE(table), opt_label,
399 0, 1, row, row+1,
400 GTK_FILL|GTK_SHRINK, GTK_FILL|GTK_SHRINK, 0, 0);
401 return opt_label;
402}
403
404/* Attach an option label and entry to the table at the specified row.
405 * The label associated with the widget is set as data on the entry
406 * with the "label" key, if access to it is needed later. The entry
407 * widget is returned. */
408static GtkWidget *cc_table_attach_option_entry(GtkWidget *table, const gchar *text, guint row)
409{
410 GtkWidget *label;
411 GtkWidget *entry;
412 label = cc_table_attach_option_label(table, text, row);
413 entry = gtk_entry_new();
414 g_object_set_data(G_OBJECT(entry), "label", label);
415 gtk_table_attach(GTK_TABLE(table), entry,
416 1, 2, row, row+1,
417 GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0);
418 return entry;
419}
420
421static void show_dialog_create_class(gint type)
422{
423 CreateClassDialog *cc_dlg;
424 GtkWidget *main_box, *table, *label, *hdr_hbox;
425 GtkWidget *opt_table, *align;
426 guint row;
427
428 cc_dlg = g_new0(CreateClassDialog, 1);
429 cc_dlg->class_type = type;
430
431 cc_dlg->dialog = gtk_dialog_new_with_buttons(_("Create Class"),
432 GTK_WINDOW(geany->main_widgets->window),
433 GTK_DIALOG_MODAL,
434 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
435 GTK_STOCK_OK, GTK_RESPONSE_OK,
436 NULL);
437
438 switch (type)
439 {
440 case GEANY_CLASS_TYPE_CPP:
441 gtk_window_set_title(GTK_WINDOW(cc_dlg->dialog), _("Create C++ Class"));
442 break;
443 case GEANY_CLASS_TYPE_GTK:
444 gtk_window_set_title(GTK_WINDOW(cc_dlg->dialog), _("Create GTK+ Class"));
445 break;
446 case GEANY_CLASS_TYPE_PHP:
447 gtk_window_set_title(GTK_WINDOW(cc_dlg->dialog), _("Create PHP Class"));
448 break;
449 }
450
451 g_signal_connect_swapped(cc_dlg->dialog, "destroy", G_CALLBACK(g_free), (gpointer)cc_dlg);
452
453 table = gtk_table_new(13, 2, FALSE);
454 gtk_table_set_col_spacings(GTK_TABLE(table), 6);
455 gtk_table_set_row_spacings(GTK_TABLE(table), 6);
456
457 main_box = ui_dialog_vbox_new(GTK_DIALOG(cc_dlg->dialog));
458 gtk_box_pack_start(GTK_BOX(main_box), table, TRUE, TRUE, 0);
459
460 row = 0;
461
462 if (type == GEANY_CLASS_TYPE_PHP || type == GEANY_CLASS_TYPE_GTK)
463 {
464 cc_table_attach_section_label(table, _("Namespace"), row++, FALSE);
465 cc_dlg->class_namespace_entry = cc_table_attach_option_entry(table, _("Name:"), row++);
466 g_signal_connect(cc_dlg->class_namespace_entry, "changed",
467 G_CALLBACK(cc_dlg_on_class_namespace_entry_changed), cc_dlg);
468 }
469
470 if (type == GEANY_CLASS_TYPE_PHP || type == GEANY_CLASS_TYPE_GTK)
471 cc_table_attach_section_label(table, _("Class"), row++, TRUE);
472 else
473 cc_table_attach_section_label(table, _("Class"), row++, FALSE);
474
475 cc_dlg->class_name_entry = cc_table_attach_option_entry(table, _("Name:"), row++);
476 g_signal_connect(cc_dlg->class_name_entry, "changed",
477 G_CALLBACK(cc_dlg_on_class_name_entry_changed), cc_dlg);
478
479 if (type != GEANY_CLASS_TYPE_PHP)
480 cc_dlg->header_entry = cc_table_attach_option_entry(table, _("Header file:"), row++);
481
482 cc_dlg->source_entry = cc_table_attach_option_entry(table, _("Source file:"), row++);
483
484 cc_table_attach_section_label(table, _("Inheritance"), row++, TRUE);
485
486 cc_dlg->base_name_entry = cc_table_attach_option_entry(table, _("Base class:"), row++);
487
488 if (type == GEANY_CLASS_TYPE_GTK)
489 gtk_entry_set_text(GTK_ENTRY(cc_dlg->base_name_entry), "GObject");
490 g_signal_connect(cc_dlg->base_name_entry, "changed",
491 G_CALLBACK(cc_dlg_on_base_name_entry_changed), (gpointer)cc_dlg);
492
493 if (type == GEANY_CLASS_TYPE_PHP)
494 cc_dlg->base_header_entry = cc_table_attach_option_entry(table, _("Base source:"), row++);
495 else
496 {
497 hdr_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
498
499 label = cc_table_attach_option_label(table, _("Base header:"), row);
500
501 cc_dlg->base_header_entry = gtk_entry_new();
502 g_object_set_data(G_OBJECT(cc_dlg->base_header_entry), "label", label);
503 gtk_box_pack_start(GTK_BOX(hdr_hbox),
504 cc_dlg->base_header_entry,
505 TRUE, TRUE, 0);
506
507 cc_dlg->base_header_global_box = gtk_check_button_new_with_label(_("Global"));
508 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cc_dlg->base_header_global_box), TRUE);
509 gtk_box_pack_start(GTK_BOX(hdr_hbox),
510 cc_dlg->base_header_global_box,
511 FALSE, TRUE, 0);
512
513 gtk_table_attach(GTK_TABLE(table), hdr_hbox,
514 1, 2, row, row+1,
515 GTK_FILL | GTK_EXPAND,
516 GTK_FILL | GTK_EXPAND,
517 0, 0);
518 row++;
519 }
520
521 if (type == GEANY_CLASS_TYPE_GTK)
522 gtk_entry_set_text(GTK_ENTRY(cc_dlg->base_header_entry), "glib-object.h");
523
524 if (type == GEANY_CLASS_TYPE_GTK)
525 {
526 cc_dlg->base_gtype_entry = cc_table_attach_option_entry(table, _("Base GType:"), row++);
527 gtk_entry_set_text(GTK_ENTRY(cc_dlg->base_gtype_entry), "G_TYPE_OBJECT");
528 }
529
530 if (type == GEANY_CLASS_TYPE_PHP)
531 cc_dlg->class_implements_entry = cc_table_attach_option_entry(table, _("Implements:"), row++);
532
533 cc_table_attach_section_label(table, _("Options"), row++, TRUE);
534
535 align = gtk_alignment_new(0.0, 0.5, 1.0, 1.0);
536 gtk_alignment_set_padding(GTK_ALIGNMENT(align), 0, 0, 12, 0);
537
538 opt_table = gtk_table_new(1, 2, FALSE);
539 gtk_table_set_row_spacings(GTK_TABLE(opt_table), 6);
540 gtk_table_set_col_spacings(GTK_TABLE(opt_table), 6);
541 gtk_container_add(GTK_CONTAINER(align), opt_table);
542
543 gtk_table_attach(GTK_TABLE(table), align,
544 0, 2, row, row+1,
545 GTK_FILL|GTK_EXPAND,
546 GTK_FILL|GTK_EXPAND,
547 0, 0);
548 row++;
549
550 cc_dlg->create_constructor_box = gtk_check_button_new_with_label(_("Create constructor"));
551 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cc_dlg->create_constructor_box), TRUE);
552 gtk_table_attach(GTK_TABLE(opt_table), cc_dlg->create_constructor_box,
553 0, 1, 0, 1, GTK_FILL|GTK_SHRINK, GTK_FILL|GTK_SHRINK, 0, 0);
554
555 cc_dlg->create_destructor_box = gtk_check_button_new_with_label(_("Create destructor"));
556 gtk_table_attach(GTK_TABLE(opt_table), cc_dlg->create_destructor_box,
557 1, 2, 0, 1, GTK_FILL|GTK_SHRINK, GTK_FILL|GTK_SHRINK, 0, 0);
558
559 if (type == GEANY_CLASS_TYPE_PHP)
560 {
561 gtk_table_resize(GTK_TABLE(opt_table), 2, 2);
562 cc_dlg->create_isabstract_box = gtk_check_button_new_with_label(_("Is abstract"));
563 gtk_table_attach(GTK_TABLE(opt_table), cc_dlg->create_isabstract_box,
564 0, 1, 1, 2, GTK_FILL|GTK_SHRINK, GTK_FILL|GTK_SHRINK, 0, 0);
565 cc_dlg->create_issingleton_box = gtk_check_button_new_with_label(_("Is singleton"));
566 gtk_table_attach(GTK_TABLE(opt_table), cc_dlg->create_issingleton_box,
567 1, 2, 1, 2, GTK_FILL|GTK_SHRINK, GTK_FILL|GTK_SHRINK, 0, 0);
568 }
569
570 gtk_widget_show_all(align);
571
572 if (type == GEANY_CLASS_TYPE_GTK)
573 {
574 cc_dlg->gtk_constructor_type_entry = cc_table_attach_option_entry(table,
575 _("Constructor type:"), row++);
576 gtk_entry_set_text(GTK_ENTRY(cc_dlg->gtk_constructor_type_entry), "GObject");
577 g_signal_connect(cc_dlg->create_constructor_box, "toggled",
578 G_CALLBACK(cc_dlg_on_set_sensitive_toggled),
579 cc_dlg->gtk_constructor_type_entry);
580 }
581 else if (type == GEANY_CLASS_TYPE_PHP)
582 gtk_table_resize(GTK_TABLE(table), row, 2);
583 else if (type == GEANY_CLASS_TYPE_CPP)
584 gtk_table_resize(GTK_TABLE(table), row, 2);
585
586 gtk_widget_show_all(cc_dlg->dialog);
587 while (gtk_dialog_run(GTK_DIALOG(cc_dlg->dialog)) == GTK_RESPONSE_OK)
588 {
589 if (create_class(cc_dlg))
590 break;
591 else
592 gdk_beep();
593 }
594 gtk_widget_destroy(cc_dlg->dialog);
595}
596
597
598static void cc_dlg_on_set_sensitive_toggled(GtkWidget *toggle_button, GtkWidget *target_widget)
599{
600 GtkWidget *label;
601
602 g_return_if_fail(toggle_button != NULL);
603 g_return_if_fail(GTK_IS_TOGGLE_BUTTON(toggle_button));
604 g_return_if_fail(target_widget != NULL);
605 g_return_if_fail(GTK_IS_WIDGET(target_widget));
606
607 label = g_object_get_data(G_OBJECT(target_widget), "label");
608
609 gtk_widget_set_sensitive(target_widget,
610 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button)));
611 gtk_widget_set_sensitive(label,
612 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toggle_button)));
613}
614
615
616static void cc_dlg_update_file_names(CreateClassDialog *cc_dlg)
617{
618 gchar *class_name;
619 gchar *class_name_down;
620 gchar *class_header = NULL;
621 gchar *class_source = NULL;
622
623 g_return_if_fail(cc_dlg != NULL);
624
625 class_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_name_entry)));
626 class_name_down = g_ascii_strdown(class_name, -1);
627 switch (cc_dlg->class_type)
628 {
629 case GEANY_CLASS_TYPE_CPP:
630 {
631 class_header = g_strconcat(class_name_down, ".hpp", NULL);
632 class_source = g_strconcat(class_name_down, ".cpp", NULL);
633 break;
634 }
635 case GEANY_CLASS_TYPE_GTK:
636 {
637 const gchar *namespace;
638 gchar *namespace_down;
639
640 namespace = gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_namespace_entry));
641 namespace_down = g_ascii_strdown(namespace, -1);
642 class_header = g_strconcat(namespace_down, class_name_down, ".h", NULL);
643 class_source = g_strconcat(namespace_down, class_name_down, ".c", NULL);
644 g_free(namespace_down);
645 break;
646 }
647 case GEANY_CLASS_TYPE_PHP:
648 {
649 class_header = NULL;
650 class_source = g_strconcat(class_name, ".php", NULL);
651 break;
652 }
653 }
654
655 if (cc_dlg->header_entry != NULL && class_header != NULL)
656 gtk_entry_set_text(GTK_ENTRY(cc_dlg->header_entry), class_header);
657 if (cc_dlg->source_entry != NULL && class_source != NULL)
658 gtk_entry_set_text(GTK_ENTRY(cc_dlg->source_entry), class_source);
659
660 g_free(class_name);
661 g_free(class_name_down);
662 g_free(class_header);
663 g_free(class_source);
664}
665
666
667static void cc_dlg_on_class_name_entry_changed(GtkWidget *entry, CreateClassDialog *cc_dlg)
668{
669 cc_dlg_update_file_names(cc_dlg);
670}
671
672
673static void cc_dlg_on_class_namespace_entry_changed(GtkWidget *entry, CreateClassDialog *cc_dlg)
674{
675
676 if (cc_dlg->class_type == GEANY_CLASS_TYPE_GTK)
677 cc_dlg_update_file_names(cc_dlg);
678}
679
680
681static gchar* str_case_split(const gchar *str, gchar splitter)
682{
683 GString *result;
684
685 g_return_val_if_fail(str != NULL, NULL);
686 if (*str == '\0')
687 return g_strdup("");
688
689 result = g_string_new(NULL);
690 g_string_append_c(result, *str);
691 while (*(++str) != '\0')
692 {
693 if (g_ascii_isupper(*str) && g_ascii_islower(result->str[result->len - 1]))
694 g_string_append_c(result, splitter);
695 g_string_append_c(result, *str);
696 }
697 return g_string_free(result, FALSE);
698}
699
700
701static void cc_dlg_on_base_name_entry_changed(GtkWidget *entry, CreateClassDialog *cc_dlg)
702{
703 gchar *base_name_splitted;
704 gchar *base_header;
705 gchar *tmp;
706
707 g_return_if_fail(entry != NULL);
708 g_return_if_fail(GTK_IS_ENTRY(entry));
709 g_return_if_fail(cc_dlg != NULL);
710
711 base_name_splitted = str_case_split(gtk_entry_get_text(GTK_ENTRY(entry)), '_');
712 if (! g_ascii_strncasecmp(gtk_entry_get_text(GTK_ENTRY(entry)), "gtk", 3))
713 /*tmp = g_strconcat("gtk/", gtk_entry_get_text(GTK_ENTRY(entry)), ".h", NULL);*/
714 /* With GTK 2.14 (and later GTK 3), single header includes are encouraged */
715 tmp = g_strdup("gtk/gtk.h");
716 else if (utils_str_equal(gtk_entry_get_text(GTK_ENTRY(entry)), "GObject"))
717 tmp = g_strdup("glib-object.h");
718 else if (cc_dlg->class_type == GEANY_CLASS_TYPE_PHP)
719 tmp = g_strconcat(gtk_entry_get_text(GTK_ENTRY(entry)), ".php", NULL);
720 else
721 tmp = g_strconcat(gtk_entry_get_text(GTK_ENTRY(entry)), ".h", NULL);
722
723 if (cc_dlg->class_type == GEANY_CLASS_TYPE_PHP)
724 base_header = g_strdup(tmp);
725 else
726 base_header = g_ascii_strdown(tmp, -1);
727
728 g_free(tmp);
729
730 gtk_entry_set_text(GTK_ENTRY(cc_dlg->base_header_entry), base_header);
731
732 if (cc_dlg->class_type == GEANY_CLASS_TYPE_GTK)
733 {
734 gchar *base_gtype;
735 if (! g_ascii_strncasecmp(gtk_entry_get_text(GTK_ENTRY(entry)), "gtk", 3))
736 tmp = g_strdup_printf("%.3s_TYPE%s",
737 base_name_splitted,
738 base_name_splitted + 3);
739 else if (utils_str_equal(gtk_entry_get_text(GTK_ENTRY(entry)), "GObject"))
740 tmp = g_strdup("G_TYPE_OBJECT");
741 else
742 tmp = g_strconcat(base_name_splitted, "_TYPE", NULL);
743 base_gtype = g_ascii_strup(tmp, -1);
744 gtk_entry_set_text(GTK_ENTRY(cc_dlg->base_gtype_entry), base_gtype);
745
746 g_free(base_gtype);
747 g_free(tmp);
748 }
749
750 g_free(base_name_splitted);
751 g_free(base_header);
752}
753
754
755static gboolean create_class(CreateClassDialog *cc_dlg)
756{
757 ClassInfo *class_info;
758 GeanyDocument *doc;
759 gchar *text;
760 gchar *tmp;
761
762 g_return_val_if_fail(cc_dlg != NULL, FALSE);
763
764 if (utils_str_equal(gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_name_entry)), ""))
765 return FALSE;
766
767 class_info = g_new0(ClassInfo, 1);
768 class_info->type = cc_dlg->class_type;
769 class_info->class_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_name_entry)));
770 tmp = str_case_split(class_info->class_name, '_');
771 class_info->class_name_up = g_ascii_strup(tmp, -1);
772 class_info->class_name_low = g_ascii_strdown(class_info->class_name_up, -1);
773 if (! utils_str_equal(gtk_entry_get_text(GTK_ENTRY(cc_dlg->base_name_entry)), ""))
774 {
775 class_info->base_name = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->base_name_entry)));
776 if (class_info->type != GEANY_CLASS_TYPE_PHP)
777 {
778 class_info->base_include = g_strdup_printf("\n#include %c%s%c\n",
779 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->base_header_global_box)) ?
780 '<' : '\"',
781 gtk_entry_get_text(GTK_ENTRY(cc_dlg->base_header_entry)),
782 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->base_header_global_box)) ?
783 '>' : '\"');
784 }
785 else
786 {
787 class_info->base_include = g_strdup_printf("\nrequire_once \"%s\";\n",
788 gtk_entry_get_text(GTK_ENTRY(cc_dlg->base_header_entry)));
789 class_info->base_decl = g_strdup_printf(" extends %s", class_info->base_name);
790 }
791 }
792 else
793 {
794 class_info->base_name = g_strdup("");
795 class_info->base_include = g_strdup("");
796 }
797 if (cc_dlg->header_entry != NULL)
798 {
799 class_info->header = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->header_entry)));
800 class_info->header_guard = g_ascii_strup(class_info->header, -1);
801 g_strdelimit(class_info->header_guard, ".-", '_');
802 }
803 switch (class_info->type)
804 {
805 case GEANY_CLASS_TYPE_CPP:
806 {
807 class_info->source = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->source_entry)));
808 if (! utils_str_equal(class_info->base_name, ""))
809 class_info->base_decl = g_strdup_printf(": public %s", class_info->base_name);
810 else
811 class_info->base_decl = g_strdup("");
812 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_constructor_box)))
813 {
814 gchar *base_constructor;
815
816 if (utils_str_equal(class_info->base_name, ""))
817 base_constructor = g_strdup("");
818 else
819 base_constructor = g_strdup_printf("\t: %s()\n", class_info->base_name);
820 class_info->constructor_decl = g_strdup_printf("%s();\n", class_info->class_name);
821 class_info->constructor_impl = g_strdup_printf("\n%s::%s()\n%s{\n\t\n}\n",
822 class_info->class_name, class_info->class_name, base_constructor);
823 g_free(base_constructor);
824 }
825 else
826 {
827 class_info->constructor_decl = g_strdup("");
828 class_info->constructor_impl = g_strdup("");
829 }
830 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_destructor_box)))
831 {
832 class_info->destructor_decl =
833 g_strdup_printf("virtual ~%s();\n", class_info->class_name);
834 class_info->destructor_impl = g_strdup_printf("\n%s::~%s()\n{\n\t\n}\n",
835 class_info->class_name, class_info->class_name);
836 }
837 else
838 {
839 class_info->destructor_decl = g_strdup("");
840 class_info->destructor_impl = g_strdup("");
841 }
842 break;
843 }
844 case GEANY_CLASS_TYPE_GTK:
845 {
846 class_info->namespace = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_namespace_entry)));
847 if (EMPTY(class_info->namespace))
848 {
849 class_info->namespace_up = g_strdup("");
850 class_info->namespace_low = g_strdup("");
851 }
852 else
853 {
854 gchar *tmp_namespace;
855 gchar *tmp_namespace_split;
856
857 tmp_namespace_split = str_case_split(class_info->namespace, '_');
858 tmp_namespace = g_strconcat(tmp_namespace_split, "_", NULL);
859 class_info->namespace_up = g_ascii_strup(tmp_namespace, -1);
860 class_info->namespace_low = g_ascii_strdown(class_info->namespace_up, -1);
861 g_free(tmp_namespace);
862 g_free(tmp_namespace_split);
863 }
864 class_info->base_gtype = g_strdup(gtk_entry_get_text(
865 GTK_ENTRY(cc_dlg->base_gtype_entry)));
866 class_info->source = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->source_entry)));
867 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_constructor_box)))
868 {
869 class_info->constructor_decl = g_strdup_printf("%s *%s%s_new (void);\n",
870 gtk_entry_get_text(GTK_ENTRY(cc_dlg->gtk_constructor_type_entry)),
871 class_info->namespace_low, class_info->class_name_low);
872 class_info->constructor_impl = g_strdup_printf("\n"
873 "%s *\n"
874 "%s%s_new (void)\n"
875 "{\n"
876 " return g_object_new (%sTYPE_%s, NULL);\n"
877 "}",
878 gtk_entry_get_text(GTK_ENTRY(cc_dlg->gtk_constructor_type_entry)),
879 class_info->namespace_low, class_info->class_name_low,
880 class_info->namespace_up, class_info->class_name_up);
881 }
882 else
883 {
884 class_info->constructor_decl = g_strdup("");
885 class_info->constructor_impl = g_strdup("");
886 }
887 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_destructor_box)))
888 {
889 class_info->gtk_destructor_registration =
890 g_strdup_printf("GObjectClass *g_object_class;\n\n"
891 " g_object_class = G_OBJECT_CLASS (klass);\n\n"
892 " g_object_class->finalize = %s%s_finalize;\n",
893 class_info->namespace_low, class_info->class_name_low);
894 class_info->destructor_decl =
895 g_strdup_printf("static void %s%s_finalize (GObject *object);\n",
896 class_info->namespace_low, class_info->class_name_low);
897 class_info->destructor_impl = g_strdup_printf("\n"
898 "static void\n"
899 "%s%s_finalize (GObject *object)\n"
900 "{\n"
901 " %s%s *self;\n\n"
902 " g_return_if_fail (%sIS_%s (object));\n\n"
903 " self = %s%s (object);\n\n"
904 " G_OBJECT_CLASS (%s%s_parent_class)->finalize (object);\n"
905 "}\n",
906 class_info->namespace_low, class_info->class_name_low,
907 class_info->namespace, class_info->class_name,
908 class_info->namespace_up, class_info->class_name_up,
909 class_info->namespace_up, class_info->class_name_up,
910 class_info->namespace_low, class_info->class_name_low);
911 }
912 else
913 {
914 class_info->gtk_destructor_registration = g_strdup("");
915 class_info->destructor_decl = g_strdup("");
916 class_info->destructor_impl = g_strdup("");
917 }
918 break;
919 }
920 case GEANY_CLASS_TYPE_PHP:
921 {
922 const gchar *tmp_str;
923
924 class_info->source = g_strdup(gtk_entry_get_text(GTK_ENTRY(cc_dlg->source_entry)));
925
926 tmp_str = gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_namespace_entry));
927 if (! utils_str_equal(tmp_str, ""))
928 class_info->namespace_decl = g_strdup_printf("namespace %s;", tmp_str);
929 else
930 class_info->namespace_decl = g_strdup("");
931
932 tmp_str = gtk_entry_get_text(GTK_ENTRY(cc_dlg->class_implements_entry));
933 if (! utils_str_equal(tmp_str, ""))
934 class_info->implements_decl = g_strdup_printf(" implements %s", tmp_str);
935 else
936 class_info->implements_decl = g_strdup("");
937
938 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_constructor_box)) &&
939 ! gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_isabstract_box)))
940 {
941 class_info->constructor_impl = g_strdup_printf("\n"
942 "\t/**\n"
943 "\t * Constructor of class %s.\n"
944 "\t *\n"
945 "\t * @return void\n"
946 "\t */\n"
947 "\tpublic function __construct()\n"
948 "\t{\n"
949 "\t\t// ...\n"
950 "\t}\n",
951 class_info->class_name);
952 }
953 else if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_constructor_box)) &&
954 gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_isabstract_box)))
955 {
956 class_info->constructor_impl = g_strdup_printf("\n"
957 "\t/**\n"
958 "\t * Constructor of class %s.\n"
959 "\t *\n"
960 "\t * @return void\n"
961 "\t */\n"
962 "\tprotected function __construct()\n"
963 "\t{\n"
964 "\t\t// ...\n"
965 "\t}\n",
966 class_info->class_name);
967 }
968 else
969 class_info->constructor_impl = g_strdup("");
970
971 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_destructor_box)))
972 {
973 class_info->destructor_impl = g_strdup_printf("\n"
974 "\t/**\n"
975 "\t * Destructor of class %s.\n"
976 "\t *\n"
977 "\t * @return void\n"
978 "\t */\n"
979 "\tpublic function __destruct()\n"
980 "\t{\n"
981 "\t\t// ...\n"
982 "\t}\n",
983 class_info->class_name);
984 }
985 else
986 class_info->destructor_impl = g_strdup("");
987
988 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_isabstract_box)))
989 class_info->abstract_decl = g_strdup("abstract ");
990 else
991 class_info->abstract_decl = g_strdup("");
992
993 if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cc_dlg->create_issingleton_box)))
994 {
995 class_info->singleton_impl = g_strdup_printf("\n"
996 "\t/**\n"
997 "\t * Holds instance of self.\n"
998 "\t * \n"
999 "\t * @var %s\n"
1000 "\t */\n"
1001 "\tprotected static $kInstance = null;\n\n"
1002 "\t/**\n"
1003 "\t * Returns instance of self.\n"
1004 "\t * \n"
1005 "\t * @return %s\n"
1006 "\t */\n"
1007 "\tpublic static function getInstance() {\n"
1008 "\t\tif(!(self::$kInstance instanceof %s)) {\n"
1009 "\t\t\tself::$kInstance = new self();\n"
1010 "\t\t}\n"
1011 "\t\treturn self::$kInstance;\n"
1012 "\t}\n",
1013 class_info->class_name,
1014 class_info->class_name,
1015 class_info->class_name);
1016 }
1017 else
1018 class_info->singleton_impl = g_strdup("");
1019 break;
1020 }
1021 }
1022
1023 /* only create the files if the filename is not empty */
1024 if (! utils_str_equal(class_info->source, ""))
1025 {
1026 doc = document_new_file(class_info->source, NULL, NULL);
1027 text = get_template_class_source(class_info);
1028 editor_insert_text_block(doc->editor, text, 0, -1, 0, TRUE);
1029 g_free(text);
1030 sci_set_current_position(doc->editor->sci, 0, TRUE);
1031 }
1032
1033 if (! utils_str_equal(class_info->header, "") && class_info->type != GEANY_CLASS_TYPE_PHP)
1034 {
1035 doc = document_new_file(class_info->header, NULL, NULL);
1036 text = get_template_class_header(class_info);
1037 editor_insert_text_block(doc->editor, text, 0, -1, 0, TRUE);
1038 g_free(text);
1039 sci_set_current_position(doc->editor->sci, 0, TRUE);
1040 }
1041
1042 free_pointers(24, tmp, class_info->namespace, class_info->namespace_up,
1043 class_info->namespace_low, class_info->class_name, class_info->class_name_up,
1044 class_info->base_name, class_info->class_name_low, class_info->base_include,
1045 class_info->header, class_info->header_guard, class_info->source, class_info->base_decl,
1046 class_info->constructor_decl, class_info->constructor_impl,
1047 class_info->gtk_destructor_registration, class_info->destructor_decl,
1048 class_info->destructor_impl, class_info->base_gtype,
1049 class_info->namespace_decl, class_info->implements_decl,
1050 class_info->abstract_decl, class_info->singleton_impl, class_info, NULL);
1051 return TRUE;
1052}
1053
1054
1055static void
1056on_menu_create_cpp_class_activate (GtkMenuItem *menuitem,
1057 gpointer user_data)
1058{
1059 show_dialog_create_class(GEANY_CLASS_TYPE_CPP);
1060}
1061
1062
1063static void
1064on_menu_create_gtk_class_activate (GtkMenuItem *menuitem,
1065 gpointer user_data)
1066{
1067 show_dialog_create_class(GEANY_CLASS_TYPE_GTK);
1068}
1069
1070
1071static void
1072on_menu_create_php_class_activate (GtkMenuItem *menuitem,
1073 gpointer user_data)
1074{
1075 show_dialog_create_class(GEANY_CLASS_TYPE_PHP);
1076}
1077
1078
1079void plugin_init(GeanyData *data)
1080{
1081 GtkWidget *menu_create_class1;
1082 GtkWidget *menu_create_class1_menu;
1083 GtkWidget *menu_create_cpp_class;
1084 GtkWidget *menu_create_gtk_class;
1085 GtkWidget *menu_create_php_class;
1086
1087 menu_create_class1 = ui_image_menu_item_new (GTK_STOCK_ADD, _("Create Cla_ss"));
1088 gtk_container_add (GTK_CONTAINER (geany->main_widgets->tools_menu), menu_create_class1);
1089
1090 menu_create_class1_menu = gtk_menu_new ();
1091 gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_create_class1), menu_create_class1_menu);
1092
1093 menu_create_cpp_class = gtk_menu_item_new_with_mnemonic (_("_C++ Class..."));
1094 gtk_container_add (GTK_CONTAINER (menu_create_class1_menu), menu_create_cpp_class);
1095
1096 menu_create_gtk_class = gtk_menu_item_new_with_mnemonic (_("_GTK+ Class..."));
1097 gtk_container_add (GTK_CONTAINER (menu_create_class1_menu), menu_create_gtk_class);
1098
1099 menu_create_php_class = gtk_menu_item_new_with_mnemonic (_("_PHP Class..."));
1100 gtk_container_add (GTK_CONTAINER (menu_create_class1_menu), menu_create_php_class);
1101
1102 g_signal_connect(menu_create_cpp_class, "activate",
1103 G_CALLBACK (on_menu_create_cpp_class_activate),
1104 NULL);
1105 g_signal_connect(menu_create_gtk_class, "activate",
1106 G_CALLBACK (on_menu_create_gtk_class_activate),
1107 NULL);
1108 g_signal_connect(menu_create_php_class, "activate",
1109 G_CALLBACK (on_menu_create_php_class_activate),
1110 NULL);
1111
1112 gtk_widget_show_all(menu_create_class1);
1113
1114 main_menu_item = menu_create_class1;
1115}
1116
1117
1118void plugin_cleanup(void)
1119{
1120 gtk_widget_destroy(main_menu_item);
1121}
ptr
GeanyBuildCommand ** ptr
Definition: build.c:2679
label
const gchar * label
Definition: build.c:2676
templates_cpp_class_header
static const gchar templates_cpp_class_header[]
Definition: classbuilder.c:101
main_menu_item
static GtkWidget * main_menu_item
Definition: classbuilder.c:38
GEANY_CLASS_TYPE_GTK
@ GEANY_CLASS_TYPE_GTK
Definition: classbuilder.c:44
GEANY_CLASS_TYPE_CPP
@ GEANY_CLASS_TYPE_CPP
Definition: classbuilder.c:43
GEANY_CLASS_TYPE_PHP
@ GEANY_CLASS_TYPE_PHP
Definition: classbuilder.c:45
templates_gtk_class_header
static const gchar templates_gtk_class_header[]
Definition: classbuilder.c:125
geany_data
GeanyData * geany_data
Definition: classbuilder.c:29
templates_cpp_class_source
static const gchar templates_cpp_class_source[]
Definition: classbuilder.c:118
CreateClassDialog
struct _CreateClassDialog CreateClassDialog
templates_gtk_class_source
static const gchar templates_gtk_class_source[]
Definition: classbuilder.c:162
document_new_file
GeanyDocument * document_new_file(const gchar *utf8_filename, GeanyFiletype *ft, const gchar *text)
Creates a new document.
Definition: document.c:824
editor_insert_text_block
void editor_insert_text_block(GeanyEditor *editor, const gchar *text, gint insert_pos, gint cursor_index, gint newline_indent_size, gboolean replace_newlines)
Inserts text, replacing \t tab chars (0x9) and \n newline chars (0xA) accordingly for the document.
Definition: editor.c:2456
text
gchar * text
Definition: editor.c:83
GEANY_FILETYPES_CPP
@ GEANY_FILETYPES_CPP
Definition: filetypes.h:80
GEANY_FILETYPES_PHP
@ GEANY_FILETYPES_PHP
Definition: filetypes.h:48
GEANY_FILETYPES_C
@ GEANY_FILETYPES_C
Definition: filetypes.h:55
geanyplugin.h
Single include for plugins.
GEANY_API_VERSION
#define GEANY_API_VERSION
The Application Programming Interface (API) version, incremented whenever any plugin data types are m...
Definition: plugindata.h:61
PLUGIN_SET_INFO
#define PLUGIN_SET_INFO(p_name, p_description, p_version, p_author)
Sets the plugin name and some other basic information about a plugin.
Definition: plugindata.h:117
PLUGIN_VERSION_CHECK
#define PLUGIN_VERSION_CHECK(api_required)
Defines a function to check the plugin is safe to load.
Definition: plugindata.h:83
geany
#define geany
Simple macro for geany_data that reduces typing.
Definition: plugindata.h:225
plugin_cleanup
void plugin_cleanup()
Called before unloading the plugin.
Definition: export.c:773
plugin_init
void plugin_init(GeanyData *data)
Called after loading the plugin.
Definition: export.c:739
NULL
#define NULL
Definition: rbtree.h:150
sci_set_current_position
void sci_set_current_position(ScintillaObject *sci, gint position, gboolean scroll_to_caret)
Sets the cursor position.
Definition: sciwrappers.c:529
entry
GtkWidget * entry
Definition: search.c:118
gtk_container_add
gtk_container_add(GTK_CONTAINER(dialog->vbox), check_button)
gtk_widget_show_all
gtk_widget_show_all(dialog)
GeanyData
This contains pointers to global variables owned by Geany for plugins to use.
Definition: plugindata.h:167
GeanyDocument
Structure for representing an open tab with all its properties.
Definition: document.h:81
GeanyDocument::editor
GeanyEditor * editor
The editor associated with the document.
Definition: document.h:98
GeanyEditor::sci
ScintillaObject * sci
The Scintilla editor GtkWidget.
Definition: editor.h:152
_ClassInfo
Definition: classbuilder.c:51
_ClassInfo::base_include
gchar * base_include
Definition: classbuilder.c:63
_ClassInfo::implements_decl
gchar * implements_decl
Definition: classbuilder.c:73
_ClassInfo::constructor_decl
gchar * constructor_decl
Definition: classbuilder.c:65
_ClassInfo::destructor_decl
gchar * destructor_decl
Definition: classbuilder.c:66
_ClassInfo::class_name_low
gchar * class_name_low
Definition: classbuilder.c:58
_ClassInfo::base_name
gchar * base_name
Definition: classbuilder.c:59
_ClassInfo::base_gtype
gchar * base_gtype
Definition: classbuilder.c:60
_ClassInfo::class_name
gchar * class_name
Definition: classbuilder.c:56
_ClassInfo::namespace_up
gchar * namespace_up
Definition: classbuilder.c:53
_ClassInfo::header_guard
gchar * header_guard
Definition: classbuilder.c:62
_ClassInfo::singleton_impl
gchar * singleton_impl
Definition: classbuilder.c:75
_ClassInfo::source
gchar * source
Definition: classbuilder.c:67
_ClassInfo::namespace_decl
gchar * namespace_decl
Definition: classbuilder.c:72
_ClassInfo::constructor_impl
gchar * constructor_impl
Definition: classbuilder.c:68
_ClassInfo::header
gchar * header
Definition: classbuilder.c:61
_ClassInfo::abstract_decl
gchar * abstract_decl
Definition: classbuilder.c:74
_ClassInfo::destructor_impl
gchar * destructor_impl
Definition: classbuilder.c:69
_ClassInfo::namespace_low
gchar * namespace_low
Definition: classbuilder.c:55
_ClassInfo::base_decl
gchar * base_decl
Definition: classbuilder.c:64
_ClassInfo::type
gint type
Definition: classbuilder.c:52
_ClassInfo::gtk_destructor_registration
gchar * gtk_destructor_registration
Definition: classbuilder.c:70
_ClassInfo::class_name_up
gchar * class_name_up
Definition: classbuilder.c:57
_CreateClassDialog
Definition: classbuilder.c:79
_CreateClassDialog::create_issingleton_box
GtkWidget * create_issingleton_box
Definition: classbuilder.c:96
_CreateClassDialog::create_isabstract_box
GtkWidget * create_isabstract_box
Definition: classbuilder.c:95
_CreateClassDialog::header_entry
GtkWidget * header_entry
Definition: classbuilder.c:83
_CreateClassDialog::class_name_entry
GtkWidget * class_name_entry
Definition: classbuilder.c:82
_CreateClassDialog::base_header_entry
GtkWidget * base_header_entry
Definition: classbuilder.c:86
_CreateClassDialog::class_implements_entry
GtkWidget * class_implements_entry
Definition: classbuilder.c:94
_CreateClassDialog::base_gtype_entry
GtkWidget * base_gtype_entry
Definition: classbuilder.c:88
_CreateClassDialog::class_type
gint class_type
Definition: classbuilder.c:80
_CreateClassDialog::create_destructor_box
GtkWidget * create_destructor_box
Definition: classbuilder.c:90
_CreateClassDialog::gtk_constructor_type_entry
GtkWidget * gtk_constructor_type_entry
Definition: classbuilder.c:91
_CreateClassDialog::class_namespace_entry
GtkWidget * class_namespace_entry
Definition: classbuilder.c:93
_CreateClassDialog::dialog
GtkWidget * dialog
Definition: classbuilder.c:81
_CreateClassDialog::create_constructor_box
GtkWidget * create_constructor_box
Definition: classbuilder.c:89
_CreateClassDialog::source_entry
GtkWidget * source_entry
Definition: classbuilder.c:84
_CreateClassDialog::base_name_entry
GtkWidget * base_name_entry
Definition: classbuilder.c:85
_CreateClassDialog::base_header_global_box
GtkWidget * base_header_global_box
Definition: classbuilder.c:87
_
#define _(String)
Definition: support.h:42
templates_get_template_fileheader
gchar * templates_get_template_fileheader(gint filetype_idx, const gchar *fname)
Definition: templates.c:457
ui_dialog_vbox_new
GtkWidget * ui_dialog_vbox_new(GtkDialog *dialog)
Makes a fixed border for dialogs without increasing the button box border.
Definition: ui_utils.c:1499
ui_image_menu_item_new
GtkWidget * ui_image_menu_item_new(const gchar *stock_id, const gchar *label)
Creates a GtkImageMenuItem with a stock image and a custom label.
Definition: ui_utils.c:1574
utils_string_replace_all
guint utils_string_replace_all(GString *haystack, const gchar *needle, const gchar *replace)
Replaces all occurrences of needle in haystack with replace.
Definition: utils.c:1529
utils_str_equal
gboolean utils_str_equal(const gchar *a, const gchar *b)
NULL-safe string comparison.
Definition: utils.c:599
EMPTY
#define EMPTY(ptr)
Returns TRUE if ptr is NULL or *ptr is FALSE.
Definition: utils.h:38