gschem/src/gschem_options_dockable.c

   1 /* gEDA - GPL Electronic Design Automation
   2  * gschem - gEDA Schematic Capture
   3  * Copyright (C) 1998-2010 Ales Hvezda
   4  * Copyright (C) 1998-2019 gEDA Contributors (see ChangeLog for details)
   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
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20 /*!
  21  * \file gschem_options_dockable.c
  22  *
  23  * \brief A dockable for editing options
  24  */
  25
  26 #include <config.h>
  27
  28 #include <stdio.h>
  29 #ifdef HAVE_STDLIB_H
  30 #include <stdlib.h>
  31 #endif
  32 #ifdef HAVE_STRING_H
  33 #include <string.h>
  34 #endif
  35
  36 #include "gschem.h"
  37
  38 #include "../include/gschem_options_dockable.h"
  39
  40
  41 static void
  42 class_init (GschemOptionsDockableClass *klass);
  43
  44 GtkWidget*
  45 create_grid_mode_widget (GschemOptionsDockable *dockable);
  46
  47 GtkWidget*
  48 create_snap_mode_widget (GschemOptionsDockable *dockable);
  49
  50 static GtkWidget*
  51 create_net_section (GschemOptionsDockable *dockable);
  52
  53 static GtkWidget*
  54 create_snap_section (GschemOptionsDockable *dockable);
  55
  56 static void
  57 dispose (GObject *object);
  58
  59 static GtkWidget *
  60 create_widget (GschemDockable *parent);
  61
  62 static void
  63 set_options (GschemOptionsDockable *dockable, GschemOptions *options);
  64
  65 static void
  66 update_grid_mode_model (GschemOptionsDockable *dockable, GtkWidget *button);
  67
  68 static void
  69 update_grid_mode_widget (GschemOptionsDockable *dockable);
  70
  71 static void
  72 update_magnetic_net_mode_model (GschemOptionsDockable *dockable);
  73
  74 static void
  75 update_magnetic_net_mode_widget (GschemOptionsDockable *dockable);
  76
  77 static void
  78 update_net_rubber_band_mode_model (GschemOptionsDockable *dockable);
  79
  80 static void
  81 update_net_rubber_band_mode_widget (GschemOptionsDockable *dockable);
  82
  83 static void
  84 update_snap_mode_model (GschemOptionsDockable *dockable, GtkWidget *button);
  85
  86 static void
  87 update_snap_mode_widget (GschemOptionsDockable *dockable);
  88
  89
  90
  91 /*! \brief Get/register options dockable type.
  92  */
  93 GType
  94 gschem_options_dockable_get_type ()
  95 {
  96   static GType type = 0;
  97
  98   if (type == 0) {
  99     static const GTypeInfo info = {
 100       sizeof(GschemOptionsDockableClass),
 101       NULL,                                       /* base_init */
 102       NULL,                                       /* base_finalize */
 103       (GClassInitFunc) class_init,
 104       NULL,                                       /* class_finalize */
 105       NULL,                                       /* class_data */
 106       sizeof(GschemOptionsDockable),
 107       0,                                          /* n_preallocs */
 108       NULL,                                       /* instance_init */
 109     };
 110
 111     type = g_type_register_static (GSCHEM_TYPE_DOCKABLE,
 112                                    "GschemOptionsDockable",
 113                                    &info,
 114                                    0);
 115   }
 116
 117   return type;
 118 }
 119
 120
 121
 122 /*! \private
 123  *  \brief Initialize the options dockable class structure
 124  *
 125  *  \param [in] klass
 126  */
 127 static void
 128 class_init (GschemOptionsDockableClass *klass)
 129 {
 130   GObjectClass *object_class;
 131
 132   g_return_if_fail (klass != NULL);
 133
 134   GSCHEM_DOCKABLE_CLASS (klass)->create_widget = create_widget;
 135
 136   object_class = G_OBJECT_CLASS (klass);
 137
 138   g_return_if_fail (object_class != NULL);
 139
 140   object_class->dispose = dispose;
 141 }
 142
 143
 144
 145 /*! \private
 146  *  \brief Create the series of buttons that make the grid mode selection widget
 147  *
 148  *  \param [in] dockable
 149  *  \return The grid mode widget
 150  */
 151 GtkWidget*
 152 create_grid_mode_widget (GschemOptionsDockable *dockable)
 153 {
 154   GtkWidget *box;
 155   int index;
 156
 157   g_return_val_if_fail (dockable != NULL, NULL);
 158
 159   box = gtk_hbox_new (FALSE, FALSE);
 160
 161   for (index=0; index<GRID_MODE_COUNT; index++) {
 162     dockable->grid_radio[index] = gtk_toggle_button_new ();
 163
 164     gtk_box_pack_start (GTK_BOX (box),                           /* box     */
 165                         dockable->grid_radio[index],             /* child   */
 166                         FALSE,                                   /* expand  */
 167                         FALSE,                                   /* fill    */
 168                         0);                                      /* padding */
 169
 170     gtk_size_group_add_widget (dockable->size_group, dockable->grid_radio[index]);
 171
 172     g_signal_connect_swapped (G_OBJECT (dockable->grid_radio[index]),
 173                               "clicked",
 174                               G_CALLBACK (update_grid_mode_model),
 175                               dockable);
 176   }
 177
 178   gtk_button_set_label (GTK_BUTTON (dockable->grid_radio[GRID_MODE_NONE]),
 179                         _("Off"));
 180
 181   gtk_button_set_label (GTK_BUTTON (dockable->grid_radio[GRID_MODE_DOTS]),
 182                         _("Dots"));
 183
 184   gtk_button_set_label (GTK_BUTTON (dockable->grid_radio[GRID_MODE_MESH]),
 185                         _("Mesh"));
 186
 187   return box;
 188 }
 189
 190
 191
 192 /*! \private
 193  *  \brief Create section with net tool settings
 194  *
 195  *  \param [in] dockable
 196  *  \return The net section widget
 197  */
 198 static GtkWidget*
 199 create_net_section (GschemOptionsDockable *dockable)
 200 {
 201   GtkWidget *label[2];
 202   GtkWidget *table;
 203   GtkWidget *editor[2];
 204
 205   /* These widgets are shown in the same order as the options menu */
 206
 207   label[0] = gschem_dialog_misc_create_property_label (_("Net Rubber Band Mode:"));
 208   label[1] = gschem_dialog_misc_create_property_label (_("Magnetic Net Mode:"));
 209
 210   /*! \todo These should become a GtkSwitch when updating to GTK 3.0 */
 211
 212   editor[0] = dockable->net_rubber_band_widget = gtk_check_button_new_with_label (_("Enabled"));
 213   editor[1] = dockable->magnetic_net_widget = gtk_check_button_new_with_label (_("Enabled"));
 214
 215   table = gschem_dialog_misc_create_property_table (label, editor, 2);
 216
 217   g_signal_connect_swapped (G_OBJECT (dockable->magnetic_net_widget),
 218                             "toggled",
 219                             G_CALLBACK (update_magnetic_net_mode_model),
 220                             dockable);
 221
 222   g_signal_connect_swapped (G_OBJECT (dockable->net_rubber_band_widget),
 223                             "toggled",
 224                             G_CALLBACK (update_net_rubber_band_mode_model),
 225                             dockable);
 226
 227   return gschem_dialog_misc_create_section_widget (_("<b>Net Options</b>"), table);
 228 }
 229
 230
 231 /*! \private
 232  *  \brief Create section with snap and grid settings
 233  *
 234  *  \param [in] dockable
 235  *  \return The snap section widget
 236  */
 237 static GtkWidget*
 238 create_snap_section (GschemOptionsDockable *dockable)
 239 {
 240   GtkWidget *label[3];
 241   GtkWidget *table;
 242   GtkWidget *editor[3];
 243
 244   label[0] = gschem_dialog_misc_create_property_label (_("Grid Mode:"));
 245   label[1] = gschem_dialog_misc_create_property_label (_("Snap Mode:"));
 246   label[2] = gschem_dialog_misc_create_property_label (_("Grid Spacing:"));
 247
 248   editor[0] = create_grid_mode_widget (dockable);
 249   editor[1] = create_snap_mode_widget (dockable);
 250   editor[2] = x_grid_size_sb_new (GSCHEM_DOCKABLE (dockable)->w_current);
 251
 252   table = gschem_dialog_misc_create_property_table (label, editor, 3);
 253
 254   return gschem_dialog_misc_create_section_widget (_("<b>Grid Options</b>"), table);
 255 }
 256
 257
 258
 259 /*! \private
 260  *  \brief Create the series of buttons that make the snap mode selection widget
 261  *
 262  *  \param [in] dockable
 263  *  \return The snap mode widget
 264  */
 265 GtkWidget*
 266 create_snap_mode_widget (GschemOptionsDockable *dockable)
 267 {
 268   GtkWidget *box;
 269   int index;
 270
 271   g_return_val_if_fail (dockable != NULL, NULL);
 272
 273   box = gtk_hbox_new (FALSE, FALSE);
 274
 275   for (index=0; index<SNAP_STATE_COUNT; index++) {
 276     dockable->snap_radio[index] = gtk_toggle_button_new ();
 277
 278     gtk_box_pack_start (GTK_BOX (box),                           /* box     */
 279                         dockable->snap_radio[index],             /* child   */
 280                         FALSE,                                   /* expand  */
 281                         FALSE,                                   /* fill    */
 282                         0);                                      /* padding */
 283
 284     gtk_size_group_add_widget (dockable->size_group, dockable->snap_radio[index]);
 285
 286     g_signal_connect_swapped (G_OBJECT (dockable->snap_radio[index]),
 287                               "clicked",
 288                               G_CALLBACK (update_snap_mode_model),
 289                               dockable);
 290   }
 291
 292   gtk_button_set_label (GTK_BUTTON (dockable->snap_radio[SNAP_OFF]),
 293                         _("Off"));
 294
 295   gtk_button_set_label (GTK_BUTTON (dockable->snap_radio[SNAP_GRID]),
 296                         _("Grid"));
 297
 298   gtk_button_set_label (GTK_BUTTON (dockable->snap_radio[SNAP_RESNAP]),
 299                         _("Resnap"));
 300
 301   return box;
 302 }
 303
 304
 305 /*! \private
 306  *  \brief Dispose
 307  *
 308  *  \param [in] object The options dockable to dispose
 309  */
 310 static void
 311 dispose (GObject *object)
 312 {
 313   GschemOptionsDockable *dockable;
 314   GschemOptionsDockableClass *klass;
 315   GObjectClass *parent_class;
 316
 317   g_return_if_fail (object != NULL);
 318
 319   dockable = GSCHEM_OPTIONS_DOCKABLE (object);
 320
 321   set_options (dockable, NULL);
 322
 323   //g_slist_foreach (dockable->bindings, (GFunc) g_object_unref, NULL);
 324   //g_slist_free (dockable->bindings);
 325   //dockable->bindings = NULL;
 326
 327   /* lastly, chain up to the parent dispose */
 328
 329   klass = GSCHEM_OPTIONS_DOCKABLE_GET_CLASS (object);
 330   g_return_if_fail (klass != NULL);
 331   parent_class = g_type_class_peek_parent (klass);
 332   g_return_if_fail (parent_class != NULL);
 333   parent_class->dispose (object);
 334 }
 335
 336
 337 /*! \private
 338  *  \brief Create widgets and set up property change notifications
 339  *
 340  *  \param [in,out] parent This dockable
 341  */
 342 static GtkWidget *
 343 create_widget (GschemDockable *parent)
 344 {
 345   GschemOptionsDockable *dockable = GSCHEM_OPTIONS_DOCKABLE (parent);
 346   GtkWidget *vbox;
 347
 348   dockable->size_group = gtk_size_group_new (GTK_SIZE_GROUP_BOTH);
 349
 350   vbox = gtk_vbox_new (FALSE, DIALOG_V_SPACING);
 351   gtk_container_set_border_width (GTK_CONTAINER (vbox), DIALOG_BORDER_SPACING);
 352
 353   gtk_box_pack_start (GTK_BOX (vbox),                          /* box     */
 354                       create_snap_section (dockable),          /* child   */
 355                       FALSE,                                   /* expand  */
 356                       FALSE,                                   /* fill    */
 357                       0);                                      /* padding */
 358
 359   gtk_box_pack_start (GTK_BOX (vbox),                          /* box     */
 360                       create_net_section (dockable),           /* child   */
 361                       FALSE,                                   /* expand  */
 362                       FALSE,                                   /* fill    */
 363                       0);                                      /* padding */
 364
 365   set_options (dockable, parent->w_current->options);
 366
 367   gtk_widget_show_all (vbox);
 368   return vbox;
 369 }
 370
 371
 372
 373 /*! \private
 374  *  \brief Set the options that this dockable manipulates
 375  *
 376  *  \param [in,out] dockable This dockable
 377  *  \param [in]     options  The options to manipulate
 378  */
 379 static void
 380 set_options (GschemOptionsDockable *dockable, GschemOptions *options)
 381 {
 382   if (dockable->options != NULL) {
 383     g_signal_handlers_disconnect_by_func (dockable->options,
 384                                           G_CALLBACK (update_snap_mode_widget),
 385                                           dockable);
 386
 387     g_signal_handlers_disconnect_by_func (dockable->options,
 388                                           G_CALLBACK (update_net_rubber_band_mode_widget),
 389                                           dockable);
 390
 391     g_signal_handlers_disconnect_by_func (dockable->options,
 392                                           G_CALLBACK (update_magnetic_net_mode_widget),
 393                                           dockable);
 394
 395     g_signal_handlers_disconnect_by_func (dockable->options,
 396                                           G_CALLBACK (update_grid_mode_widget),
 397                                           dockable);
 398
 399     g_object_unref (dockable->options);
 400   }
 401
 402   dockable->options = options;
 403
 404   if (dockable->options != NULL) {
 405     g_object_ref (dockable->options);
 406
 407     g_signal_connect_swapped (dockable->options,
 408                               "notify::grid-mode",
 409                               G_CALLBACK (update_grid_mode_widget),
 410                               dockable);
 411
 412     g_signal_connect_swapped (dockable->options,
 413                               "notify::magnetic-net-mode",
 414                               G_CALLBACK (update_magnetic_net_mode_widget),
 415                               dockable);
 416
 417     g_signal_connect_swapped (dockable->options,
 418                               "notify::net-rubber-band-mode",
 419                               G_CALLBACK (update_net_rubber_band_mode_widget),
 420                               dockable);
 421
 422     g_signal_connect_swapped (dockable->options,
 423                               "notify::snap-mode",
 424                               G_CALLBACK (update_snap_mode_widget),
 425                               dockable);
 426   }
 427
 428   update_grid_mode_widget (dockable);
 429   update_magnetic_net_mode_widget (dockable);
 430   update_net_rubber_band_mode_widget (dockable);
 431   update_snap_mode_widget (dockable);
 432 }
 433
 434
 435 /*! \private
 436  *  \brief Update the grid mode in the model
 437  *
 438  *  \param [in,out] dockable This dockable
 439  */
 440 static void
 441 update_grid_mode_model (GschemOptionsDockable *dockable, GtkWidget *button)
 442 {
 443   g_return_if_fail (dockable != NULL);
 444
 445   if (dockable->options != NULL) {
 446     int index;
 447
 448     for (index = 0; index < GRID_MODE_COUNT; index++) {
 449       if (dockable->grid_radio[index] == button) {
 450         gschem_options_set_grid_mode (dockable->options, index);
 451         break;
 452       }
 453     }
 454   }
 455 }
 456
 457
 458
 459 /*! \private
 460  *  \brief Update the grid mode widget with the current value
 461  *
 462  *  \param [in,out] dockable This dockable
 463  */
 464 static void
 465 update_grid_mode_widget (GschemOptionsDockable *dockable)
 466 {
 467   g_return_if_fail (dockable != NULL);
 468
 469   if (dockable->options != NULL) {
 470     GRID_MODE grid_mode;
 471     int index;
 472
 473     grid_mode = gschem_options_get_grid_mode (dockable->options);
 474
 475     for (index=0; index<GRID_MODE_COUNT; index++) {
 476       g_signal_handlers_block_by_func (G_OBJECT (dockable->grid_radio[index]),
 477                                        G_CALLBACK (update_grid_mode_model),
 478                                        dockable);
 479     }
 480
 481     for (index=0; index<GRID_MODE_COUNT; index++) {
 482       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dockable->grid_radio[index]),
 483                                     (grid_mode == index));
 484     }
 485
 486     for (index=0; index<GRID_MODE_COUNT; index++) {
 487       g_signal_handlers_unblock_by_func (G_OBJECT (dockable->grid_radio[index]),
 488                                          G_CALLBACK (update_grid_mode_model),
 489                                          dockable);
 490     }
 491   }
 492 }
 493
 494
 495
 496 /*! \private
 497  *  \brief Update the magnetic net mode in the model
 498  *
 499  *  \param [in,out] dockable This dockable
 500  */
 501 static void
 502 update_magnetic_net_mode_model (GschemOptionsDockable *dockable)
 503 {
 504   GschemToplevel *w_current;
 505
 506   g_return_if_fail (dockable != NULL);
 507
 508   g_object_get (dockable, "gschem-toplevel", &w_current, NULL);
 509
 510   g_return_if_fail (w_current != NULL);
 511
 512   gschem_options_set_magnetic_net_mode (w_current->options,
 513                                         gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dockable->magnetic_net_widget)));
 514 }
 515
 516
 517
 518 /*! \private
 519  *  \brief Update the net rubber band mode widget with the current value
 520  *
 521  *  \param [in,out] dockable This dockable
 522  */
 523 static void
 524 update_magnetic_net_mode_widget (GschemOptionsDockable *dockable)
 525 {
 526   g_return_if_fail (dockable != NULL);
 527
 528   if (dockable->options != NULL) {
 529     GschemToplevel *w_current;
 530
 531     g_object_get (dockable, "gschem-toplevel", &w_current, NULL);
 532
 533     g_return_if_fail (w_current != NULL);
 534
 535     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dockable->magnetic_net_widget),
 536                                   gschem_options_get_magnetic_net_mode (w_current->options));
 537   }
 538 }
 539
 540
 541 /*! \private
 542  *  \brief Update the net rubber band mode in the model
 543  *
 544  *  \param [in,out] dockable This dockable
 545  */
 546 static void
 547 update_net_rubber_band_mode_model (GschemOptionsDockable *dockable)
 548 {
 549   GschemToplevel *w_current;
 550
 551   g_return_if_fail (dockable != NULL);
 552
 553   g_object_get (dockable, "gschem-toplevel", &w_current, NULL);
 554
 555   g_return_if_fail (w_current != NULL);
 556
 557   gschem_options_set_net_rubber_band_mode (w_current->options,
 558                                            gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (dockable->net_rubber_band_widget)));
 559 }
 560
 561
 562
 563 /*! \private
 564  *  \brief Update the net rubber band mode widget with the current value
 565  *
 566  *  \param [in,out] dockable This dockable
 567  */
 568 static void
 569 update_net_rubber_band_mode_widget (GschemOptionsDockable *dockable)
 570 {
 571   g_return_if_fail (dockable != NULL);
 572
 573   if (dockable->options != NULL) {
 574     GschemToplevel *w_current;
 575
 576     g_object_get (dockable, "gschem-toplevel", &w_current, NULL);
 577
 578     g_return_if_fail (w_current != NULL);
 579
 580     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dockable->net_rubber_band_widget),
 581                                   gschem_options_get_net_rubber_band_mode (w_current->options));
 582   }
 583 }
 584
 585
 586
 587 /*! \private
 588  *  \brief Update the snap mode in the model
 589  *
 590  *  \param [in,out] dockable This dockable
 591  */
 592 static void
 593 update_snap_mode_model (GschemOptionsDockable *dockable, GtkWidget *button)
 594 {
 595   g_return_if_fail (dockable != NULL);
 596
 597   if (dockable->options != NULL) {
 598     int index;
 599
 600     for (index = 0; index < SNAP_STATE_COUNT; index++) {
 601       if (dockable->snap_radio[index] == button) {
 602         gschem_options_set_snap_mode (dockable->options, index);
 603         break;
 604       }
 605     }
 606   }
 607 }
 608
 609
 610
 611 /*! \private
 612  *  \brief Update the snap mode widget with the current value
 613  *
 614  *  \param [in,out] dockable This dockable
 615  */
 616 static void
 617 update_snap_mode_widget (GschemOptionsDockable *dockable)
 618 {
 619   g_return_if_fail (dockable != NULL);
 620
 621   if (dockable->options != NULL) {
 622     int index;
 623     SNAP_STATE snap_mode;
 624
 625     snap_mode = gschem_options_get_snap_mode (dockable->options);
 626
 627     for (index=0; index<SNAP_STATE_COUNT; index++) {
 628       g_signal_handlers_block_by_func (G_OBJECT (dockable->snap_radio[index]),
 629                                        G_CALLBACK (update_snap_mode_model),
 630                                        dockable);
 631     }
 632
 633     for (index=0; index<SNAP_STATE_COUNT; index++) {
 634       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dockable->snap_radio[index]),
 635                                     (snap_mode == index));
 636   }
 637
 638     for (index=0; index<SNAP_STATE_COUNT; index++) {
 639       g_signal_handlers_unblock_by_func (G_OBJECT (dockable->snap_radio[index]),
 640                                          G_CALLBACK (update_snap_mode_model),
 641                                          dockable);
 642     }
 643   }
 644 }