plugins/classbuilder.c

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