home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d5xx / d570 / view.lha / View / main.c < prev    next >
C/C++ Source or Header  |  1991-11-21  |  51KB  |  1,720 lines
  1. /*-- AutoRev header do NOT edit!
  2. *
  3. *   Program         :   main.c
  4. *   Copyright       :   © 1991 Jaba Development
  5. *   Author          :   Jan van den Baard
  6. *   Creation Date   :   21-Apr-91
  7. *   Current version :   1.5
  8. *   Translator      :   DICE v2.6
  9. *
  10. *   REVISION HISTORY
  11. *
  12. *   Date          Version         Comment
  13. *   ---------     -------         ------------------------------------------
  14. *   17-Sep-91     1.5             Changed input-handler to commodity broker.
  15. *   16-Sep-91     1.4             Added mini line editor.
  16. *   16-Sep-91     1.4             Added text save option.
  17. *   16-Sep-91     1.4             Added pattern gadget in FileRequesters.
  18. *   23-Aug-91     1.3             View now support ECS screen modes.
  19. *   12-Aug-91     1.2             Added Save text block option.
  20. *   12-Aug-91     1.2             Search now from top-line.
  21. *   03-Jul-91     1.1             Removed Enforcer hits!
  22. *   03-Jul-91     1.1             Fixed bug in decrunch routine!
  23. *   21-Apr-91     1.0             View main program. OS 2 ONLY!
  24. *
  25. *-- REV_END --*/
  26.  
  27. #include "view.h"
  28.  
  29. /*
  30.  * Function proto-types.
  31.  */
  32. long OpenConsole( void );
  33. void CloseConsole( void );
  34. void Quit( long );
  35. void Inform( char * );
  36. void Display( struct Line * );
  37. void CheckDir( UBYTE * );
  38. void LoadFile( long );
  39. void DisplayText( void );
  40. void MoveTo( UBYTE, UBYTE );
  41. void LineDown( void );
  42. void LineUp( void );
  43. void Top( void );
  44. void Bottom( void );
  45. void PageUp( void );
  46. void PageDown( void );
  47. void Percentage( void );
  48. void BytesShown( void );
  49. void InfoLine( void );
  50. void ErrorLine( UBYTE * );
  51. void WaitKey( void );
  52. void Help( void );
  53. long CountEsc( struct Line *, long );
  54. void DoFound( void );
  55. void PrintFound( UWORD );
  56. void GetSomething( ULONG );
  57. void FindN( void );
  58. void FindP( void );
  59. void EditFile( void );
  60. void PrintFile( void );
  61. __geta4 void PrintProc( void );
  62. long IsItADir( void );
  63. long CheckPP( void );
  64. long CheckBlock( UWORD );
  65. long ParseName( char * );
  66. void SetMark( UWORD );
  67. void UnSetMark( UWORD );
  68. void JumpMark( UWORD );
  69. void SaveBlock( WORD );
  70. void EditLine( void );
  71. void SetupComm( void );
  72. void QuitComm( void );
  73. void OpenLibs( void );
  74. void OpenDisplay( void );
  75. void CloseDisplay( void );
  76. void GetRequest( void );
  77. void MainLoop( void );
  78. void myMain( BOOL );
  79.  
  80. /*
  81.  * External function proto-types.
  82.  */
  83. extern void _waitwbmsg( void );
  84. extern void _exit( int );
  85. extern void ConvertKeyTab( void );
  86. extern void HandleKeyboard( UWORD, UWORD );
  87. extern long HandleMsg( struct MsgPort * );
  88. extern void ClearMsg( struct MsgPort * );
  89.  
  90. /*
  91.  * Macros.
  92.  */
  93. #define MAXCOL(w,f)     (w->Width  / f->tf_XSize)
  94. #define CLRLIN()        SetAPen(VW_rport,2); RectFill(VW_rport,0,0,VW_wnd->Width,VW_font->tf_YSize-1);
  95. #define CLRBLK()        setmem(&VW_blk[0],(10*sizeof(struct TextBlock)),0);
  96. #define CxOn(b)         ActivateCxObj(b,TRUE);
  97. #define CxOff(b)        ActivateCxObj(b,FALSE);
  98. #define BitMask(b)      ( 1L << ((ULONG)b) )
  99.  
  100. /*
  101.  * Workbench message.
  102.  */
  103. extern struct WBStartup *_WBMsg;
  104.  
  105. /*
  106.  * Commodity data.
  107.  */
  108. UBYTE                   *CX_PRIORITY      = "PRIORITY";
  109. UBYTE                   *CX_POPWINDOW     = "POPWINDOW";
  110. UBYTE                   *CX_VIEW          = "VIEW";
  111. UBYTE                   *CX_FLUSH         = "FLUSH";
  112. UBYTE                   *CX_QUIT          = "QUIT";
  113.  
  114. UWORD                    CX_DEF_PRIORITY  = 0;
  115. UBYTE                   *CX_DEF_POPWINDOW = "YES";
  116. UBYTE                   *CX_DEF_VIEW      = "lalt lcommand v";
  117. UBYTE                   *CX_DEF_FLUSH     = "lalt lcommand f";
  118. UBYTE                   *CX_DEF_QUIT      = "lalt lcommand q";
  119.  
  120. #define                  CX_VERSION         "1.5"
  121. #define                  CX_NAME            "View"
  122. #define                  CX_DESCRIPTION     "Ascii text file viewer."
  123. #define                  CX_COPYRIGHT       "© 1991 Jaba Development"
  124. #define                  CX_TITLE           CX_NAME " " CX_VERSION ", " CX_COPYRIGHT
  125.  
  126. #define                  CXC_VIEW           1L
  127. #define                  CXC_FLUSH          2L
  128. #define                  CXC_QUIT           3L
  129.  
  130. UBYTE                   *VW_vers   = "\0$VER: View © 1991 Jaba Development -- v1.5";
  131.  
  132. struct MsgPort          *VW_cxport = NULL;
  133. struct MsgPort          *VW_idport = NULL;
  134.  
  135. ULONG                    VW_cxmask = NULL;
  136. ULONG                    VW_idmask = NULL;
  137.  
  138. UWORD                    VW_dopen  = FALSE;
  139. UWORD                    VW_isopen = FALSE;
  140. UWORD                    VW_fsu    = TRUE;
  141.  
  142. CxObj                   *VW_broker = NULL;
  143. CxObj                   *VW_view, *VW_flush, *VW_quit;
  144.  
  145. UBYTE                   *VW_quitstr, *VW_flushstr, *VW_viewstr, *VW_namestr;
  146.  
  147. struct NewBroker         VW_newbroker = {
  148.     NB_VERSION, CX_NAME, CX_TITLE, CX_DESCRIPTION,
  149.     NBU_NOTIFY | NBU_UNIQUE, COF_SHOW_HIDE, NULL, 0
  150. };
  151.  
  152. /*
  153.  * Main program data.
  154.  */
  155. struct MsgPort          *VW_cport = NULL;
  156. struct IOStdReq         *VW_creq  = NULL;
  157. struct Window           *VW_wnd   = NULL;
  158. struct Screen           *VW_scr   = NULL;
  159. struct AsciiText        *VW_text  = NULL;
  160. struct FileRequester    *VW_freq  = NULL, *VW_save = NULL;
  161. struct RastPort         *VW_rport;
  162. struct TextFont         *VW_font;
  163. struct Line             *VW_first;
  164. struct Line             *VW_last;
  165.  
  166. APTR                     VW_wdptr;
  167. struct Process          *VW_proc;
  168.  
  169. struct RDArgs            VW_iargs = { { 0,0,0 },0,0,0,0,RDAF_NOPROMPT };
  170. struct RDArgs           *VW_fargs = 0L;
  171. struct StringScan        VW_search;
  172. struct TextBlock         VW_blk[10];
  173.  
  174. ULONG                    VW_args[7] = { 0,0,0,0,0,0,0 };
  175.  
  176. BOOL                     VW_found = FALSE, VW_printing = FALSE;
  177. BOOL                     VW_err = TRUE;
  178. ULONG                    VW_class, VW_signal, VW_shown;
  179. UWORD                    VW_code, VW_id, VW_qual, VW_ymax;
  180. UWORD                    VW_mode, VW_pmode, VW_maxlin, VW_pmark;
  181. UWORD                    DriPens = ~0;
  182. LONG                     VW_num;
  183.  
  184. UBYTE                    VW_name[256];
  185. UBYTE                    VW_fbuf[256];
  186. UBYTE                    VW_patt[32] = "#?";
  187.  
  188. UBYTE                    NullStr     = 0; /* no Enforcer complaints */
  189. UBYTE                   *Template  = "Name,PRIORITY/n,POPWINDOW/k,VIEW/k,FLUSH/k,QUIT/k";
  190. UBYTE                   *GetString = "Type string :";
  191. UBYTE                   *GetLong   = "Type percentage:";
  192. UBYTE                   *Lines[]   = { "ViewSleepy", "Out of memory !",
  193.                                        "Searching...", "ViewPrinting",
  194.                                        "Block %-2.2ld not marked !"
  195.                                      };
  196.  
  197. UBYTE                   *Dir   = 0L, *SDir = 0L;
  198. UBYTE                   *File  = 0L, *SFile = 0L;
  199.  
  200. Tag StringTags[] = {
  201.     GTST_String, VW_fbuf, GTST_MaxChars, 256, TAG_DONE };
  202.  
  203. Tag StringTags1[] = {
  204.     GTST_String, 0L, GTST_MaxChars, 0L, TAG_DONE };
  205.  
  206. struct StringExtend se = {
  207.     NULL,1,2,1,3,NULL,NULL,NULL,0,0,0,0 };
  208.  
  209. Tag IntegerTags[] = {
  210.     GTIN_Number, 0, GTIN_MaxChars,3, TAG_DONE };
  211.  
  212. Tag NewScreenTags[] = {
  213.     SA_Pens, &DriPens, SA_DisplayID, NULL, SA_Overscan, OSCAN_TEXT, TAG_DONE };
  214.  
  215. Tag NewWindowTags[] = {
  216.     WA_InnerWidth, 200, WA_InnerHeight, 12, TAG_DONE };
  217.  
  218. Tag NewWindowTags1[] = {
  219.     WA_InnerWidth, 320, WA_InnerHeight, 12, TAG_DONE };
  220.  
  221. Tag NewWindowTags2[] = {
  222.     WA_RptQueue, 1, TAG_DONE };
  223.  
  224. Tag RequestTags[] = {
  225.     ASL_LeftEdge, 20, ASL_TopEdge, 15, ASL_Width, 300, ASL_Height, 175,
  226.     ASL_OKText, "Load", ASL_FuncFlags, FILF_PATGAD, TAG_DONE };
  227.  
  228. Tag RequestTags1[] = {
  229.     ASL_LeftEdge, 20, ASL_TopEdge, 15, ASL_Width, 300, ASL_Height, 175,
  230.     ASL_OKText, "Save", ASL_FuncFlags, FILF_PATGAD | FILF_SAVE, TAG_DONE };
  231.  
  232. Tag RequestTags2[] = {
  233.     ASL_Window, NULL, ASL_Dir, 0L, ASL_File, 0L,
  234.     ASL_Pattern, &VW_patt[0], ASL_Hail, 0L, TAG_DONE };
  235.  
  236. Tag ProcessTags[] = {
  237.     NP_Entry, NULL, NP_StackSize, 4096L, NP_Name, "ViewPrinting", TAG_DONE };
  238.  
  239. struct NewScreen         ns = {
  240.     0,0,640,200,2,-1,-1,HIRES,CUSTOMSCREEN,NULL,NULL,NULL,NULL };
  241.  
  242. struct NewWindow         nw = {
  243.     0,0,640,200,-1,-1,IDCMP_RAWKEY,
  244.     WFLG_ACTIVATE+WFLG_RMBTRAP+WFLG_SMART_REFRESH+WFLG_BORDERLESS+WFLG_BACKDROP,
  245.     NULL,NULL,NULL,NULL,NULL,0,0,0,0,CUSTOMSCREEN };
  246.  
  247. struct NewWindow         nws = {
  248.     0,0,200,12,-1,-1,IDCMP_GADGETUP,
  249.     WFLG_RMBTRAP+WFLG_ACTIVATE+WFLG_SMART_REFRESH+WFLG_DRAGBAR,
  250.     NULL,NULL,NULL,NULL,NULL,0,0,0,0,CUSTOMSCREEN };
  251.  
  252. struct NewWindow         nwe = {
  253.     0,0,320,12,-1,-1,IDCMP_GADGETUP+IDCMP_CLOSEWINDOW,
  254.     WFLG_RMBTRAP+WFLG_CLOSEGADGET+WFLG_ACTIVATE+WFLG_SMART_REFRESH+WFLG_DRAGBAR,
  255.     NULL,NULL,(UBYTE *)"Edit Line",NULL,NULL,0,0,0,0,CUSTOMSCREEN };
  256.  
  257. struct NewWindow         nwp = {
  258.     0,0,138,11,-1,-1,IDCMP_CLOSEWINDOW,
  259.     WFLG_SMART_REFRESH+WFLG_RMBTRAP+WFLG_DRAGBAR+WFLG_CLOSEGADGET,
  260.     NULL,NULL,(UBYTE *)"Printing...",NULL,NULL,0,0,0,0,CUSTOMSCREEN };
  261.  
  262. struct TextAttr TOPAZ_80 = {
  263.     (STRPTR)"topaz.font",TOPAZ_EIGHTY,FS_NORMAL,FPF_ROMFONT };
  264.  
  265. UBYTE   *Header   = "  \033[0;1mView version " CX_VERSION " © 1991 Jaba Development\n"\
  266.                     "      \033[0;33mWritten with DICE C by Jan van den Baard\033[0m\n\n";
  267. UBYTE   *HelpText = " \033[32mSpace\033[0m,\033[32mPg Dn \033[33m \033[0m          : Page down (MORE).\n"\
  268.                     " \033[32mBackspace\033[0m,\033[32mPg Up\033[0m        : Page up (LESS).\n"\
  269.                     " \033[32mReturn\033[0m,\033[32mDn\033[0m,\033[32mNk Dn\033[0m        : Next line.\n"\
  270.                     " \033[32mEnter\033[0m,\033[32mUp\033[0m,\033[32mNk Up\033[0m         : Previous line.\n"\
  271.                     " \033[32m<\033[0m,\033[32mNk Left\033[0m/\033[32m>\033[0m,\033[32mNk Right\033[0m   : First/Last page (TOP/BOTTOM).\n"\
  272.                     " \033[32m/\033[0m,\033[32mF\033[0m                    : Find first (case sensitive).\n"\
  273.                     " \033[32mN\033[0m/\033[32mP\033[0m                    : Find next/previous (case sensitive).\n"\
  274.                     " \033[32m.\033[0m,\033[32mS\033[0m                    : Find first (case insensitive).\n"\
  275.                     " \033[32mCTRL+N\033[0m/\033[32mCTRL+P\033[0m          : Find next/previous (case insensitive).\n"\
  276.                     " \033[32mCTRL+L\033[0m,\033[32mR\033[0m               : Refresh display.\n"\
  277.                     " \033[32m%\033[0m                      : Goto N%.\n"\
  278.                     " \033[32mE\033[0m                      : Edit with ENV:EDITOR.\n"\
  279.                     " \033[32mL\033[0m                      : Load a new file.\n"\
  280.                     " \033[32mJ\033[0m                      : Jump to last found string.\n"\
  281.                     " \033[32mB\033[0m                      : Goto sleep (loose text).\n"\
  282.                     " \033[32mCTRL+B\033[0m                 : Goto sleep (remember text).\n"\
  283.                     " \033[32mLSHIFT+CTRL+D\033[0m/\033[32m+P\033[0m       : Dump page/file to printer.\n"\
  284.                     " \033[32mH\033[0m,\033[32mHELP\033[0m                 : Help page.\n"\
  285.                     " \033[32mQ\033[0m,\033[32mCTRL+C\033[0m,\033[32mESC\033[0m           : Quit view\n\n"\
  286.                     "    \033[31;1mPRESS A KEY FOR MORE";
  287. UBYTE   *HelpText1 = " \033[0;32mFn\033[0m                     : Mark text block #\033[32mn\033[0m.\n"\
  288.                      " \033[32mSHIFT+Fn\033[0m               : Unmark text block #\033[32mn\033[0m.\n"\
  289.                      " \033[32mCTRL+Fn\033[0m                : Jump to text block #\033[32mn\033[0m.\n"\
  290.                      " \033[32mLSHIFT+CTRL+Fn\033[0m         : Print text block #\033[32mn\033[0m.\n"\
  291.                      " \033[32mLALT+Fn\033[0m                : Save text block #\033[32mn\033[0m.\n"\
  292.                      " \033[32mCTRL+S\033[0m                 : Save whole text.\n"\
  293.                      " \033[32mSHIFT+E\033[0m                : Edit a line of text.\n\n"\
  294.                      "    \033[31;1mPRESS A KEY TO CONTINUE";
  295.  
  296. APTR                         ConsoleDevice = 0L;
  297. extern struct IntuitionBase *IntuitionBase;     /* AUTO INIT */
  298. extern struct GfxBase       *GfxBase;           /* AUTO INIT */
  299. extern struct AslBase       *AslBase;           /* AUTO INIT */
  300. extern struct GadToolsBase  *GadToolsBase;      /* AUTO INIT */
  301. extern struct UtilityBase   *UtilityBase;       /* AUTO INIT */
  302.  
  303. struct CxBase               *CxBase     = 0L;
  304. struct IconBase             *IconBase   = 0L;
  305. struct NoFragBase           *NoFragBase = 0L;
  306. struct PPBase               *PPBase     = 0L;
  307.  
  308. #define ESC                  0x1b
  309. #define CSI                  0x9b
  310. #define FF                   0x0c
  311.  
  312. char    MoveStr[]           = { CSI,0x00,0x00,0x3b,0x00,0x00,0x48,0x00 };
  313. char    ClearStr[]          = { 0x0c,0x00 };
  314. char    ScrUpStr[]          = { CSI,0x53,0x00 };
  315. char    ScrDnStr[]          = { CSI,0x54,0x00 };
  316. char    StdStr[]            = { ESC,0x63,CSI,0x30,0x20,0x70,CSI,0x00,0x38,0x79,0x00 };
  317. char    *ResStr             = "\033[0m";
  318. char    *FFStr              = "\033[7mF\033[0m";
  319.  
  320. long OpenConsole( void )
  321. {
  322.     if(!(VW_cport = CreateMsgPort()))
  323.         return FALSE;
  324.     if(!(VW_creq = (struct IOStdReq *)CreateIORequest(VW_cport, (long)sizeof(struct IOStdReq))))
  325.         return FALSE;
  326.  
  327.     VW_creq->io_Data        = (APTR)VW_wnd;
  328.     VW_creq->io_Length      = sizeof(struct Window);
  329.  
  330.     if(!OpenDevice("console.device",0,(struct IORequest *)VW_creq,0))
  331.         ConsoleDevice       = VW_creq->io_Device;
  332.     else
  333.         return FALSE;
  334.  
  335.     ConvertKeyTab();
  336.     Inform(StdStr);
  337.     return TRUE;
  338. }
  339.  
  340. void CloseConsole( void )
  341. {
  342.     if(ConsoleDevice) {
  343.         CloseDevice((struct IORequest *)VW_creq);
  344.         ConsoleDevice = 0L;
  345.     }
  346.     if(VW_creq) {
  347.         DeleteIORequest((struct IORequest *)VW_creq);
  348.         VW_creq = 0L;
  349.     }
  350.     if(VW_cport) {
  351.         DeleteMsgPort(VW_cport);
  352.         VW_cport = 0L;
  353.     }
  354. }
  355.  
  356. void OpenLibs( void )
  357. {
  358.     if(NOT(NoFragBase = (struct NoFragBase *)OpenLibrary("nofrag.library",NOFRAG_VERSION)))
  359.         Quit( RETURN_FAIL );
  360.     if(NOT(CxBase = (struct CxBase *)OpenLibrary("commodities.library",36L)))
  361.         Quit( RETURN_FAIL );
  362.     if(NOT(IconBase = (struct IconBase *)OpenLibrary("icon.library",36L)))
  363.         Quit( RETURN_FAIL );
  364.  
  365.     PPBase = (struct PPBase *)OpenLibrary("powerpacker.library",33L);
  366. }
  367.  
  368. void OpenDisplay( void )
  369. {
  370.     struct Screen *plock;
  371.  
  372.     if(!(plock = LockPubScreen("Workbench")))
  373.         Quit( RETURN_FAIL );
  374.  
  375.     ns.Width         = nw.Width  = plock->Width;
  376.     ns.Height        = nw.Height = plock->Height;
  377.     ns.ViewModes     = plock->ViewPort.Modes;
  378.     NewScreenTags[3] = GetVPModeID(&plock->ViewPort);
  379.  
  380.     UnlockPubScreen(NULL,plock);
  381.  
  382.     if(!(VW_scr = OpenScreenTagList(&ns,(struct TagItem *)&NewScreenTags[0])))
  383.         Quit( RETURN_FAIL );
  384.  
  385.     nw.Screen = VW_scr;
  386.     if(!(VW_wnd = OpenWindowTagList(&nw,(struct TagList *)&NewWindowTags2[0])))
  387.         Quit( RETURN_FAIL );
  388.  
  389.     ShowTitle(VW_scr,FALSE);
  390.  
  391.     VW_idport             = VW_wnd->UserPort;
  392.     VW_idmask             = BitMask( VW_idport->mp_SigBit );
  393.  
  394.     VW_proc               = FindTask(0L);
  395.     VW_wdptr              = VW_proc->pr_WindowPtr;
  396.     VW_proc->pr_WindowPtr = (APTR)VW_wnd;
  397.     VW_rport              = VW_wnd->RPort;
  398.     VW_font               = VW_rport->Font;
  399.     VW_maxlin             = (VW_wnd->Height / VW_font->tf_YSize) - 1;
  400.     sprintf((char *)&StdStr[7],"%02.2ldy",VW_font->tf_YSize);
  401.     if(!OpenConsole())
  402.         Quit( RETURN_FAIL );
  403.  
  404.     VW_isopen = TRUE;
  405.  
  406.     if(NOT VW_text) {
  407.         if(VW_fsu) {
  408.             if(VW_namestr) {
  409.                 if(!ParseName(VW_namestr))
  410.                     LoadFile(TRUE);
  411.                 else
  412.                     LoadFile(FALSE);
  413.             } else {
  414.                 VW_name[0] = 0;
  415.                 Dir  = (char *)&NullStr;
  416.                 File = (char *)&NullStr;
  417.                 LoadFile(TRUE);
  418.             }
  419.         } else
  420.             LoadFile(TRUE);
  421.     }
  422.     if(VW_text) {
  423.         DisplayText();
  424.         BytesShown();
  425.         InfoLine();
  426.     }
  427.     VW_fsu = FALSE;
  428. }
  429.  
  430. void CloseDisplay( void )
  431. {
  432.     CloseConsole();
  433.     if(VW_wnd) {
  434.         VW_proc->pr_WindowPtr = VW_wdptr;
  435.         CloseWindow(VW_wnd);
  436.         VW_wnd    = NULL;
  437.         VW_idport = NULL;
  438.         VW_idmask = NULL;
  439.     }
  440.     if(VW_scr) {
  441.         CloseScreen(VW_scr);
  442.         VW_scr = NULL;
  443.     }
  444.  
  445.     VW_isopen = FALSE;
  446. }
  447.  
  448. void GetRequest( void )
  449. {
  450.     if(!(VW_freq = AllocAslRequest(ASL_FileRequest,(struct TagItem *)&RequestTags[0])))
  451.         Quit( RETURN_FAIL );
  452.     if(!(VW_save = AllocAslRequest(ASL_FileRequest,(struct TagItem *)&RequestTags1[0])))
  453.         Quit( RETURN_FAIL );
  454.     CLRBLK();
  455. }
  456.  
  457. void Quit( long code )
  458. {
  459.     CloseDisplay();
  460.     QuitComm();
  461.  
  462.     if(VW_text)
  463.         FreeAscii(VW_text);
  464.     if(VW_freq)
  465.         FreeAslRequest(VW_freq);
  466.     if(VW_save)
  467.         FreeAslRequest(VW_save);
  468.     if(IconBase)
  469.         CloseLibrary(IconBase);
  470.     if(CxBase)
  471.         CloseLibrary(CxBase);
  472.     if(NoFragBase)
  473.         CloseLibrary(NoFragBase);
  474.     if(VW_fargs)
  475.         FreeArgs(VW_fargs);
  476.     _exit(code);
  477. }
  478.  
  479. void Inform( char *text )
  480. {
  481.     VW_creq->io_Command = CMD_WRITE;
  482.     VW_creq->io_Data    = (APTR)text;
  483.     VW_creq->io_Length  = (LONG)strlen(text);
  484.     DoIO((struct IORequest *)VW_creq);
  485. }
  486.  
  487. void Display( struct Line *line )
  488. {
  489.     Inform(ResStr);
  490.     VW_creq->io_Command = CMD_WRITE;
  491.     VW_creq->io_Data    = (APTR)line->Text;
  492.     VW_creq->io_Length  = (LONG)line->Size-1;
  493.  
  494.     if(line->Text[0] == FF) {
  495.         Inform(FFStr);
  496.         VW_creq->io_Data   = (APTR)&line->Text[1];
  497.         VW_creq->io_Length = (LONG)line->Size-2;
  498.     }
  499.     DoIO((struct IORequest *)VW_creq);
  500. }
  501.  
  502. void CheckDir( UBYTE *name )
  503. {
  504.     if(name[strlen(name)-1] != ':' && name[strlen(name)-1] != '/' && strlen(name))
  505.             strcat(name,"/");
  506. }
  507.  
  508. void LoadFile( long request )
  509. {
  510.     UBYTE           *ppdata;
  511.     ULONG            pplen;
  512.     BPTR             ppout;
  513.     BOOL             pptemp = FALSE;
  514.     LONG             pperr;
  515.     UBYTE            lbuf[7], *fname;
  516.     UWORD            lnum = 1;
  517.     LONG             ret;
  518.     struct BuffIO   *file;
  519.     struct Line     *line;
  520.  
  521.     ErrorLine("View v" CX_VERSION " © 1991 Jaba Development");
  522.  
  523.     if(request == TRUE) {
  524.  
  525.         RequestTags2[1]  = VW_wnd;
  526.         RequestTags2[3]  = Dir;
  527.         RequestTags2[5]  = File;
  528.         RequestTags2[9]  = "Please select file to load...";
  529.  
  530.         ret = AslRequest(VW_freq,(struct TagItem *)&RequestTags2[0]);
  531.         if(ret) {
  532.             Dir  = VW_freq->rf_Dir;
  533.             File = VW_freq->rf_File;
  534.             strcpy(VW_name,Dir);
  535.             strcpy(VW_patt,VW_freq->rf_Pat);
  536.             CheckDir(VW_name);
  537.             strcat(VW_name,File);
  538.         } else {
  539.             InfoLine();
  540.             return;
  541.         }
  542.     }
  543.  
  544.     if(VW_text) {
  545.         FreeAscii(VW_text);
  546.         VW_text = 0L;
  547.         CLRBLK();
  548.     }
  549.  
  550.     Inform(ClearStr);
  551.     Inform(StdStr);
  552.  
  553.     if(PPBase && CheckPP()) {
  554.         ErrorLine("Loading and decrunching file....");
  555.         if((pperr = ppLoadData(VW_name,DECR_POINTER,MEMF_PUBLIC,&ppdata,&pplen,0L)) < 0) {
  556.             switch(pperr) {
  557.                 case    PP_OPENERR:
  558.                     ErrorLine("PPLIB: Can't open the file !");
  559.                     break;
  560.                 case    PP_READERR:
  561.                     ErrorLine("PPLIB: Read error !");
  562.                     break;
  563.                 case    PP_NOMEMORY:
  564.                     ErrorLine("PPLIB: Out of memory !");
  565.                     break;
  566.                 case    PP_PASSERR:
  567.                     ErrorLine("PPLIB: Incorrect password !");
  568.                     break;
  569.                 case    PP_UNKNOWNPP:
  570.                     ErrorLine("PPLIB: Unknown PowerPacker version !");
  571.                     break;
  572.             }
  573.             return;
  574.         }
  575.  
  576.         fname = "T:view.pp.tmp.v" CX_VERSION ".decrunched";
  577.         if((ppout = Open(fname,MODE_NEWFILE))) {
  578.             if(Write(ppout,ppdata,pplen) != pplen) {
  579.                 ErrorLine("Error writing '.tmp' file !");
  580.                 pptemp = FALSE;
  581.             } else
  582.                 pptemp = TRUE;
  583.             Close(ppout);
  584.         } else {
  585.             ErrorLine("Can't open '.tmp' file !");
  586.             pptemp = FALSE;
  587.         }
  588.         FreeMem(ppdata,pplen);
  589.  
  590.         if(!pptemp)
  591.             goto ppCleanUp;
  592.     } else {
  593.         ErrorLine("Loading file....");
  594.         fname = VW_name;
  595.     }
  596.  
  597.  
  598.     if((VW_text = AllocAscii(ANSITAB,MAXCOL(VW_wnd,VW_font),ATF_SkipEsc+ATF_TabConvert))) {
  599.         if((file = BOpen(fname,MODE_OLDFILE))) {
  600.             while((line = BGetS(file,VW_text)))
  601.                 AddTail((struct List *)VW_text,(struct Node *)line);
  602.  
  603.             switch(BIoErr(file)) {
  604.                 case ASE_READ:
  605.                     ErrorLine("READ ERROR !");
  606.                     goto CleanExit;
  607.                 case ASE_NOMEM:
  608.                     ErrorLine(Lines[1]);
  609.                     goto CleanExit;
  610.             }
  611.             BClose(file);
  612.             VW_first = VW_text->First;
  613.             VW_found = FALSE;
  614.             DisplayText();
  615.             BytesShown();
  616.             ClearMsg(VW_wnd->UserPort);
  617.             InfoLine();
  618.             goto ppCleanUp;
  619.         } else {
  620.             ErrorLine("Could not open the file !");
  621.             FreeAscii(VW_text);
  622.             VW_text = 0L;
  623.             goto ppCleanUp;
  624.         }
  625.     } else {
  626.         ErrorLine(Lines[1]);
  627.         goto ppCleanUp;
  628.     }
  629. CleanExit:
  630.     FreeAscii(VW_text);
  631.     VW_text = 0L;
  632.     BClose(file);
  633.     ClearMsg(VW_wnd->UserPort);
  634. ppCleanUp:
  635.     if(pptemp)
  636.         DeleteFile(fname);
  637. }
  638.  
  639. void DisplayText( void )
  640. {
  641.     UWORD   y=1,i=0;
  642.  
  643.     if(!VW_text)    return;
  644.  
  645.     for(VW_last = VW_first; i < VW_maxlin; i++, VW_last = VW_last->Next, y++) {
  646.         if(VW_last == VW_text->Last->Next)  break;
  647.         MoveTo(1,y);
  648.         Display(VW_last);
  649.         if(VW_found && VW_last == VW_search.Line) PrintFound(y);
  650.     }
  651.     VW_ymax = y-1;
  652. }
  653.  
  654. void MoveTo(UBYTE c, UBYTE r)
  655. {
  656.     sprintf((char *)&MoveStr[1],"%02ld;%02ldH",r,c);
  657.     Inform(MoveStr);
  658. }
  659.  
  660. void LineDown( void )
  661. {
  662.     if(!VW_text)    return;
  663.     if(VW_last == VW_text->Last->Next) return;
  664.  
  665.     VW_first = VW_first->Next;
  666.     Inform(ScrUpStr);
  667.     MoveTo(1,VW_ymax);
  668.     Display(VW_last);
  669.  
  670.     VW_shown += VW_last->Size;
  671.     if(VW_found && VW_last == VW_search.Line) PrintFound(VW_ymax);
  672.  
  673.     VW_last = VW_last->Next;
  674. }
  675.  
  676. void LineUp( void )
  677. {
  678.     if(!VW_text)    return;
  679.     if(VW_first == VW_text->First) return;
  680.  
  681.     VW_last   = VW_last->Prev;
  682.     VW_shown -= VW_last->Size;
  683.     VW_first  = VW_first->Prev;
  684.     Inform(ScrDnStr);
  685.     MoveTo(1,1);
  686.     Display(VW_first);
  687.     if(VW_found && VW_first == VW_search.Line) PrintFound(1);
  688. }
  689.  
  690. void Top( void )
  691. {
  692.     if(!VW_text) return;
  693.     if(VW_first == VW_text->First) return;
  694.  
  695.     VW_first = VW_text->First;
  696.     Inform(ClearStr);
  697.     DisplayText();
  698.     BytesShown();
  699. }
  700.  
  701. void Bottom( void )
  702. {
  703.     UWORD   i;
  704.  
  705.     if(!VW_text)    return;
  706.     if(VW_last == VW_text->Last->Next) return;
  707.  
  708.     VW_last = VW_first = VW_text->Last;
  709.  
  710.     for(i = 1; i < VW_maxlin; i++)
  711.         VW_first = VW_first->Prev;
  712.  
  713.     VW_shown = VW_text->NumBytes;
  714.     Inform(ClearStr);
  715.     DisplayText();
  716. }
  717.  
  718. void PageDown( void )
  719. {
  720.     UWORD   i;
  721.  
  722.     if(!VW_text) return;
  723.     if(VW_last == VW_text->Last->Next) return;
  724.  
  725.     for(i = 1; i < VW_maxlin; i++) {
  726.         VW_first  = VW_first->Next;
  727.         VW_shown += VW_last->Size;
  728.         if((VW_last = VW_last->Next) == VW_text->Last->Next) break;
  729.     }
  730.  
  731.     Inform(ClearStr);
  732.     DisplayText();
  733. }
  734.  
  735. void PageUp( void )
  736. {
  737.     UWORD   i;
  738.  
  739.     if(!VW_text) return;
  740.     if(VW_first == VW_text->First) return;
  741.  
  742.     for(i = 1; i < VW_maxlin; i++) {
  743.         VW_last   = VW_last->Prev;
  744.         VW_shown -= VW_last->Size;
  745.         if((VW_first = VW_first->Prev) == VW_text->First) break;
  746.     }
  747.     Inform(ClearStr);
  748.     DisplayText();
  749. }
  750.  
  751. void Percentage( void )
  752. {
  753.     ULONG   perc;
  754.     char    pcbuf[5];
  755.  
  756.     if(!VW_text)    return;
  757.     perc = (ULONG)(VW_shown * 100 / VW_text->NumBytes);
  758.     if(perc == 100 && (VW_last != VW_text->Last->Next)) perc = 99;
  759.     VW_num = perc;
  760.     sprintf(pcbuf,"%3ld%%",perc);
  761.     SetAPen(VW_rport,3);
  762.     SetBPen(VW_rport,2);
  763.     SetDrMd(VW_rport,JAM2);
  764.     Move(VW_rport,544,VW_font->tf_Baseline);
  765.     Text(VW_rport,pcbuf,strlen(pcbuf));
  766.     SetAPen(VW_rport,1);
  767.     Move(VW_rport,584,VW_font->tf_Baseline);
  768.     Text(VW_rport,"Shown.",6);
  769. }
  770.  
  771. void BytesShown( void )
  772. {
  773.     struct Line *line;
  774.  
  775.     VW_shown = 0L;
  776.  
  777.     for(line = VW_text->First; line != VW_last; line = line->Next)
  778.         VW_shown += line->Size;
  779. }
  780.  
  781. void InfoLine( void )
  782. {
  783.     UBYTE   ibuf[100];
  784.  
  785.     CLRLIN();
  786.  
  787.     VW_err = FALSE;
  788.  
  789.     SetAPen(VW_rport,1);
  790.     SetDrMd(VW_rport,JAM1);
  791.  
  792.     if(VW_text) {
  793.         sprintf(ibuf,"File : %-31.31ls %-6.6ld Lines, %-6.6ld Bytes.",VW_name,VW_text->NumLines-VW_text->NumSplit,VW_text->NumBytes);
  794.     } else
  795.         strcpy(ibuf,"No text in memory (press 'l' to load a file)");
  796.  
  797.     Move(VW_rport,1,VW_font->tf_Baseline);
  798.     Text(VW_rport,ibuf,strlen(ibuf));
  799. }
  800.  
  801. void ErrorLine( UBYTE *text )
  802. {
  803.     CLRLIN();
  804.     VW_err = TRUE;
  805.     SetAPen(VW_rport,1);
  806.     SetDrMd(VW_rport,JAM1);
  807.     Move(VW_rport,1,VW_font->tf_Baseline);
  808.     Text(VW_rport,text,strlen(text));
  809. }
  810.  
  811. void WaitKey( void )
  812. {
  813.     while(1) {
  814.         WaitPort(VW_wnd->UserPort);
  815.         while(HandleMsg(VW_wnd->UserPort));
  816.         if(((VW_code & IECODE_UP_PREFIX) != IECODE_UP_PREFIX) &&
  817.            (!(VW_qual & IEQUALIFIER_REPEAT)))
  818.             break;
  819.     }
  820.     ClearMsg(VW_wnd->UserPort);
  821. }
  822.  
  823. void Help( void )
  824. {
  825.     Move(VW_rport,0,0);
  826.     SetAPen(VW_rport,0);
  827.     SetDrMd(VW_rport,JAM1);
  828.     ClearScreen(VW_rport);
  829.  
  830.     MoveTo(1,1);
  831.     Inform(Header);
  832.     Inform(HelpText);
  833.  
  834.     WaitKey();
  835.  
  836.     Move(VW_rport,0,0);
  837.     SetAPen(VW_rport,0);
  838.     SetDrMd(VW_rport,JAM1);
  839.     ClearScreen(VW_rport);
  840.  
  841.     MoveTo(1,1);
  842.     Inform(Header);
  843.     Inform(HelpText1);
  844.  
  845.     WaitKey();
  846.  
  847.     Move(VW_rport,0,0);
  848.     SetAPen(VW_rport,0);
  849.     SetDrMd(VW_rport,JAM1);
  850.     ClearScreen(VW_rport);
  851.     DisplayText();
  852.     InfoLine();
  853. }
  854.  
  855. long CountEsc(struct Line *line, long off)
  856. {
  857.     UWORD   i;
  858.     LONG    c = 0L;
  859.     char   *ptr = line->Text, chr;
  860.  
  861.     for(i = 0;i <= off; i++) {
  862.         if((*ptr == ESC) || (*ptr == CSI)) {
  863.             while(1) {
  864.                c++;
  865.                i++;
  866.                chr = (*ptr++) - ' ';
  867.                if((chr >= '?' && chr <= 'Z') || !chr) break;
  868.             }
  869.         }
  870.         else ptr++;
  871.     }
  872.     return(c);
  873. }
  874.  
  875. void DoFound( void )
  876. {
  877.     struct Line *line;
  878.     USHORT       i,y=0,yy;
  879.  
  880.     VW_last = VW_search.Line;
  881.  
  882.     for(i = 0; i < VW_maxlin; i++)
  883.         if((VW_last = VW_last->Next) == VW_text->Last->Next) break;
  884.  
  885.     VW_first = VW_last;
  886.  
  887.     for(yy = VW_ymax, i = VW_maxlin; i >= 1; i--, yy--) {
  888.         if((VW_first = VW_first->Prev) == VW_text->First) break;
  889.         if(VW_first == VW_search.Line) y = yy;
  890.     }
  891.  
  892.     VW_shown = 0L;
  893.  
  894.     for(line = VW_text->First; line != VW_last; line = line->Next)
  895.         VW_shown += line->Size;
  896.  
  897.     Inform(ClearStr);
  898.     DisplayText();
  899. }
  900.  
  901. void PrintFound( UWORD y )
  902. {
  903.     char wrd[256];
  904.  
  905.     setmem(&wrd[0],256,0);
  906.  
  907.     Inform("\033[32;43m");
  908.     strncpy(wrd,(char *)&VW_search.Line->Text[VW_search.TextOffset],VW_search.StringSize);
  909.     MoveTo(VW_search.TextOffset - CountEsc(VW_search.Line,VW_search.TextOffset)+1,y);
  910.     Inform(wrd);
  911.     Inform(ResStr);
  912. }
  913.  
  914. void GetSomething( ULONG kind )
  915. {
  916.     struct Gadget    *g = 0L, *glist = 0L;
  917.     struct Window    *w = 0L;
  918.     struct Line      *line;
  919.     struct NewGadget  ng;
  920.     APTR              vi = 0L;
  921.     ULONG             sizex = 0L, sizen = 0L, i;
  922.  
  923.     if(!VW_text) return;
  924.  
  925.     setmem(&ng,sizeof(struct NewGadget),0);
  926.  
  927.     nws.Screen   = VW_scr;
  928.     nws.LeftEdge = (VW_wnd->Width >> 1) - 106;
  929.     nws.TopEdge  = (VW_wnd->Height >> 1) - 12;
  930.     if(kind == STRING_KIND)
  931.         nws.Title    = GetString;
  932.     else
  933.         nws.Title    = GetLong;
  934.  
  935.     if((w = OpenWindowTagList(&nws,(struct TagItem *)&NewWindowTags[0]))) {
  936.         if((vi = GetVisualInfoA(VW_scr,(struct TagItem *)&StringTags[4]))) {
  937.             if((g = CreateContext(&glist))) {
  938.  
  939.                 ng.ng_LeftEdge   = w->BorderLeft;
  940.                 ng.ng_TopEdge    = w->BorderTop;
  941.                 ng.ng_Width      = 200;
  942.                 ng.ng_Height     = 12;
  943.                 ng.ng_TextAttr   = &TOPAZ_80;
  944.                 ng.ng_VisualInfo = vi;
  945.  
  946.                 if(kind == STRING_KIND)
  947.                     g = CreateGadgetA(STRING_KIND,g,&ng,(struct TagItem *)&StringTags[0]);
  948.                 else {
  949.                     IntegerTags[1] = VW_num;
  950.                     g = CreateGadgetA(INTEGER_KIND,g,&ng,(struct TagItem *)&IntegerTags[0]);
  951.                 }
  952.                 if(g) {
  953.                     g->Activation |= GACT_STRINGCENTER;
  954.                     g->Activation |= GACT_STRINGEXTEND;
  955.                     se.InitialModes = NULL;
  956.                     ((struct StringInfo *)g->SpecialInfo)->Extension = &se;
  957.                     AddGList(w,glist,-1L,-1L,NULL);
  958.                     RefreshGList(glist,w,NULL,-1);
  959.                     GT_RefreshWindow(w,NULL);
  960.                     ActivateGadget(g,w,NULL);
  961.  
  962.                     while(1) {
  963.                         WaitPort(w->UserPort);
  964.                         while(HandleMsg(w->UserPort));
  965.                         if(VW_class == IDCMP_GADGETUP) {
  966.                             if(kind == STRING_KIND) {
  967.                                 strcpy(VW_fbuf,((struct StringInfo *)g->SpecialInfo)->Buffer);
  968.                                 CloseWindow(w);
  969.                                 w = 0L;
  970.                                 ErrorLine(Lines[2]);
  971.                                 if(FindFrom(VW_text,VW_fbuf,&VW_search,VW_first,VW_mode)) {
  972.                                     VW_found = TRUE;
  973.                                     DoFound();
  974.                                     InfoLine();
  975.                                     goto CleanExit;
  976.                                 } else {
  977.                                     VW_found = FALSE;
  978.                                     DisplayBeep(VW_scr);
  979.                                     InfoLine();
  980.                                     goto CleanExit;
  981.                                 }
  982.                             } else {
  983.                                 CloseWindow(w);
  984.                                 w = 0L;
  985.                                 VW_num = ((struct StringInfo *)g->SpecialInfo)->LongInt;
  986.                                 if(VW_num > 0 && VW_num < 100) {
  987.  
  988.                                     sizen = VW_num * VW_text->NumBytes / 100;
  989.  
  990.                                     for(line = VW_text->First; line->Next; line = line->Next) {
  991.                                         sizex += line->Size;
  992.                                         if(sizex > sizen) break;
  993.                                     }
  994.  
  995.                                     VW_first = line;
  996.  
  997.                                     for(i = 1; i < VW_maxlin; i++ )
  998.                                         if((VW_first = VW_first->Prev) == VW_text->First) break;
  999.  
  1000.                                     VW_last = VW_first;
  1001.  
  1002.                                     for(i = 1; i < VW_maxlin; i++)
  1003.                                         if((VW_last = VW_last->Next) == VW_text->Last->Next) break;
  1004.  
  1005.                                     VW_shown = 0L;
  1006.                                     for(line = VW_text->First; line != VW_last->Next; line = line->Next)
  1007.                                         VW_shown += line->Size;
  1008.  
  1009.                                     Inform(ClearStr);
  1010.                                     DisplayText();
  1011.                                     goto CleanExit;
  1012.                                 } else if(VW_num == 100) {
  1013.                                     Bottom();
  1014.                                     goto CleanExit;
  1015.                                 } else if(!VW_num) {
  1016.                                     Top();
  1017.                                     goto CleanExit;
  1018.                                 } else {
  1019.                                     DisplayText();
  1020.                                     DisplayBeep(VW_scr);
  1021.                                     goto CleanExit;
  1022.                                 }
  1023.                             }
  1024.                         }
  1025.                     }
  1026.                 }
  1027.             }
  1028.         }
  1029.     }
  1030. CleanExit:
  1031.     if(w)           CloseWindow(w);
  1032.     if(vi)          FreeVisualInfo(vi);
  1033.     if(glist)       FreeGadgets(glist);
  1034.     ClearMsg(VW_wnd->UserPort);
  1035. }
  1036.  
  1037. struct Line *MakeNewLine( UBYTE *text )
  1038. {
  1039.     struct Line *line = NULL, *rep;
  1040.     UBYTE       *txt = NULL;
  1041.     UWORD        len;
  1042.  
  1043.     rep = VW_first;
  1044.     len = strlen(text)+1;
  1045.  
  1046.     if((line = (struct Line *)AllocItem(VW_text->MemoryUsed,(ULONG)sizeof(struct Line),MEMF_PUBLIC))) {
  1047.         if(txt = (UBYTE *)AllocItem(VW_text->MemoryUsed,(ULONG)len,MEMF_PUBLIC)) {
  1048.  
  1049.             strcpy(txt,text);
  1050.             if(txt[len-1] != 0x0A)
  1051.                 txt[len-1] = 0x0A;
  1052.  
  1053.             line->Flags = rep->Flags;
  1054.             line->Size  = len-1;
  1055.             line->Text  = txt;
  1056.  
  1057.             Insert((void *)VW_text,(void *)line,(void *)rep);
  1058.  
  1059.             Remove(rep);
  1060.             FreeItem(VW_text->MemoryUsed,rep->Text,rep->Size);
  1061.             FreeItem(VW_text->MemoryUsed,rep,(ULONG)sizeof(struct Line));
  1062.  
  1063.             VW_first = line;
  1064.             Inform(ClearStr);
  1065.             DisplayText();
  1066.             return;
  1067.         }
  1068.     }
  1069.     ErrorLine(Lines[1]);
  1070.     if(txt)  FreeItem(VW_text->MemoryUsed,txt,len);
  1071.     if(line) FreeItem(VW_text->MemoryUsed,line,(ULONG)sizeof(struct Line));
  1072. }
  1073.  
  1074. void EditLine( void )
  1075. {
  1076.     struct Gadget    *g = 0L, *glist = 0L;
  1077.     struct Window    *w = 0L;
  1078.     struct NewGadget  ng;
  1079.     APTR              vi = 0L;
  1080.     UBYTE             TextLine[257];
  1081.  
  1082.     if(!VW_text) return;
  1083.  
  1084.     setmem(&ng,sizeof(struct NewGadget),0);
  1085.     setmem(&TextLine[0],257,0);
  1086.  
  1087.     nwe.Screen   = VW_scr;
  1088.     nwe.LeftEdge = (VW_wnd->Width >> 1) - 166;
  1089.     nwe.TopEdge  = (VW_wnd->Height >> 1) - 12;
  1090.  
  1091.     if((w = OpenWindowTagList(&nwe,(struct TagItem *)&NewWindowTags1[0]))) {
  1092.         if((vi = GetVisualInfoA(VW_scr,(struct TagItem *)&StringTags[4]))) {
  1093.             if((g = CreateContext(&glist))) {
  1094.  
  1095.                 ng.ng_LeftEdge   = w->BorderLeft;
  1096.                 ng.ng_TopEdge    = w->BorderTop;
  1097.                 ng.ng_Width      = 320;
  1098.                 ng.ng_Height     = 12;
  1099.                 ng.ng_TextAttr   = &TOPAZ_80;
  1100.                 ng.ng_VisualInfo = vi;
  1101.  
  1102.                 strncpy(TextLine,VW_first->Text,VW_first->Size);
  1103.  
  1104.                 StringTags1[1] = TextLine;
  1105.                 StringTags1[3] = MAXCOL(VW_wnd,VW_font);
  1106.  
  1107.                 g = CreateGadgetA(STRING_KIND,g,&ng,(struct TagItem *)&StringTags1[0]);
  1108.  
  1109.                 g->Activation  |= GACT_STRINGEXTEND;
  1110.                 se.InitialModes = SGM_NOFILTER;
  1111.                 ((struct StringInfo *)g->SpecialInfo)->Extension = &se;
  1112.  
  1113.                 if(g) {
  1114.                     g->Activation |= GACT_STRINGCENTER;
  1115.                     AddGList(w,glist,-1L,-1L,NULL);
  1116.                     RefreshGList(glist,w,NULL,-1);
  1117.                     GT_RefreshWindow(w,NULL);
  1118.                     ActivateGadget(g,w,NULL);
  1119.  
  1120.                     while(1) {
  1121.                         WaitPort(w->UserPort);
  1122.                         while(HandleMsg(w->UserPort));
  1123.                         if(VW_class == IDCMP_GADGETUP) {
  1124.                             MakeNewLine((UBYTE *)((struct StringInfo *)g->SpecialInfo)->Buffer);
  1125.                             break;
  1126.                         } else
  1127.                             break;
  1128.                     }
  1129.                 }
  1130.             }
  1131.         }
  1132.     }
  1133. CleanExit:
  1134.     if(w)           CloseWindow(w);
  1135.     if(vi)          FreeVisualInfo(vi);
  1136.     if(glist)       FreeGadgets(glist);
  1137.     ClearMsg(VW_wnd->UserPort);
  1138. }
  1139.  
  1140. void FindN( void )
  1141. {
  1142.     if(!VW_text) return;
  1143.  
  1144.     if(VW_found) {
  1145.         ErrorLine(Lines[2]);
  1146.         if(NextOccurrence(&VW_search,VW_mode)) {
  1147.             DoFound();
  1148.             InfoLine();
  1149.             return;
  1150.         }
  1151.     }
  1152.     InfoLine();
  1153.     DisplayBeep(VW_scr);
  1154. }
  1155.  
  1156. void FindP( void )
  1157. {
  1158.     if(!VW_text) return;
  1159.  
  1160.     if(VW_found) {
  1161.         ErrorLine(Lines[2]);
  1162.         if(PreviousOccurrence(&VW_search,VW_mode)) {
  1163.             DoFound();
  1164.             InfoLine();
  1165.             return;
  1166.         }
  1167.     }
  1168.     InfoLine();
  1169.     DisplayBeep(VW_scr);
  1170. }
  1171.  
  1172. /*
  1173.  * Run the editor described in the environment variable
  1174.  * 'EDITOR'. The editor may NOT be crunched!
  1175.  */
  1176. void EditFile( void )
  1177. {
  1178.     struct  Segment *resseg;
  1179.     BPTR    segment;
  1180.     WORD    elen, rc;
  1181.     UBYTE   ebuf[256]; /* should be enough to hold the editor path & name */
  1182.  
  1183.     if(!VW_text)    return;
  1184.  
  1185.     if((elen = GetVar("EDITOR",ebuf,256,NULL)) > 0) {
  1186.         Forbid();
  1187.         resseg = FindSegment(ebuf,0,0);
  1188.         Permit();
  1189.         if(resseg) { /* Found it on the resident list */
  1190.             ScreenToBack(VW_scr);
  1191.             rc = RunCommand(resseg->seg_Seg,8192L,VW_name,strlen(VW_name));
  1192.             goto RunExit;
  1193.         } else if((segment = LoadSeg(ebuf))) { /* loaded it from disk */
  1194.             ScreenToBack(VW_scr);
  1195.             rc = RunCommand(segment,8192L,VW_name,strlen(VW_name));
  1196.             UnLoadSeg(segment);
  1197.             goto RunExit;
  1198.         } else {
  1199.             ErrorLine("Could not run the editor !");
  1200.             goto CleanExit;
  1201.         }
  1202.     } else {
  1203.         ErrorLine("ENV:EDITOR variable not set (Use SetEnv) !");
  1204.         goto CleanExit;
  1205.     }
  1206.  
  1207. RunExit:
  1208.     sprintf(ebuf,"Editor return code : %ld",rc);
  1209.     ErrorLine(ebuf);
  1210. CleanExit:
  1211.     ScreenToFront(VW_scr);
  1212.     return;
  1213. }
  1214.  
  1215. long CheckBlock( UWORD mark )
  1216. {
  1217.     UBYTE   errl[31];
  1218.  
  1219.     if(!VW_blk[mark].TopLine || !VW_blk[mark].BottomLine) {
  1220.         sprintf(errl,Lines[4],mark+1);
  1221.         ErrorLine(errl);
  1222.         return(FALSE);
  1223.     }
  1224.     return(TRUE);
  1225. }
  1226.  
  1227. void PrintFile( void )
  1228. {
  1229.     if(!VW_text)    return;
  1230.  
  1231.     if(VW_pmode == PRT_BLOCK) {
  1232.         if(!CheckBlock(VW_pmark))
  1233.             return;
  1234.     }
  1235.  
  1236.     ProcessTags[1] = PrintProc;
  1237.  
  1238.     if(!CreateNewProc((struct TagItem *)&ProcessTags[0]))
  1239.         ErrorLine("Can't start printing process !");
  1240.     else {
  1241.         while(!FindTask(Lines[3]));
  1242.         VW_printing = TRUE;
  1243.     }
  1244. }
  1245.  
  1246. __geta4 void PrintProc( void )
  1247. {
  1248.     struct BuffIO       *pfile = 0L;
  1249.     struct Window       *pwin = 0L;
  1250.     struct IntuiMessage *pmsg;
  1251.     struct Line         *l, *t;
  1252.     ULONG                class;
  1253.  
  1254.     if(!VW_text) return;
  1255.  
  1256.     if((pfile = BOpen("PRT:",MODE_NEWFILE))) {
  1257.         nwp.Screen = VW_scr;
  1258.         if((pwin = OpenWindow(&nwp))) {
  1259.             if(VW_pmode == PRT_PAGE) {
  1260.                 l = VW_first;
  1261.                 t = VW_last;
  1262.             } else if(VW_pmode == PRT_FILE) {
  1263.                 l = VW_text->First;
  1264.                 t = VW_text->Last->Next;
  1265.             } else {
  1266.                 l = VW_blk[VW_pmark].TopLine;
  1267.                 t = VW_blk[VW_pmark].BottomLine;
  1268.             }
  1269.  
  1270.             for( ; l != t; l = l->Next) {
  1271.                 if((pmsg = GT_GetIMsg(pwin->UserPort))) {
  1272.                     class = pmsg->Class;
  1273.                     GT_ReplyIMsg(pmsg);
  1274.                 }
  1275.                 if(class == IDCMP_CLOSEWINDOW)
  1276.                     goto CleanExit;
  1277.  
  1278.                 BPutS(pfile,l);
  1279.  
  1280.                 if(BIoErr(pfile) != ASE_OK) {
  1281.                     ErrorLine("Print error !");
  1282.                     goto CleanExit;
  1283.                 }
  1284.             }
  1285.         }
  1286.     } else
  1287.         ErrorLine("Printer trouble !");
  1288. CleanExit:
  1289.     if(pwin)        CloseWindow(pwin);
  1290.     if(pfile)       BClose(pfile);
  1291. }
  1292.  
  1293. long IsItADir( void )
  1294. {
  1295.     struct FileInfoBlock    *fib;
  1296.     BPTR                     lock;
  1297.     long                     ret = -1L;
  1298.  
  1299.     if((fib = AllocMem((ULONG)sizeof(struct FileInfoBlock),MEMF_PUBLIC))) {
  1300.         if((lock = Lock((char *)&VW_name[0],ACCESS_READ))) {
  1301.             Examine(lock,fib);
  1302.             ret = fib->fib_DirEntryType;
  1303.             UnLock(lock);
  1304.         }
  1305.         FreeMem(fib,(ULONG)sizeof(struct FileInfoBlock));
  1306.     }
  1307.     return(ret);
  1308. }
  1309.  
  1310. long ParseName( char *arg )
  1311. {
  1312.     char *str;
  1313.  
  1314.     if(arg) {
  1315.         if((str = (char *)strrchr(arg,'/')) || (str = (char *)strrchr(arg,':'))) {
  1316.             if(IsItADir() < 0) {
  1317.                 str++;
  1318.                 File = &VW_name[str-arg];
  1319.                 *str = 0;
  1320.                 Dir = arg;
  1321.                 if(strlen(File))
  1322.                     return TRUE;
  1323.                 else
  1324.                     return FALSE;
  1325.             } else {
  1326.                 Dir = &VW_name[0];
  1327.                 File = &NullStr;
  1328.                 return FALSE;
  1329.             }
  1330.         }
  1331.         if(arg[0]) {
  1332.             if(IsItADir() > 0) {
  1333.                 Dir = arg;
  1334.                 File = &NullStr;
  1335.                 return FALSE;
  1336.             } else {
  1337.                 File = arg;
  1338.                 Dir = &NullStr;
  1339.                 return TRUE;
  1340.             }
  1341.         }
  1342.     }
  1343.     Dir = File = &NullStr;
  1344.     return FALSE;
  1345. }
  1346.  
  1347. long CheckPP( void )
  1348. {
  1349.     BPTR    file;
  1350.     ULONG   ident;
  1351.  
  1352.     if(!(file = Open(VW_name,MODE_OLDFILE))) {
  1353.         strcat(VW_name,".pp");
  1354.         if(!(file = Open(VW_name,MODE_OLDFILE))) {
  1355.             ErrorLine("Could not open the file");
  1356.             return FALSE;
  1357.         }
  1358.     }
  1359.     Read(file,&ident,4L);
  1360.     Close(file);
  1361.     if(ident == 'PP20' || ident == 'PX20') return TRUE;
  1362.     return FALSE;
  1363. }
  1364.  
  1365. void myMain( BOOL cli )
  1366. {
  1367.     struct WBArg *wba;
  1368.  
  1369.     OpenLibs();
  1370.     GetRequest();
  1371.  
  1372.     if(NOT cli) {
  1373.         if(_WBMsg->sm_ArgList->wa_Lock)
  1374.             CurrentDir(_WBMsg->sm_ArgList->wa_Lock);
  1375.     }
  1376.  
  1377.     SetupComm();
  1378.     MainLoop();
  1379.     return;
  1380. }
  1381.  
  1382. void SetMark( UWORD mark )
  1383. {
  1384.     struct Line     *line, *lt;
  1385.     UBYTE            errl[31];
  1386.  
  1387.     if(!VW_text)    return;
  1388.  
  1389.     if(!VW_blk[mark].TopLine) {
  1390.         VW_blk[mark].TopLine = VW_first;
  1391.         return;
  1392.     } else if(!VW_blk[mark].BottomLine) {
  1393.         VW_blk[mark].BottomLine = VW_last;
  1394.  
  1395.         for(line = VW_text->First; line->Next; line = line->Next) {
  1396.             if(line == VW_blk[mark].TopLine) break;
  1397.             else if(line == VW_blk[mark].BottomLine) {
  1398.                 lt = VW_blk[mark].TopLine;
  1399.                 VW_blk[mark].TopLine    = line->Prev;
  1400.                 VW_blk[mark].BottomLine = lt->Next;
  1401.                 break;
  1402.             }
  1403.         }
  1404.         sprintf(errl,"Block %-2.2ld marked !",mark+1);
  1405.         ErrorLine(errl);
  1406.         return;
  1407.     } else {
  1408.         sprintf(errl,"Block %-2.2ld already marked !",mark+1);
  1409.         ErrorLine(errl);
  1410.         return;
  1411.     }
  1412. }
  1413.  
  1414. void UnSetMark( UWORD mark )
  1415. {
  1416.     UBYTE   errl[31];
  1417.  
  1418.     if(!VW_text)    return;
  1419.  
  1420.     VW_blk[mark].TopLine = VW_blk[mark].BottomLine = NULL;
  1421.  
  1422.     sprintf(errl,"Block %-2.2ld unmarked !",mark+1);
  1423.     ErrorLine(errl);
  1424. }
  1425.  
  1426. void JumpMark( UWORD mark )
  1427. {
  1428.     struct Line *line;
  1429.  
  1430.     if(!VW_text)    return;
  1431.  
  1432.     if(!CheckBlock(mark))
  1433.         return;
  1434.  
  1435.     VW_first = VW_blk[mark].TopLine;
  1436.     Inform(ClearStr);
  1437.     DisplayText();
  1438.     VW_shown = 0L;
  1439.  
  1440.     for(line=VW_text->First; line != VW_last; line = line->Next)
  1441.         VW_shown += line->Size;
  1442.  
  1443.     Percentage();
  1444. }
  1445.  
  1446. void SaveBlock( WORD mark )
  1447. {
  1448.     struct BuffIO       *ofile;
  1449.     struct Line         *f, *t;
  1450.     ULONG                ret;
  1451.     UBYTE                oname[256];
  1452.  
  1453.     if(mark >= 0) {
  1454.         if(!CheckBlock(mark))
  1455.             return;
  1456.     } else {
  1457.         if(NOT VW_text)
  1458.             return;
  1459.     }
  1460.  
  1461.     RequestTags2[1]  = VW_wnd;
  1462.     RequestTags2[3]  = SDir;
  1463.     RequestTags2[5]  = SFile;
  1464.     if(mark >= 0)
  1465.         RequestTags2[9]  = "Save text block as...";
  1466.     else
  1467.         RequestTags2[9]  = "Save text as...";
  1468.  
  1469.     ret = AslRequest(VW_save,(struct TagItem *)&RequestTags2[0]);
  1470.     if(ret) {
  1471.         SDir  = VW_save->rf_Dir;
  1472.         SFile = VW_save->rf_File;
  1473.         strcpy(oname,SDir);
  1474.         strcpy(VW_patt,VW_save->rf_Pat);
  1475.         CheckDir(oname);
  1476.         strcat(oname,SFile);
  1477.     } else {
  1478.         InfoLine();
  1479.         return;
  1480.     }
  1481.  
  1482.     if((ofile = BOpen((char *)&oname[0],MODE_NEWFILE))) {
  1483.         ErrorLine("Writing...");
  1484.         if(mark >= 0) {
  1485.             f = VW_blk[mark].TopLine;
  1486.             t = VW_blk[mark].BottomLine;
  1487.         } else {
  1488.             f = VW_text->First;
  1489.             t = VW_text->Last->Next;
  1490.         }
  1491.  
  1492.         for( ; f != t; f = f->Next )
  1493.             BPutS(ofile,f);
  1494.  
  1495.         if(BClose(ofile) != ASE_OK)
  1496.             ErrorLine("Write Error !");
  1497.     } else
  1498.         ErrorLine("Can't open write file !");
  1499.     InfoLine();
  1500. }
  1501.  
  1502. void SetupComm( void )
  1503. {
  1504.     struct WBArg *wba;
  1505.     char         *popwindow, **tooltypes;
  1506.     long          priority;
  1507.  
  1508.     if(_WBMsg) {
  1509.         tooltypes = ArgArrayInit( 0L, _WBMsg );
  1510.  
  1511.         priority    = ArgInt( tooltypes, CX_PRIORITY, CX_DEF_PRIORITY );
  1512.         popwindow   = ArgString( tooltypes, CX_POPWINDOW, CX_DEF_POPWINDOW );
  1513.         VW_viewstr  = ArgString( tooltypes, CX_VIEW, CX_DEF_VIEW );
  1514.         VW_flushstr = ArgString( tooltypes, CX_FLUSH, CX_DEF_FLUSH );
  1515.         VW_quitstr  = ArgString( tooltypes, CX_QUIT, CX_DEF_QUIT );
  1516.  
  1517.         wba = (struct WBArg *)_WBMsg->sm_ArgList;
  1518.         if(_WBMsg->sm_NumArgs > 1) {
  1519.             wba++;
  1520.             CurrentDir(wba->wa_Lock);
  1521.             strcpy(VW_name,(char *)wba->wa_Name);
  1522.             VW_namestr = (char *)wba->wa_Name;
  1523.         }
  1524.     } else {
  1525.         strcpy(VW_name,(char *)VW_args[0]);
  1526.  
  1527.         VW_namestr  = (char *)VW_args[0];
  1528.  
  1529.         if(VW_args[1])  priority    = VW_args[1];
  1530.         else            priority    = CX_DEF_PRIORITY;
  1531.         if(VW_args[2])  popwindow   = (char *)VW_args[2];
  1532.         else            popwindow   = CX_DEF_POPWINDOW;
  1533.         if(VW_args[3])  VW_viewstr  = (char *)VW_args[3];
  1534.         else            VW_viewstr  = CX_DEF_VIEW;
  1535.         if(VW_args[4])  VW_flushstr = (char *)VW_args[4];
  1536.         else            VW_flushstr = CX_DEF_FLUSH;
  1537.         if(VW_args[5])  VW_quitstr  = (char *)VW_args[5];
  1538.         else            VW_quitstr  = CX_DEF_QUIT;
  1539.     }
  1540.  
  1541.  
  1542.     if(NOT Stricmp( popwindow, CX_DEF_POPWINDOW )) VW_dopen = TRUE;
  1543.     else                                           VW_dopen = FALSE;
  1544.  
  1545.     if(NOT( VW_cxport = CreateMsgPort()))
  1546.         Quit( RETURN_FAIL );
  1547.  
  1548.     VW_newbroker.nb_Pri  = priority;
  1549.     VW_newbroker.nb_Port = VW_cxport;
  1550.  
  1551.     VW_cxmask            = BitMask( VW_cxport->mp_SigBit );
  1552.  
  1553.     if(NOT( VW_broker = CxBroker( &VW_newbroker, NULL )))
  1554.         Quit( RETURN_FAIL );
  1555.  
  1556.     if(NOT( VW_quit = HotKey( VW_quitstr, VW_cxport, CXC_QUIT )))
  1557.         Quit( RETURN_FAIL );
  1558.     AttachCxObj( VW_broker, VW_quit );
  1559.  
  1560.     if(NOT( VW_flush = HotKey( VW_flushstr, VW_cxport, CXC_FLUSH )))
  1561.         Quit( RETURN_FAIL );
  1562.     AttachCxObj( VW_broker, VW_flush );
  1563.  
  1564.     if(NOT( VW_view = HotKey( VW_viewstr, VW_cxport, CXC_VIEW )))
  1565.         Quit( RETURN_FAIL );
  1566.     AttachCxObj( VW_broker, VW_view );
  1567.  
  1568.     if(CxObjError( VW_quit ) || CxObjError( VW_flush ) || CxObjError( VW_view ))
  1569.         Quit( RETURN_FAIL );
  1570.  
  1571.     if(_WBMsg)
  1572.         ArgArrayDone();
  1573.  
  1574.     CxOn( VW_broker );
  1575. }
  1576.  
  1577. void QuitComm( void )
  1578. {
  1579.     struct Message  *tmp;
  1580.  
  1581.     if(VW_broker)
  1582.         DeleteCxObjAll( VW_broker );
  1583.     if(VW_cxport) {
  1584.         ClearMsg( VW_cxport );
  1585.         DeleteMsgPort( VW_cxport );
  1586.     }
  1587. }
  1588.  
  1589. void MainLoop( void )
  1590. {
  1591.     struct Message      *msg;
  1592.     struct IntuiMessage *imsg;
  1593.     ULONG                sig, type, id, class;
  1594.     BOOL                 running = TRUE;
  1595.  
  1596.     if(VW_dopen)    OpenDisplay();
  1597.  
  1598.     do {
  1599.         if(VW_isopen)   Percentage();
  1600.  
  1601.         sig = Wait( SIGBREAKF_CTRL_C | VW_cxmask | VW_idmask );
  1602.  
  1603.         if(( sig & SIGBREAKF_CTRL_C ) == SIGBREAKF_CTRL_C ) {
  1604.             running = FALSE;
  1605.         } else if(( sig & VW_cxmask ) == VW_cxmask ) {
  1606.  
  1607.             while (( msg = (struct Message *)GetMsg( VW_cxport ))) {
  1608.  
  1609.                 id   = CxMsgID((CxMsg *)msg);
  1610.                 type = CxMsgType((CxMsg *)msg);
  1611.                 ReplyMsg(msg);
  1612.  
  1613.                 switch( type ) {
  1614.  
  1615.                     case    CXM_IEVENT:
  1616.  
  1617.                         switch( id ) {
  1618.  
  1619.                             case    CXC_VIEW:
  1620.                                     if(NOT VW_isopen)
  1621.                                         OpenDisplay();
  1622.                                     else
  1623.                                         ScreenToFront( VW_scr );
  1624.                                     break;
  1625.  
  1626.                             case    CXC_FLUSH:
  1627.                                     if(NOT VW_isopen) {
  1628.                                         FreeAscii(VW_text);
  1629.                                         VW_text = NULL;
  1630.                                     }
  1631.                                     break;
  1632.  
  1633.                             case    CXC_QUIT:
  1634.                                     if(NOT VW_isopen)
  1635.                                         running = FALSE;
  1636.                                     break;
  1637.                         }
  1638.                         break;
  1639.  
  1640.                     case    CXM_COMMAND:
  1641.                         switch( id ) {
  1642.  
  1643.                             case    CXCMD_KILL:
  1644.                                 running = FALSE;
  1645.                                 break;
  1646.  
  1647.                             case    CXCMD_DISABLE:
  1648.                                 CxOff( VW_broker );
  1649.                                 break;
  1650.  
  1651.                             case    CXCMD_ENABLE:
  1652.                                 CxOn( VW_broker );
  1653.                                 break;
  1654.  
  1655.                             case    CXCMD_UNIQUE:
  1656.                             case    CXCMD_APPEAR:
  1657.                                 if(NOT VW_isopen)
  1658.                                     OpenDisplay();
  1659.                                 else
  1660.                                     ScreenToFront( VW_scr );
  1661.                                 break;
  1662.  
  1663.                             case    CXCMD_DISAPPEAR:
  1664.                                 if(VW_isopen)
  1665.                                     CloseDisplay();
  1666.                                 break;
  1667.                         }
  1668.                         break;
  1669.                 }
  1670.             }
  1671.         } else if(VW_isopen) {
  1672.             if(( sig & VW_idmask ) == VW_idmask) {
  1673.  
  1674.                 while(HandleMsg(VW_wnd->UserPort)) {
  1675.                     Percentage();
  1676.                     Forbid();
  1677.                     if(!FindTask(Lines[3])) VW_printing = FALSE;
  1678.                     Permit();
  1679.  
  1680.                     if(VW_class == IDCMP_RAWKEY)
  1681.                             HandleKeyboard( VW_code, VW_qual );
  1682.                 }
  1683.             }
  1684.         }
  1685.     } while( running == TRUE );
  1686.  
  1687.     if(VW_isopen)
  1688.         CloseDisplay();
  1689.     CxOff( VW_broker );
  1690.     Quit(NULL);
  1691. }
  1692.  
  1693. extern struct Library *SysBase;
  1694.  
  1695. /*
  1696.  * I don't use the stdio routines from the c.lib and
  1697.  * I use "ReadArgs()" to parse the arguments so I can
  1698.  * safely use the "_main" entry point. This saves a
  1699.  * hell of a lot of bytes in the executable.
  1700.  */
  1701. void _main( void )
  1702. {
  1703.     struct Process              *proc = FindTask(NULL);
  1704.  
  1705.     if(SysBase->lib_Version < 36) /* sanity check */
  1706.         _exit(RETURN_FAIL);
  1707.  
  1708.     if(proc->pr_CLI) {
  1709.         if((VW_fargs = ReadArgs(Template,&VW_args[0],&VW_iargs)))
  1710.             myMain(TRUE);
  1711.             return;
  1712.     } else {
  1713.         myMain(FALSE);
  1714.         return;
  1715.     }
  1716.  
  1717.     _waitwbmsg(); /* to get the workbench message, dummy! never called! */
  1718.     atoi("");
  1719. }
  1720.