home *** CD-ROM | disk | FTP | other *** search
/ Computer Club Elmshorn Atari PD / CCE_PD.iso / pc / 0600 / CCE_0682.ZIP / CCE_0682.PD / DSPSHELL / C_SOURCE / DSPSHELL.C next >
C/C++ Source or Header  |  1993-09-27  |  25KB  |  883 lines
  1. /*********************************************
  2.  * DSPSHELL    Version 1.0                      *
  3.  * von      Mario Bahr                          *    
  4.  * 14532 Kleinmachnow                        *
  5.  * Karl-Marx-Straße 110                      * 
  6.  * unter Nutzung einer erweiterten POWERGEM- *
  7.  * BIBLIOTHEK von Boris Sander aus TOS 4/93  *
  8.  *********************************************/
  9.  
  10. #include <stdio.h>
  11. #include <aes.h>
  12. #include <vdi.h>
  13. #include <tos.h>
  14. #include <stdlib.h>
  15. #include <process.h>
  16. #include <string.h>
  17. #include <time.h >
  18. #include "D:\DSPSHELL\dspshell.h" 
  19. #include "scancode.h"
  20. #include "powergem.h"
  21. #include "powrtext.h"
  22. #include "easyfsel.h"
  23.  
  24.  
  25. #define NO_DATEI -33
  26. #define FILE_EXIST -34
  27. #define FILE_NOEXIST -35
  28. #define NO_PRG -36
  29. #define FALSE_EXTENSION -100
  30. #define TEXT_ERROR    -200
  31.  
  32. #define FEHLER -1
  33.  
  34. #define EDITOR 1
  35. #define EXECUTE 2
  36.  
  37. /* Globale Variablen ----------------------------------------------------- */
  38. typedef struct 
  39. {
  40. char edit[15];        /* aktuelle Datei            */
  41. char edit_path[256];/* Pfad für aktuelle Datei   */
  42. char editor[256];    /* Pfad für Editor           */
  43. char a56[256];        /* Pfad für A56              */
  44. char otl[256];        /* Pfad für out to lod       */
  45. char exe_path[256]; /* Pfad für anderes Programm */
  46. int main_x,main_y;    /* Koordinaten des SHELL-Fensters */ 
  47. }CONFIGURATION;
  48.  
  49. CONFIGURATION config,temp; 
  50. int prg_flag;
  51. char prg_pfad[256]; /* Pfad für dieses Programm */
  52.  
  53. TEXT *reportA56 = NULL;        /* Zeiger auf A56-Reporttext */
  54. TEXT *reportotl = NULL;        /* Zeiger auf OTL-Reporttext */
  55. char main_info[]=" DSP-SHELL V1.0 ";
  56. char reportA56_info[]=" Report of A56 ";
  57. char reportotl_info[]=" Report of OUT to LOD ";
  58.  
  59. int TEXT_ELEMENTS=NAME|CLOSER|MOVER|SIZER|FULLER|UPARROW|
  60.                  DNARROW|RTARROW|LFARROW|VSLIDE|HSLIDE;
  61.  
  62. /* Prototyp -------------------------------------------------------------- */
  63. int main(void);
  64. void exit_prg(void);
  65. void infobox(void);
  66. void open_anzeige(char *text,char *file);
  67. void close_anzeige(void);
  68. void init_all(void);
  69. void read_config(void);
  70. void save_config(void);
  71. void new_file(void);
  72. void open_file(void);
  73. void parameter(void);
  74. void start_editor(void);
  75. void start_exe(void);
  76. void execute_editor(void);
  77. void execute_exe(void);
  78. void execute_asm(void);
  79. void execute_otl(void);
  80. void make_all(void);
  81. int set_execute(char *dest,char *title);
  82. void show_report(TEXT **report,char *name,char *file,
  83.                         void (*draw)(struct WINDOW *win),int(*close)
  84.                         (struct WINDOW *win) );
  85. void draw_A56report(struct WINDOW *win);
  86. void draw_otlreport(struct WINDOW *win);
  87. int close_A56report(struct WINDOW *win);
  88. int close_otlreport(struct WINDOW *win);
  89. void text_down(void);
  90. void text_up(void);
  91. void text_right(void);
  92. void text_left(void);
  93. void texts_down(void);
  94. void texts_up(void);
  95. void text_a(void);
  96. void text_e(void);
  97.  
  98. int error(int fehler_e);
  99.  
  100. /* ---------------------------------------------------------------------- */
  101. /* Hauptinitialisierung                                                      */
  102. /* ---------------------------------------------------------------------- */
  103. int main(void)
  104. {
  105. char resourcen[256];
  106. get_akt_path(prg_pfad);
  107.  
  108. build_filname(resourcen,prg_pfad,"DSPSHELL.RSC");
  109.  
  110. do
  111.     {    
  112.     if (init_powergem(resourcen, MENUE))  /* PowerGEM initialisieren */
  113.         {
  114.         /* Funktionen des Menüs anmelden ------------------ */
  115.  
  116.         init_desktop(DESKTOP);        
  117.         key_action( CNTRL_W, untop_win);    /* Fensterwechsel mit ^W */ 
  118.         /* Cursortasten für Text */
  119.         key_action( CUR_DOWN, text_down);    /* Zeilen und Spaltenweise */
  120.         key_action( CUR_UP, text_up);
  121.         key_action( CUR_RIGHT, text_right);
  122.         key_action( CUR_LEFT, text_left);    
  123.  
  124.         key_action( SHFT_CD, texts_down);    /* Seitenweise            */    
  125.         key_action( SHFT_CU, texts_up);
  126.  
  127.         key_action( HOME, text_a);        /* an den Anfang         */
  128.         key_action( SHFT_HOME, text_e); /* ans Ende                */
  129.  
  130.         menu_action( MTINFO ,  M_INFO  , CNTRL_I, infobox       ); 
  131.         menu_action( MTDATEI , M_NEU   , CNTRL_N, new_file      );
  132.         menu_action( MTDATEI , M_OEFFNEN,CNTRL_O, open_file     );
  133.         menu_action( MTDATEI , M_ENDE   ,CNTRL_Q, exit_prg         );
  134.         menu_action( MTDATEI , MEXE      ,ALT_E  , execute_exe    );
  135.         menu_action( MTDO_IT , MEDITOR  ,CNTRL_E, execute_editor);
  136.         menu_action( MTDO_IT , MASSEMBLE,ALT_A,   execute_asm   );
  137.         menu_action( MTDO_IT , MOUTLOD  ,ALT_L,   execute_otl   );
  138.         menu_action( MTDO_IT , MMAKEALL ,ALT_X,   make_all        );
  139.         menu_action( MTOPTION, MPFAD   , ALT_C  , parameter        );
  140.         menu_action( MTOPTION, MSAVE   , ALT_S  , save_config   );
  141.         
  142.  
  143.         /* Zu überwachende Ereignisse festlegen -> multi */
  144.         watch_events(MU_MESAG|MU_BUTTON|MU_KEYBD, 2,1,1); 
  145.         graf_mouse(ARROW, NULL);
  146.         init_all();
  147.         multi(); 
  148.         }
  149.     if(prg_flag== EDITOR) /* Da sicherlich GEM-Programm 
  150.                                 -> eigene Applikation terminieren */
  151.         start_editor();
  152.  
  153.     if(prg_flag ==    EXECUTE)
  154.         start_exe();        /* andere Applikation starten */                
  155.  
  156.     }while(prg_flag);
  157. return 0;
  158. }
  159. /*************************************************
  160.  * Beendet Programm  und sichert Konfiguration   *
  161.  *************************************************/
  162. void exit_prg(void)
  163. {
  164. prg_flag=0;    
  165. save_config();
  166. exit_powergem();
  167. } 
  168.  
  169. /************************
  170.  * Infobox                 *
  171.  ************************/
  172. void infobox(void)
  173. {
  174. struct WINDOW *info;
  175.  
  176. info = create_dial(DINFO, 0, NAME|MOVER,UNMODAL,0, 0, 0,0,0);
  177.  
  178. if (info)
  179.     {
  180.     button_action(info, DINFOOK,break_dial, FALSE);
  181.     open_window(info, "DSP-SHELL", 0);
  182.     }
  183. }
  184. /************************
  185.  * Anzeige  an            *
  186.  ************************/
  187. void open_anzeige(char *text,char *file)
  188. {
  189. struct WINDOW *anzeige;
  190.  
  191. anzeige = create_dial(DANZEIGE, 0, NAME|MOVER,MODAL,0, 0, 0,0,0);
  192.  
  193. if (anzeige)
  194.     {
  195.     set_text(anzeige, ANZEIGE, text, (int)strlen(text),FALSE);
  196.     set_text(anzeige, DNAME, file, (int)strlen(file),FALSE);
  197.     open_window(anzeige, "DSP-SHELL ", 0);
  198.     }
  199. }
  200. /************************
  201.  * Anzeige  aus            *
  202.  ************************/
  203. void close_anzeige(void)
  204. {
  205. break_dial();
  206. }
  207.  
  208. /********************************************************************
  209.  * Initialisiert alles, und stellt kleines Fenster dar                 *
  210.  * Zugriff auf globale Struktur config                              *
  211.  ********************************************************************/
  212. void init_all(void)
  213. {
  214. struct WINDOW *init;
  215.  
  216. init = create_dial(MAIN, 0, NAME|MOVER,UNMODAL,0, 0, 0,0,0);
  217.  
  218. if (init)
  219.     {
  220.     read_config();
  221.     set_text(init, IN_DATEI, config.edit,
  222.                      (int)strlen(config.edit), FALSE);
  223.     button_action(init, IN_DATEI,open_file, FALSE);
  224.     button_action(init, DEDITOR,execute_editor,FALSE);
  225.     button_action(init, DASSEMBLE,execute_asm, FALSE);
  226.     button_action(init, DOUTTOLOD,execute_otl, FALSE);
  227.     button_action(init, DMAKEALL ,make_all, FALSE);
  228.     init->actual_position.g_x=config.main_x;
  229.     init->actual_position.g_y=config.main_y;
  230.     open_window(init, main_info, 0);
  231.     }
  232. else
  233.     exit_powergem();    
  234. }
  235. /********************************************************************
  236.  * Liest aktuelle Konfiguration ein                                  *
  237.  * Zugriff auf globale Struktur config und auf app_cntrl-Struktur    *
  238.  ********************************************************************/
  239. void read_config(void)
  240. {
  241. FILE *config_file;
  242. char configuration[256];
  243.  
  244. build_filname(configuration,prg_pfad,"DSPSHELL.SYS");
  245.  
  246. config_file=fopen(configuration,"r");        /* Daten einlesen */
  247. if(config_file != NULL)
  248.     {
  249.     fscanf(config_file,"%s\n%s\n%s\n%s\n%s\n%s\n",config.edit,
  250.     config.edit_path,config.editor,config.a56,config.otl,config.exe_path);
  251.     fscanf(config_file,"%i %i\n",&config.main_x,&config.main_y);
  252.     if(config.main_x+100  >= get_app_cntrl()->workarea.g_w ||     /* bei geringerer Auflösung */
  253.             config.main_y+100  >= get_app_cntrl()->workarea.g_h || 
  254.             config.main_x  <= get_app_cntrl()->workarea.g_x || 
  255.             config.main_y  <= get_app_cntrl()->workarea.g_y )
  256.         {
  257.         config.main_x=get_app_cntrl()->workarea.g_x+5;
  258.         config.main_y=get_app_cntrl()->workarea.g_y+10;
  259.         }         
  260.     fclose(config_file);
  261.     }
  262. else
  263.     {
  264.     sprintf(config.edit,"NEW.ASM");
  265.     get_akt_path(config.edit_path); /* aktuellen Pfad setzen */
  266.     sprintf(config.editor,"C:\\EDITOR\\EDITOR.PRG");
  267.     sprintf(config.a56,"C:\\DSP\\A56.TTP");
  268.     sprintf(config.otl,"C:\\DSP\\OUTTOLOD.TTP");
  269.     config.main_x=get_app_cntrl()->workarea.g_x+5;
  270.     config.main_y=get_app_cntrl()->workarea.g_y+10;
  271.     get_akt_path(config.exe_path);
  272.     }
  273. }
  274. /********************************************************************
  275.  * Sichert aktuelle Konfiguration                                       *
  276.  * Zugriff auf globale Struktur config                              *
  277.  ********************************************************************/
  278. void save_config(void)
  279. {
  280. FILE *config_file;
  281. char configuration[256];
  282. struct WINDOW *main;
  283. int dummy;
  284.  
  285. build_filname(configuration,prg_pfad,"DSPSHELL.SYS");
  286.  
  287. config_file=fopen(configuration,"w");
  288. if(config_file != NULL)
  289.     {
  290.     fprintf(config_file,"%s\n%s\n%s\n%s\n%s\n%s\n",config.edit,
  291.             config.edit_path,config.editor,config.a56,config.otl
  292.                 ,config.exe_path);
  293.     main=get_winfn(main_info);
  294.     if(main)    /* Koordinaten sichern */
  295.         {
  296.         wind_get(main->w_handle,WF_CURRXYWH,&config.main_x,
  297.             &config.main_y, &dummy, &dummy); 
  298.         }    
  299.     fprintf(config_file,"%i %i\n",config.main_x,config.main_y);
  300.     fclose(config_file);
  301.     }
  302. }
  303. /********************************************************************
  304.  * Legt eine neue Datei an                                               *
  305.  * Zugriff auf globale Struktur config                              *
  306.  ********************************************************************/
  307. void new_file(void)
  308. {
  309. char datei[15]="";
  310. char path[256];
  311. char dat_path[256];
  312. FILE *new;
  313. time_t date_clock;
  314.  
  315. strcpy(path,config.edit_path);
  316. if(easy_fsel(path,datei,"CREATE NEW FILE" ) && datei[0] != 0x0)
  317.     {
  318.     if(check_extension(datei,"ASM")==FALSE)
  319.         {
  320.         error(FALSE_EXTENSION);
  321.         return;
  322.         }
  323.     build_filname(dat_path,path,datei);
  324.     if(!exist_file(dat_path))
  325.         {
  326.         if( (new=fopen(dat_path,"w")) != NULL)
  327.             {
  328.             strcpy(config.edit,datei);    
  329.             strcpy(config.edit_path,path);    
  330.             date_clock=time(&date_clock);
  331.             fprintf(new,";DSP56-File: %s \n",ctime(&date_clock));  
  332.             fclose(new);
  333.             blank(0,0,0,0,0); /* REDRAW */
  334.             }
  335.         else
  336.             error(NO_DATEI);
  337.         }    
  338.     else
  339.         error(FILE_EXIST);
  340.     }        
  341. }
  342. /********************************************************************
  343.  * Öffnet eine Datei                                                  *
  344.  * Zugriff auf globale Struktur config                              *
  345.  ********************************************************************/
  346. void open_file(void)
  347. {
  348. char datei[15]="";
  349. char path[256];
  350. char dat_path[256];
  351. FILE *_datei;
  352.  
  353. strcpy(path,config.edit_path);
  354. if(easy_fsel(path,datei,"OPEN FILE" ) && datei[0] != 0x0)
  355.     {
  356.     if(check_extension(datei,"ASM")==FALSE)
  357.         {
  358.         error(FALSE_EXTENSION);
  359.         return;
  360.         }
  361.     build_filname(dat_path,path,datei);
  362.     if(exist_file(dat_path))
  363.         {
  364.         if((_datei=fopen(dat_path,"r")) != NULL)
  365.             {
  366.             strcpy(config.edit,datei);    
  367.             strcpy(config.edit_path,path);    
  368.             set_text(get_winfn(main_info),IN_DATEI,config.edit,
  369.                                  (int)strlen(config.edit),TRUE);
  370.             fclose(_datei);    /* Wir haben sie uns ja bereits gemerkt */  
  371.             }
  372.         else
  373.             error(NO_DATEI);
  374.         }    
  375.     else
  376.         error(FILE_NOEXIST);
  377.     }        
  378. }
  379.  
  380. void set_new(void);
  381. void select_editor(void);
  382. void select_asm(void);
  383. void select_otl(void);
  384.  
  385. /********************************************************************
  386.  * Parameter setzen                                                    *
  387.  * Zugriff auf globale Struktur config                              *
  388.  ********************************************************************/
  389. void parameter(void)
  390. {
  391. struct WINDOW *parameter;
  392.  
  393. parameter = create_dial(PARAMETER, 0, NAME|MOVER,MODAL,0, 0, 0,0,0);
  394.  
  395. if (parameter)
  396.     {
  397.     memcpy(&temp,&config,sizeof(config)); /* Werte kopieren */
  398.     
  399.     set_text(parameter, PSEDITOR, temp.editor,
  400.                      (int)strlen(temp.editor), FALSE);
  401.     set_text(parameter, PSASM, temp.a56,
  402.                      (int)strlen(temp.a56), FALSE);
  403.     set_text(parameter, PSOUTTOLOD, temp.otl,
  404.                      (int)strlen(temp.otl), FALSE);
  405.  
  406.     
  407.     button_action(parameter,PARACAN,break_dial, FALSE);
  408.     button_action(parameter,PARAOK,set_new, FALSE);
  409.     button_action(parameter,PSEDITOR,select_editor, FALSE);
  410.     button_action(parameter,PSASM,select_asm, FALSE);
  411.     button_action(parameter,PSOUTTOLOD,select_otl, FALSE);
  412.  
  413.     open_window(parameter, "DSP-SHELL", 0);
  414.     }
  415. else
  416.     exit_powergem();    
  417. }
  418. /***********************************************
  419.  * Setzt die Parameter                         *
  420.  ***********************************************/
  421. void set_new(void)
  422. {
  423. memcpy(&config,&temp,sizeof(CONFIGURATION)); /* Werte kopieren */
  424. break_dial();
  425. }
  426. /***********************************************
  427.  * Editor selektieren                          *
  428.  ***********************************************/
  429. void select_editor(void)
  430. {
  431. char dest[256]="";
  432. if(set_execute(dest,"SELECT EDITOR") != FEHLER)
  433.     {
  434.     strcpy(temp.editor,dest);
  435.     }
  436. }
  437. /***********************************************
  438.  * Assembler selektieren                       *
  439.  ***********************************************/
  440. void select_asm(void)
  441. {
  442. char dest[256]="";
  443. if(set_execute(dest,"SELECT ASM56") != FEHLER)
  444.     strcpy(temp.a56,dest);
  445. }
  446. /***********************************************
  447.  * OUT TO LOD  selektieren                     *
  448.  ***********************************************/
  449. void select_otl(void)
  450. {
  451. char dest[256]="";
  452. if(set_execute(dest,"SELECT OUTTOLOD") != FEHLER)
  453.     strcpy(temp.otl,dest);
  454. }
  455.  
  456. /***********************************************
  457.  * Programm selektieren                        *
  458.  * Input: dest Zeiger für Zielstring           * 
  459.  *          title Zeiger auf Titel               *    
  460.  * Output:evtl. Fehlercode                       *
  461.  ***********************************************/
  462. int set_execute(char *dest,char *title)
  463. {
  464. char datei[15]="";
  465. char path[256];
  466. char dat_path[256];
  467.  
  468. strcpy(path,config.edit_path);
  469. if(easy_fsel(path,datei,title ) && datei[0] != 0x0)
  470.     {
  471.     build_filname(dat_path,path,datei);
  472.     if(exist_file(dat_path))
  473.         {
  474.         strcpy(dest,dat_path);    
  475.         blank(0,0,0,0,0); /* REDRAW */
  476.         }
  477.     else
  478.         return(error(FILE_NOEXIST));
  479.     }        
  480. else
  481.     return FEHLER;
  482. return 0;
  483. }
  484. /***********************************************
  485.  * Setzt Flags um den Editor zu starten        *
  486.  ***********************************************/
  487. void execute_editor(void)
  488. {
  489. blank(0,0,0,0,0); /* REDRAW */
  490.  
  491. exit_powergem();
  492. prg_flag=EDITOR;
  493. }
  494. /**********************************************
  495.  * Startet anderes Programm                      *
  496.  **********************************************/
  497. void execute_exe(void)
  498. {
  499. char datei[15];
  500. char path[240];
  501.  
  502. extract_filename(path,datei,config.exe_path);
  503. strcat(path,"\\*.*");
  504. if(easy_fsel(path,datei,"EXECUTE PRG" ) && datei[0] != 0x0)
  505.     {
  506.     build_filname(config.exe_path,path,datei);
  507.     prg_flag=EXECUTE;
  508.     exit_powergem();
  509.     }
  510. }
  511. /***********************************************
  512.  * Startet den (GEM)-EDITOR                    *     
  513.  ***********************************************/
  514. void start_editor(void)
  515. {
  516. int ret_code;
  517. char dat_pfad1[256],datei[15],e_pfad[256],old_pfad[256];
  518. char dat_pfad2[256];
  519.  
  520. save_config();
  521. get_akt_path(old_pfad);
  522. extract_filename(e_pfad,datei,config.editor);
  523. build_filname(dat_pfad1,config.edit_path,config.edit);
  524. build_filname(dat_pfad2,config.edit_path,"REPORT.A56 ");
  525. strcat(dat_pfad2,dat_pfad1);
  526. set_new_path(e_pfad);
  527. if(exec( datei,dat_pfad2,old_pfad , &ret_code) <0)
  528.     error(NO_PRG);
  529. set_new_path(old_pfad);
  530. }
  531. /***********************************************
  532.  * Startet beliebiges Programm                    *     
  533.  ***********************************************/
  534. void start_exe(void)
  535. {
  536. char datei[15],parameter[2]="",e_pfad[256],old_pfad[256];
  537. int ret_code;
  538.  
  539. save_config();
  540. get_akt_path(old_pfad);
  541. extract_filename(e_pfad,datei,config.exe_path);
  542.  
  543. set_new_path(e_pfad);
  544. if(exec( datei,parameter,e_pfad , &ret_code) <0)
  545.     error(NO_PRG);
  546. set_new_path(old_pfad);
  547. }
  548. /***********************************************
  549.  * Ruft den Assembler auf und übergibt ihm     *
  550.  * die zu assemblierende Datei                   *
  551.  ***********************************************/
  552. void execute_asm(void)
  553. {
  554. int ret_code,f_handle,flag =FALSE;
  555. char dat_path[128];
  556. char buf[13]="report.a56";
  557. char parameter[256]="-o";
  558. time_t date_clock;
  559.  
  560. build_filname(dat_path,config.edit_path,buf);
  561. f_handle = (int)Fcreate(dat_path,0);
  562. if(f_handle > 0)
  563.     {
  564.     strcpy(buf,config.edit);
  565.     swap_extension(buf,"OUT");    /* OUT-Endung setzen          */
  566.     build_filname(dat_path,config.edit_path,buf);
  567.     
  568.     graf_mouse(HOURGLASS,0);
  569.     open_anzeige("   ASSEMBLE  TO ",dat_path);
  570.     
  571.     strcat(parameter,dat_path);        /* an Parameterliste anhängen */
  572.     build_filname(dat_path,config.edit_path,config.edit);
  573.     strcat(parameter," ");        /* Leerzeichen                   */
  574.     strcat(parameter,dat_path); /* ASM-File anhängen          */
  575.     
  576.     Fforce(1,f_handle);    /* Bildschirmausgabe in Datei umlenken */
  577.     date_clock=time(&date_clock);
  578.     printf("DSP56 - OUT - Report: %s \n",ctime(&date_clock));  
  579.     printf("A56 Assembler say: \n"); 
  580.     
  581.     if(exec( config.a56,parameter,get_akt_path(dat_path), &ret_code) <0 )
  582.         {
  583.         graf_mouse(ARROW,0);
  584.         error(NO_PRG);
  585.         flag =TRUE;        
  586.         }
  587.     Fforce(1,1);
  588.     Fclose(f_handle);                                                            
  589.     close_anzeige();
  590.     graf_mouse(ARROW,0);
  591.     if( ret_code != 0 && flag == FALSE )
  592.         show_report(&reportA56,reportA56_info,"REPORT.A56",
  593.                                     draw_A56report,close_A56report);
  594.  
  595.     }
  596. else
  597.     error(NO_DATEI);
  598. }
  599.  
  600. /***********************************************
  601.  * Wandelt OUT in LOD Format                   *
  602.  ***********************************************/
  603. void execute_otl(void)
  604. {
  605. int ret_code,f_handle;
  606. char dat_path[256],buf[256];
  607. char report[13]="report.otl";
  608. time_t date_clock;
  609.  
  610. build_filname(dat_path,config.edit_path,report);
  611.  
  612. f_handle = (int)Fcreate(dat_path,0);
  613. if(f_handle > 0)
  614.     {
  615.     Fforce(1,f_handle);    /* Bildschirmausgabe in Datei umlenken */
  616.     date_clock=time(&date_clock);
  617.     printf("DSP56 - LOD - Report %s \n",ctime(&date_clock));  
  618.     printf("OUT to LOD say: \n"); 
  619.     build_filname(dat_path,config.edit_path,config.edit);
  620.     graf_mouse(HOURGLASS,0);
  621.     strcpy(buf,dat_path);
  622.     open_anzeige("    OUT TO LOD ",    swap_extension(buf,"LOD"));
  623.     swap_extension(dat_path,"OUT");
  624.  
  625.     if(exec( config.otl,dat_path,get_akt_path(buf), &ret_code) < 0 )
  626.         {    
  627.         graf_mouse(ARROW,0);
  628.         error(NO_PRG);
  629.         }
  630.     Fforce(1,1);
  631.     Fclose(f_handle);
  632.     close_anzeige();
  633.     graf_mouse(ARROW,0);
  634.     if(ret_code != 0)
  635.         show_report(&reportotl,reportotl_info,"REPORT.OTL",
  636.                                     draw_otlreport,close_otlreport);
  637.     }
  638. else
  639.     error(NO_DATEI);
  640. }
  641. /*******************************************
  642.  * Assembliert und wandelt um in einem Zug *
  643.  *******************************************/
  644. void make_all(void)
  645. {
  646. execute_asm();
  647. execute_otl();
  648. }
  649. /************************************************
  650.  * Zeigt  Report                                *
  651.  * Input: report: Zeiger auf TEXT                *
  652.  *        name:   Name des Fensters                *
  653.  *        file:   einzulesende Datei(ohne Pfad!)*
  654.  *                   -> Pfad von Source             *
  655.  *        draw:   Zeiger auf Textredrawfunktion    *
  656.  *        close   Zeiger auf Closefunktion        *    
  657.  ************************************************/
  658. void show_report(TEXT **report,char *name,char *file,
  659.     void (*draw)(struct WINDOW *win),int (*close)(struct WINDOW *win))
  660. {
  661. struct WINDOW *win;
  662. GRECT winpos,*desk; 
  663. char dat_path[256];
  664.  
  665. break_win( (win=get_winfn(name)) );    /* Falls das Fenster schon offen
  666.                                         -> schließen */        
  667.  
  668. build_filname(dat_path,config.edit_path,file);
  669. *report = text_read(dat_path,4);
  670. if(*report == NULL)
  671.     {error(TEXT_ERROR);return;}            /*     Fehler beim einlesen */            
  672.  
  673.  
  674. desk=&get_app_cntrl()->workarea;
  675.  
  676. winpos.g_x =desk->g_x + ((rand())&0x1F)+10;
  677. winpos.g_y =desk->g_y + ((rand())&0x1F)+10;
  678. winpos.g_w =desk->g_w-winpos.g_x; 
  679. winpos.g_h =desk->g_h-winpos.g_y; 
  680.  
  681. win = create_window(desk, &winpos, 150, 150, TEXT_ELEMENTS,                
  682.             DATA_WINDOW,draw, 0, 0, 0 ,0 ,close);
  683. if (win)
  684.     {
  685.     /* Slider initialisieren -------------------------- */
  686.     init_slider(win, (*report)->max_spalten ,(*report)->zeilen,
  687.     get_app_cntrl()->gl_wchar ,get_app_cntrl()->gl_hchar);
  688.     open_window(win, name,"");
  689.     }
  690.  
  691. }
  692.  
  693. /************************************
  694.  * Zeichnet den A56-Text             *
  695.  ************************************/
  696. void draw_A56report(struct WINDOW *win)
  697. {
  698. text_draw(win,reportA56);
  699. }
  700. /************************************
  701.  * Zeichnet den OTL-Text             *
  702.  ************************************/
  703. void draw_otlreport(struct WINDOW *win)
  704. {
  705. text_draw(win,reportotl);
  706. }
  707. /************************************
  708.  * Schließt A56 Text                 *
  709.  ************************************/
  710. int close_A56report(struct WINDOW *win)
  711. {
  712. if(win)
  713.     text_free(reportA56);
  714. return 0;
  715. }
  716. /************************************
  717.  * Schließt OTL Text                 *
  718.  ************************************/
  719. int close_otlreport(struct WINDOW *win)
  720. {
  721. if(win)
  722.     text_free(reportotl);
  723. return 0;
  724. }
  725. /****************************************
  726.  * Text eine Position nach unten        *
  727.  *                                        *
  728.  ****************************************/
  729. void text_down(void)
  730. {
  731. struct WINDOW *win;
  732. int wh;
  733.  
  734. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  735. win=get_winfh(wh);
  736. set_y_slider(win, get_y_slider(win)+1);
  737. }
  738.  
  739. /****************************************
  740.  * Text eine Position nach oben            *
  741.  *                                        *
  742.  ****************************************/
  743. void text_up(void)
  744. {
  745. struct WINDOW *win;
  746. int wh;
  747.  
  748. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  749. win=get_winfh(wh);
  750. set_y_slider(win, get_y_slider(win)-1);
  751. }
  752.  
  753. /****************************************
  754.  * Text eine Position nach rechts        *
  755.  *                                        *
  756.  ****************************************/
  757. void text_right(void)
  758. {
  759. struct WINDOW *win;
  760. int wh;
  761.  
  762. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  763. win=get_winfh(wh);
  764. set_x_slider(win, get_x_slider(win)+1);
  765. }
  766.  
  767. /****************************************
  768.  * Text eine Position nach links        *
  769.  *                                        *
  770.  ****************************************/
  771. void text_left(void)
  772. {
  773. struct WINDOW *win;
  774. int wh;
  775.  
  776. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  777. win=get_winfh(wh);
  778. set_x_slider(win, get_x_slider(win)-1);
  779. }
  780. /****************************************
  781.  * Text eine Seite nach unten            *
  782.  *                                        *
  783.  ****************************************/
  784. void texts_down(void)
  785. {
  786. struct WINDOW *win;
  787. int w_z;            /* Anzahl der mögliche Spalten */
  788. int wh;
  789.  
  790. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  791. win=get_winfh(wh);
  792. if(win)                /* Wir haben ja nur Textfenster mit Slider */
  793.     {                /*   -> keine weitere Abfrage nötig         */     
  794.     w_z=abs(win->workarea.g_h/get_app_cntrl()->gl_hchar-2);
  795.     set_y_slider(win, get_y_slider(win)+ w_z);
  796.     }
  797. }
  798. /****************************************
  799.  * Text eine Seite nach oben            *
  800.  *                                        *
  801.  ****************************************/
  802. void texts_up(void)
  803. {
  804. struct WINDOW *win;
  805. int w_z;            /* Anzahl der mögliche Spalten */
  806. int wh;
  807.  
  808. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  809. win=get_winfh(wh);
  810. if(win)                /* Wir haben ja nur Textfenster mit Slider */
  811.     {                /*   -> keine weitere Abfrage nötig         */     
  812.     w_z=abs(win->workarea.g_h/get_app_cntrl()->gl_hchar-2);
  813.     set_y_slider(win, get_y_slider(win)- w_z);
  814.     }
  815. }
  816. /****************************************
  817.  * Text an den Anfang                    *
  818.  *                                        *
  819.  ****************************************/
  820. void text_a(void)
  821. {
  822. struct WINDOW *win;
  823. int wh;
  824.  
  825. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  826. win=get_winfh(wh);
  827. set_y_slider(win,0);
  828. }
  829. /****************************************
  830.  * Textende                                *
  831.  *                                        *
  832.  ****************************************/
  833. void text_e(void)
  834. {
  835. struct WINDOW *win;
  836. int wh;
  837.  
  838. wind_get(0, WF_TOP, &wh, 0,0,0);     /* Oberstes Fenster ermitteln  */  
  839. win=get_winfh(wh);
  840. set_y_slider(win,LAST_ZEILE);/* Auch wenn es diese Zeile nicht gibt */ 
  841. }
  842.  
  843. /************************************************
  844.  * Fehlermeldungen                                *
  845.  ************************************************/
  846. int error(int fehler_e)
  847. {
  848. char meldung[80];
  849. char tfehler[80];
  850. char *fehl_p;
  851. fehl_p=tfehler;
  852. if(fehler_e<0)
  853.     {
  854.     switch(fehler_e)
  855.         {
  856.         case NO_DATEI:
  857.             fehl_p=" File Error ! ";
  858.             break;
  859.         case FILE_EXIST:
  860.             fehl_p=" File exist ! ";
  861.             break;
  862.         case FILE_NOEXIST:
  863.             fehl_p=" File does'nt exist ! ";
  864.             break;
  865.         case FALSE_EXTENSION:
  866.             fehl_p=" Use only Files with '.asm' ! ";
  867.             break;
  868.         case NO_PRG:
  869.             fehl_p=" Cannot start Program ! ";
  870.             break;
  871.         case TEXT_ERROR:
  872.             fehl_p=" Cannot read text ! ";
  873.         default:
  874.             fehl_p="Not described Error !   ";
  875.         }    
  876.     sprintf(meldung,"[3][ | %s ][ OK ]",fehl_p);
  877.     form_alert(1,meldung);                /* Fehlermeldung zeigen    */
  878.     return FEHLER;
  879.     } 
  880. return 0;
  881. }
  882.  
  883. /* EOF */