~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Linux Cross Reference
Tina5/tina-tools/tinatool/tlbase/tlbaseSeq_tool.c

Version: ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /**********
  2  * 
  3  * Copyright (c) 2003, Division of Imaging Science and Biomedical Engineering,
  4  * University of Manchester, UK.  All rights reserved.
  5  * 
  6  * Redistribution and use in source and binary forms, with or without modification,
  7  * are permitted provided that the following conditions are met:
  8  *
  9  *   . Redistributions of source code must retain the above copyright notice, 
 10  *     this list of conditions and the following disclaimer.
 11  *    
 12  *   . Redistributions in binary form must reproduce the above copyright notice,
 13  *     this list of conditions and the following disclaimer in the documentation 
 14  *     and/or other materials provided with the distribution.
 15  * 
 16  *   . Neither the name of the University of Manchester nor the names of its
 17  *     contributors may be used to endorse or promote products derived from this 
 18  *     software without specific prior written permission.
 19  * 
 20  * 
 21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
 25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 31  * POSSIBILITY OF SUCH DAMAGE.
 32  *
 33  **********
 34  * 
 35  * Program :    TINA
 36  * File    :  $Source: /home/tina/cvs/tina-tools/tinatool/tlbase/tlbaseSeq_tool.c,v $
 37  * Date    :  $Date: 2009/05/15 15:51:20 $
 38  * Version :  $Revision: 1.15 $
 39  * CVS Id  :  $Id: tlbaseSeq_tool.c,v 1.15 2009/05/15 15:51:20 paul Exp $
 40  *
 41  * Notes : Sequence Tool. What more is there to say?
 42  *         The purpose of this new incarnation of the sequence tool is
 43  *         twofold:
 44  *         1) To be able to do all the sequence tool stuff which could be
 45  *            be done before
 46  *         2) To have a proper sequence structure, so we can have multiple 
 47  *            instantiations of a sequence like you can have for imrects etc
 48  *********
 49 */
 50 
 51 #include "tlbaseSeq_tool.h"
 52 
 53 #if HAVE_CONFIG_H
 54 #   include <config.h>
 55 #endif
 56 
 57 #include <stdio.h>
 58 #include <string.h>
 59 #include <sys/param.h>
 60 #include <tina/sys/sysDef.h>
 61 #include <tina/sys/sysPro.h>
 62 #include <tina/file/filePro.h>
 63 #include <tina/image/imgDef.h>
 64 #include <tina/image/imgPro.h>
 65 #include <tina/geometry/geomDef.h>
 66 #include <tina/geometry/geomPro.h>
 67 #include <tinatool/wdgts/wdgtsPro.h>
 68 #include <tinatool/tlbase/tlbasePro.h>
 69 #include <tina/file/fileThirdParty_air.h>
 70 #include <tinatool/draw/drawDef.h>
 71 #include <tinatool/draw/drawPro.h>
 72 #include <tinatool/tlbase/tlbase_SeqPro.h>
 73 #include <tinatool/tlbase/tlbase_SeqDef.h>
 74 #include <tinatool/tlbase/tlbaseSeq_disp.h>
 75 #include <tinatool/tlbase/tlbaseSeq_view.h>
 76 #include <tinatool/tlmedical/tlmedPro.h>
 77 
 78 static int offset = 0;
 79 static int stride = 1;
 80 static int frame = 0;
 81 static char filename[MAXPATHLEN]; /* well.. i disapprove */
 82 /* Note that a fixed array filename is required (const char -ie a string)
 83    as opposed to a dynamically allocated char *, as the twc callback stuff
 84    requires it.
 85    This is not a fixed requirement, we could reprogramme it :) */
 86 /*static char *filename;*/
 87 static int end = 0;
 88 static int file_type = SEQTL_AIFF_FILE;
 89 static double xscale = 1.0, yscale = 1.0, zscale = 1.0, tscale = 1.0;
 90 
 91 static void *poffset = NULL, *pstride=NULL, *pfilename=NULL, *pend=NULL;
 92 static void *pxs=NULL, *pys=NULL, *pzs=NULL, *ptmp=NULL;
 93 static void *pcurfr=NULL, *seq_image_choice=NULL;
 94 static List *seq_init_funcs_list=NULL;
 95 
 96 /*mjs 25/11/05 added scale factor flag variables and functions so user can choose which scale 
 97  factors to use when loading DICOM data*/
 98 static int seq_scale_factor_flag = 0;
 99 
100 int get_seq_scale_factor_flag()
101 {
102   return(seq_scale_factor_flag);
103 }
104 
105 static void set_seq_scale_factor_flag(int flag)
106 {
107   seq_scale_factor_flag = flag;
108   return;
109 }
110 
111 
112 /* seq-init-funcs-list is a list of pointers to functions. These functions */
113 /* are invoked whenever seq-load is called, allowing tools higher in the   */
114 /* libraries (esp. the coreg tool) to update themselves whenever the       */
115 /* sequence changes, without having direct calls to them at this level of  */
116 /* the libraries. Calling seq_init_funcs_add will add a new function to    */
117 /* the list: the functions are actually invoked by seq_init_funcs_run. At  */
118 /* the moment, the functions have to have void arguments and return types. */
119 /*                                                                         */
120 /* paul.bromiley@manchester.ac.uk 29/11/2004                               */
121 
122 void seq_init_funcs_add(void (*function_to_add)())
123 {
124         List *el=NULL;
125 
126         /* warning: argument #1 is incompatible with prototype:
127         prototype: pointer to void : "/home/fx/tina-libs/tina/sys/sysLst_list.h", line 100
128         argument : pointer to function() returning void */
129         el = link_alloc(function_to_add, 5367);
130         seq_init_funcs_list = list_addtoend(seq_init_funcs_list, el);
131 }
132 
133 void seq_init_funcs_run(void)
134 {
135         void (*function_to_run)(void)=NULL;
136         List *plist=NULL;
137 
138         for(plist = seq_init_funcs_list; plist!=NULL; plist=plist->next)
139         {
140           /* warning: assignment type mismatch:
141         pointer to function(void) returning void "=" pointer to void */
142                 function_to_run = plist->to;
143                 function_to_run();
144         }
145 }
146 
147 
148 static int seq_file_type_find(void)
149 {
150         Sequence *seq = seq_get_current();
151         List *lptr = get_seq_current_el(seq);
152         Imrect *im=NULL;
153         int vtype, seq_im_type;
154 
155         if(lptr!=NULL)
156         {
157                 im = (Imrect *)lptr->to;
158                 if(im!=NULL)
159                 {
160                         vtype = im->vtype;
161                         if (vtype==uchar_v) seq_im_type = 1;
162                         if (vtype==char_v) seq_im_type = 1;
163                         if (vtype==short_v) seq_im_type = 2;
164                         if (vtype==ushort_v) seq_im_type = 2;
165                         if (vtype==int_v) seq_im_type = 2;
166                         if (vtype==uint_v) seq_im_type = 2;
167                         if (vtype==float_v) seq_im_type = 3;
168                 }
169         }
170         else seq_im_type = 0;
171         return seq_im_type;
172 }
173 
174 
175 static void seq_file_type_reset(void)
176 {
177         int val=seq_file_type_find();
178 
179         switch (val)
180         {
181                 case 1:
182                         tw_choice_reset(seq_image_choice, 1);
183                         break;
184                 case 2:
185                         tw_choice_reset(seq_image_choice, 2);
186                         break;
187                 case 3:
188                         tw_choice_reset(seq_image_choice, 3);
189                         break;
190                 default:
191                         tw_choice_reset(seq_image_choice, 0);
192         }
193 }
194 
195 
196 int    get_seq_filechoice(void)
197 {
198   return(file_type);
199 }
200 
201 
202 void seq_file_choice_proc(int val)
203 {
204     file_type = val;
205 }
206 
207 /* forces Sequence dimensions to be as on interface. For use when
208    loading in sequences of aiff images etc, where no dimensions are specified. */
209 
210 
211 static void seq_update_proc(void)
212 {
213   Sequence *seq = NULL;
214   int filename_length;
215 
216   if ((seq = seq_get_current()) == NULL)
217     return;
218 
219   seq->dim[0] = xscale;
220   seq->dim[1] = yscale;
221   seq->dim[2] = zscale;
222   seq->dim[3] = tscale;
223 
224   filename_length = strlen(filename);
225   seq->filename = cvector_copy(filename, 0, filename_length);
226 
227   seq->stride = stride; /* not sure you'd ever want to do this */
228   seq->offset = offset;
229 
230   return;
231 }
232 
233 /* seq_param_update updates the interface with the values in the
234    Sequence structure */
235 
236 
237 void seq_param_update(Sequence *seq)
238 {
239 
240   if (seq == NULL)
241     return;
242 
243   offset = seq->offset;
244   stride = seq->stride;
245   xscale = seq->dim[0];
246   yscale = seq->dim[1];
247   zscale = seq->dim[2];
248   tscale = seq->dim[3];
249 
250   end = get_end_frame(seq);
251 
252   (void) tw_sglobal_reset(pfilename);
253   (void) tw_iglobal_reset(poffset);
254   (void) tw_iglobal_reset(pstride);
255   (void) tw_fglobal_reset(pxs);
256   (void) tw_fglobal_reset(pys);
257   (void) tw_fglobal_reset(pzs);
258   (void) tw_fglobal_reset(ptmp);
259 
260   (void) tw_iglobal_reset(pcurfr);
261   (void) tw_iglobal_reset(pend);
262   seq_file_type_reset();
263 }
264 
265 
266 static void inter_update_proc(void)
267 {
268   Sequence *seq = NULL;
269 
270   if ((seq = (Sequence *)seq_get_current()) == NULL)
271     return;
272 
273   seq_param_update(seq);
274 
275 }
276 
277 /* Number of last image in sequence only available from interface,
278    have functions to get and set the end number*/
279 
280 
281 int get_seq_end(void)
282 {
283   return(end);
284 }
285 
286 void set_seq_end(int new_end)
287 {
288   end = new_end;
289   if (pend != NULL)
290     tw_iglobal_reset(pend);
291 
292 }
293 
294 
295 static void seq_cast_proc(Sequence *seq, Vartype vtype, int bin_flag)
296 {
297         List *nptr=NULL, *mptr=NULL;
298         Imrect *im=NULL, *im2=NULL, *im3=NULL;
299 
300         if(seq==NULL) return;
301         nptr=get_seq_start_el(seq);
302 
303         for(mptr=nptr; mptr!=NULL; mptr=mptr->next)
304         {
305                 im = (Imrect *)mptr->to;
306                 if(bin_flag==1)
307                 {
308                         im3 = im_bthresh(0.5, im);
309                         im_free(im);
310                         im=im3;
311                 }
312                 im2 = (Imrect *)im_cast(im, vtype);
313                 mptr->to = im2;
314                 im_free(im);
315         }
316 }
317 
318 
319 void seq_type_choice_proc(int val)
320 {
321         /* Allows casting of whole image sequences, like the image casting choice
322         buttons in imcalc. There may be complications here if you produce sequences
323         containing images of different variable types PAB 25/12/2004*/
324 
325     Sequence *seq=seq_get_current();
326 
327     switch (val)
328     {
329     case 0:
330         seq_cast_proc(seq, uchar_v, 1);
331         tw_choice_reset(seq_image_choice, 0);
332         break;
333     case 1:
334         seq_cast_proc(seq, uchar_v, 0);
335         tw_choice_reset(seq_image_choice, 1);
336         break;
337     case 2:
338         seq_cast_proc(seq, short_v, 0);
339         tw_choice_reset(seq_image_choice, 2);
340         break;
341     case 3:
342         seq_cast_proc(seq, float_v, 0);
343         tw_choice_reset(seq_image_choice, 3);
344         break;
345     default:
346         tw_choice_reset(seq_image_choice, 0);
347         break;
348     }
349     tv_init(seq_tv_get());
350     seq_show_current(seq);
351     seq_init_funcs_run();
352 }
353 
354 
355 /* button call to save sequence. */
356 
357 
358 static void seq_save_proc(void)
359 {
360   Sequence * seq = seq_get_current();
361 
362   if (seq == NULL)
363     {
364       error(" no sequence to save \n", non_fatal);
365       return;
366     }
367   seq_save(seq, filename, &offset, &stride, NULL, NULL, file_type);
368   /*seq_save(seq, filename, NULL, NULL, NULL, NULL, file_type);*/
369     /* all these values will be null if called from this button
370        but user can insert own values when calling seq_save by self*/
371 }
372 
373 
374 /* Button call to load sequences. allows user to potentially load specified sequence */
375 
376 
377 static void seq_load_proc(void)
378 {
379   Sequence *seq = NULL;
380   int end_frame;
381 
382   if ((seq = seq_load(filename, offset, stride, end, file_type)) == NULL)
383      {
384       format("sequence is NULL");
385       return;
386     }
387   seq_set_current(seq);
388 
389   end_frame = get_end_frame(seq);
390   set_seq_end(end_frame);
391   frame = seq->offset;
392 
393   tv_init(seq_tv_get());
394   seq_show_current(seq);
395   seq_param_update(seq);
396 
397   seq_init_funcs_run();
398 }
399 
400 
401 void seq_load_wrapper(char *ext_filename, int ext_offset, int ext_stride, int ext_end, int ext_file_type)
402 {
403         /* External loader for sequence tool paul.bromiley@manchester.ac.uk 30/11/2004*/
404 
405         strcpy(filename, ext_filename);
406         offset = ext_offset;
407         stride = ext_stride;
408         end = ext_end;
409         file_type = ext_file_type;
410 
411         /* Existing loader handles the rest... well done mjs! */
412 
413         seq_load_proc();
414 }
415 
416 
417 /* not sure if these should be static or not. */
418 /* jumps to and shows first image in the sequence */
419 
420 
421 static void show_first_proc(void)
422 {
423   Sequence *seq = seq_get_current();
424 
425   if (seq == NULL)
426     return;
427 
428   seq_update_proc();
429   frame = seq->offset;
430   tw_iglobal_reset(pcurfr);
431   seq->current = seq->start;
432 
433   seq_show_current(seq);
434   inter_update_proc();
435 }
436 
437 /*jumps to and shows last image in sequence */
438 
439 
440 static void show_end_proc(void)
441 {
442   Sequence *seq = seq_get_current();
443 
444   if (seq == NULL)
445     return;
446 
447   seq_update_proc();
448   frame = get_end_frame(seq);
449   set_seq_current_el(seq, get_seq_end_el(seq));
450   seq_show_current(seq);
451   inter_update_proc();
452 }
453 
454 /* moves through the sequence by one stride at a time.
455    function is used for both up and down directions, direction
456    moved in determined by the sign of the variable "incr" */
457 
458 
459 static void show_incr_proc(int incr)
460 {
461   Sequence *seq = seq_get_current();
462 
463   if (seq == NULL)
464     return;
465 
466   seq_update_proc();
467   frame = frame + (incr*seq->stride);
468   tw_iglobal_reset(pcurfr);
469 
470   set_seq_current_frame(seq, frame);
471 
472   seq_show_current(seq);
473   inter_update_proc();
474 }
475 
476 /* jumps to the image frame specified by the frame field on the tool */
477 
478 
479 static void jumpto_proc(void)
480 {
481 
482   Sequence *seq = (Sequence *)seq_get_current();
483 
484   if (seq == NULL)
485     return;
486 
487   seq_update_proc();
488   set_seq_current_frame(seq, frame);
489   seq_show_current(seq);
490   inter_update_proc();
491 }
492 
493 
494 /* removes one frame from the sequence */
495 /* wrote explanantion of this elsewhere????*/
496 
497 
498 static void delete_seq_frame_proc(void)
499 {
500   Sequence * data = seq_get_current();
501   Tv      *tv_ptr = seq_tv_get();
502 
503   if ((tv_ptr == NULL))
504     return;
505 
506   if (data == NULL)
507     return;
508 
509   seq_update_proc();
510   data = delete_seq_frame(data);
511   set_seq_end(get_end_frame(data));
512 
513   if (data != NULL)
514   {
515      seq_set_current(data);
516      frame = data->offset + get_seq_current_frame(data);
517      seq_param_update(data);
518   }
519 
520   tv_free_background(tv_ptr);
521   tv_repaint(tv_ptr);
522   inter_update_proc();
523   return;
524 }
525 
526 /*button wrapper to insert frame into sequence */
527 
528 
529 static void insert_seq_frame_proc(void)
530 {
531   Sequence * data = seq_get_current();
532   Imrect  *im = NULL;
533   Tv      *tv_ptr = seq_tv_get();
534   int      image_data = IMAGE_DATA;
535 
536   if (tv_ptr == NULL)
537     return;
538 
539   /*
540     if (data == NULL)
541      return;
542   */
543 
544   if (data == NULL)
545     {
546       if ((data = seq_alloc()) == NULL)
547         {
548           error("can't allocate sequence \n", non_fatal);
549           return;
550         }
551     }
552 
553   seq_update_proc();
554   if ((im = seq_pop_data(im, image_data)) == NULL)
555     return;
556 
557   seq_frame_insert(im, data);
558 
559   seq_show_current(data);
560   seq_show_bits();
561   set_seq_end(get_seq_end()+data->stride);
562   frame = frame+data->stride; /*check this works */
563   inter_update_proc();
564 }
565 
566 /* replaces a frame with imrect on imcalc stack*/
567 
568 
569 static void replace_seq_frame_proc(void)
570 {
571   Sequence * data = seq_get_current();
572   Imrect *im = NULL;
573   Imrect *im1 = NULL;
574   List *lptr = get_seq_current_el(data);
575   Tv     *tv_ptr = seq_tv_get();
576   int     image_data;
577 
578   image_data = IMAGE_DATA;
579 
580   if (data == NULL)
581     return;
582 
583   if (tv_ptr == NULL)
584     return;
585 
586   if((lptr == NULL) || (lptr->to == NULL))
587     {
588       error("unable to replace here ", warning);
589       return;
590     }
591 
592   if (frame < data->offset || frame > get_seq_end())
593     {
594       error("unable to replace here ", warning);
595       return;
596     }
597 
598 
599   seq_update_proc();
600   if ((im = seq_pop_data(im, image_data)) == NULL)
601     return;
602 
603   im1 = lptr->to;
604   lptr->to = im;
605   im_free(im1);
606   seq_image_set(im);
607   seq_show_bits();
608   seq_show_current(data);
609   inter_update_proc();
610   return;
611 
612 }
613 
614 /* button proc to push frame onto imcalc stack */
615 
616 
617 static void push_seq_frame_proc(void)
618 {
619 
620   Sequence *data = (Sequence *) seq_get_current();
621 
622   if (data == NULL)
623     return;
624 
625   if (frame < data->offset || frame > get_seq_end())
626     {
627       error("unable to push from here ", warning);
628       return;
629     }
630 
631   seq_update_proc();
632   seq_push_data(get_seq_current_el(data)->to);
633 
634   return;
635 
636 }
637 
638 void seq_str_rm_proc(void)
639 {
640 /* temporary proc to remove whole sequence */
641   Tv * seq_tv = seq_tv_get();
642   Sequence *seq = seq_get_current();
643 
644   seq_rm(seq);
645 
646   seq_image_set(NULL);
647   if (seq_tv == NULL)
648     return;
649   tv_erase(seq_tv);
650   tv_free_background(seq_tv);
651   tv_init(seq_tv);
652 
653 }
654 
655 static void stack_seq_proc(void)
656 {
657 /* moves a sequence of images on the stack into the sequence */
658   Sequence *seq = NULL;
659   Tv *seq_tv = seq_tv_get();
660 
661   seq_update_proc();
662   seq_str_rm_proc();
663   stack_seq(NULL);
664   if(seq_tv!=NULL)
665   {
666       tv_erase(seq_tv);
667       tv_free_background(seq_tv);
668       tv_init(seq_tv); /* don't need tv_free_background if use tv_init() */
669   }
670   if (imcalc_tv_get()!= NULL) tv_init(imcalc_tv_get());
671   if (imcal2_tv_get()!= NULL) tv_init(imcal2_tv_get());
672 
673   set_seq_end(get_end_frame(seq));
674   inter_update_proc();
675 }
676 
677 
678 static void copy_test_proc(void)
679 {
680   Sequence *seq = NULL;
681   Sequence *copy = NULL;
682 
683   if ((seq = seq_get_current()) == NULL)
684     return;
685 
686   copy = seq_copy(seq);
687   seq_rm(seq);
688   seq_set_current(copy);
689   seq_show_current(copy);
690 }
691 
692 void seq_scales_update(double nxscale, double nyscale, double nzscale)
693 {
694    xscale = nxscale;
695    yscale = nyscale;
696    zscale = nzscale;
697    (void) tw_fglobal_reset(pxs);
698    (void) tw_fglobal_reset(pys);
699    (void) tw_fglobal_reset(pzs);
700    format("Warning: remember to update the sequence scales before output \n");
701 }
702 
703 static void seq_scan_proc(void)
704 {
705    scan_files(filename, NULL);
706    tw_sglobal_reset(pfilename);
707 }
708 
709 static void     tv_choice_proc(int val)
710 {
711     switch (val)
712     {
713       case 0:
714       {
715         if (seq_tv_get()==NULL)
716         {
717           seq_tv_set(seq_tv_make());
718          }
719          tv_set_next(seq_tv());
720          seq_image_on(1);
721       }
722       break;
723     }
724 }
725 
726 void set_seq_sfile(struct air16 *air1)
727 {
728    char *newfilename = air1->s_file;
729 
730    strcpy(filename,newfilename);
731    tw_sglobal_reset(pfilename);
732 }
733 
734 void set_seq_rfile(struct air16 *air1, int num)
735 {
736    char *newfilename = air1->r_file;
737 
738    strcpy(filename,newfilename);
739    parse_fname(NULL,filename,num);
740    tw_sglobal_reset(pfilename);
741 }
742 
743 
744 void         seq_tool(int x, int y)
745 {
746   static void *tool = NULL;
747   int val;
748 
749   if (tool)
750   {
751       tw_show_tool(tool);
752       return;
753   }
754 
755   tool = tw_tool("Sequence Tool", x, y);
756 
757   tw_choice("Tv : ", tv_choice_proc, 0, "sequence", NULL);
758   tw_help_button("sequence_tool");
759   tw_newrow();
760 
761   tw_choice("File:    ", seq_file_choice_proc, 0,
762             "AIFF", "ANLZ", "RAD", "NEMA", "PGM", "DICOM", NULL);
763   tw_menubar("", "DICOM (re)scale?", 
764              "Rescale", set_seq_scale_factor_flag, 0,
765              "Scale", set_seq_scale_factor_flag, 1,
766              NULL, NULL);
767   tw_newrow();
768   val = seq_file_type_find();
769   seq_image_choice = tw_choice("Image type:  ",
770            seq_type_choice_proc,val,"bin","chr","int","flt", NULL);
771   tw_newrow();
772 
773   poffset = (void *)tw_iglobal("Start :", &offset, 3);
774   pstride = (void *)tw_iglobal("Stride:", &stride, 3);
775   pcurfr = (void *)tw_iglobal("Cur. frame:", &frame, 3);
776   pend = (void *)tw_iglobal("  End :", &end, 3);
777   tw_newrow();
778   pfilename = (void *)tw_sglobal("Image File:", filename, 40);
779   tw_button("Scan", seq_scan_proc, NULL);
780   tw_newrow();
781   tw_label("Scales:");
782   pxs = (void *)tw_fglobal("x:", &xscale, 10);
783   pys = (void *)tw_fglobal("y:", &yscale, 10);
784   pzs = (void *)tw_fglobal("z:", &zscale, 10);
785   ptmp = (void *)tw_fglobal("t:", &tscale, 10);
786   tw_newrow();
787   tw_button("Load", seq_load_proc, NULL);
788   tw_button("Save", seq_save_proc, NULL);
789   tw_button("First", show_first_proc, NULL);
790   tw_button("<", show_incr_proc, (void *)-1);
791   tw_button(">", show_incr_proc, (void *)1);
792   tw_button("End", show_end_proc, NULL);
793   tw_button("Jumpto", jumpto_proc, NULL);
794   tw_newrow();
795   tw_button("Del Seq", seq_str_rm_proc, NULL);
796   tw_button("Del", delete_seq_frame_proc, NULL);
797   tw_button("Ins", insert_seq_frame_proc, NULL);
798   tw_button("Rep", replace_seq_frame_proc, NULL);
799   tw_button("Push", push_seq_frame_proc, NULL);
800   tw_button("Stack->Seq", stack_seq_proc, NULL);
801   tw_newrow();
802 /*
803   tw_label("Test Buttons:");
804   tw_newrow();
805   tw_button("Copy, delete and show", copy_test_proc, NULL);
806 */
807   tw_end_tool();
808 }
809 
810 
811 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.