Changeset 688

Show
Ignore:
Timestamp:
12/28/09 08:51:06 (5 years ago)
Author:
erikd
Message:

Clean up large number of '#if 0' and '#if 1' code blocks.

Remove code chunks surrounded by '#if 0' .. '#endif'.
Remove '#if 1' and '#endif' around code chunks that are actually being used.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • sweep/trunk/plugins/fade/fade.c

    r526 r688  
    5151  if (op_total == 0) op_total = 1; 
    5252  run_total = 0; 
    53  
    54 #if 0 
    55   /* Find max */ 
    56   for (gl = sounddata->sels; active && gl; gl = gl->next) { 
    57     sel = (sw_sel *)gl->data; 
    58  
    59     offset = 0; 
    60     remaining = sel->sel_end - sel->sel_start; 
    61  
    62     while (active && remaining > 0) { 
    63       g_mutex_lock (sample->ops_mutex); 
    64  
    65       if (sample->edit_state == SWEEP_EDIT_STATE_CANCEL) { 
    66         active = FALSE; 
    67       } else { 
    68  
    69         d = sounddata->data + frames_to_bytes (f, sel->sel_start + offset); 
    70  
    71         n = MIN(remaining, 1024); 
    72  
    73         for (i=0; i < n * f->channels; i++) { 
    74           if(d[i]>=0) max = MAX(max, d[i]); 
    75           else max = MAX(max, -d[i]); 
    76         } 
    77  
    78         remaining -= n; 
    79         offset += n; 
    80  
    81         run_total += n; 
    82         sample_set_progress_percent (sample, run_total / op_total); 
    83       } 
    84  
    85       g_mutex_unlock (sample->ops_mutex); 
    86     } 
    87   } 
    88  
    89   if (max != 0) factor = SW_AUDIO_T_MAX / (gfloat)max; 
    90 #endif 
    9153 
    9254  /* Fade */ 
  • sweep/trunk/plugins/ladspa/ladspameta.c

    r684 r688  
    144144 
    145145  if LADSPA_IS_HINT_SAMPLE_RATE (prhd) { 
    146 #if 0 
    147     lower *= format->rate; 
    148     upper *= format->rate; 
    149 #else 
    150146    lower *= 44100; 
    151147    upper *= 44100; 
    152 #endif 
    153148  } 
    154149 
  • sweep/trunk/plugins/reverse/reverse.c

    r125 r688  
    2727 
    2828#include "../src/sweep_app.h" /* XXX */ 
    29  
    30 #if 0 
    31 static void 
    32 region_reverse (gpointer data, sw_format * format, int nr_frames, 
    33                 sw_param_set pset, gpointer custom_data) 
    34 { 
    35   glong i, sw; 
    36   gpointer d, e, t; 
    37  
    38   sw = frames_to_bytes (format, 1); 
    39   t = g_malloc (sw); 
    40  
    41   d = data; 
    42   e = d + frames_to_bytes (format, nr_frames); 
    43  
    44   for (i = 0; i <= nr_frames/2; i++) { 
    45     memcpy (t, d, sw); 
    46     memcpy (d, e, sw); 
    47     memcpy (e, t, sw); 
    48      
    49     d += sw; 
    50     e -= sw; 
    51   } 
    52  
    53   g_free (t); 
    54 } 
    55 #endif 
    5629 
    5730static sw_sample * 
     
    12598apply_reverse (sw_sample * sample, sw_param_set pset, gpointer custom_data) 
    12699{ 
    127 #if 0 
    128   return 
    129     perform_filter_region_op (sample, _("Reverse"), 
    130                                (SweepFilterRegion)region_reverse, pset, NULL); 
    131 #endif 
    132  
    133100  return 
    134101    perform_filter_op (sample, _("Reverse"), 
  • sweep/trunk/src/about_dialog.c

    r668 r688  
    103103    gtk_widget_show(label); 
    104104 
    105 #if 0 
    106     label = gtk_label_new("Copyright (c) 2000 Conrad Parker, conrad@vergenet.net"); 
    107     gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0); 
    108     gtk_widget_show(label); 
    109 #endif 
    110  
    111105 /* FIXME: old style code 
    112106  *   gtk_widget_pop_style(); 
    113107  */ 
    114  
    115 #if 0 
    116     alignment = gtk_alignment_new(0.5, 0.5, 0.0, 0.0); 
    117     gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0); 
    118     gtk_widget_show(alignment); 
    119  
    120     label = gtk_label_new(_("http://sweep.sourceforge.net/")); 
    121     gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 0); 
    122     gtk_widget_show(label); 
    123 #endif 
    124108 
    125109    button = gtk_button_new_with_label ("http://sweep.sourceforge.net/"); 
  • sweep/trunk/src/callbacks.c

    r557 r688  
    179179set_tool_cb (GtkWidget * widget, gpointer data) 
    180180{ 
    181 #if 0 
    182   gint tool = (gint)data; 
    183  
    184   /*  current_tool = tool;*/ 
    185 #endif 
    186181  g_print ("NOOOOOOOOOOOOOO global current_tool\n"); 
    187182} 
  • sweep/trunk/src/channelops.c

    r211 r688  
    211211  main_vbox = GTK_DIALOG(dialog)->vbox; 
    212212 
    213 #if 0 
    214   current = g_strdup_printf (_("Currently: %d channels"), 
    215                              sample->sounddata->format->channels); 
    216   label = gtk_label_new (current); 
    217   gtk_box_pack_start (GTK_BOX(main_vbox), label, TRUE, TRUE, 8); 
    218   gtk_widget_show (label); 
    219 #endif 
    220  
    221213  chooser = channelcount_chooser_new (_("Output channels")); 
    222214  gtk_box_pack_start (GTK_BOX(main_vbox), chooser, TRUE, TRUE, 0); 
  • sweep/trunk/src/db_ruler.c

    r340 r688  
    263263    gtk_ruler_draw_pos (ruler); 
    264264 
    265 #if 0 
    266   printf ("%f\t%f dB\n", ruler->position, 20 * log10 (fabs(ruler->position))); 
    267 #endif 
    268  
    269265  return FALSE; 
    270266} 
  • sweep/trunk/src/db_slider.c

    r298 r688  
    9999} 
    100100 
    101 #if 0 
    102 static int 
    103 slider_get_value (GtkWidget * slider) 
    104 { 
    105   return 
    106     GPOINTER_TO_INT (g_object_get_data (G_OBJECT(slider), "value")); 
    107 } 
    108  
    109 static int 
    110 slider_set_value (GtkWidget * slider, int value) 
    111 { 
    112   GtkWidget * combo_entry; 
    113   int i; 
    114  
    115   combo_entry = 
    116     GTK_WIDGET (g_object_get_data (G_OBJECT(slider), "combo_entry")); 
    117  
    118   for (i = 0; choices[i].name != NULL; i++) { 
    119     if (value == choices[i].value) { 
    120       gtk_entry_set_text (GTK_ENTRY(combo_entry), choices[i].name); 
    121       return value; 
    122     } 
    123   } 
    124  
    125   /* not in the entry -- assume first choice is "Custom" and set that */ 
    126   gtk_entry_set_text (GTK_ENTRY(combo_entry), choices[0].name); 
    127  
    128   return slider_set_value_direct (slider, value);; 
    129 } 
    130 #endif 
    131  
    132101#define VALUE_TO_DB(v) (20 * log10(v)) 
    133102#define DB_TO_VALUE(d) (pow (10, ((d) / 20))) 
  • sweep/trunk/src/driver.c

    r687 r688  
    544544    g_object_set_data (G_OBJECT (dialog), "main_combo", main_combo); 
    545545 
    546 #if 0 
    547     button = gtk_button_new_with_label (_("Default")); 
    548     gtk_box_pack_start (GTK_BOX(hbox), button, FALSE, FALSE, 0); 
    549     gtk_widget_show (button); 
    550     g_signal_connect (G_OBJECT(button), "clicked", 
    551                         G_CALLBACK(default_devicename_cb), NULL); 
    552 #endif 
    553  
    554546    separator = gtk_hseparator_new (); 
    555547    gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 8); 
     
    698690    gtk_widget_show (hbox); 
    699691 
    700 #if 0 
    701     checkbutton = 
    702       gtk_check_button_new_with_label (_("Remember these options")); 
    703     gtk_box_pack_start (GTK_BOX (hbox), checkbutton, TRUE, TRUE, 0); 
    704     gtk_widget_show (checkbutton); 
    705  
    706     g_object_set_data (G_OBJECT (dialog), "rem_options_chb", checkbutton); 
    707  
    708     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(checkbutton), TRUE); 
    709 #endif 
    710  
    711692    hbox2 = gtk_hbox_new (TRUE, 4); 
    712693    gtk_box_pack_end (GTK_BOX (hbox), hbox2, FALSE, TRUE, 0); 
  • sweep/trunk/src/driver_alsa.c

    r687 r688  
    176176  snd_pcm_uframes_t period_size = PBUF_SIZE/format->channels; 
    177177 
    178 #if 1 
    179178  if (handle->driver_flags == O_RDONLY) { 
    180179    dir = (int)SND_PCM_STREAM_CAPTURE; 
     
    184183    return; 
    185184  } 
    186 #else 
    187   dir = 0; 
    188 #endif 
    189185 
    190186  snd_pcm_hw_params_alloca (&hwparams); 
     
    339335  int err; 
    340336 
    341 #if 0 
    342   gint16 * bbuf; 
    343   size_t byte_count; 
    344   ssize_t bytes_written; 
    345   int need_bswap; 
    346   int i; 
    347  
    348   if (handle == NULL) { 
    349 #ifdef DEBUG 
    350     g_print ("handle NULL in write()\n"); 
    351 #endif 
    352     return -1; 
    353   } 
    354  
    355   byte_count = count * sizeof (gint16); 
    356   bbuf = alloca (byte_count); 
    357  
    358   for (i = 0; i < count; i++) { 
    359     bbuf[i] = (gint16)(PLAYBACK_SCALE * buf[i]); 
    360   } 
    361  
    362   err = snd_pcm_writei(pcm_handle, bbuf, uframes); 
    363 #else 
    364337  /*printf ("sweep: alsa_write \n");*/ 
    365338 
     
    369342  // this basicaly ripped straight out of alsaplayer alsa-final driver: 
    370343  err = snd_pcm_writei(pcm_handle, buf, uframes); 
    371 #endif 
    372344 
    373345  if (err == -EPIPE) { 
  • sweep/trunk/src/edit.c

    r124 r688  
    14991499} 
    15001500 
    1501 #if 0 
    1502 static sw_operation paste_in_op = { 
    1503   SWEEP_EDIT_MODE_ALLOC, 
    1504   (SweepCallback)do_paste_in, 
    1505   (SweepFunction)NULL, 
    1506   (SweepCallback)undo_by_splice_out, 
    1507   (SweepFunction)splice_data_destroy, 
    1508   (SweepCallback)redo_by_splice_in, 
    1509   (SweepFunction)splice_data_destroy 
    1510 }; 
    1511  
    1512 /* XXX: why is this **out ?? */ 
    1513 sw_op_instance * 
    1514 do_paste_in (sw_sample * in, sw_sample ** out) 
    1515 { 
    1516   sw_op_instance * inst; 
    1517   sw_edit_buffer * eb; 
    1518  
    1519   if (ebuf == NULL) return NULL; 
    1520  
    1521   inst = sw_op_instance_new (in, "Paste in", &paste_in_op); 
    1522   /*eb = edit_buffer_copy (ebuf);*/ 
    1523   eb = edit_buffer_ref (ebuf); 
    1524  
    1525   (*out)->sounddata = splice_in_eb (in->sounddata, ebuf); 
    1526  
    1527   inst->redo_data = inst->undo_data = 
    1528     splice_data_new (eb, NULL); 
    1529  
    1530   sample_refresh_views (*out); 
    1531  
    1532   return inst; 
    1533 } 
    1534 #endif 
    1535  
    15361501static void 
    15371502do_paste_insert_thread (sw_op_instance * inst) 
     
    17581723} 
    17591724 
    1760 #if 0 
    1761 static sw_operation paste_over_op = { 
    1762   SWEEP_EDIT_MODE_FILTER, 
    1763   (SweepCallback)NULL, 
    1764   (SweepFunction)NULL, 
    1765   (SweepCallback)undo_by_paste_over, 
    1766   (SweepFunction)paste_over_data_destroy, 
    1767   (SweepCallback)redo_by_paste_over, 
    1768   (SweepFunction)paste_over_data_destroy 
    1769 }; 
    1770  
    1771 sw_op_instance * 
    1772 do_paste_over (sw_sample * in, sw_sample **out) 
    1773 { 
    1774   sw_op_instance * inst; 
    1775   sw_edit_buffer * old_eb, * new_eb; 
    1776  
    1777   if (ebuf == NULL) return NULL; 
    1778  
    1779   inst = sw_op_instance_new (in, "Paste over", &paste_over_op); 
    1780   old_eb = edit_buffer_from_sample (in); 
    1781  
    1782   *out = paste_over (in, ebuf); 
    1783   new_eb = edit_buffer_from_sample (*out); 
    1784  
    1785   inst->redo_data = inst->undo_data = 
    1786     paste_over_data_new (old_eb, new_eb); 
    1787  
    1788   sample_refresh_views (*out); 
    1789  
    1790   return inst; 
    1791 } 
    1792 #endif 
    1793  
    17941725sw_sample * 
    17951726do_paste_as_new (void) 
  • sweep/trunk/src/file_dialogs.c

    r557 r688  
    635635  gtk_widget_show (menuitem); 
    636636 
    637 #if 1 
    638637  /* MP3 (encoding not supported due to patent restrictions) */ 
    639638 
     
    642641  gtk_menu_append (GTK_MENU(menu), menuitem); 
    643642  gtk_widget_show (menuitem); 
    644 #endif 
    645643 
    646644#ifdef HAVE_OGGVORBIS 
     
    860858    break; 
    861859  default: 
    862 #if 0 
    863     g_assert_not_reached (); 
    864 #else 
    865860    sample_save_as_cb (widget, data); 
    866 #endif 
    867861    break; 
    868862  } 
  • sweep/trunk/src/file_mad.c

    r305 r688  
    388388  if (!file_is_mpeg_audio (pathname)) return NULL; 
    389389 
    390 #if 0 
    391   fd = open (pathname, O_RDONLY); 
    392  
    393   if (fstat (fd, &statbuf) == -1 || statbuf.st_size == 0) return NULL; 
    394 #endif 
    395  
    396390  /* Create the sample/sounddata, initially with length 0, to be grown 
    397391   * as the file is decoded 
  • sweep/trunk/src/file_sndfile1.c

    r277 r688  
    137137update_save_options_caps (sndfile_save_options * so) 
    138138{ 
    139  
    140 /*-    SF_INFO * sfinfo; 
    141   sndfile_subformat_caps * fcaps, * caps; 
    142  
    143   sfinfo = so->sfinfo; 
    144   fcaps = get_format_caps (sfinfo->format); 
    145   caps = get_subformat_caps (fcaps, sfinfo->format); 
    146  
    147   if (caps) { 
    148     gtk_widget_set_sensitive (so->radio_mono, caps->cap_mono); 
    149     gtk_widget_set_sensitive (so->radio_stereo, caps->cap_stereo); 
    150   } else { 
    151     gtk_widget_set_sensitive (so->radio_mono, FALSE); 
    152     gtk_widget_set_sensitive (so->radio_stereo, FALSE); 
    153   } 
    154 -*/ 
    155 #if 0 
    156  
    157   SF_INFO tmp_sfinfo; 
    158  
    159   memcpy (&tmp_sfinfo, so->sfinfo, sizeof (SF_INFO)); 
    160  
    161   tmp_sfinfo.channels = 1; 
    162   gtk_widget_set_sensitive (so->radio_mono, sf_format_check (&tmp_sfinfo)); 
    163  
    164   tmp_sfinfo.channels = 2; 
    165   gtk_widget_set_sensitive (so->radio_stereo, sf_format_check (&tmp_sfinfo)); 
    166 #endif 
    167  
    168139  update_ok_button (so); 
    169140} 
     
    180151 
    181152  sfinfo = so->sfinfo; 
    182  
    183 #if 0 
    184 #define BLOCK_AND_SET(r,d) \ 
    185   gtk_signal_handler_block_by_data(GTK_OBJECT((r)), (d));       \ 
    186   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON((r)), TRUE);  \ 
    187   gtk_signal_handler_unblock_by_data(GTK_OBJECT((r)), (d)); 
    188  
    189   switch (sfinfo->channels) { 
    190   case 1: 
    191     BLOCK_AND_SET(so->radio_mono, so); 
    192     break; 
    193   case 2: 
    194     BLOCK_AND_SET(so->radio_stereo, so); 
    195     break; 
    196   default: 
    197     break; 
    198   } 
    199 #endif 
    200153 
    201154  update_ok_button (so); 
  • sweep/trunk/src/file_speex.c

    r668 r688  
    746746  run_total = 0; 
    747747 
    748 #if 0 
    749   if (format->channels != 1) { 
    750     fprintf (stderr, "Unsupported channel count for Speex encoding\n"); 
    751     return -1; 
    752   } 
    753 #endif 
    754  
    755748  if (!(outfile = fopen (pathname, "w"))) { 
    756749    sweep_perror (errno, pathname); 
     
    928921    op.b_o_s = 0; 
    929922    /* op.e_o_s was set above */ 
    930 #if 0 /* XXX: was set above */ 
    931     if (eos) 
    932       op.e_o_s = 1; 
    933     else 
    934       op.e_o_s = 0; 
    935 #endif 
    936923    op.granulepos = id * frame_size; 
    937924    op.packetno = 2 + (id-1)/so->framepack; 
     
    961948  } 
    962949 
    963 #if 0 
    964   /*Flush all pages left to be written*/ 
    965   while (ogg_stream_flush(&os, &og)) 
    966     { 
    967       n = fwrite (og.header, 1, og.header_len, outfile); 
    968       n += fwrite (og.body, 1, og.body_len, outfile); 
    969        
    970       if (fflush (outfile) == 0) { 
    971         bytes_written += n; 
    972       } else { 
    973         errno_save = errno; 
    974         active = FALSE; 
    975       } 
    976     } 
    977 #endif 
    978  
    979950  /* clean up and exit.  speex_info_clear() must be called last */ 
    980951 
     
    993964    char time_buf[BUF_LEN], bytes_buf[BUF_LEN]; 
    994965 
    995 #if 1 
    996966    sample_store_and_free_pathname (sample, pathname); 
    997 #else 
    998     g_free (pathname); 
    999 #endif 
    1000967 
    1001968    /* Mark the last mtime for this sample */ 
  • sweep/trunk/src/file_vorbis.c

    r277 r688  
    620620    char time_buf[BUF_LEN], bytes_buf[BUF_LEN]; 
    621621 
    622 #if 1 
    623622    sample_store_and_free_pathname (sample, pathname); 
    624 #else 
    625     g_free (pathname); 
    626 #endif 
    627623 
    628624    /* Mark the last mtime for this sample */ 
  • sweep/trunk/src/head.c

    r284 r688  
    489489    gtk_box_pack_start (GTK_BOX (tool_hbox), button, FALSE, TRUE, 0); 
    490490    gtk_widget_show (button); 
    491 #if 0 
    492     gtk_widget_add_accelerator (button, "clicked", accel_group, 
    493                                 GDK_r, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); 
    494 #endif 
    495 g_signal_handlers_block_matched (GTK_OBJECT(button), G_SIGNAL_MATCH_DATA, 0, 
     491    g_signal_handlers_block_matched (GTK_OBJECT(button), G_SIGNAL_MATCH_DATA, 0, 
    496492                                                                        0, 0, 0, hctl); 
    497493    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(button), head->going); 
  • sweep/trunk/src/interface.c

    r557 r688  
    225225  style_LCD = create_style(color_LCD, color_LCD, FALSE); 
    226226  style_light_grey = create_style (color_light_grey, color_light_grey, TRUE); 
    227 #if 0 
    228   style_green_grey = create_style (color_green_grey, color_green_grey, TRUE); 
    229 #else 
    230227  style_green_grey = style_light_grey; 
    231 #endif 
    232228 
    233229  style_red_grey = create_style (color_red_grey, color_red_grey, TRUE); 
    234230 
    235 #if 0 
    236   style_dark_grey = create_style(&gdkwhite, color_dark_grey, TRUE); 
    237 #else 
    238231  style_dark_grey = style_light_grey; 
    239 #endif 
    240232 
    241233  style_red = create_style (&gdkblack, color_red, FALSE); 
     
    300292} 
    301293 
    302  
    303 #if 0 
    304 static void 
    305 main_destroy_cb (GtkWidget * widget, gpointer data) 
    306 { 
    307   gtk_main_quit(); 
    308 } 
    309  
    310  
    311 GtkWidget* 
    312 create_toolbox (void) 
    313 { 
    314   GtkWidget *window1; 
    315   GtkWidget *vbox1; 
    316   GtkWidget *handlebox2; 
    317   GtkWidget *menubar1; 
    318   GtkWidget *handlebox1; 
    319   GtkWidget *toolbar1; 
    320   GtkWidget *button1, * button; 
    321   GtkWidget *pixmap1, *pixmap3; 
    322   GtkWidget *menu; 
    323   GtkWidget *menuitem; 
    324   GtkAccelGroup *accel_group; 
    325  
    326   window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); 
    327   gtk_window_set_title (GTK_WINDOW (window1), _("Sweep")); 
    328   gtk_widget_realize (window1); 
    329  
    330   g_signal_connect (G_OBJECT(window1), "destroy", 
    331                       G_CALLBACK(main_destroy_cb), NULL); 
    332  
    333  
    334   vbox1 = gtk_vbox_new (FALSE, 0); 
    335   gtk_widget_show (vbox1); 
    336   gtk_container_add (GTK_CONTAINER (window1), vbox1); 
    337  
    338   handlebox2 = gtk_handle_box_new (); 
    339   gtk_widget_show (handlebox2); 
    340   gtk_box_pack_start (GTK_BOX (vbox1), handlebox2, FALSE, FALSE, 0); 
    341  
    342   menubar1 = gtk_menu_bar_new (); 
    343   gtk_widget_show (menubar1); 
    344   gtk_container_add (GTK_CONTAINER (handlebox2), menubar1); 
    345  
    346   /* Create a GtkAccelGroup and add it to the window. */ 
    347   accel_group = gtk_accel_group_new(); 
    348   gtk_window_add_accel_group (GTK_WINDOW(window1), accel_group); 
    349  
    350   menu = gtk_menu_new(); 
    351  
    352   menuitem = gtk_menu_item_new_with_label (_("File")); 
    353   gtk_menu_item_set_submenu (GTK_MENU_ITEM(menuitem), menu); 
    354   gtk_menu_bar_append (GTK_MENU_BAR(menubar1), menuitem); 
    355   gtk_widget_show(menuitem); 
    356  
    357   menuitem = gtk_menu_item_new_with_label (_("New")); 
    358   gtk_menu_append (GTK_MENU(menu), menuitem); 
    359   g_signal_connect (G_OBJECT(menuitem), "activate", 
    360                       G_CALLBACK(sample_new_empty_cb), NULL); 
    361   gtk_widget_show(menuitem); 
    362   gtk_widget_add_accelerator (menuitem, "activate", accel_group, 
    363                               GDK_n, GDK_CONTROL_MASK, 
    364                               GTK_ACCEL_VISIBLE); 
    365  
    366   menuitem = gtk_menu_item_new_with_label (_("Open")); 
    367   gtk_menu_append (GTK_MENU(menu), menuitem); 
    368   g_signal_connect (G_OBJECT(menuitem), "activate", 
    369                       G_CALLBACK(sample_load_cb), window1); 
    370   gtk_widget_show(menuitem); 
    371   gtk_widget_add_accelerator (menuitem, "activate", accel_group, 
    372                               GDK_o, GDK_CONTROL_MASK, 
    373                               GTK_ACCEL_VISIBLE); 
    374  
    375   menuitem = gtk_menu_item_new_with_label (_("Quit")); 
    376   gtk_menu_append (GTK_MENU(menu), menuitem); 
    377   g_signal_connect (G_OBJECT(menuitem), "activate", 
    378                       G_CALLBACK(exit_cb), window1); 
    379   gtk_widget_show(menuitem); 
    380   gtk_widget_add_accelerator (menuitem, "activate", accel_group, 
    381                               GDK_q, GDK_CONTROL_MASK, 
    382                               GTK_ACCEL_VISIBLE); 
    383  
    384   menu = gtk_menu_new(); 
    385  
    386   menuitem = gtk_menu_item_new_with_label (_("Help")); 
    387   gtk_menu_item_set_submenu (GTK_MENU_ITEM(menuitem), menu); 
    388   gtk_menu_bar_append (GTK_MENU_BAR(menubar1), menuitem); 
    389   gtk_widget_show(menuitem); 
    390  
    391   menuitem = gtk_menu_item_new_with_label (_("About...")); 
    392   gtk_menu_append (GTK_MENU(menu), menuitem); 
    393   g_signal_connect (G_OBJECT(menuitem), "activate", 
    394                       G_CALLBACK(about_dialog_create), NULL); 
    395   gtk_widget_show(menuitem); 
    396  
    397 #if 0 
    398   handlebox1 = gtk_handle_box_new (); 
    399   gtk_widget_show (handlebox1); 
    400   gtk_box_pack_start (GTK_BOX (vbox1), handlebox1, FALSE, FALSE, 0); 
    401  
    402   toolbar1 = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_BOTH); 
    403   gtk_widget_show (toolbar1); 
    404   gtk_container_add (GTK_CONTAINER (handlebox1), toolbar1); 
    405  
    406   /* SELECT */ 
    407  
    408   pixmap1 = create_widget_from_xpm (toolbar1, rect_xpm); 
    409   gtk_widget_show (pixmap1); 
    410  
    411   button1 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), 
    412                                         GTK_TOOLBAR_CHILD_RADIOBUTTON, 
    413                                         NULL, /* Radio group */ 
    414                                         _("Select"), 
    415                                         _("Select regions of a sample"),  
    416                                         _("This tool allows you to select" 
    417                                           " regions of a sample. You can then" 
    418                                           " apply edits and effects to the:" 
    419                                           " selected regions. Hold down shift" 
    420                                           " whilst selecting to add" 
    421                                           " discontinuous regions to the" 
    422                                           " selection."), 
    423                                         pixmap1, /* icon */ 
    424                                         set_tool_cb, (gpointer)TOOL_SELECT); 
    425   gtk_widget_show (button1); 
    426  
    427 #if 0 
    428   /* MOVE */ 
    429  
    430   button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), 
    431                                        GTK_TOOLBAR_CHILD_RADIOBUTTON, 
    432                                        button1, /* Radio group */ 
    433                                         _("Move"), 
    434                                        _("Move regions in a sample"), 
    435                                        _("With this tool you can move" 
    436                                          " selected regions of a sample."), 
    437                                        NULL, /* icon */ 
    438                                        set_tool_cb, (gpointer)TOOL_MOVE); 
    439   gtk_widget_show (button); 
    440 #endif 
    441  
    442   /* SCRUB */ 
    443  
    444   button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), 
    445                                        GTK_TOOLBAR_CHILD_RADIOBUTTON, 
    446                                        button1, /* Radio group */ 
    447                                        _("Scrub"), 
    448                                        _("Locate sounds directly"), 
    449                                        _("Place the play marker on a sample." 
    450                                          " Click anywhere in a view to" 
    451                                          " instantly move the playback" 
    452                                          " position to that part of the" 
    453                                          " sample."), 
    454                                        NULL, /* icon */ 
    455                                        set_tool_cb, (gpointer)TOOL_SCRUB); 
    456   gtk_widget_show (button); 
    457  
    458   /* ZOOM */ 
    459  
    460   pixmap3 = create_widget_from_xpm (window1, magnify_xpm); 
    461   gtk_widget_show (pixmap3); 
    462  
    463   button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), 
    464                                        GTK_TOOLBAR_CHILD_RADIOBUTTON, 
    465                                        button1, /* Radio group */ 
    466                                        _("Zoom"), 
    467                                        _("Zoom in & out"), 
    468                                        _("Zoom in and out of a view. Click" 
    469                                          " anywhere in a view to zoom in on" 
    470                                          " that part of the sample. Hold" 
    471                                          " down shift and click on the view" 
    472                                          " to zoom out."), 
    473                                        pixmap3, /* icon */ 
    474                                        set_tool_cb, (gpointer)TOOL_ZOOM); 
    475   gtk_widget_show (button); 
    476  
    477 #if 1 /* These need undos! */ 
    478  
    479   /* PENCIL */ 
    480  
    481   button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), 
    482                                        GTK_TOOLBAR_CHILD_RADIOBUTTON, 
    483                                        button1, /* Radio group */ 
    484                                        _("Pencil"), 
    485                                        _("Edit PCM sample values"), 
    486                                        _("When zoomed down to individual " 
    487                                          " samples, click to edit"), 
    488                                        NULL, /* icon */ 
    489                                        set_tool_cb, (gpointer)TOOL_PENCIL); 
    490   gtk_widget_show (button); 
    491  
    492   /* NOISE */ 
    493  
    494   button = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), 
    495                                        GTK_TOOLBAR_CHILD_RADIOBUTTON, 
    496                                        button1, /* Radio group */ 
    497                                        _("Noise"), 
    498                                        _("Add noise"), 
    499                                        _("Randomise PCM values"), 
    500                                        NULL, /* icon */ 
    501                                        set_tool_cb, (gpointer)TOOL_NOISE); 
    502   gtk_widget_show (button); 
    503 #endif 
    504  
    505 #endif /* TOOLBAR */ 
    506  
    507   return window1; 
    508 } 
    509  
    510 #endif 
    511  
    512294/* 
    513295 * close the window when Ctrl and w are pressed. 
  • sweep/trunk/src/levelmeter.c

    r278 r688  
    9292  attributes.event_mask = gtk_widget_get_events(widget) | 
    9393    GDK_EXPOSURE_MASK 
    94 #if 0 
    95     | GDK_BUTTON_PRESS_MASK | 
    96     GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | 
    97     GDK_POINTER_MOTION_HINT_MASK 
    98 #endif 
    9994    ; 
    10095  attributes.visual = gtk_widget_get_visual(widget); 
  • sweep/trunk/src/main.c

    r684 r688  
    7676} 
    7777 
    78 #if 0 
    79 static gint 
    80 initial_sample_new (gpointer data) 
    81 { 
    82   sample_new_empty_cb (NULL, NULL); 
    83  
    84   return FALSE; 
    85 } 
    86 #endif 
    87  
    8878static gint 
    8979initial_sample_ask (gpointer data) 
     
    10797{ 
    10898  int i; 
    109 #if 0 
    110   GtkWidget *toolbox; 
    111 #endif 
    11299 
    113100  gboolean show_version = FALSE; 
     
    130117#ifdef DEVEL_CODE 
    131118  g_print (_("WARNING: Build includes incomplete development code.\n")); 
    132 #endif 
    133  
    134 #if 0 
    135 #if defined (SNDFILE_1) 
    136   if (sizeof (sw_framecount_t) != sizeof (sf_count_t)) { 
    137     puts ("Software was configured incorrectly. Cannot run.\n") ; 
    138         exit (1) ; 
    139         } 
    140 #endif 
    141119#endif 
    142120 
     
    169147      ignore_failed_tdb_lock = TRUE; 
    170148      argv[i] = NULL;                       
    171 #if 0 
    172     } else if (strcmp (argv[i], "--no-toolbox") == 0) { 
    173       show_toolbox = FALSE; 
    174       argv[i] = NULL; 
    175 #endif 
    176149 
    177150#ifdef DEVEL_CODE 
     
    207180                          "                           file system. (possibly unsafe) \n" )); 
    208181 
    209 #if 0 
    210     g_print (_("  --no-toolbox             Do not show the toolbox window.\n")); 
    211 #endif 
    212182  } 
    213183 
     
    241211  init_playback (); 
    242212 
    243 #if 0 
    244   if (show_toolbox) { 
    245     toolbox = create_toolbox (); 
    246     gtk_widget_show (toolbox); 
    247   } 
    248 #endif 
    249  
    250  
    251213   
    252214  gtk_main (); 
  • sweep/trunk/src/notes.c

    r435 r688  
    9191  { N_("D#5"), 2.378414, GDK_0, "D#5"}, 
    9292  { N_("E5") , 2.519842, GDK_p, "E5" }, 
    93 #if 0 
    94   { N_("F5") , 2.669680, GDK_bracketleft, "F5" }, 
    95   { N_("F#5"), 2.828427, GDK_None, "F#5" }, 
    96   { N_("G5") , 2.996614, GDK_None, "G5" }, 
    97   { N_("G#5"), 3.174802, GDK_None, "G#5" }, 
    98   { N_("A5") , 3.363586, GDK_None, "A5" }, 
    99   { N_("Bb5"), 3.563595, GDK_None, "Bb5" }, 
    100   { N_("B5") , 3.775497, GDK_None, "B5" }, 
    101 #endif 
    102  
    10393} ; 
    10494 
  • sweep/trunk/src/param.c

    r557 r688  
    248248ps_adjuster_destroy (sw_ps_adjuster * ps) 
    249249{ 
    250 #if 0 /* XXX */ 
    251   GList * gl; 
    252  
    253   g_free (ps->pset); 
    254  
    255   for (gl = ps->plsk_list; gl; gl = gl->next) { 
    256     g_free (gl->data); 
    257   } 
    258 #endif 
    259250} 
    260251 
     
    766757  ps->table = table; 
    767758 
    768 #if 0 
    769   frame = gtk_frame_new (_("Preview")); 
    770   gtk_box_pack_start (GTK_BOX(hbox), frame, TRUE, TRUE, 8); 
    771   gtk_widget_show (frame); 
    772  
    773   vbox = gtk_vbox_new (FALSE, 4); 
    774   gtk_container_add (GTK_CONTAINER (frame), vbox); 
    775   gtk_container_set_border_width (GTK_CONTAINER(vbox), 8); 
    776   gtk_widget_show (vbox); 
    777 #endif 
    778  
    779759  ok_button = gtk_button_new_with_label (_("OK")); 
    780760  GTK_WIDGET_SET_FLAGS (GTK_WIDGET (ok_button), GTK_CAN_DEFAULT); 
  • sweep/trunk/src/paste_dialogs.c

    r557 r688  
    5050 
    5151 
    52 #if 0 
    53 static GtkWidget * 
    54 create_pixmap_button (GtkWidget * widget, gchar ** xpm_data, 
    55                       const gchar * label_text, const gchar * tip_text, 
    56                       GCallback clicked) 
    57 { 
    58   GtkWidget * hbox; 
    59   GtkWidget * label; 
    60   GtkWidget * pixmap; 
    61   GtkWidget * button; 
    62   GtkTooltips * tooltips; 
    63  
    64   button = gtk_button_new (); 
    65  
    66   hbox = gtk_hbox_new (FALSE, 2); 
    67   gtk_container_add (GTK_CONTAINER(button), hbox); 
    68   gtk_container_set_border_width (GTK_CONTAINER(button), 8); 
    69   gtk_widget_show (hbox); 
    70  
    71   if (xpm_data != NULL) { 
    72     pixmap = create_widget_from_xpm (widget, xpm_data); 
    73     gtk_box_pack_start (GTK_BOX(hbox), pixmap, FALSE, FALSE, 8); 
    74     gtk_widget_show (pixmap); 
    75   } 
    76  
    77   if (label_text != NULL) { 
    78     label = gtk_label_new (label_text); 
    79     gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 8); 
    80     gtk_widget_show (label); 
    81   } 
    82  
    83   if (tip_text != NULL) { 
    84     tooltips = gtk_tooltips_new (); 
    85     gtk_tooltips_set_tip (tooltips, button, tip_text, NULL); 
    86   } 
    87  
    88   if (clicked != NULL) { 
    89     g_signal_connect (G_OBJECT (button), "clicked", 
    90                         G_CALLBACK(clicked), NULL); 
    91   } 
    92  
    93   return button; 
    94 } 
    95 #endif 
    96  
    9752static void 
    9853paste_dialog_destroy (GtkWidget * widget, gpointer data) 
     
    242197                     G_CALLBACK (paste_dialog_destroy), sample); 
    243198 
    244 #if 0 
    245   gtk_accel_group_add (accel_group, GDK_w, GDK_CONTROL_MASK, GDK_NONE, 
    246                        GTK_OBJECT(dialog), "destroy"); 
    247 #endif 
    248  
    249199  main_vbox = GTK_DIALOG(dialog)->vbox; 
    250200 
  • sweep/trunk/src/play.c

    r687 r688  
    139139                     (gpointer)s); 
    140140} 
    141  
    142 #if 0 
    143 static struct timeval tv_instant = {0, 0}; 
    144 #endif 
    145141 
    146142static sw_framecount_t 
     
    679675  } 
    680676 
    681 #if 0 
    682   { 
    683     fd_set fds; 
    684      
    685     FD_ZERO (&fds); 
    686     FD_SET (handle->driver_fd, &fds); 
    687      
    688     if (select (handle->driver_fd+1, &fds, NULL, NULL, &tv_instant) == 0); 
    689   } 
    690 #else 
    691677  device_wait (handle); 
    692 #endif 
    693678 
    694679  return; 
     
    733718 
    734719      head_read (head, pbuf, n, handle->driver_rate); 
    735            
    736 #if 0 
    737       if (f->channels != handle->driver_channels) { 
    738         channel_convert (pbuf, f->channels, devbuf, 
    739                          handle->driver_channels, n); 
    740       } 
    741 #else 
     720 
    742721      channel_convert_adding (pbuf, f->channels, devbuf, 
    743722                              handle->driver_channels, n); 
    744 #endif 
    745723         
    746724      /* XXX: store the head->offset NOW for device_offset referencing */ 
     
    748726      g_mutex_lock (s->play_mutex); 
    749727           
    750 #if 0 
    751       head->realoffset = head->offset; 
    752 #else 
    753728      head->realoffset = device_offset (handle); 
    754729      if (head->realoffset == -1) { 
    755730        head->realoffset = head->offset; 
    756731      } 
    757 #endif 
    758732         
    759733      head->offset = head->realoffset; 
     
    903877  } 
    904878 
    905 #if 0 
    906   if (!head->looping) { 
    907     device_drain (handle); 
    908  
    909     HEAD_SET_GOING (head, FALSE); 
    910   } 
    911 #endif 
    912  
    913879  if (use_monitor) { 
    914880    device_reset (monitor_handle); 
  • sweep/trunk/src/preferences.c

    r666 r688  
    210210 
    211211  nval = * (long *)val_data.dptr; 
    212 #if 0 
    213   val = g_ntohl (nval); 
    214 #else 
    215212  val = nval; 
    216 #endif 
    217213 
    218214  * (long *)val_data.dptr = val; 
     
    232228  key_data.dsize = strlen (key); 
    233229 
    234 #if 0 
    235   nval = g_htonl (val); 
    236 #else 
    237230  nval = val; 
    238 #endif 
    239231 
    240232  val_data.dptr = (char *)&nval; 
  • sweep/trunk/src/sample-display.c

    r557 r688  
    9393  ((sw_audio_t)(CHANNEL_HEIGHT/2 - (y - (YPOS_TO_CHANNEL(y) * CHANNEL_HEIGHT)))/(CHANNEL_HEIGHT/2)) 
    9494 
    95 #if 0 
    96 #define YPOS_TO_CHANNEL(y) \ 
    97   (s->view->sample->sounddata->format->channels == 2 ? (y > s->height/2) : 0) 
    98  
    99 #define YPOS_TO_VALUE_1(y) \ 
    100   ((sw_audio_t)(s->height/2 - y)/(s->height/2)) 
    101  
    102 #define YPOS_TO_VALUE_L(y) \ 
    103   ((sw_audio_t)(s->height/4 - y)/(s->height/4)) 
    104  
    105 #define YPOS_TO_VALUE_R(y) \ 
    106   ((sw_audio_t)(3*s->height/4 - y)/(s->height/4)) 
    107  
    108 #define YPOS_TO_VALUE_2(y) \ 
    109   (YPOS_TO_CHANNEL(y) ? YPOS_TO_VALUE_R(y) : YPOS_TO_VALUE_L(y)) 
    110 #endif 
    111  
    11295#define MARCH_INTERVAL 300 
    11396#define PULSE_INTERVAL 450 
     
    120103                         * last_tmp_view 
    121104                         */ 
    122  
    123 #if 1 
    124105 
    125106static const int default_colors[] = { 
     
    131112  240, 230, 240, /* sel box */ 
    132113  110, 110, 100, /* tmp_sel XOR mask */ 
    133 #if 1 
    134114  108, 115, 134,    /* sel bg */ 
    135 #else 
    136   62, 68, 118,  /* sel bg */ 
    137 #endif 
    138115  166, 166, 154, /* minmax */ 
    139116  240, 250, 240, /* highlight */ 
     
    142119}; 
    143120 
    144 #else 
    145  
    146 static const int default_colors[] = { 
    147 #if 0 
    148   86, 86, 80,    /* bg */ 
    149 #elif 0 
    150   220, 220, 210, /* bg */ 
    151 #else 
    152   200, 200, 193,    /* bg */ 
    153 #endif 
    154   199, 203, 158, /* fg */ 
    155   20, 230, 0,    /* play */ 
    156   200, 200, 200, /* user */ 
    157   200, 200, 200, /* zero */ 
    158   240, 230, 240, /* sel box */ 
    159   110, 110, 100, /* tmp_sel XOR mask */ 
    160   118, 118, 108, /* sel bg XOR mask */ 
    161   154, 166, 154, /* minmax */ 
    162   219, 219, 211, /* highlight */ 
    163   81, 101, 81,   /* lowlight */ 
    164   240, 0, 0,     /* rec */ 
    165 }; 
    166 #endif 
    167  
    168121static const int bg_colors[] = { 
    169122  250, 250, 237,    /* black bg */ 
     
    171124  147, 147, 140,    /* orange bg */ 
    172125  160, 160, 150,    /* yellow bg */ 
    173 #if 0 
    174   210, 210, 193,    /* blue bg */ 
    175 #else 
    176126  250, 250, 237,    /* blue bg */ 
    177 #endif 
    178127  160, 160, 150,    /* white bg */ 
    179128  0, 0, 0,          /* greenscreen bg */ 
     
    702651  attributes.wclass = GDK_INPUT_OUTPUT; 
    703652  attributes.window_type = GDK_WINDOW_CHILD; 
    704 #if 0 
    705   attributes.event_mask = gtk_widget_get_events (widget) 
    706     | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK 
    707     | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK 
    708     | GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK | 
    709     GDK_FOCUS_CHANGE_MASK | GDK_KEY_PRESS_MASK; 
    710 #else 
    711653  attributes.event_mask = GDK_ALL_EVENTS_MASK; 
    712 #endif 
    713654 
    714655  attributes.visual = gtk_widget_get_visual (widget); 
     
    1035976  } 
    1036977 
    1037 #if 0 
    1038   cheight = (sh+3)/channels; 
    1039   cerr = (sh+3) - (channels * cheight); 
    1040   if (cerr == channels - 1) { 
    1041     cheight++; 
    1042     cerr = 0; 
    1043   } 
    1044   cy = 0; 
    1045 #else 
    1046978  cheight = sh / channels; 
    1047979  cerr = sh - (channels * cheight); 
     
    1051983  } 
    1052984  cy = 0; 
    1053 #endif 
    1054985 
    1055986  for (i = 0; i < channels; i++) { 
     
    1059990                                          x, cy, width, 1); 
    1060991      cy += 1; 
    1061  
    1062 #if 0 
    1063       if (i == channels/2) { 
    1064         gtk_style_apply_default_background (GTK_WIDGET(s)->style, win, 
    1065                                             TRUE, GTK_STATE_NORMAL, NULL, 
    1066                                             x, cy, width, cerr); 
    1067         cy += cerr; 
    1068       } 
    1069 #endif 
    1070992    } 
    1071993 
     
    12791201} 
    12801202 
    1281  
    1282 /*** PLAY MARKER, CURSOR ***/ 
    1283  
    1284 #if 0 
    1285 static int 
    1286 sample_display_startoffset_to_xpos (SampleDisplay *s, 
    1287                                     int offset) 
    1288 { 
    1289   int d = offset - s->view->start; 
    1290  
    1291   if(d < 0) 
    1292     return 0; 
    1293   if(d >= (s->view->end - s->view->start)) 
    1294     return s->width; 
    1295  
    1296   return d * s->width / (s->view->end - s->view->start); 
    1297 } 
    1298  
    1299  
    1300 static int 
    1301 sample_display_endoffset_to_xpos (SampleDisplay *s, 
    1302                                   int offset) 
    1303 { 
    1304   if((s->view->end - s->view->start) < s->width) { 
    1305     return sample_display_startoffset_to_xpos(s, offset); 
    1306   } else { 
    1307     int d = offset - s->view->start; 
    1308     int l = (1 - (s->view->end - s->view->start)) / s->width; 
    1309  
    1310     /* you get these tests by setting the complete formula below 
    1311      * equal to 0 or s->width, respectively, and then resolving 
    1312      * towards d. 
    1313      */ 
    1314     if(d < l) 
    1315       return 0; 
    1316     if(d > (s->view->end - s->view->start) + l) 
    1317       return s->width; 
    1318  
    1319     return (d * s->width + (s->view->end - s->view->start) - 1) / (s->view->end - s->view->start); 
    1320   } 
    1321 } 
    1322 #endif /* _{start,end}offset_to_xpos */ 
    13231203 
    13241204static gint 
     
    14811361 
    14821362  if(x >= x_min && x <= x_max) { 
    1483 #if 0 
    1484     gdk_draw_rectangle(win, gc, TRUE, 
    1485                        x-1, 0,  
    1486                        3, s->height); 
    1487 #endif 
    1488  
    14891363    gdk_draw_line(win, s->zeroline_gc, 
    14901364                  x-2, 0,  
    14911365                  x-2, s->height); 
    1492 #if 1 
     1366 
    14931367    gdk_draw_line(win, gc, 
    14941368                  x-1, 0,  
     
    14971371                  x+1, 0,  
    14981372                  x+1, s->height); 
    1499 #endif 
    15001373 
    15011374    gdk_draw_line(win, s->zeroline_gc, 
     
    15411414                                        TRUE, GTK_STATE_NORMAL, 
    15421415                                        NULL, 0, 0, s->width, s->height); 
    1543 #if 0 
    1544                                         area->x, area->y, 
    1545                                         area->width, area->height); 
    1546 #endif 
    15471416  } else { 
    15481417    const int x_min = area->x; 
     
    15701439                                       x_min, x_max); 
    15711440    } else { 
    1572 #if 1 
    15731441      /* Draw play offset */ 
    15741442      sample_display_draw_play_offset (drawable, s->play_gc, 
    15751443                                       s, s->play_offset_x, 
    15761444                                       x_min, x_max); 
    1577 #endif 
    15781445      /* Draw user offset */ 
    15791446      sample_display_draw_user_offset (drawable, s->user_gc, 
     
    15891456                                      x_min, x_max); 
    15901457    } 
    1591  
    1592 #if 0 
    1593     /* Draw focus indicator */ 
    1594     if (GTK_WIDGET_HAS_FOCUS(widget)) { 
    1595       /* ??? */ 
    1596     } 
    1597 #endif 
    15981458 
    15991459#ifdef DOUBLE_BUFFER 
     
    19021762  sampledata[offset*channels + channel] = value; 
    19031763 
    1904 #if 0 
    1905   if (sample->sounddata->format->channels == 1) { 
    1906     value = YPOS_TO_VALUE_1(y); 
    1907     sampledata[offset] = value; 
    1908   } else { 
    1909     channel = YPOS_TO_CHANNEL(y); 
    1910     value = YPOS_TO_VALUE_2(y); 
    1911     sampledata[offset*2 + channel] = value; 
    1912   } 
    1913 #endif 
    1914  
    19151764  sample_refresh_views (sample); 
    19161765} 
     
    22152064        if (sample_display_on_sel (s, x, y)) { 
    22162065          sample_display_handle_sel_button_press (s, x, y, state); 
    2217 #if 0 
    2218         } else if (sample_display_on_playmarker (s, x, y)) { 
    2219           /* If the cursor is near the play marker, move that */ 
    2220           s->selecting = SELECTING_PLAYMARKER; 
    2221           SET_CURSOR(widget, NEEDLE); 
    2222 #ifndef SEL_SCRUBS 
    2223           sample_set_scrubbing (sample, TRUE); 
    2224           sample_display_handle_playmarker_motion (s, x, y); 
    2225 #endif 
    2226 #endif 
    22272066        } else { 
    22282067          sample_display_handle_sel_button_press (s, x, y, state); 
     
    25032342        gdk_window_set_cursor (widget->window, NULL); 
    25042343    } 
    2505  
    2506 #if 0 
    2507     /* Consistency check: without this, some button release events 
    2508      * are lost if they occur during motion. Here, we ensure that 
    2509      * if this sample_display s is not selecting yet has a selection 
    2510      */ 
    2511     if(s->selection_mode && s->view->sample->tmp_sel) { 
    2512       sample_display_sink_tmp_sel (s); 
    2513     } 
    2514 #endif 
    25152344  } 
    25162345     
  • sweep/trunk/src/sweep_sample.c

    r557 r688  
    162162 
    163163  s->play_mutex = g_mutex_new (); 
    164 #if 0 
    165   s->play_mode = SWEEP_TRANSPORT_STOP; 
    166   s->stop_offset = 0; 
    167   s->play_offset = 0; 
    168   s->play_looping = FALSE; 
    169   s->play_scrubbing = FALSE; 
    170   s->previewing = FALSE; 
    171   s->play_reverse = FALSE; 
    172   s->play_mute = FALSE; 
    173 #endif 
    174164  s->user_offset = 0; 
    175165  s->by_user = 0; 
     
    179169  s->rate = 1.0; 
    180170 
    181 #if 0 
    182   s->color = ((int)random()) % VIEW_COLOR_MAX; 
    183 #else 
    184171  s->color = filename_color_hash ((gchar *)g_basename (s->pathname)); 
    185 #endif 
    186172 
    187173  s->info_clist = NULL; 
     
    10681054  head_set_scrubbing (head, scrubbing); 
    10691055 
    1070 #if 0 
    1071   g_mutex_lock (s->play_mutex); 
    1072  
    1073   s->play_scrubbing = scrubbing; 
    1074  
    1075   g_mutex_unlock (s->play_mutex); 
    1076 #endif 
    1077  
    10781056  sample_set_progress_ready (s); 
    10791057} 
     
    10881066  head_set_looping (head, looping); 
    10891067   
    1090 #if 0 
    1091   g_mutex_lock (s->play_mutex); 
    1092  
    1093   s->play_looping = looping; 
    1094 #endif 
    1095  
    10961068  for(gl = s->views; gl; gl = gl->next) { 
    10971069    v = (sw_view *)gl->data; 
    10981070    view_refresh_looping (v); 
    10991071  } 
    1100  
    1101 #if 0 
    1102   g_mutex_unlock (s->play_mutex); 
    1103 #endif 
    11041072} 
    11051073 
     
    11121080 
    11131081  head_set_reverse (head, reverse); 
    1114  
    1115 #if 0 
    1116   g_mutex_lock (s->play_mutex); 
    1117  
    1118   s->play_reverse = reverse; 
    1119 #endif 
    11201082 
    11211083  for(gl = s->views; gl; gl = gl->next) { 
     
    11231085    view_refresh_playrev (v); 
    11241086  } 
    1125  
    1126 #if 0 
    1127   g_mutex_unlock (s->play_mutex); 
    1128 #endif 
    11291087} 
    11301088 
     
    11371095 
    11381096  head_set_mute (head, mute); 
    1139  
    1140 #if 0 
    1141   g_mutex_lock (s->play_mutex); 
    1142  
    1143   s->play_mute = mute; 
    1144 #endif 
    11451097 
    11461098  for(gl = s->views; gl; gl = gl->next) { 
     
    11481100    view_refresh_mute (v); 
    11491101  } 
    1150  
    1151 #if 0 
    1152   g_mutex_unlock (s->play_mutex); 
    1153 #endif 
    11541102} 
    11551103 
     
    11731121{ 
    11741122  head_set_previewing (s->play_head, previewing); 
    1175 #if 0 
    1176   g_mutex_lock (s->play_mutex); 
    1177  
    1178   s->previewing = previewing; 
    1179  
    1180   g_mutex_unlock (s->play_mutex); 
    1181 #endif 
    11821123} 
    11831124 
     
    14201361  g_mutex_lock (sounddata->sels_mutex); 
    14211362 
    1422 #if 0 
    1423   sounddata->sels = sels_invert (sounddata->sels, sounddata->nr_frames); 
    1424  
    1425 #else 
    1426  
    14271363  if (!sounddata->sels) { 
    14281364    sounddata_set_selection_1 (sounddata, 0, sounddata->nr_frames); 
     
    14531389 
    14541390out: 
    1455 #endif 
    14561391 
    14571392  g_mutex_unlock (sounddata->sels_mutex); 
  • sweep/trunk/src/sweep_selection.c

    r460 r688  
    246246    register_operation (sample, inst); 
    247247  } 
    248  
    249 #if 0 
    250   sample_set_edit_state (sample, SWEEP_EDIT_STATE_DONE); 
    251 #endif 
    252248} 
    253249 
  • sweep/trunk/src/sweep_sounddata.c

    r682 r688  
    2626#include <string.h> 
    2727#include <glib.h> 
    28  
    29 #if 0 
    30 #include <unistd.h> 
    31 #include <sys/mman.h> 
    32 #endif 
    3328 
    3429#include <sweep/sweep_types.h> 
     
    6257    len = frames_to_bytes (s->format, sample_length); 
    6358 
    64 #if 1 
    6559    s->data = g_malloc0 ((size_t)len); 
    66 #else 
    67     s->data = sweep_large_alloc_zero (len, PROT_READ|PROT_WRITE); 
    68 #endif 
    69  
    7060 
    7161    if (!(s->data)) { 
    72 #if 0 
    73 #if (SIZEOF_OFF_T == 8) 
    74       fprintf(stderr, "Unable to allocate %lld bytes for sample data.\n", len); 
    75 #else 
    7662      fprintf(stderr, "Unable to allocate %d bytes for sample data.\n", len); 
    77 #endif 
    78 #else 
    79       fprintf(stderr, "Unable to allocate %d bytes for sample data.\n", len); 
    80 #endif 
    8163      g_free(s); 
    8264      return NULL; 
     
    121103 
    122104  if (sounddata->refcount <= 0) { 
    123 #if 1 
    124105    g_free (sounddata->data); 
    125 #else 
    126     len = frames_to_bytes (sounddata->format, sounddata->nr_frames); 
    127     munmap (sounddata->data, len); 
    128 #endif 
    129106    g_mutex_free(sounddata->data_mutex); 
    130107    sounddata_clear_selection (sounddata); 
  • sweep/trunk/src/sweep_undo.c

    r557 r688  
    106106      inst->op->_do_ ((sw_sample *)inst, (void *)inst); 
    107107 
    108 #if 0 /* XXX: need to tell main thread to start playback; freezes from here */ 
    109       if (inst->op->edit_mode == SWEEP_EDIT_MODE_ALLOC && was_going) { 
    110 #if 0 
    111         g_mutex_lock (sample->play_mutex); 
    112         head_set_going (sample->play_head, TRUE); 
    113         g_mutex_unlock (sample->play_mutex); 
    114 #else 
    115         sample_play (sample); 
    116 #endif 
    117       } 
    118 #endif  
    119108      g_mutex_lock (sample->edit_mutex); 
    120109       
     
    696685/* Standard undo/redo functions */ 
    697686 
    698 #if 0 
    699 replace_data * 
    700 replace_data_new (sw_sample * old_sample, sw_sample * new_sample) 
    701 { 
    702   replace_data * r; 
    703  
    704   r = g_malloc (sizeof(replace_data)); 
    705  
    706   r->old_sample = old_sample; 
    707   r->new_sample = new_sample; 
    708  
    709   return r; 
    710 }; 
    711  
    712 void 
    713 undo_by_replace (replace_data * r) 
    714 { 
    715   sample_replace_throughout (r->new_sample, r->old_sample); 
    716  
    717   sample_refresh_views (r->new_sample); 
    718 } 
    719  
    720 void 
    721 redo_by_replace (replace_data * r) 
    722 { 
    723   sample_replace_throughout (r->old_sample, r->new_sample); 
    724  
    725   sample_refresh_views (r->new_sample); 
    726 } 
    727 #endif 
    728  
    729687sounddata_replace_data * 
    730688sounddata_replace_data_new (sw_sample * sample, 
  • sweep/trunk/src/time_ruler.c

    r359 r688  
    296296          if (i == 0) 
    297297            { 
    298 #if 1 
    299298              snprint_time (unit_str, UNIT_STR_LEN, (sw_time_t)cur); 
    300 #else 
    301               snprint_time_smpte (unit_str, UNIT_STR_LEN, (sw_time_t)cur, 10.0); 
    302 #endif 
    303299                  pango_layout_set_text (layout, unit_str, -1); 
    304300                  pango_layout_get_extents (layout, NULL, &logical_rect); 
  • sweep/trunk/src/undo_dialog.c

    r557 r688  
    5757  undo_dialog = NULL; 
    5858} 
    59  
    60 #if 0 
    61 static void 
    62 undo_dialog_ok_cb (GtkWidget * widget, gpointer data) 
    63 { 
    64   GtkWidget * dialog; 
    65  
    66   dialog = gtk_widget_get_toplevel (widget); 
    67   gtk_widget_hide (dialog); 
    68 } 
    69 #endif 
    7059 
    7160static void 
     
    247236 
    248237  for (gl = g_list_last (ud_sample->registered_ops); gl; gl = gl->prev) { 
    249 #if 0 
    250     inst = (sw_op_instance *)gl->data; 
    251  
    252     if (gl == ud_sample->current_undo) { 
    253       need_undo = TRUE; 
    254     } 
    255 #endif 
    256  
    257238    if (i == s) { 
    258239      sel_gl = gl; 
     
    264245 
    265246  g_mutex_unlock (ud_sample->ops_mutex); 
    266  
    267 #if 0 
    268   if (need_undo) { 
    269     while (ud_sample->current_undo != sel_gl) 
    270       undo_current (ud_sample); 
    271   } else { 
    272     while (ud_sample->current_undo != sel_gl) 
    273       redo_current (ud_sample); 
    274   } 
    275 #endif 
    276247 
    277248  revert_op (ud_sample, sel_gl); 
     
    434405    revert_button = button; 
    435406 
    436 #if 0 
    437  
    438     /* OK */ 
    439  
    440     ok_button = gtk_button_new_with_label (_("OK")); 
    441     GTK_WIDGET_SET_FLAGS (GTK_WIDGET (ok_button), GTK_CAN_DEFAULT); 
    442     gtk_box_pack_start (GTK_BOX (GTK_DIALOG(undo_dialog)->action_area), 
    443                         ok_button, TRUE, TRUE, 0); 
    444     gtk_widget_show (ok_button); 
    445     g_signal_connect (G_OBJECT(ok_button), "clicked", 
    446                         G_CALLBACK (undo_dialog_ok_cb), 
    447                         NULL); 
    448 #endif 
    449  
    450407    /* Cancel */ 
    451408 
     
    460417 
    461418    gtk_widget_grab_default (button); 
    462  
    463 #if 0 
    464     gtk_widget_grab_default (ok_button); 
    465 #endif 
    466  
    467  
    468419  } 
    469420 
  • sweep/trunk/src/view.c

    r557 r688  
    7878 */ 
    7979#define VIEW_MIN_WIDTH 197 
    80 #if 0 
    81 #define VIEW_MAX_WIDTH 517 
    82 #define VIEW_DEFAULT_HEIGHT 320 
    83 #else 
    8480#define VIEW_MAX_WIDTH 1034 
    8581#define VIEW_DEFAULT_HEIGHT_PER_CHANNEL 320 
    86 #endif 
    8782 
    8883#define DEFAULT_MIN_ZOOM 8 
     
    208203  submenu = menu; 
    209204 
    210 #if 0 
    211   first_name[4] = '\0'; 
    212   last_name[4] = '\0'; 
    213 #endif 
    214  
    215205  if (plugins) 
    216206    /*strncpy (first_name, ((sw_procedure *)plugins->data)->name, 4);*/ 
     
    292282  for (gl = view->channelops_widgets; gl; gl = gl->next) { 
    293283    view->nomodify_widgets = g_list_remove (view->nomodify_widgets, gl->data); 
    294 #if 0 
    295     view->noready_widgets = g_list_remove (view->noready_widgets, gl->data); 
    296     view->noalloc_widgets = g_list_remove (view->noalloc_widgets, gl->data); 
    297 #endif 
    298284  } 
    299285  g_list_free (view->channelops_widgets); 
     
    438424  accel_group = gtk_accel_group_new(); 
    439425  g_object_set_data(G_OBJECT(view->window), "accel_group", accel_group); 
    440 #if 0 
    441   if (GTK_IS_MENU(m)) 
    442     gtk_window_add_accel_group (GTK_WINDOW(view->window), accel_group); 
    443 #endif 
    444426 
    445427  /* File */ 
     
    703685 
    704686 
    705 #if 0 
    706   create_view_menu_item (submenu, _("Left"), "<Sweep-View>/View/Left", view, 
    707                                                   zoom_left_cb, FALSE, 
    708                                                                                                   GDK_Left, GDK_BUTTON1_MASK, s);  
    709  
    710   create_view_menu_item (submenu, _("Right"), "<Sweep-View>/View/Right", view, 
    711                                                   zoom_right_cb, FALSE, 
    712                                                                                                   GDK_Right, GDK_BUTTON1_MASK, s);  
    713 #endif 
    714  
    715687  create_view_menu_item (submenu, _("Zoom normal"), "<Sweep-View>/View/Zoom normal", view, 
    716688                                                  zoom_norm_cb, FALSE, 
     
    12401212  gtk_widget_show(menuitem); 
    12411213 
    1242 #if 0 
    1243   menuitem = gtk_menu_item_new(); /* Separator */ 
    1244   gtk_menu_append(GTK_MENU(menu), menuitem); 
    1245   gtk_widget_show(menuitem); 
    1246  
    1247   /* Properties */ 
    1248  
    1249   menuitem = gtk_menu_item_new_with_label(_("File properties ...")); 
    1250   gtk_menu_append(GTK_MENU(menu), menuitem); 
    1251   g_signal_connect (G_OBJECT(menuitem), "activate", 
    1252                      G_CALLBACK(show_info_dialog_cb), view); 
    1253   gtk_widget_show(menuitem); 
    1254 #endif 
    1255  
    12561214  return menu; 
    12571215} 
     
    13251283                     G_CALLBACK(view_new_cb), s); 
    13261284  gtk_widget_show(menuitem); 
    1327  
    1328 #if 0 
    1329   menuitem = gtk_menu_item_new(); /* Separator */ 
    1330   gtk_menu_append(GTK_MENU(menu), menuitem); 
    1331   gtk_widget_show(menuitem); 
    1332  
    1333   /* Properties */ 
    1334  
    1335   menuitem = gtk_menu_item_new_with_label(_("File properties ...")); 
    1336   gtk_menu_append(GTK_MENU(menu), menuitem); 
    1337   g_signal_connect (G_OBJECT(menuitem), "activate", 
    1338                      G_CALLBACK(show_info_dialog_cb), view); 
    1339   gtk_widget_show(menuitem); 
    1340 #endif 
    13411285 
    13421286  return menu; 
     
    14961440#define VIEW_TOOLBAR_TOGGLE_BUTTON SW_TOOLBAR_TOGGLE_BUTTON 
    14971441#define VIEW_TOOLBAR_RADIO_BUTTON SW_TOOLBAR_RADIO_BUTTON 
    1498  
    1499 #if 0 
    1500 typedef enum { 
    1501   VIEW_TOOLBAR_BUTTON, 
    1502   VIEW_TOOLBAR_TOGGLE_BUTTON, 
    1503   VIEW_TOOLBAR_RADIO_BUTTON, 
    1504 } view_toolbar_button_type; 
    1505  
    1506 static GtkWidget * 
    1507 create_pixmap_button (GtkWidget * widget, gchar ** xpm_data, 
    1508                       const gchar * tip_text, const gchar * custom_name, 
    1509                       view_toolbar_button_type button_type, 
    1510                       GCallback clicked, 
    1511                       GCallback pressed, GCallback released, 
    1512                       gpointer data) 
    1513 { 
    1514   GtkWidget * pixmap; 
    1515   GtkWidget * button; 
    1516   GtkTooltips * tooltips; 
    1517  
    1518   switch (button_type) { 
    1519   case VIEW_TOOLBAR_TOGGLE_BUTTON: 
    1520     button = gtk_toggle_button_new (); 
    1521     break; 
    1522   case VIEW_TOOLBAR_RADIO_BUTTON: 
    1523     button = gtk_radio_button_new (NULL); 
    1524     break; 
    1525   case VIEW_TOOLBAR_BUTTON: 
    1526   default: 
    1527     button = gtk_button_new (); 
    1528     break; 
    1529   } 
    1530  
    1531   if (xpm_data != NULL) { 
    1532     pixmap = create_widget_from_xpm (widget, xpm_data); 
    1533     gtk_widget_show (pixmap); 
    1534     gtk_container_add (GTK_CONTAINER (button), pixmap); 
    1535   } 
    1536  
    1537   if (tip_text != NULL) { 
    1538     tooltips = gtk_tooltips_new (); 
    1539     gtk_tooltips_set_tip (tooltips, button, tip_text, NULL); 
    1540   } 
    1541  
    1542   if (style != NULL) { 
    1543     gtk_widget_set_style (button, style); 
    1544   } 
    1545  
    1546   if (clicked != NULL) { 
    1547     g_signal_connect (G_OBJECT (button), "clicked", 
    1548                         G_CALLBACK(clicked), data); 
    1549   } 
    1550  
    1551   if (pressed != NULL) { 
    1552     g_signal_connect (G_OBJECT(button), "pressed", 
    1553                         G_CALLBACK(pressed), data); 
    1554   } 
    1555  
    1556   if (released != NULL) { 
    1557     g_signal_connect (G_OBJECT(button), "released", 
    1558                         G_CALLBACK(released), data); 
    1559   } 
    1560  
    1561   return button; 
    1562 } 
    1563 #endif 
    15641442 
    15651443static void 
     
    16531531  GtkWidget * frame; 
    16541532  GtkWidget * label; 
    1655 #if 0 
    1656   GtkWidget * entry; 
    1657 #endif 
    1658  
    1659 #if 0 
    1660   GtkWidget * toolbar; 
    1661 #endif 
    16621533 
    16631534#ifdef DEVEL_CODE 
     
    16981569  view->channelops_widgets = NULL; 
    16991570 
    1700 #if 0 
    1701   win_width = CLAMP (sample->sounddata->nr_frames / 150, 
    1702                      VIEW_MIN_WIDTH, VIEW_MAX_WIDTH); 
    1703   win_height = 
    1704     VIEW_DEFAULT_HEIGHT_PER_CHANNEL * 
    1705     MIN (2, sample->sounddata->format->channels); 
    1706 #else 
    17071571  screen_width = gdk_screen_width (); 
    17081572  screen_height = gdk_screen_height (); 
     
    17161580 
    17171581  win_height *= MIN (2, sample->sounddata->format->channels); 
    1718 #endif 
    17191582 
    17201583  window = gtk_window_new(GTK_WINDOW_TOPLEVEL); 
     
    19821845 
    19831846  gtk_widget_set_style (tool_hbox, style_dark_grey); 
    1984  
    1985 #if 0 
    1986   /* Zoom all */ 
    1987   button = create_pixmap_button (window, zoom_all_xpm, _("Zoom all"), 
    1988                                  NULL, VIEW_TOOLBAR_BUTTON, G_CALLBACK (zoom_all_cb), 
    1989                                  NULL, NULL, view); 
    1990   gtk_button_set_relief (GTK_BUTTON(button), GTK_RELIEF_NONE); 
    1991   gtk_box_pack_start (GTK_BOX (tool_hbox), button, FALSE, TRUE, 0); 
    1992   gtk_widget_show (button); 
    1993 #endif 
    19941847 
    19951848  /* Zoom in */ 
     
    22092062  gtk_widget_show (label); 
    22102063 
    2211 #if 0 
    2212   rate_adj = gtk_adjustment_new (50.0,   /* value */ 
    2213                                  0.0,    /* lower */ 
    2214                                  100.0,  /* upper */ 
    2215                                  0.001,  /* step incr */ 
    2216                                  0.001,  /* page incr */ 
    2217                                  0.001   /* page size */ 
    2218                                  ); 
    2219 #else 
    22202064  rate_adj = gtk_adjustment_new (0.0,    /* value */ 
    22212065                                 -100.0, /* lower */ 
     
    22252069                                 0.0     /* page size */ 
    22262070                                 ); 
    2227 #endif 
    22282071 
    22292072  /*  view->rate = 1.0;*/ 
     
    25972440 
    25982441  hbox = gtk_hbox_new (FALSE, 0); 
    2599 #if 0 
    2600   gtk_table_attach (GTK_TABLE(table), hbox, 
    2601                    0, 3, 3, 4, 
    2602                    GTK_FILL|GTK_SHRINK, GTK_FILL, 
    2603                    0, 0); 
    2604 #endif 
     2442 
    26052443  gtk_box_pack_start (GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0); 
    26062444  gtk_widget_show (hbox); 
     
    27052543                      view->display); 
    27062544                       
    2707 #if 0 
    2708   g_signal_connect_swapped (G_OBJECT(view->display), 
    2709                              "motion_notify_event", 
    2710                              G_CALLBACK(view_set_pos_indicator_cb), 
    2711                              G_OBJECT(view->display)); 
    2712 #endif 
    2713  
    27142545  if (sample->sounddata->sels) 
    27152546    sample_display_start_marching_ants (SAMPLE_DISPLAY(view->display)); 
     
    33473178            view->sample->play_head->scrubbing ? _("Scrub!") : _("Ready")); 
    33483179 
    3349 #if 0 
    3350   if (view->sample->play_head->scrubbing) { 
    3351     snprintf (buf, BUF_LEN, "Sweep %s - %s", VERSION, _("Scrub!")); 
    3352   } else { 
    3353     snprintf (buf, BUF_LEN, "Sweep %s - %s", VERSION, _("Ready")); 
    3354   } 
    3355 #endif 
    3356  
    33573180  gtk_progress_set_format_string (GTK_PROGRESS(view->progress), buf); 
    33583181  gtk_progress_set_percentage (GTK_PROGRESS(view->progress), 0.0); 
     
    34403263  if (s->sounddata->nr_frames > 0) { 
    34413264    snprintf(buf, BUF_LEN, 
    3442 #if 0 
    3443              "%s (%dHz %s) %0d%% - Sweep " VERSION, 
    3444              s->filename ? s->filename : _("Untitled"), 
    3445              s->sounddata->format->rate, 
    3446              s->sounddata->format->channels == 1 ? _("Mono") : _("Stereo"), 
    3447 #else 
    34483265             "%s%s %0d%% - Sweep " VERSION, 
    34493266             s->modified ? _("*") : "", 
    34503267             s->pathname ? g_basename (s->pathname) : _("Untitled"), 
    3451 #endif 
     3268 
    34523269             s->progress_percent); 
    34533270  } else { 
    34543271    snprintf(buf, BUF_LEN, 
    3455 #if 0 
    3456              "%s (%dHz %s) %s - Sweep " VERSION, 
    3457              s->filename ? s->filename : _("Untitled"), 
    3458              s->sounddata->format->rate, 
    3459              s->sounddata->format->channels == 1 ? _("Mono") : _("Stereo"), 
    3460 #else 
    34613272             "%s%s %s - Sweep " VERSION, 
    34623273             s->modified ? _("*") : "", 
    34633274             s->pathname ? g_basename (s->pathname) : _("Untitled"), 
    3464 #endif 
    34653275             _("Empty")); 
    34663276  } 
     
    35733383  } 
    35743384 
    3575 #if 0 
    3576   if (adj->page_size > adj->upper - adj->value) 
    3577     adj->page_size = adj->upper - adj->value; 
    3578 #endif 
    3579  
    3580 #if 0 
    3581   if (v->end > v->sample->sounddata->nr_frames) 
    3582     v->end = v->sample->sounddata->nr_frames; 
    3583 #endif  
    35843385 
    35853386  if (adj->page_increment == 0) {