home *** CD-ROM | disk | FTP | other *** search
/ Meeting Pearls 3 / Meeting_Pearls_III.iso / Pearls / texmf / source / driver / print / amiga / muiprint.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-08-10  |  17.2 KB  |  640 lines
  1. #include "defines.h"
  2.  
  3. #include <sprof.h>
  4.  
  5. #include "muiprint.h"
  6.  
  7. #include "globals.h"
  8. #include "globvars.h"
  9. #include "version.h"
  10.  
  11. #include "globals.i"
  12.  
  13.  
  14. extern const char VersionStr[];
  15.  
  16.  
  17. /*
  18.  * Fuer die locale-Library:
  19.  *
  20.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  21.  * Achtung:
  22.  * Es muss/sollte 'multiple-include' erlaubt sein!
  23.  */
  24. #include "local.i"
  25.  
  26. #undef  CATCOMP_ARRAY
  27. #undef  CATCOMP_BLOCK
  28. #undef  CATCOMP_STRINGS
  29. #define CATCOMP_NUMBERS
  30. #include "localstr.h"
  31.  
  32.  
  33.  
  34.  
  35.  
  36.  
  37. static struct Library * MUIMasterBase = NULL;
  38.  
  39. // Application
  40. static APTR MUIAppObject = NULL,
  41.             MainWin      = NULL,
  42.             MessWin      = NULL,
  43.             WorkWin      = NULL,
  44.         FatalWin     = NULL;
  45.  
  46. // MessWin
  47. static APTR LV_Messages  = NULL,
  48.         BT_CloseMess = NULL,
  49.             TX_MessLine  = NULL;
  50.  
  51. // WorkWin
  52. static APTR TX_PrintLine = NULL,
  53.         GA_Gauge     = NULL,
  54.         BT_WorkAbbruch = NULL;
  55.  
  56. // FatalWin
  57. static APTR BT_FatalAbbruch = NULL;
  58.  
  59.  
  60.  
  61. static const char LangerString[] = "                           ";
  62.  
  63. static char DVIpattern[16];
  64. static const char * CYA_Seiten  [] = { NULL, NULL, NULL };
  65.  
  66.  
  67. static struct List MessageList;
  68.  
  69.  
  70.  
  71. static void MUIinit(void);
  72. static void MUISetWorkString(void);
  73.  
  74.  
  75.  
  76.  
  77.  
  78. /* MUIfree() wird *nur* von AbortRun() [globals.c] aufgerufen! */
  79. void MUIfree(void)
  80. {
  81.   if (MUIAppObject) {
  82.     MUI_DisposeObject(MUIAppObject);
  83.     MUIAppObject = NULL;
  84.   }
  85.  
  86.   if (MUIMasterBase) {
  87.     CloseLibrary(MUIMasterBase);
  88.     MUIMasterBase = NULL;
  89.   }
  90. }
  91.  
  92.  
  93. static void MUIinit(void)
  94. {
  95.   if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN))) {
  96.     usegui = FALSE;
  97.     Fatal(15, MSG_NO_LIBRARY, MUIMASTER_NAME, MUIMASTER_VMIN);
  98.   }
  99.   
  100.   NewList(&MessageList);
  101.  
  102.   CYA_Seiten[0] = GetTeXString(MSG_MUI_MW_SEITEN_ALL);
  103.   CYA_Seiten[1] = GetTeXString(MSG_MUI_MW_SEITEN_VONBIS);
  104. }
  105.  
  106.  
  107. static __inline char * GetTeXLabel(int id)
  108. {
  109.   return (GetTeXString(id) + 2);
  110. }
  111.  
  112. static __inline char GetTeXKey(int id)
  113. {
  114.   return *GetTeXString(id);
  115. }
  116.  
  117.  
  118.  
  119. /*
  120. **
  121. ** Message Window (Message/Warning/Fatal)
  122. **
  123. */
  124.  
  125. static void InitMUIMessageWindow(void)
  126. {
  127.   if (MUIAppObject && !MessWin) {
  128.     MessWin = WindowObject,
  129.     MUIA_Window_Title, GetTeXString(MSG_MUI_ME_WINTITLE),
  130.     MUIA_Window_ID,    MAKE_ID('M','E','S','S'),
  131.     (ArgPubname) ? MUIA_Window_PublicScreen : TAG_IGNORE, ArgPubname,
  132.     
  133.     WindowContents, VGroup,
  134.         Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, MUIA_FrameTitle, GetTeXString(MSG_MUI_ME_TITEL), End,
  135.         Child, LV_Messages = ListviewObject,
  136.                     MUIA_Listview_Input,    FALSE,
  137.                     MUIA_Listview_List,    ListObject,
  138.                     ReadListFrame,
  139.                      End, End,
  140.         Child, TX_MessLine = TextObject, TextFrame, MUIA_Text_Contents, LangerString, MUIA_Background, MUII_TextBack,MUIA_InputMode, MUIV_InputMode_None, End,
  141.         Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  142.         Child, HGroup,
  143.             Child, HSpace(0),
  144.             Child, HSpace(20),
  145.             Child, BT_CloseMess = SimpleButton(GetTeXString(MSG_MUI_ME_CLOSE)),
  146.             Child, HSpace(20),
  147.             Child, HSpace(0),
  148.                End,
  149.         End,
  150.     End;
  151.  
  152.     if (!MessWin) Fatal(10, MSG_MUI_MW_APP_FAIL);
  153.  
  154.     DoMethod(MUIAppObject, OM_ADDMEMBER, MessWin);
  155.  
  156.     DoMethod(MessWin,MUIM_Notify,MUIA_Window_CloseRequest,TRUE, MessWin, 3, MUIM_Set, MUIA_Window_Open, FALSE);
  157.     DoMethod(BT_CloseMess, MUIM_Notify, MUIA_Pressed, FALSE, MessWin, 3, MUIM_Set, MUIA_Window_Open, FALSE);
  158.   }
  159. }
  160.  
  161. void MUIShowMessWin(void)
  162. {
  163.   static int notfirst = FALSE;        // ueberspringe die Copyright-Warnung
  164.   long open;
  165.  
  166.   if (!notfirst) {
  167.     notfirst = TRUE;
  168.   }
  169.   else {
  170.     InitMUIMessageWindow();
  171.  
  172.     get(MessWin,MUIA_Window_Open,&open);  
  173.     if (!open) set(MessWin, MUIA_Window_Open, TRUE);
  174.   }
  175. }
  176.  
  177. void MUIMessage(char * str)
  178. {
  179.   char * ptr, * old;
  180.   struct ListEntry * Entry;
  181.   
  182.   if (!MUIMasterBase || !MUIAppObject) {
  183.     usegui = FALSE;
  184.     return;
  185.   }
  186.  
  187.   // alle newlines wegloeschen (fuehrendes ueberspringen, restlichen ersetzen)
  188.   if (*str == '\n') str++;
  189.   while (ptr = strchr(str, '\n')) *ptr = ' ';
  190.  
  191.   InitMUIMessageWindow();
  192.  
  193.     
  194.   get(TX_MessLine, MUIA_Text_Contents, &old);
  195.  
  196.   if(Entry = (struct ListEntry *)malloc(sizeof(struct ListEntry) + strlen(old) + 1)) {
  197.     Entry -> Title = (STRPTR)(Entry + 1);
  198.     strcpy(Entry -> Title, old);
  199.     AddTail(&MessageList,(struct Node *)Entry);
  200.  
  201.     DoMethod(LV_Messages, MUIM_List_Insert, &Entry -> Title, 1, MUIV_List_Insert_Bottom);
  202.     set(LV_Messages,MUIA_List_Active,MUIV_List_Active_Bottom);
  203.   }
  204.  
  205.   set(TX_MessLine, MUIA_Text_Contents, str);
  206. }
  207.  
  208.  
  209.  
  210. /*
  211. **
  212. ** Working Window
  213. **
  214. */
  215.  
  216. void InitMUIWorkWindow(void)
  217. {
  218.   APTR BT_SeeMess;
  219.  
  220.   if (MUIAppObject && !WorkWin) {
  221.    WorkWin = WindowObject,
  222.     MUIA_Window_Title, GetTeXString(MSG_MUI_WO_WINTITLE),
  223.     MUIA_Window_ID,    MAKE_ID('W','O','R','K'),
  224.     (ArgPubname) ? MUIA_Window_PublicScreen : TAG_IGNORE, ArgPubname,
  225.     
  226.     WindowContents, VGroup,
  227.         Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, MUIA_FrameTitle, GetTeXString(MSG_MUI_WO_TITEL), End,
  228.         Child, HGroup,
  229.             Child, TX_PrintLine = TextObject, TextFrame, MUIA_Text_Contents, LangerString, MUIA_Background, MUII_TextBack, MUIA_InputMode, MUIV_InputMode_None, End,
  230.             Child, BT_SeeMess = SimpleButton(GetTeXString(MSG_MUI_WO_SEEMESS)), MUIA_Weight, 5,
  231.             End,
  232.         Child, GA_Gauge = GaugeObject, GaugeFrame, MUIA_Gauge_Horiz, TRUE, MUIA_Gauge_InfoText, "", End,
  233.         Child, ScaleObject, End,
  234.         Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  235.         Child, HGroup,
  236.             Child, HSpace(0),
  237.             Child, BT_WorkAbbruch = SimpleButton(GetTeXString(MSG_MUI_MW_CANCEL)),
  238.             Child, HSpace(0),
  239.             End,
  240.         End,
  241.     End;
  242.  
  243.     if (!WorkWin) Fatal(10, MSG_MUI_MW_APP_FAIL);
  244.  
  245.     DoMethod(MUIAppObject, OM_ADDMEMBER, WorkWin);
  246.  
  247.     DoMethod(WorkWin,MUIM_Notify,MUIA_Window_CloseRequest,TRUE, MUIAppObject, 2, MUIM_Application_ReturnID, CancelPrintID);
  248.     DoMethod(BT_WorkAbbruch, MUIM_Notify, MUIA_Pressed, FALSE, MUIAppObject, 2, MUIM_Application_ReturnID, CancelPrintID);
  249.     
  250.     InitMUIMessageWindow();
  251.     DoMethod(BT_SeeMess, MUIM_Notify, MUIA_Pressed, FALSE, MessWin, 3, MUIM_Set, MUIA_Window_Open, TRUE);
  252.     
  253.     set(WorkWin, MUIA_Window_Open, TRUE);
  254.   }
  255. }
  256.  
  257. static void MUISetWorkString(void)
  258. {
  259.   char * ptr, * startstr, * endstr;
  260.   char sarr[16], earr[16];
  261.   char s[170];
  262.  
  263.   InitMUIMessageWindow();
  264.   
  265.   ptr = FilePart(filename);
  266.   
  267.   if (FirstPage == -1000000L && LastPage  == 1000000L) {
  268.     sprintf(s, "%s, %s", ptr, GetTeXString(MSG_MUI_WORK_DOALL));
  269.   }
  270.   else {
  271.     if (FirstPage == -1000000L) {
  272.       startstr = GetTeXString(MSG_MUI_WORK_START);
  273.     }
  274.     else {
  275.       sprintf(sarr, "%ld", FirstPage);
  276.       startstr = sarr;
  277.     }
  278.  
  279.     if (LastPage == 1000000L) {
  280.       endstr = GetTeXString(MSG_MUI_WORK_END);
  281.     }
  282.     else {
  283.       sprintf(earr, "%ld", LastPage);
  284.       endstr = earr;
  285.     }
  286.  
  287.     sprintf(s,"%s, %s %s %s %s", ptr, GetTeXString(MSG_MUI_WORK_FROM), startstr, GetTeXString(MSG_MUI_WORK_TO), endstr);
  288.   }
  289.   
  290.   set(TX_PrintLine, MUIA_Text_Contents, s);
  291. }
  292.  
  293.  
  294. void MUISetWorkCurPage(int pagenum)
  295. {
  296.   if (WorkWin) {
  297.     static char ptr[50];
  298.  
  299.     sprintf(ptr, "%s %ld", GetTeXString(MSG_MUI_WORK_PAGE), pagenum);
  300.     set(GA_Gauge, MUIA_Gauge_InfoText, ptr);
  301.   }
  302.   
  303.   MUIEvent();
  304. }
  305.  
  306.  
  307. void MUISetGauge(int lines)
  308. {
  309.   if (WorkWin) {
  310.     int proz = (lines * 100) / paper_height;
  311.     
  312.     if (proz > 100) proz = 100;
  313.   
  314.     set(GA_Gauge, MUIA_Gauge_Current, proz);
  315.   }
  316.  
  317.   MUIEvent();
  318. }
  319.  
  320.  
  321.  
  322.  
  323.  
  324. /*
  325. **
  326. ** Fatal-Window
  327. **
  328. */
  329.  
  330. void MUIFatal(char * str)
  331. {
  332.   int running = TRUE;
  333.  
  334.   if (!MUIMasterBase || !MUIAppObject) {
  335.     usegui = FALSE;
  336.     return;
  337.   }
  338.  
  339.   if (!FatalWin) {
  340.     FatalWin = WindowObject,
  341.     MUIA_Window_Title, GetTeXString(MSG_MUI_FA_WINTITLE),
  342.     MUIA_Window_ID,    MAKE_ID('F','A','T','A'),
  343.     (ArgPubname) ? MUIA_Window_PublicScreen : TAG_IGNORE, ArgPubname,
  344.     
  345.     WindowContents, VGroup,
  346.         Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, MUIA_FrameTitle, GetTeXString(MSG_MUI_FA_TITEL), End,
  347.         Child, TextObject, TextFrame, MUIA_Text_Contents, str, MUIA_Background, MUII_TextBack, MUIA_InputMode, MUIV_InputMode_None, End,
  348.         Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  349.         Child, HGroup,
  350.             Child, HSpace(0),
  351.             Child, BT_FatalAbbruch = SimpleButton(GetTeXString(MSG_MUI_MW_CANCEL)),
  352.             Child, HSpace(0),
  353.             End,
  354.         End,
  355.     End;
  356.  
  357.     if (!FatalWin) AbortRun(20);    // hier *kein* Fatal!
  358.  
  359.     DoMethod(MUIAppObject, OM_ADDMEMBER, FatalWin);
  360.  
  361.     DoMethod(FatalWin,MUIM_Notify,MUIA_Window_CloseRequest,TRUE, MUIAppObject, 2, MUIM_Application_ReturnID, FatalID);
  362.     DoMethod(BT_FatalAbbruch, MUIM_Notify, MUIA_Pressed, FALSE, MUIAppObject, 2, MUIM_Application_ReturnID, FatalID);
  363.   }
  364.  
  365.   set(MainWin, MUIA_Window_Sleep, TRUE);
  366.   if (WorkWin) set(WorkWin, MUIA_Window_Sleep, TRUE);
  367.   if (MessWin) set(MessWin, MUIA_Window_Sleep, TRUE);
  368.  
  369.   set(FatalWin,MUIA_Window_Open,TRUE);
  370.  
  371.   while (running) {
  372.     ULONG retsig = 0L;
  373.  
  374.     switch (DoMethod(MUIAppObject,MUIM_Application_Input,&GUIsignals)) {
  375.  
  376.         case FatalID:
  377.             running = FALSE;
  378.             break;
  379.     }
  380.  
  381.         if (running && GUIsignals) {
  382.           PROFILE_OFF();
  383.           retsig = Wait(GUIsignals | SIGBREAKF_CTRL_C);
  384.           PROFILE_ON();
  385.         }
  386.  
  387.         if (retsig & SIGBREAKF_CTRL_C) running = FALSE;
  388.   }
  389.  
  390.   set(FatalWin,MUIA_Window_Open,FALSE);
  391. }
  392.  
  393.  
  394.  
  395. /*
  396. **
  397. ** Main-Window
  398. **
  399. */
  400.  
  401. void MUImainwin(void)
  402. {
  403.   APTR MainWin, POP_DVIfile, CY_Seiten, ST_von, ST_bis, ST_num, ST_kopien, BT_pref, BT_print, BT_cancel;
  404.   BOOL running = TRUE;
  405.   BOOL startprint = FALSE;
  406.   
  407.   (void)ParsePatternNoCase("#?.dvi", DVIpattern, sizeof(DVIpattern));
  408.  
  409.   MUIinit();
  410.  
  411.   MUIAppObject = ApplicationObject,
  412.         MUIA_Application_Title      , "DVIprint",
  413.         MUIA_Application_Version    , VersionStr,
  414.         MUIA_Application_Copyright  , "©1990-94, Georg Heßmann. All Rights Reserved.",
  415.         MUIA_Application_Author     , "Georg Heßmann",
  416.         MUIA_Application_Description, GetTeXString(MSG_MUI_MW_DESCRIPTION),
  417.         MUIA_Application_Base       , "DVIPRINT",
  418.  
  419.         SubWindow, MainWin = WindowObject,
  420.             MUIA_Window_Title, "DVIprint",
  421.             MUIA_Window_ID   , MAKE_ID('M','W','I','N'),
  422.             (ArgPubname) ? MUIA_Window_PublicScreen : TAG_IGNORE, ArgPubname,
  423.  
  424.             WindowContents, VGroup,
  425.             
  426.                 Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, MUIA_FrameTitle, GetTeXString(MSG_MUI_MW_TITEL), End,
  427.                 
  428.                 Child, HGroup,
  429.                     Child, KeyLabel2(GetTeXLabel(MSG_MUI_MW_DVIFILE),GetTeXKey(MSG_MUI_MW_DVIFILE)),
  430.                     Child, POP_DVIfile = PopaslObject,
  431.                         MUIA_Popstring_String, KeyString(filename,256,GetTeXKey(MSG_MUI_MW_DVIFILE)),
  432.                         MUIA_Popstring_Button, PopButton(MUII_PopFile),
  433.                         ASLFR_TitleText, GetTeXString(MSG_MUI_MW_ASL_DVIFILE),
  434.                         ASLFR_RejectIcons, TRUE,
  435.                         ASLFR_AcceptPattern, DVIpattern,
  436.                         End,
  437.                         End,
  438.                 Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  439.                 Child, ColGroup(2),
  440.                     Child, KeyLabel1(GetTeXLabel(MSG_MUI_MW_SEITEN), GetTeXKey(MSG_MUI_MW_SEITEN)), Child, CY_Seiten = KeyCycle(CYA_Seiten, GetTeXKey(MSG_MUI_MW_SEITEN)),
  441.                     Child, HSpace(0),     Child, ColGroup(4), 
  442.                                       Child, KeyLLabel2(GetTeXLabel(MSG_MUI_MW_VON), GetTeXKey(MSG_MUI_MW_VON)), 
  443.                                       Child, ST_von = StringObject, MUIA_ControlChar, GetTeXKey(MSG_MUI_MW_VON), MUIA_String_Accept, "1234567890", MUIA_String_MaxLen, 5, StringFrame, End,
  444.                                       Child, KeyLLabel2(GetTeXLabel(MSG_MUI_MW_BIS), GetTeXKey(MSG_MUI_MW_BIS)), 
  445.                                       Child, ST_bis = StringObject, MUIA_ControlChar, GetTeXKey(MSG_MUI_MW_BIS), MUIA_String_Accept, "1234567890", MUIA_String_MaxLen, 5, StringFrame, End,
  446.                                       End,
  447.                     Child, HSpace(0),     Child, HSpace(0),
  448.                     Child, KeyLabel2(GetTeXLabel(MSG_MUI_MW_NUM), GetTeXKey(MSG_MUI_MW_NUM)), Child, HGroup,
  449.                             Child, ST_num = StringObject, MUIA_ControlChar, GetTeXKey(MSG_MUI_MW_NUM), StringFrame, MUIA_Weight, 90, MUIA_String_Accept, "1234567890", MUIA_String_MaxLen, 5, End, 
  450.                             Child, HSpace(0),
  451.                             Child, KeyLabel2(GetTeXLabel(MSG_MUI_MW_KOPIEN), GetTeXKey(MSG_MUI_MW_KOPIEN)), Child, ST_kopien = StringObject, MUIA_ControlChar, GetTeXKey(MSG_MUI_MW_KOPIEN), StringFrame, MUIA_Weight, 50, MUIA_String_Integer, 1, MUIA_String_Accept, "1234567890", MUIA_String_MaxLen, 5, End, 
  452.                             End,
  453.                        End,
  454.                 Child, RectangleObject, MUIA_Rectangle_HBar, TRUE, MUIA_FixHeight, 8, End,
  455.                 Child, HGroup, MUIA_Group_SameSize, TRUE,
  456.                     Child, BT_print  = SimpleButton(GetTeXString(MSG_MUI_MW_DRUCKEN)),
  457.                     Child, BT_pref = SimpleButton(GetTeXString(MSG_MUI_MW_PREF)),
  458.                     Child, BT_cancel = SimpleButton(GetTeXString(MSG_MUI_MW_CANCEL)),
  459.                     End,
  460.                 End,
  461.             End,
  462.         End;
  463.  
  464.   if (!MUIAppObject) {
  465.     usegui = FALSE;
  466.     Fatal(10, MSG_MUI_MW_APP_FAIL);
  467.   }
  468.  
  469.  
  470.  
  471. /*
  472. ** Aktionen auf Button legen
  473. */
  474.  
  475.   DoMethod(MainWin,MUIM_Notify,MUIA_Window_CloseRequest,TRUE, MUIAppObject,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  476.   DoMethod(BT_cancel,MUIM_Notify,MUIA_Pressed,FALSE, MUIAppObject,2,MUIM_Application_ReturnID,MUIV_Application_ReturnID_Quit);
  477.   DoMethod(BT_pref,MUIM_Notify,MUIA_Pressed,FALSE, MUIAppObject,2,MUIM_Application_ReturnID, PrefsID);
  478.   DoMethod(BT_print,MUIM_Notify,MUIA_Pressed,FALSE, MUIAppObject,2,MUIM_Application_ReturnID, PrintID);
  479.   
  480.   set(BT_pref, MUIA_Disabled, TRUE);    // ist noch nicht implementiert
  481.  
  482.  
  483.  
  484.  
  485. /*
  486. ** Defaultwerte nach den Optionen setzen
  487. */
  488.  
  489.   /*
  490.   ** Setzen der MainWindow Werte
  491.   */
  492.   if (FirstPage != -1000000L) {
  493.     set(ST_von, MUIA_String_Integer, FirstPage);
  494.     set(CY_Seiten, MUIA_Cycle_Active, 1);
  495.   }
  496.   if (LastPage  != 1000000L) {
  497.     set(ST_bis, MUIA_String_Integer, LastPage);
  498.     set(CY_Seiten, MUIA_Cycle_Active, 1);
  499.   }
  500.   if (NrOfPagesToPrint != 1000000L) {
  501.     set(ST_num, MUIA_String_Integer, NrOfPagesToPrint);
  502.   }
  503.   set(ST_kopien, MUIA_String_Integer, ncopies);
  504.  
  505.  
  506. /*
  507. ** CY_Seiten -- ST_von -- ST_bis handling
  508. */
  509.  
  510.   DoMethod(ST_von, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, CY_Seiten, 3, MUIM_Set, MUIA_Cycle_Active, 1);
  511.   DoMethod(ST_bis, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, CY_Seiten, 3, MUIM_Set, MUIA_Cycle_Active, 1);
  512.  
  513.   DoMethod(CY_Seiten, MUIM_Notify, MUIA_Cycle_Active, 0, ST_von, 3, MUIM_Set, MUIA_Disabled, TRUE);
  514.   DoMethod(CY_Seiten, MUIM_Notify, MUIA_Cycle_Active, 0, ST_bis, 3, MUIM_Set, MUIA_Disabled, TRUE);
  515.   DoMethod(CY_Seiten, MUIM_Notify, MUIA_Cycle_Active, 0, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, NULL); // diese Zeile ist notwendig, weil MUI auch disablede Gadgets aktiviert :-(
  516.   DoMethod(CY_Seiten, MUIM_Notify, MUIA_Cycle_Active, 1, ST_von, 3, MUIM_Set, MUIA_Disabled, FALSE);
  517.   DoMethod(CY_Seiten, MUIM_Notify, MUIA_Cycle_Active, 1, ST_bis, 3, MUIM_Set, MUIA_Disabled, FALSE);
  518.   DoMethod(CY_Seiten, MUIM_Notify, MUIA_Cycle_Active, 1, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, ST_von);
  519.   
  520.   { 
  521.     long ac;
  522.     get(CY_Seiten, MUIA_Cycle_Active, &ac);
  523.     if (ac == 0) {
  524.       nnset(ST_von, MUIA_Disabled, TRUE);
  525.       nnset(ST_bis, MUIA_Disabled, TRUE);
  526.     }
  527.   }
  528.  
  529.  
  530. /*
  531. ** set cycle-chain 
  532. */
  533.  
  534.   DoMethod(MainWin, MUIM_Window_SetCycleChain, POP_DVIfile, CY_Seiten, ST_von, ST_bis, ST_num, ST_kopien, BT_print, BT_pref, BT_cancel, NULL);
  535.  
  536.   // RETURN cycle
  537.   DoMethod(POP_DVIfile, MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, CY_Seiten);
  538.   DoMethod(ST_von,      MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, ST_bis);
  539.   DoMethod(ST_bis,      MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, ST_num);
  540.   DoMethod(ST_num,      MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, ST_kopien);
  541.   DoMethod(ST_kopien,   MUIM_Notify, MUIA_String_Acknowledge, MUIV_EveryTime, MainWin, 3, MUIM_Set, MUIA_Window_ActiveObject, BT_print);
  542.  
  543.  
  544.  
  545.  
  546. /*
  547. ** Input loop...
  548. */
  549.  
  550.   set(MainWin,MUIA_Window_Open,TRUE);
  551.  
  552.  
  553.   while (running && !startprint) {
  554.         ULONG retsig = 0L;
  555.  
  556.         switch (DoMethod(MUIAppObject,MUIM_Application_Input,&GUIsignals))
  557.         {
  558.             case MUIV_Application_ReturnID_Quit:
  559.                 running = FALSE;
  560.                 break;
  561.             case PrefsID:
  562.                 break;
  563.             case PrintID:
  564.                 set(MainWin, MUIA_Window_Sleep, TRUE);
  565.                 startprint = TRUE;
  566.                 break;
  567.             case CancelPrintID:
  568.                 // kann eigentlich nicht vorkommen
  569.                 running = FALSE;
  570.                 break;
  571.         }
  572.  
  573.             if (running && !startprint && GUIsignals) {
  574.               PROFILE_OFF();
  575.                   retsig = Wait(GUIsignals | SIGBREAKF_CTRL_C);
  576.                   PROFILE_ON();
  577.                 }
  578.  
  579.             if (retsig & SIGBREAKF_CTRL_C) running = FALSE;
  580.   }
  581.  
  582.   set(MainWin,MUIA_Window_Open,FALSE);  // gut oder nicht??
  583.  
  584.  
  585.  
  586.  
  587. /*
  588. **
  589. ** Die Variablen nach den Werten in den Gadgets setzen
  590. **
  591. */
  592.  
  593.   { char * ptr = NULL;
  594.  
  595.     get(ST_von, MUIA_String_Contents, &ptr);
  596.     if (ptr && *ptr) get(ST_von, MUIA_String_Integer, &FirstPage);
  597.     else FirstPage = -1000000L;
  598.  
  599.     get(ST_bis, MUIA_String_Contents, &ptr);
  600.     if (ptr && *ptr) get(ST_bis, MUIA_String_Integer, &LastPage);
  601.     else LastPage = 1000000L;
  602.  
  603.     get(ST_num, MUIA_String_Contents, &ptr);
  604.     if (ptr && *ptr) get(ST_num, MUIA_String_Integer, &NrOfPagesToPrint);
  605.     else NrOfPagesToPrint = 1000000L;
  606.  
  607.     get(ST_kopien, MUIA_String_Integer, &ncopies);
  608.     if (ncopies < 1) ncopies = 1;
  609.  
  610.     get(POP_DVIfile, MUIA_String_Contents, &ptr);
  611.     strcpy(filename, ptr);
  612.   }
  613.   
  614.   if (running) {
  615.     InitMUIWorkWindow();
  616.     MUISetWorkString();
  617.   }
  618.   else {
  619.     CXBRK();
  620.   }
  621.  
  622. }
  623.  
  624.  
  625. void MUIEvent(void)
  626. {
  627.   switch (DoMethod(MUIAppObject,MUIM_Application_Input,&GUIsignals)) {
  628.     case MUIV_Application_ReturnID_Quit:
  629.     case CancelPrintID:
  630.         CXBRK();    /* mach Schluss Mann, ey */
  631.         break;
  632.     case PrefsID:
  633.     case PrintID:
  634.         // kann nicht sein
  635.         break;
  636.   }
  637. }
  638.  
  639.  
  640.