home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 3 / CD_Magazyn_EXEC_nr_3.iso / Internet / Strony_WWW / Opus4.x / DOpus414JRsrc.lha / DirectoryOpus4 / Program / view.c < prev    next >
C/C++ Source or Header  |  2000-03-29  |  88KB  |  1,872 lines
  1. /*
  2.  
  3. Directory Opus 4
  4. Original GPL release version 4.12
  5. Copyright 1993-2000 Jonathan Potter
  6.  
  7. This program is free software; you can redistribute it and/or
  8. modify it under the terms of the GNU General Public License
  9. as published by the Free Software Foundation; either version 2
  10. of the License, or (at your option) any later version.
  11.  
  12. This program is distributed in the hope that it will be useful,
  13. but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15. GNU General Public License for more details.
  16.  
  17. You should have received a copy of the GNU General Public License
  18. along with this program; if not, write to the Free Software
  19. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20.  
  21. All users of Directory Opus 4 (including versions distributed
  22. under the GPL) are entitled to upgrade to the latest version of
  23. Directory Opus version 5 at a reduced price. Please see
  24. http://www.gpsoft.com.au for more information.
  25.  
  26. The release of Directory Opus 4 under the GPL in NO WAY affects
  27. the existing commercial status of Directory Opus 5.
  28.  
  29. */
  30.  
  31. #include "dopus.h"
  32. #include "view.h"
  33. #include "searchdata.h"
  34. #include <proto/powerpacker.h>
  35.  
  36. static struct NewWindow
  37.         viewwin={
  38.                 0,0,0,0,
  39.                 255,255,
  40.                 IDCMP_RAWKEY|IDCMP_MOUSEBUTTONS|IDCMP_GADGETUP|
  41.                         IDCMP_GADGETDOWN|IDCMP_INACTIVEWINDOW|IDCMP_ACTIVEWINDOW|IDCMP_MOUSEMOVE,
  42.                 WFLG_BORDERLESS|WFLG_RMBTRAP,
  43.                 NULL,NULL,NULL,NULL,NULL,0,0,0,0,CUSTOMSCREEN},
  44.         ansiread_win={
  45.                 0,0,0,0,
  46.                 255,255,
  47.                 0,
  48.                 WFLG_BORDERLESS|WFLG_BACKDROP,
  49.                 NULL,NULL,NULL,NULL,NULL,
  50.                 0,0,0,0,CUSTOMSCREEN};
  51.  
  52. struct ViewMessage {
  53.         char *filename;
  54.         char *name;
  55.         int function;
  56.         char *initialsearch;
  57.         struct ViewData *viewdata;
  58. };
  59.  
  60. viewfile(filename,name,function,initialsearch,viewdata,wait,noftype)
  61. char *filename,*name;
  62. int function;
  63. char *initialsearch;
  64. struct ViewData *viewdata;
  65. int wait,noftype;
  66. {
  67.         struct ArbiterLaunch launch;
  68.         struct ViewMessage *view_message;
  69.         struct DOpusRemember *memkey=NULL;
  70.         int flags;
  71.  
  72.         if (!noftype) {
  73.                 switch (function) {
  74.                         case FUNC_HEXREAD:
  75.                                 if (checkfiletypefunc(filename,FTFUNC_HEXREAD)) return(1);
  76.                                 break;
  77.                         case FUNC_ANSIREAD:
  78.                                 if (checkfiletypefunc(filename,FTFUNC_ANSIREAD)) return(1);
  79.                                 break;
  80.                         default:
  81.                                 if (checkfiletypefunc(filename,FTFUNC_READ)) return(1);
  82.                                 break;
  83.                 }
  84.         }
  85.  
  86.         if ((view_message=LAllocRemember(&memkey,sizeof(struct ViewMessage),MEMF_CLEAR)) &&
  87.                 copy_string(filename,&view_message->filename,&memkey) &&
  88.                 copy_string(name,&view_message->name,&memkey) &&
  89.                 copy_string(initialsearch,&view_message->initialsearch,&memkey)) {
  90.  
  91.                 launch.launch_code=(void *)view_file_process;
  92.                 launch.launch_name="dopus_view";
  93.                 launch.launch_memory=memkey;
  94.                 launch.data=(APTR)view_message;
  95.  
  96.                 view_message->function=function;
  97.                 view_message->viewdata=viewdata;
  98.  
  99.                 if (wait || viewdata) flags=ARB_WAIT;
  100.                 else flags=0;
  101.                 return(arbiter_command(ARBITER_LAUNCH,(APTR)&launch,flags));
  102.         }
  103.  
  104.         LFreeRemember(&memkey);
  105.         return(0);
  106. }
  107.  
  108. void __saveds view_file_process()
  109. {
  110.         int a,b,c,in,err,size,old_file_size,old_buffer_size,fsize,retcode=100;
  111.         short
  112.                 scroll_speed,
  113.                 scroll_pos_1,
  114.                 scroll_pos_2,
  115.                 scroll_pos_3,
  116.                 scroll_pos_4,
  117.                 scroll_pos_5,
  118.                 scroll_pos_6,
  119.                 scroll_pos_7;
  120.         ULONG class;
  121.         USHORT code,qual,gadgetid;
  122.         char buf[60];
  123.         struct ConUnit *view_console_unit=NULL;
  124.         struct ViewData *vdata;
  125.         struct Gadget *gadget;
  126.         struct IntuiMessage *msg;
  127.         struct Process *my_process;
  128.         struct ArbiterMessage *my_startup_message;
  129.         struct ViewMessage *view_msg;
  130.         char *filename,*name;
  131.         int function;
  132.         char *initialsearch;
  133.         struct ViewData *viewdata;
  134.         struct MsgPort *view_port;
  135.         struct IOStdReq *view_req=NULL;
  136.         UBYTE key_matrix[13];
  137.         char portname[20],titlebuf[300];
  138.  
  139.         my_process=(struct Process *)FindTask(NULL);
  140.         WaitPort(&my_process->pr_MsgPort);
  141.         my_startup_message=(struct ArbiterMessage *)GetMsg(&my_process->pr_MsgPort);
  142.  
  143.         view_msg=(struct ViewMessage *)(my_startup_message->data);
  144.         filename=view_msg->filename;
  145.         name=view_msg->name;
  146.         function=view_msg->function;
  147.         initialsearch=view_msg->initialsearch;
  148.         viewdata=view_msg->viewdata;
  149.  
  150.         Forbid();
  151.         for (a=0;;a++) {
  152.                 lsprintf(portname,"DOPUS_VIEW%ld",a);
  153.                 if (!(FindPort(portname))) break;
  154.         }
  155.         Permit();
  156.  
  157.         if (!(view_port=LCreatePort(portname,0))) goto view_end;
  158.         if (view_req=(struct IOStdReq *)LCreateExtIO(view_port,sizeof(struct IOStdReq))) {
  159.                 if (OpenDevice("keyboard.device",0,(struct IORequest *)view_req,0)) {
  160.                         LDeleteExtIO((struct IORequest *)view_req);
  161.                         view_req=NULL;
  162.                         goto view_end;
  163.                 }
  164.         }
  165.  
  166.         if (CheckExist(filename,&size)>=0) {
  167.                 retcode=-2;
  168.                 goto view_end;
  169.         }
  170.         if (size<1) {
  171.                 retcode=-3;
  172.                 goto view_end;
  173.         }
  174.  
  175.         if (viewdata) vdata=viewdata;
  176.         else {
  177.                 if (!(vdata=AllocMem(sizeof(struct ViewData),MEMF_CLEAR))) {
  178.                         retcode=-4;
  179.                         goto view_end;
  180.                 }
  181.         }
  182.  
  183.         strcpy(vdata->view_port_name,portname);
  184.         vdata->view_port=view_port;
  185.         vdata->view_file_size=size;
  186.  
  187.         view_clearsearch(vdata);
  188.  
  189.         vdata->view_search_string[0]=
  190.                 vdata->view_scroll_dir=
  191.                 vdata->view_scroll=
  192.                 vdata->view_last_line=
  193.                 vdata->view_last_charpos=0;
  194.         vdata->view_last_char=NULL;
  195.         vdata->view_first_hilite=
  196.                 vdata->view_current_hilite=NULL;
  197.         vdata->view_search_flags=search_flags;
  198.  
  199.         if (vdata->view_window) {
  200.                 Forbid();       
  201.                 vdata->view_window->UserPort->mp_SigTask=(void *)my_process;
  202.                 Permit();
  203.         }
  204.         else {
  205.                 short scr_pens[ARB_PEN_LASTPEN];
  206.  
  207.                 vdata->view_colour_table[PEN_BACKGROUND]=0;
  208.                 vdata->view_colour_table[PEN_SHADOW]=config->gadgetbotcol;
  209.                 vdata->view_colour_table[PEN_SHINE]=config->gadgettopcol;
  210.                 vdata->view_colour_table[PEN_TEXT]=1;
  211.                 vdata->view_colour_table[PEN_TEXTBACKGROUND]=0;
  212.                 vdata->view_colour_table[VIEWPEN_STATUSTEXT]=config->statusfg;
  213.                 vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND]=config->statusbg;
  214.                 vdata->view_colour_table[VIEWPEN_LAST_COLOUR]=-1;
  215.  
  216.                 if (config->statusbg==0) {
  217.                         scr_pens[ARB_PEN_DETAIL]=config->statusbg;
  218.                         scr_pens[ARB_PEN_BLOCK]=config->statusfg;
  219.                 }
  220.                 else {
  221.                         scr_pens[ARB_PEN_DETAIL]=config->statusfg;
  222.                         scr_pens[ARB_PEN_BLOCK]=config->statusbg;
  223.                 }
  224.  
  225.                 if (!(vdata->view_screen=
  226.                         open_subprocess_screen(globstring[STR_TEXT_VIEWER_TITLE],
  227.                                 scr_font[FONT_TEXT],&vdata->view_memory,
  228.                                 (system_version2)?NULL:scr_pens)) ||
  229.                                 !(vdata->view_font=OpenFont(vdata->view_screen->Font))) {
  230.                         retcode=-4;
  231.                         goto view_end;
  232.                 }
  233.  
  234.                 viewwin.TopEdge=vdata->view_screen->BarHeight+2;
  235.                 viewwin.Width=vdata->view_screen->Width;
  236.                 viewwin.Height=vdata->view_screen->Height-(vdata->view_screen->BarHeight+2);
  237.                 viewwin.Screen=vdata->view_screen;
  238.                 viewwin.BlockPen=vdata->view_colour_table[PEN_SHINE];
  239.  
  240.                 if (!(vdata->view_gadgets=LAllocRemember(&vdata->view_memory,
  241.                                 sizeof(struct Gadget)*VIEW_GADGET_COUNT,MEMF_CLEAR)) ||
  242.                         !(vdata->view_window=OpenWindow(&viewwin))) {
  243.                         CloseScreen(vdata->view_screen);
  244.                         LFreeRemember(&vdata->view_memory);
  245.                         if (!viewdata) FreeMem(vdata,sizeof(struct ViewData));
  246.                         retcode=-4;
  247.                         goto view_end;
  248.                 }
  249.  
  250.                 vdata->view_rastport=vdata->view_window->RPort;
  251.  
  252.                 vdata->view_status_bar_ypos=vdata->view_window->Height-(vdata->view_font->tf_YSize+1);
  253.  
  254.                 vdata->view_vis_info.vi_fg=vdata->view_colour_table[VIEWPEN_STATUSTEXT];
  255.                 vdata->view_vis_info.vi_bg=vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND];
  256.                 vdata->view_vis_info.vi_shine=vdata->view_colour_table[PEN_SHINE];
  257.                 vdata->view_vis_info.vi_shadow=vdata->view_colour_table[PEN_SHADOW];
  258.  
  259.                 vdata->view_vis_info.vi_stringcol[0]=vdata->view_colour_table[PEN_TEXT];
  260.                 vdata->view_vis_info.vi_stringcol[1]=vdata->view_colour_table[PEN_TEXTBACKGROUND];
  261.                 vdata->view_vis_info.vi_activestringcol[0]=vdata->view_colour_table[PEN_TEXT];
  262.                 vdata->view_vis_info.vi_activestringcol[1]=vdata->view_colour_table[PEN_TEXTBACKGROUND];
  263.  
  264.                 if (vdata->view_window->UserData=LAllocRemember(&vdata->view_memory,SEARCH_COLOURS,0)) {
  265.                         vdata->view_window->UserData[SEARCH_COL_FG]=
  266.                                 vdata->view_colour_table[VIEWPEN_STATUSTEXT];
  267.                         vdata->view_window->UserData[SEARCH_COL_BG]=
  268.                                 vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND];
  269.                         vdata->view_window->UserData[SEARCH_COL_SHINE]=
  270.                                 vdata->view_colour_table[PEN_SHINE];
  271.                         vdata->view_window->UserData[SEARCH_COL_SHADOW]=
  272.                                 vdata->view_colour_table[PEN_SHADOW];
  273.                         vdata->view_window->UserData[SEARCH_COL_STRINGFG]=
  274.                                 vdata->view_colour_table[PEN_TEXT];
  275.                         vdata->view_window->UserData[SEARCH_COL_STRINGBG]=
  276.                                 vdata->view_colour_table[PEN_TEXTBACKGROUND];
  277.                         vdata->view_window->UserData[SEARCH_COL_STRINGSELFG]=
  278.                                 vdata->view_colour_table[PEN_TEXT];
  279.                         vdata->view_window->UserData[SEARCH_COL_STRINGSELBG]=
  280.                                 vdata->view_colour_table[PEN_TEXTBACKGROUND];
  281.                 }
  282.  
  283.                 vdata->view_vis_info.vi_font=vdata->view_font;
  284.                 if (vdata->view_vis_info.vi_flags&VISF_WINDOW)
  285.                         vdata->view_vis_info.vi_screen=(struct Screen *)vdata->view_window;
  286.                 else vdata->view_vis_info.vi_screen=vdata->view_screen;
  287.  
  288.                 if (config->generalscreenflags&SCR_GENERAL_REQDRAG)
  289.                         vdata->view_vis_info.vi_flags|=VISF_BORDERS;
  290.  
  291.                 vdata->view_vis_info.vi_language=config->language;
  292.  
  293.                 if (config->viewbits&VIEWBITS_TEXTBORDERS) {
  294.                         vdata->view_lines_per_screen=(vdata->view_status_bar_ypos-6)/vdata->view_font->tf_YSize;
  295.  
  296.                         vdata->view_display_left=4;
  297.                         vdata->view_display_top=((vdata->view_status_bar_ypos-6)-
  298.                                 (vdata->view_lines_per_screen*vdata->view_font->tf_YSize))/2;
  299.                         if (vdata->view_display_top<2) vdata->view_display_top=2;
  300.  
  301.                         vdata->view_display_right=vdata->view_window->Width-20;
  302.                         vdata->view_display_bottom=vdata->view_status_bar_ypos-5;
  303.  
  304.                         Do3DBox(vdata->view_rastport,vdata->view_display_left-2,1,
  305.                                 (vdata->view_display_right-vdata->view_display_left)+4,
  306.                                 vdata->view_display_bottom,
  307.                                 vdata->view_colour_table[PEN_SHINE],
  308.                                 vdata->view_colour_table[PEN_SHADOW]);
  309.  
  310.                         vdata->view_gadgets[VIEW_SCROLLGADGET].LeftEdge=vdata->view_display_right+8;
  311.                         vdata->view_gadgets[VIEW_SCROLLGADGET].TopEdge=2;
  312.                         vdata->view_gadgets[VIEW_SCROLLGADGET].Height=vdata->view_display_bottom-2;
  313.                         vdata->view_gadgets[VIEW_SCROLLGADGET].Width=8;
  314.                         vdata->view_gadgets[VIEW_SCROLLGADGET].Flags=GFLG_GADGHNONE;
  315.                         vdata->view_gadgets[VIEW_SCROLLGADGET].Activation=
  316.                                 GACT_IMMEDIATE|GACT_RELVERIFY|GACT_FOLLOWMOUSE;
  317.                         vdata->view_gadgets[VIEW_SCROLLGADGET].GadgetType=GTYP_PROPGADGET;
  318.                         vdata->view_gadgets[VIEW_SCROLLGADGET].GadgetRender=
  319.                                 (APTR)&vdata->view_prop_image;
  320.                         vdata->view_gadgets[VIEW_SCROLLGADGET].SpecialInfo=
  321.                                 (APTR)&vdata->view_prop_info;
  322.                         vdata->view_gadgets[VIEW_SCROLLGADGET].GadgetID=VIEW_SCROLLGADGET;
  323.  
  324.                         vdata->view_prop_info.Flags=AUTOKNOB|FREEVERT|PROPNEWLOOK|PROPBORDERLESS;
  325.                         vdata->view_prop_info.VertBody=MAXBODY;
  326.  
  327.                         AddGList(vdata->view_window,&vdata->view_gadgets[VIEW_SCROLLGADGET],-1,1,NULL);
  328.                         RefreshGList(&vdata->view_gadgets[VIEW_SCROLLGADGET],vdata->view_window,NULL,1);
  329.                         Do3DBox(vdata->view_rastport,
  330.                                 vdata->view_gadgets[VIEW_SCROLLGADGET].LeftEdge-2,
  331.                                 vdata->view_gadgets[VIEW_SCROLLGADGET].TopEdge-1,
  332.                                 vdata->view_gadgets[VIEW_SCROLLGADGET].Width+4,
  333.                                 vdata->view_gadgets[VIEW_SCROLLGADGET].Height+2,
  334.                                 vdata->view_colour_table[PEN_SHINE],
  335.                                 vdata->view_colour_table[PEN_SHADOW]);
  336.  
  337.                         vdata->view_scroll_bar=1;
  338.                 }
  339.                 else {
  340.                         vdata->view_lines_per_screen=(vdata->view_status_bar_ypos-1)/vdata->view_font->tf_YSize;
  341.  
  342.                         vdata->view_display_left=vdata->view_display_top=0;
  343.                         vdata->view_display_right=vdata->view_window->Width-1;
  344.                         vdata->view_display_bottom=vdata->view_display_top+
  345.                                 (vdata->view_lines_per_screen*vdata->view_font->tf_YSize)-1;
  346.                 }
  347.  
  348.                 vdata->view_display_height=vdata->view_lines_per_screen*vdata->view_font->tf_YSize;
  349.  
  350.                 for (a=9;a<11;a++) {
  351.                         vdata->view_gadgets[a].TopEdge=vdata->view_status_bar_ypos;
  352.                         vdata->view_gadgets[a].Width=vdata->view_font->tf_XSize*((a==9)?6:4);
  353.                         vdata->view_gadgets[a].Height=vdata->view_font->tf_YSize;
  354.                         vdata->view_gadgets[a].Flags=GFLG_GADGHCOMP;
  355.                         vdata->view_gadgets[a].Activation=GACT_RELVERIFY;
  356.                         vdata->view_gadgets[a].GadgetType=GTYP_BOOLGADGET;
  357.                         vdata->view_gadgets[a].GadgetID=a;
  358.                 }
  359.  
  360.                 vdata->view_gadgets[VIEW_JUMPTOLINE].NextGadget=&vdata->view_gadgets[VIEW_JUMPTOPERCENT];
  361.                 vdata->view_gadgets[VIEW_JUMPTOLINE].LeftEdge=
  362.                         vdata->view_window->Width-((vdata->view_font->tf_XSize*49)+14);
  363.                 vdata->view_gadgets[VIEW_JUMPTOPERCENT].LeftEdge=
  364.                         vdata->view_window->Width-((vdata->view_font->tf_XSize*22)+14);
  365.  
  366.                 view_setupscreen(vdata);
  367.                 AddGadgetBorders(&vdata->view_memory,
  368.                         vdata->view_gadgets,9,
  369.                         vdata->view_colour_table[PEN_SHINE],vdata->view_colour_table[PEN_SHADOW]);
  370.                 AddGList(vdata->view_window,vdata->view_gadgets,-1,11,NULL);
  371.         }
  372.  
  373.         vdata->view_char_width=((vdata->view_display_right-vdata->view_display_left)+1)/
  374.                 vdata->view_font->tf_XSize;
  375.  
  376.         if (function==FUNC_HEXREAD) {
  377.                 vdata->view_char_width=(vdata->view_char_width>62)?62:vdata->view_char_width;
  378.                 vdata->view_max_line_length=16;
  379.         }
  380.         else vdata->view_max_line_length=vdata->view_char_width+1;
  381.  
  382.         a=vdata->view_window->Height/8;
  383.         scroll_pos_1=a;
  384.         scroll_pos_2=a*2;
  385.         scroll_pos_3=a*3;
  386.         scroll_pos_4=a*4;
  387.         scroll_pos_5=a*5;
  388.         scroll_pos_6=a*6;
  389.         scroll_pos_7=a*7;
  390.  
  391.         vdata->view_display_as_hex=(function==FUNC_HEXREAD);
  392.  
  393.         view_busy(vdata);
  394.         ActivateWindow(vdata->view_window);
  395.  
  396.         view_status_text(vdata,globstring[STR_READING_FILE]);
  397. tryload:
  398.         if (vdata->view_file_size>16) {
  399.                 if (!PPBase ||
  400.                         (err=ppLoadData(filename,DECR_POINTER,MEMF_CLEAR,
  401.                                 (UBYTE **)&vdata->view_text_buffer,&size,NULL))==PP_UNKNOWNPP)
  402.                         goto readnormal;
  403.  
  404.                 old_file_size=vdata->view_file_size;
  405.                 old_buffer_size=vdata->view_buffer_size;
  406.  
  407.                 vdata->view_file_size=vdata->view_buffer_size=size;
  408.  
  409.                 if ((size%16)==0) size+=16;
  410.                 else size=((vdata->view_file_size/16)+1)*16;
  411.  
  412.                 vdata->view_last_char=vdata->view_text_buffer+size-16;
  413.                 vdata->view_last_charpos=vdata->view_file_size-
  414.                         (vdata->view_last_char-vdata->view_text_buffer);
  415.  
  416.                 if (err) {
  417.                         vdata->view_text_buffer=NULL;
  418.                         vdata->view_file_size=0;
  419.  
  420.                         if (err==PP_NOMEMORY) {
  421.                                 view_status_text(vdata,globstring[STR_NO_MEMORY_TO_DECRUNCH]);
  422.                                 vdata->view_file_size=old_file_size;
  423.                                 vdata->view_buffer_size=old_buffer_size;
  424.                                 goto readnormal;
  425.                         }
  426.                         else if (err==PP_PASSERR) {
  427.                                 view_status_text(vdata,globstring[STR_BAD_PASSWORD]);
  428.                                 view_simplerequest(vdata,globstring[STR_BAD_PASSWORD],globstring[STR_CONTINUE],NULL);
  429.                                 goto cleanup;
  430.                         }
  431.                         else {
  432. readnormal:
  433.                                 if (!(in=Open(filename,MODE_OLDFILE))) goto cleanup;
  434.                                 if ((vdata->view_file_size%16)==0)
  435.                                         vdata->view_buffer_size=vdata->view_file_size+16;
  436.                                 else vdata->view_buffer_size=((vdata->view_file_size/16)+1)*16;
  437.  
  438.                                 for (a=0;a<2;a++) {
  439.                                         if (vdata->view_text_buffer=AllocMem(vdata->view_buffer_size,MEMF_CLEAR))
  440.                                                 break;
  441.                                         if ((vdata->view_buffer_size=AvailMem(MEMF_PUBLIC|MEMF_LARGEST))<16)
  442.                                                 break;
  443.                                         if (vdata->view_buffer_size<=vdata->view_file_size)
  444.                                                 vdata->view_file_size=vdata->view_buffer_size;
  445.                                 }
  446.                                 if (!vdata->view_text_buffer) {
  447.                                         Close(in);
  448.                                         goto cleanup;
  449.                                 }
  450.  
  451.                                 fsize=Read(in,vdata->view_text_buffer,vdata->view_file_size);
  452.  
  453.                                 if (vdata->view_buffer_size!=vdata->view_file_size &&
  454.                                         fsize>-1 && fsize!=vdata->view_file_size) vdata->view_file_size=fsize;
  455.  
  456.                                 Close(in);
  457.                                 if (fsize==-1) goto cleanup;
  458.                                 vdata->view_last_char=vdata->view_text_buffer+vdata->view_buffer_size-16;
  459.                                 vdata->view_last_charpos=vdata->view_file_size-
  460.                                         (vdata->view_last_char-vdata->view_text_buffer);
  461.                         }
  462.                 }
  463.         }
  464.         else {
  465.                 vdata->view_buffer_size=16;
  466.                 if (!(in=Open(filename,MODE_OLDFILE))) goto cleanup;
  467.                 if (!(vdata->view_text_buffer=AllocMem(16,MEMF_CLEAR))) {
  468.                         Close(in);
  469.                         goto cleanup;
  470.                 }
  471.                 vdata->view_file_size=Read(in,vdata->view_text_buffer,16);
  472.                 Close(in);
  473.                 vdata->view_last_char=vdata->view_text_buffer;
  474.                 vdata->view_last_charpos=vdata->view_file_size;
  475.         }
  476.  
  477.         vdata->view_text_offset=
  478.                 vdata->view_old_offset=
  479.                 vdata->view_line_count=
  480.                 vdata->view_top_buffer_pos=
  481.                 vdata->view_bottom_buffer_pos=0;
  482.  
  483.         view_status_text(vdata,globstring[STR_COUNTING_LINES]);
  484.  
  485.         if (function==FUNC_SMARTREAD) {
  486.                 if ((vdata->view_line_count=smartcountlines(vdata))==-1) {
  487.                         vdata->view_display_as_hex=1;
  488.                         vdata->view_max_line_length=16;
  489.                         vdata->view_char_width=62;
  490.                 }
  491.                 else if (vdata->view_line_count==-2) function=FUNC_ANSIREAD;
  492.                 else removetabs(vdata);
  493.         }
  494.  
  495.         if (function==FUNC_ANSIREAD) {
  496.                 vdata->view_tab_size=config->tabsize;
  497.                 vdata->view_line_count=ansicountlines(vdata);
  498.         }
  499.         else {
  500.                 if (vdata->view_display_as_hex) {
  501.                         vdata->view_file_size=vdata->view_buffer_size;
  502.                         vdata->view_line_count=vdata->view_file_size/16;
  503.                         if (vdata->view_file_size<16) {
  504.                                 vdata->view_line_count=1;
  505.                         }
  506.                         else if (vdata->view_file_size%16!=0) {
  507.                                 ++vdata->view_line_count;
  508.                         }
  509.                 }
  510.                 else {
  511.                         vdata->view_line_count=countlines(vdata);
  512.                 }
  513.         }
  514.  
  515.         vdata->view_last_line=vdata->view_line_count-vdata->view_lines_per_screen;
  516.         if (vdata->view_last_line<0) vdata->view_last_line=0;
  517.  
  518.         if (function==FUNC_ANSIREAD && !vdata->view_display_as_hex) {
  519.                 vdata->view_display_as_ansi=1;
  520.  
  521.                 ansiread_win.Width=vdata->view_char_width*vdata->view_font->tf_XSize;
  522.                 ansiread_win.Height=vdata->view_font->tf_YSize*3;
  523.                 ansiread_win.Screen=vdata->view_screen;
  524.  
  525.                 if (!(vdata->view_ansiread_window=OpenWindow(&ansiread_win)))
  526.                         vdata->view_display_as_ansi=0;
  527.                 else {
  528.                         SetFont(vdata->view_ansiread_window->RPort,vdata->view_font);
  529.                         vdata->view_console_request.io_Data=(APTR)vdata->view_ansiread_window;
  530.                         Delay(5);
  531.                 }
  532.  
  533.                 if (vdata->view_display_as_ansi) {
  534.                         if (OpenDevice("console.device",0,(struct IORequest *)&vdata->view_console_request,0))
  535.                                 vdata->view_display_as_ansi=0;
  536.                         else {
  537.                                 view_console_unit=(struct ConUnit *)vdata->view_console_request.io_Unit;
  538.                                 for (a=0;a<MAXTABS;a++) {
  539.                                         view_console_unit->cu_TabStops[a]=a*config->tabsize;
  540.                                 }
  541.                                 view_console_unit->cu_TabStops[MAXTABS-1]=0xffff;
  542.                                 lsprintf(buf,"\x9b\x30\x20\x70\x9b%ld\x74",vdata->view_lines_per_screen);
  543.                                 view_print(vdata,buf,1,strlen(buf));
  544.                                 vdata->view_max_line_length=255;
  545.                         }
  546.                 }
  547.         }
  548.         else vdata->view_display_as_ansi=0;
  549.  
  550.         view_status_text(vdata,name);
  551.         vdata->view_file_name=name;
  552.         vdata->view_path_name=filename;
  553.         view_update_status(vdata);
  554.         view_penrp(vdata);
  555.  
  556.         vdata->view_scroll_width=vdata->view_char_width*vdata->view_font->tf_XSize;
  557.         view_displayall(vdata);
  558.         retcode=1;
  559.  
  560.         if (config->viewbits&VIEWBITS_TEXTBORDERS) {
  561.                 FixSliderBody(vdata->view_window,&vdata->view_gadgets[VIEW_SCROLLGADGET],
  562.                         vdata->view_line_count,vdata->view_lines_per_screen,1);
  563.                 FixSliderPot(vdata->view_window,&vdata->view_gadgets[VIEW_SCROLLGADGET],
  564.                         0,vdata->view_line_count,vdata->view_lines_per_screen,1);
  565.         }
  566.  
  567.         lsprintf(titlebuf,"%s - \"%s\"",globstring[STR_FILE],vdata->view_path_name);
  568.         SetWindowTitles(vdata->view_window,(char *)-1,titlebuf);
  569.  
  570.         vdata->view_window->WLayer->Flags|=LAYERBACKDROP;
  571.  
  572.         view_unbusy(vdata);
  573.  
  574.         if (initialsearch) {
  575.                 strcpy(vdata->view_search_string,initialsearch);
  576.                 view_search(vdata,1);
  577.         }
  578.  
  579.         FOREVER {
  580.                 while (msg=(struct IntuiMessage *)GetMsg(vdata->view_window->UserPort)) {
  581.                         class=msg->Class; code=msg->Code; qual=msg->Qualifier;
  582.                         gadget=(struct Gadget *)msg->IAddress;
  583.                         ReplyMsg((struct Message *)msg);
  584.  
  585.                         switch (class) {
  586.                                 case IDCMP_MOUSEMOVE:
  587.                                         if (vdata->view_gadgets[VIEW_SCROLLGADGET].Flags&GFLG_SELECTED)
  588.                                                 view_fix_scroll_gadget(vdata);
  589.                                         break;
  590.                                 case IDCMP_MOUSEBUTTONS:
  591.                                         if (code==SELECTDOWN) view_togglescroll(vdata);
  592.                                         else if (code==MENUDOWN) {
  593.                                                 retcode=-1;
  594.                                                 goto cleanup;
  595.                                         }
  596.                                         break;
  597.                                 case IDCMP_GADGETDOWN:
  598.                                         if (vdata->view_scroll) {
  599.                                                 view_togglescroll(vdata);
  600.                                                 break;
  601.                                         }
  602.                                         gadgetid=gadget->GadgetID;
  603.                                         switch (gadgetid) {
  604.                                                 case VIEW_SCROLLGADGET:
  605.                                                         view_fix_scroll_gadget(vdata);
  606.                                                         break;
  607.                                                 case VIEW_SCROLLUP:
  608.                                                 case VIEW_SCROLLDOWN:
  609.                                                         if (gadgetid==VIEW_SCROLLUP) a=view_lineup(vdata);
  610.                                                         else a=view_linedown(vdata);
  611.                                                         if (!a) break;
  612.                                                         Delay(5);
  613.                                                         FOREVER {
  614.                                                                 if (msg=(struct IntuiMessage *)GetMsg(vdata->view_window->UserPort)) {
  615.                                                                         if (msg->Class==IDCMP_GADGETUP ||
  616.                                                                                 (msg->Class==IDCMP_MOUSEBUTTONS && msg->Code==SELECTUP))
  617.                                                                                 break;
  618.                                                                         ReplyMsg((struct Message *)msg); msg=NULL;
  619.                                                                 }
  620.                                                                 if (gadgetid==VIEW_SCROLLUP) a=view_lineup(vdata);
  621.                                                                 else a=view_linedown(vdata);
  622.                                                                 if (!a) break;
  623.                                                         }
  624.                                                         if (msg) ReplyMsg((struct Message *)msg);
  625.                                                         break;
  626.                                         }
  627.                                         break;
  628.                                 case IDCMP_GADGETUP:
  629.                                         if (vdata->view_scroll) {
  630.                                                 view_togglescroll(vdata);
  631.                                                 break;
  632.                                         }
  633.                                         gadgetid=gadget->GadgetID;
  634. testgad:
  635.                                         switch (gadgetid) {
  636.                                                 case VIEW_SCROLLGADGET:
  637.                                                         view_fix_scroll_gadget(vdata);
  638.                                                         break;
  639.                                                 case VIEW_PAGEUP:
  640.                                                         view_pageup(vdata);
  641.                                                         break;
  642.                                                 case VIEW_PAGEDOWN:
  643.                                                         view_pagedown(vdata);
  644.                                                         break;
  645.                                                 case VIEW_GOTOP:
  646.                                                         view_gotop(vdata);
  647.                                                         break;
  648.                                                 case VIEW_GOBOTTOM:
  649.                                                         view_gobottom(vdata);
  650.                                                         break;
  651.                                                 case VIEW_SEARCH:
  652.                                                         view_search(vdata,1);
  653.                                                         break;
  654.                                                 case VIEW_QUIT:
  655.                                                         goto cleanup;
  656.                                                         break;
  657.                                                 case VIEW_PRINT:
  658.                                                         view_checkprint(vdata,0);
  659.                                                         break;
  660.                                                 case VIEW_JUMPTOLINE:
  661.                                                 case VIEW_JUMPTOPERCENT:
  662.                                                         view_busy(vdata);
  663.                                                         buf[0]=0;
  664.                                                         if (gadgetid==VIEW_JUMPTOLINE) {
  665.                                                                 a=10;
  666.                                                                 b=STR_JUMP_TO_LINE;
  667.                                                         }
  668.                                                         else {
  669.                                                                 a=4;
  670.                                                                 b=STR_JUMP_TO_PERCENTAGE;
  671.                                                         }
  672.                                                         if (!(view_whatsit(vdata,globstring[b],a,buf)) || !buf[0]) {
  673.                                                                 view_unbusy(vdata);
  674.                                                                 break;
  675.                                                         }
  676.                                                         a=atoi(buf); if (a<0) a=0;
  677.                                                         if (gadgetid==VIEW_JUMPTOPERCENT)
  678.                                                                 a=((a+1)*(vdata->view_last_line))/100;
  679.                                                         if (a>vdata->view_last_line) a=vdata->view_last_line;
  680.  
  681.                                                         if (vdata->view_display_as_hex) {
  682.                                                                 if (vdata->view_text_offset!=a) {
  683.                                                                         vdata->view_text_offset=a;
  684.                                                                         view_displayall(vdata);
  685.                                                                 }
  686.                                                                 view_unbusy(vdata);
  687.                                                                 break;
  688.                                                         }
  689.  
  690.                                                         if (vdata->view_text_offset!=a) {
  691.                                                                 if (vdata->view_text_offset<a) {
  692.                                                                         if (a-vdata->view_text_offset<vdata->view_last_line-a) {
  693.                                                                                 for (b=vdata->view_text_offset;b<a;b++) {
  694.                                                                                         for (c=vdata->view_top_buffer_pos;c<vdata->view_file_size;c++)
  695.                                                                                                 if (vdata->view_text_buffer[c]==10) break;
  696.                                                                                         vdata->view_top_buffer_pos=c+1;
  697.                                                                                 }
  698.                                                                         }
  699.                                                                         else {
  700.                                                                                 vdata->view_text_offset=vdata->view_last_line;
  701.                                                                                 vdata->view_top_buffer_pos=vdata->view_file_size;
  702.                                                                                 for (c=0;c<vdata->view_lines_per_screen;c++) {
  703.                                                                                         for (b=vdata->view_top_buffer_pos-2;b>=0;b--)
  704.                                                                                                 if (vdata->view_text_buffer[b]==10) break;
  705.                                                                                         vdata->view_top_buffer_pos=b+1;
  706.                                                                                 }
  707.                                                                                 for (b=a;b<vdata->view_text_offset;b++) {
  708.                                                                                         for (c=vdata->view_top_buffer_pos-2;c>=0;c--)
  709.                                                                                                 if (vdata->view_text_buffer[c]==10) break;
  710.                                                                                         vdata->view_top_buffer_pos=c+1;
  711.                                                                                 }
  712.                                                                         }
  713.                                                                 }
  714.                                                                 else {
  715.                                                                         if (vdata->view_text_offset-a<a) {
  716.                                                                                 for (b=a;b<vdata->view_text_offset;b++) {
  717.                                                                                         for (c=vdata->view_top_buffer_pos-2;c>=0;c--)
  718.                                                                                                 if (vdata->view_text_buffer[c]==10) break;
  719.                                                                                         vdata->view_top_buffer_pos=c+1;
  720.                                                                                 }
  721.                                                                         }
  722.                                                                         else {
  723.                                                                                 vdata->view_top_buffer_pos=0;
  724.                                                                                 for (b=0;b<a;b++) {
  725.                                                                                         for (c=vdata->view_top_buffer_pos;c<vdata->view_file_size;c++)
  726.                                                                                                 if (vdata->view_text_buffer[c]==10) break;
  727.                                                                                         vdata->view_top_buffer_pos=c+1;
  728.                                                                                 }
  729.                                                                         }
  730.                                                                 }
  731.                                                                 vdata->view_text_offset=a;
  732.                                                                 view_displayall(vdata);
  733.                                                         }
  734.                                                         view_unbusy(vdata);
  735.                                                         break;
  736.                                         }
  737.                                         break;
  738.                                 case IDCMP_RAWKEY:
  739.                                         if (vdata->view_scroll && code!=0x40) {
  740.                                                 view_togglescroll(vdata);
  741.                                                 break;
  742.                                         }
  743.                                         switch (code) {
  744.                                                 case 0x45:
  745.                                                         retcode=-1;
  746.                                                 case 0x10:
  747.                                                 case 0x32:
  748.                                                         goto cleanup;
  749.                                                 case 0x35:
  750.                                                 case 0x1d:
  751.                                                         view_gobottom(vdata);
  752.                                                         break;
  753.                                                 case 0x14:
  754.                                                 case 0x3d:
  755.                                                         view_gotop(vdata);
  756.                                                         break;
  757.                                                 case 0x16:
  758.                                                 case 0x3f:
  759. /* Code added by Pavel Cizek, 28. 3. 2000:
  760.  *   It enables to use backspace to goto one page up
  761.  */
  762.                                                 case 0x41:
  763. /* End of inserted code */
  764.                                                         view_pageup(vdata);
  765.                                                         break;
  766.                                                 case 0x22:
  767.                                                 case 0x1f:
  768. /* Code added by Pavel Cizek, 28. 3. 2000:
  769.  *   It enables to use space to goto one page down
  770.  *   The code for scroll toggle had to be omitted.
  771.  */
  772.                                                 case 0x40:
  773. /* End of inserted code */
  774.                                                         view_pagedown(vdata);
  775.                                                         break;
  776.                                                 case 0x21:
  777. /* Code added by Pavel Cizek, 28. 3. 2000:
  778.  *   It enables to use '/' to invoke search window
  779.  */
  780.                                                 case 0x3A:
  781. /* End of inserted code */
  782.                                                         view_search(vdata,1);
  783.                                                         break;
  784.                                                 case 0x26:
  785.                                                         gadgetid=VIEW_JUMPTOLINE;
  786.                                                         goto testgad;
  787.                                                 case 0x36:
  788.                                                         view_search(vdata,0);
  789.                                                         break;
  790. /* Code deleted by Pavel Cizek, 28. 3. 2000:
  791.  *   It was deactivated so that space can be used for Page Down command
  792.                                                 case 0xc0:
  793.                                                         view_togglescroll(vdata);
  794.                                                        break;
  795.  * End of deleted code
  796.  */
  797.                                                 case CURSOR_UP:
  798.                                                 case 0x3e:
  799.                                                         if (vdata->view_line_count<=vdata->view_lines_per_screen) break;
  800.                                                         view_readkeys(view_req,key_matrix);
  801.                                                         if (!(qual&IEQUALIFIER_REPEAT) ||
  802.                                                                 key_matrix[9]&16 || key_matrix[7]&64) {
  803.                                                                 if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) view_pageup(vdata);
  804.                                                                 else if (qual&IEQUALIFIER_CONTROL) view_gotop(vdata);
  805.                                                                 else view_lineup(vdata);
  806.                                                         }
  807.                                                         break;
  808.                                                 case CURSOR_DOWN:
  809.                                                 case 0x1e:
  810.                                                         if (vdata->view_line_count<=vdata->view_lines_per_screen) break;
  811.                                                         view_readkeys(view_req,key_matrix);
  812.                                                         if (!(qual&IEQUALIFIER_REPEAT) ||
  813.                                                                 key_matrix[9]&32 || key_matrix[3]&64) {
  814.                                                                 if (qual&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT)) view_pagedown(vdata);
  815.                                                                 else if (qual&IEQUALIFIER_CONTROL) view_gobottom(vdata);
  816.                                                                 else view_linedown(vdata);
  817.                                                         }
  818.                                                         break;
  819.                                                 case 0x19: view_checkprint(vdata,0); break;
  820.                                                 case 0x33: view_checkprint(vdata,1); break;
  821.                                         }
  822.                                         break;
  823.                         }
  824.                 }
  825.                 if (IntuitionBase->ActiveWindow==vdata->view_window && vdata->view_scroll) {
  826.                         a=vdata->view_window->MouseY;
  827.                         if (a<scroll_pos_4) {
  828.                                 if (a<scroll_pos_1) scroll_speed=1;
  829.                                 else if (a<scroll_pos_2) scroll_speed=vdata->view_font->tf_YSize/4;
  830.                                 else if (a<scroll_pos_3) scroll_speed=vdata->view_font->tf_YSize/2;
  831.                                 else if (a<scroll_pos_4-10) scroll_speed=vdata->view_font->tf_YSize;
  832.                                 else scroll_speed=0;
  833.  
  834.                                 if (scroll_speed>0 && vdata->view_line_count>vdata->view_lines_per_screen) {
  835.                                         --vdata->view_text_offset;
  836.                                         if (vdata->view_text_offset<0) {
  837.                                                 vdata->view_text_offset=0;
  838.                                                 view_togglescroll(vdata);
  839.                                         }
  840.                                         else {
  841.                                                 if (vdata->view_scroll_dir==1) view_display(vdata,scroll_speed,1);
  842.                                                 else view_display(vdata,scroll_speed,0);
  843.                                         }
  844.                                         vdata->view_scroll_dir=-1;
  845.                                 }
  846.                         }
  847.                         else {
  848.                                 if (a>scroll_pos_7) scroll_speed=1;
  849.                                 else if (a>scroll_pos_6) scroll_speed=vdata->view_font->tf_YSize/4;
  850.                                 else if (a>scroll_pos_5) scroll_speed=vdata->view_font->tf_YSize/2;
  851.                                 else if (a>scroll_pos_4+10) scroll_speed=vdata->view_font->tf_YSize;
  852.                                 else scroll_speed=0;
  853.                                 if (scroll_speed>0 && vdata->view_line_count>vdata->view_lines_per_screen) {
  854.                                         ++vdata->view_text_offset;
  855.                                         vdata->view_scroll_dir=1;
  856.                                         if (vdata->view_text_offset>vdata->view_last_line) {
  857.                                                 vdata->view_text_offset=vdata->view_last_line;
  858.                                                 view_togglescroll(vdata);
  859.                                         }
  860.                                         else view_display(vdata,scroll_speed,0);
  861.                                 }
  862.                         }
  863.                         continue;
  864.                 }
  865.                 Wait(1<<vdata->view_window->UserPort->mp_SigBit);
  866.         }
  867.  
  868. cleanup:
  869.         if (vdata->view_text_buffer)
  870.                 FreeMem(vdata->view_text_buffer,vdata->view_buffer_size);
  871.         if (view_console_unit)
  872.                 CloseDevice((struct IORequest *)&vdata->view_console_request);
  873.         if (vdata->view_ansiread_window) {
  874.                 CloseWindow(vdata->view_ansiread_window);
  875.                 vdata->view_ansiread_window=NULL;
  876.         }
  877.         view_clearhilite(vdata,0);
  878.         if (!viewdata) {
  879.                 cleanupviewfile(vdata);
  880.                 FreeMem(vdata,sizeof(struct ViewData));
  881.         }
  882.         else {
  883.                 SetBusyPointer(vdata->view_window);
  884.                 vdata->view_window->WLayer->Flags&=~LAYERBACKDROP;
  885.         }
  886.  
  887. view_end:
  888.         if (view_req) {
  889.                 CloseDevice((struct IORequest *)view_req);
  890.                 LDeleteExtIO((struct IORequest *)view_req);
  891.         }
  892.         if (view_port) LDeletePort(view_port);
  893.         my_startup_message->command=retcode;
  894.         Forbid();
  895.         ReplyMsg((struct Message *)my_startup_message);
  896.         return;
  897. }
  898.  
  899. void cleanupviewfile(vdata)
  900. struct ViewData *vdata;
  901. {
  902.         if (vdata->view_screen) {
  903.                 ScreenToBack(vdata->view_screen);
  904.                 if (vdata->view_window) CloseWindow(vdata->view_window);
  905.                 CloseScreen(vdata->view_screen);
  906.                 if (vdata->view_font) CloseFont(vdata->view_font);
  907.         }
  908.         LFreeRemember(&vdata->view_memory);
  909. }
  910.  
  911. void view_display(vdata,scroll_speed,w)
  912. struct ViewData *vdata;
  913. int scroll_speed,w;
  914. {
  915.         int a,b,c,d;
  916.  
  917.         view_clearhilite(vdata,1);
  918.         view_clearsearch(vdata);
  919.  
  920.         d=vdata->view_font->tf_YSize/scroll_speed;
  921.  
  922.         if (vdata->view_text_offset<vdata->view_old_offset) {
  923.                 --vdata->view_old_offset;
  924.                 a=0;
  925.                 while (a<vdata->view_font->tf_YSize) {
  926.                         if (a+d>vdata->view_font->tf_YSize) d=vdata->view_font->tf_YSize-a;
  927.                         view_doscroll(vdata,-d,vdata->view_scroll_width);
  928.                         a+=d;
  929.                 }
  930.                 if (vdata->view_display_as_hex) {
  931.                         view_print(vdata,&vdata->view_text_buffer[vdata->view_text_offset*16],0,16);
  932.                         view_update_status(vdata);
  933.                         return;
  934.                 }
  935.                 else {
  936.                         for (a=vdata->view_top_buffer_pos-2,b=0;a>=0;a--,b++) {
  937.                                 if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  938.                                         break;
  939.                         }
  940.                         c=vdata->view_top_buffer_pos-a-1;
  941.                         vdata->view_top_buffer_pos=a+1;
  942.                         for (a=vdata->view_bottom_buffer_pos-2,b=0;a>=0;a--,b++) {
  943.                                 if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  944.                                         break;
  945.                         }
  946.                         vdata->view_bottom_buffer_pos=a+1;
  947.                 }
  948.                 if (vdata->view_top_buffer_pos+c>vdata->view_file_size)
  949.                         c=vdata->view_file_size-vdata->view_top_buffer_pos;
  950.                 view_print(vdata,&vdata->view_text_buffer[vdata->view_top_buffer_pos],0,c);
  951.         }
  952.         else if (vdata->view_text_offset>vdata->view_old_offset) {
  953.                 ++vdata->view_old_offset;
  954.                 a=0;
  955.                 while (a<vdata->view_font->tf_YSize) {
  956.                         if (a+d>vdata->view_font->tf_YSize) d=vdata->view_font->tf_YSize-a;
  957.                         view_doscroll(vdata,d,vdata->view_scroll_width);
  958.                         a+=d;
  959.                 }
  960.                 if (!w && !vdata->view_display_as_hex) {
  961.                         for (a=vdata->view_top_buffer_pos,b=0;a<vdata->view_file_size;a++,b++) {
  962.                                 if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  963.                                         break;
  964.                         }
  965.                         vdata->view_top_buffer_pos=a+1;
  966.                 }
  967.                 if (!vdata->view_display_as_hex) {
  968.                         for (a=vdata->view_bottom_buffer_pos,b=0;a<vdata->view_file_size;a++,b++) {
  969.                                 if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  970.                                         break;
  971.                         }
  972.                         vdata->view_bottom_buffer_pos=a+1;
  973.                 }
  974.                 if (vdata->view_bottom_buffer_pos<vdata->view_file_size) {
  975.                         if (vdata->view_display_as_hex) {
  976.                                 view_print(vdata,
  977.                                         &vdata->view_text_buffer[(vdata->view_text_offset+vdata->view_lines_per_screen-1)*16],
  978.                                         vdata->view_lines_per_screen-1,16);
  979.                         }
  980.                         else {
  981.                                 for (a=vdata->view_bottom_buffer_pos,b=0;a<vdata->view_file_size;a++,b++) {
  982.                                         if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  983.                                         break;
  984.                                 }
  985.                                 c=a-vdata->view_bottom_buffer_pos+1;
  986.                                 if (vdata->view_bottom_buffer_pos+c>vdata->view_file_size)
  987.                                         c=vdata->view_file_size-vdata->view_bottom_buffer_pos;
  988.                                 view_print(vdata,
  989.                                         &vdata->view_text_buffer[vdata->view_bottom_buffer_pos],
  990.                                         vdata->view_lines_per_screen-1,c);
  991.                         }
  992.                 }
  993.         }
  994.         view_update_status(vdata);
  995. }
  996.  
  997. void view_displayall(vdata)
  998. struct ViewData *vdata;
  999. {
  1000.         int a,c,d,f;
  1001.  
  1002.         SetAPen(vdata->view_rastport,vdata->view_colour_table[PEN_TEXTBACKGROUND]);
  1003.         RectFill(vdata->view_rastport,
  1004.                 vdata->view_display_left,
  1005.                 vdata->view_display_top,
  1006.                 vdata->view_display_right,
  1007.                 vdata->view_display_bottom);
  1008.         SetAPen(vdata->view_rastport,vdata->view_colour_table[PEN_TEXT]);
  1009.  
  1010.         view_clearhilite(vdata,0);
  1011.         view_clearsearch(vdata);
  1012.  
  1013.         f=d=vdata->view_bottom_buffer_pos=vdata->view_top_buffer_pos;
  1014.  
  1015.         if (vdata->view_display_as_hex) {
  1016.                 d=vdata->view_text_offset*16;
  1017.                 for (a=0;a<vdata->view_lines_per_screen;a++) {
  1018.                         if (d<vdata->view_file_size)
  1019.                                 view_print(vdata,&vdata->view_text_buffer[d],a,16);
  1020.                         d+=16;
  1021.                 }
  1022.         }
  1023.         else {
  1024.                 for (a=0;a<vdata->view_lines_per_screen;a++) {
  1025.                         for (c=0;c<vdata->view_max_line_length;c++) {
  1026.                                 if (vdata->view_text_buffer[f]==10) break;
  1027.                                 ++f;
  1028.                         }
  1029.                         ++f;
  1030.                         if (d+c+1>vdata->view_file_size)
  1031.                                 c=vdata->view_file_size-d-1;
  1032.                         if (d<vdata->view_file_size)
  1033.                                 view_print(vdata,&vdata->view_text_buffer[d],a,c+1);
  1034.                         d=f;
  1035.                         if (a<vdata->view_lines_per_screen-1)
  1036.                                 vdata->view_bottom_buffer_pos=d;
  1037.                 }
  1038.         }
  1039.  
  1040.         vdata->view_old_offset=vdata->view_text_offset;
  1041.         view_update_status(vdata);
  1042. }
  1043.  
  1044. void view_print(vdata,str,y,len)
  1045. struct ViewData *vdata;
  1046. char *str;
  1047. int y,len;
  1048. {
  1049.         unsigned char textbuf[300];
  1050.  
  1051.         if (vdata->view_display_as_ansi) {
  1052.                 if (len>0) {
  1053.                         if (str[len-1]=='\n') --len;
  1054.                         vdata->view_console_request.io_Data=(APTR)"\x9b;0m\f";
  1055.                         vdata->view_console_request.io_Length=5;
  1056.                         vdata->view_console_request.io_Command=CMD_WRITE;
  1057.                         DoIO((struct IORequest *)&vdata->view_console_request);
  1058.  
  1059.                         vdata->view_console_request.io_Data=(APTR)str;
  1060.                         vdata->view_console_request.io_Length=len;
  1061.                         vdata->view_console_request.io_Command=CMD_WRITE;
  1062.                         DoIO((struct IORequest *)&vdata->view_console_request);
  1063.  
  1064.                         if (y>-1) {
  1065.                                 ClipBlit(vdata->view_ansiread_window->RPort,0,0,
  1066.                                         vdata->view_rastport,
  1067.                                         vdata->view_display_left,
  1068.                                         vdata->view_display_top+(y*vdata->view_font->tf_YSize),
  1069.                                         vdata->view_ansiread_window->Width,
  1070.                                         vdata->view_font->tf_YSize,0xc0);
  1071.                         }
  1072.                 }
  1073.         }
  1074.         else {
  1075.                 Move(vdata->view_rastport,
  1076.                         vdata->view_display_left,
  1077.                         vdata->view_display_top+(y*vdata->view_font->tf_YSize)+vdata->view_font->tf_Baseline);
  1078.  
  1079.                 if (vdata->view_display_as_hex) {
  1080.                         view_makeuphex(vdata,str,textbuf,vdata->view_text_offset+y);
  1081.                         len=vdata->view_char_width;
  1082.                 }
  1083.                 else {
  1084.                         if (len>vdata->view_char_width) len=vdata->view_char_width;
  1085.                         CopyMem(str,(char *)textbuf,len);
  1086.                         if (textbuf[len-1]==10) textbuf[len-1]=' ';
  1087.                 }
  1088.                 if (len>0) Text(vdata->view_rastport,(char *)textbuf,len);
  1089.         }
  1090. }
  1091.  
  1092. void view_update_status(vdata)
  1093. struct ViewData *vdata;
  1094. {
  1095.         char textbuf[80];
  1096.         int a;
  1097.  
  1098.         view_pensrp(vdata);
  1099.         Move(vdata->view_rastport,
  1100.                 vdata->view_window->Width-((vdata->view_font->tf_XSize*49)+14),
  1101.                 vdata->view_status_bar_ypos+vdata->view_font->tf_Baseline);
  1102.  
  1103.         if (vdata->view_line_count<=vdata->view_lines_per_screen)
  1104.                 a=100;
  1105.         else a=(vdata->view_text_offset*100)/vdata->view_last_line;
  1106.  
  1107.         lsprintf(textbuf,
  1108.                 "%-6ld > %-6ld / %-6ld   %-3ld%%",vdata->view_text_offset,
  1109.                 (vdata->view_text_offset+vdata->view_lines_per_screen>vdata->view_line_count)?
  1110.                         vdata->view_line_count:vdata->view_text_offset+vdata->view_lines_per_screen,
  1111.                 vdata->view_line_count,a);
  1112.  
  1113.         Text(vdata->view_rastport,textbuf,31);
  1114.  
  1115.         if (config->viewbits&VIEWBITS_TEXTBORDERS && vdata->view_scroll_bar)
  1116.                 FixSliderPot(vdata->view_window,
  1117.                         &vdata->view_gadgets[VIEW_SCROLLGADGET],
  1118.                         vdata->view_text_offset,
  1119.                         vdata->view_line_count,
  1120.                         vdata->view_lines_per_screen,1);
  1121.  
  1122.         view_penrp(vdata);
  1123. }
  1124.  
  1125. void view_pensrp(vdata)
  1126. struct ViewData *vdata;
  1127. {
  1128.         SetAPen(vdata->view_rastport,vdata->view_colour_table[VIEWPEN_STATUSTEXT]);
  1129.         SetBPen(vdata->view_rastport,vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND]);
  1130.         SetDrMd(vdata->view_rastport,JAM2);
  1131. }
  1132.  
  1133. void view_penrp(vdata)
  1134. struct ViewData *vdata;
  1135. {
  1136.         SetAPen(vdata->view_rastport,vdata->view_colour_table[PEN_TEXT]);
  1137.         SetBPen(vdata->view_rastport,vdata->view_colour_table[PEN_TEXTBACKGROUND]);
  1138.         SetDrMd(vdata->view_rastport,JAM1);
  1139. }
  1140.  
  1141. void view_pageup(vdata)
  1142. struct ViewData *vdata;
  1143. {
  1144.         int a,b,c;
  1145.  
  1146.         if (vdata->view_text_offset==0) return;
  1147.         vdata->view_text_offset-=vdata->view_lines_per_screen;
  1148.         if (vdata->view_text_offset<0) {
  1149.                 vdata->view_text_offset=0;
  1150.                 vdata->view_top_buffer_pos=0;
  1151.         }
  1152.         else if (!vdata->view_display_as_hex) {
  1153.                 for (c=0;c<vdata->view_lines_per_screen;c++) {
  1154.                         for (a=vdata->view_top_buffer_pos-2,b=0;a>=0;a--,b++) {
  1155.                                 if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  1156.                                         break;
  1157.                         }
  1158.                         vdata->view_top_buffer_pos=a+1;
  1159.                 }
  1160.         }
  1161.         view_displayall(vdata);
  1162. }
  1163.  
  1164. void view_pagedown(vdata)
  1165. struct ViewData *vdata;
  1166. {
  1167.         int a,b,c;
  1168.  
  1169.         if (vdata->view_text_offset==vdata->view_last_line ||
  1170.                 vdata->view_line_count<=vdata->view_lines_per_screen) return;
  1171.  
  1172.         vdata->view_text_offset+=vdata->view_lines_per_screen;
  1173.  
  1174.         if (vdata->view_text_offset>vdata->view_last_line) {
  1175.                 vdata->view_text_offset=vdata->view_last_line;
  1176.  
  1177.                 if (!vdata->view_display_as_hex) {
  1178.                         vdata->view_top_buffer_pos=vdata->view_file_size;
  1179.                         for (c=0;c<vdata->view_lines_per_screen;c++) {
  1180.                                 for (a=vdata->view_top_buffer_pos-2,b=0;a>=0;a--,b++) {
  1181.                                         if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  1182.                                                 break;
  1183.                                 }
  1184.                                 vdata->view_top_buffer_pos=a+1;
  1185.                         }
  1186.                 }
  1187.         }
  1188.         else {
  1189.                 if (!vdata->view_display_as_hex) {
  1190.                         vdata->view_top_buffer_pos=vdata->view_bottom_buffer_pos;
  1191.                         for (a=vdata->view_top_buffer_pos,b=0;a<vdata->view_file_size;a++,b++) {
  1192.                                 if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  1193.                                         break;
  1194.                         }
  1195.                         vdata->view_top_buffer_pos=a+1;
  1196.                 }
  1197.         }
  1198.         view_displayall(vdata);
  1199. }
  1200.  
  1201. void view_gotop(vdata)
  1202. struct ViewData *vdata;
  1203. {
  1204.         if (vdata->view_text_offset) {
  1205.                 vdata->view_text_offset=0;
  1206.                 vdata->view_top_buffer_pos=0;
  1207.                 view_displayall(vdata);
  1208.         }
  1209. }
  1210.  
  1211. void view_gobottom(vdata)
  1212. struct ViewData *vdata;
  1213. {
  1214.         int a,b,c;
  1215.  
  1216.         if (vdata->view_text_offset!=vdata->view_last_line &&
  1217.                 vdata->view_line_count>vdata->view_lines_per_screen) {
  1218.  
  1219.                 vdata->view_text_offset=vdata->view_last_line;
  1220.  
  1221.                 if (!vdata->view_display_as_hex) {
  1222.                         vdata->view_top_buffer_pos=vdata->view_file_size;
  1223.  
  1224.                         for (c=0;c<vdata->view_lines_per_screen;c++) {
  1225.                                 for (a=vdata->view_top_buffer_pos-2,b=0;a>=0;a--,b++) {
  1226.                                         if (vdata->view_text_buffer[a]==10 || b==vdata->view_max_line_length)
  1227.                                                 break;
  1228.                                 }
  1229.                                 vdata->view_top_buffer_pos=a+1;
  1230.                         }
  1231.                 }
  1232.                 view_displayall(vdata);
  1233.         }
  1234. }
  1235.  
  1236. void view_search(vdata,ask)
  1237. struct ViewData *vdata;
  1238. int ask;
  1239. {
  1240.         int a,off,bpos,c,d,e,f,mlen;
  1241.         char temp[80];
  1242.  
  1243.         status_haveaborted=0;
  1244.         view_clearhilite(vdata,1);
  1245.  
  1246.         if (!vdata->view_search_string[0]) ask=1;
  1247.         strcpy(temp,vdata->view_search_string);
  1248.         view_busy(vdata);
  1249.  
  1250.         if (ask) {
  1251.                 if (!(get_search_data(vdata->view_search_string,&vdata->view_search_flags,
  1252.                         vdata->view_window,vdata->view_font))) {
  1253.                         view_unbusy(vdata);
  1254.                         return;
  1255.                 }
  1256.         }
  1257.  
  1258.         if (!vdata->view_search_string[0]) {
  1259.                 view_unbusy(vdata);
  1260.                 return;
  1261.         }
  1262.  
  1263.         if (LStrCmpI(temp,vdata->view_search_string)) view_clearsearch(vdata);
  1264.  
  1265.         if (vdata->view_display_as_hex) {
  1266.                 if (vdata->view_search_offset!=-1) {
  1267.                         a=(vdata->view_search_offset*16)+vdata->view_search_charoffset;
  1268.                         off=vdata->view_search_offset;
  1269.                 }
  1270.                 else {
  1271.                         a=vdata->view_text_offset*16;
  1272.                         off=vdata->view_text_offset;
  1273.                 }
  1274.         }
  1275.         else {
  1276.                 if (vdata->view_search_charoffset!=-1) {
  1277.                         a=vdata->view_search_charoffset;
  1278.                         off=vdata->view_search_offset;
  1279.                 }
  1280.                 else {
  1281.                         a=vdata->view_top_buffer_pos;
  1282.                         off=vdata->view_text_offset;
  1283.                 }
  1284.         }
  1285. dosearch:
  1286.         if ((typesearch(0,vdata->view_search_string,
  1287.                 vdata->view_search_flags,&vdata->view_text_buffer[a],
  1288.                 vdata->view_file_size-a))>-1) {
  1289.  
  1290.                 if (vdata->view_display_as_hex) {
  1291.                         bpos=search_found_position-vdata->view_text_buffer;
  1292.                         off=bpos/16; c=bpos%16;
  1293.                         mlen=search_found_size;
  1294.                         if (vdata->view_pick_charoffset!=bpos) {
  1295.                                 if (!(vdata->view_text_offset==vdata->view_last_line ||
  1296.                                         vdata->view_line_count<vdata->view_lines_per_screen ||
  1297.                                         vdata->view_text_offset>vdata->view_last_line ||
  1298.                                         off<vdata->view_text_offset+vdata->view_lines_per_screen)) {
  1299.  
  1300.                                         vdata->view_text_offset=
  1301.                                                 vdata->view_search_offset=off;
  1302.  
  1303.                                         if (vdata->view_text_offset>vdata->view_last_line)
  1304.                                                 view_gobottom(vdata);
  1305.                                         else view_displayall(vdata);
  1306.                                 }
  1307.                                 else if (vdata->view_text_offset>vdata->view_last_line) {
  1308.                                         view_gobottom(vdata);
  1309.                                 }
  1310.  
  1311.                                 d=(10+(c*2)+(c/4))*vdata->view_font->tf_XSize;
  1312.                                 if ((f=c+mlen)>16) f=16;
  1313.                                 e=(10+(f*2)+(f/4))*vdata->view_font->tf_XSize;
  1314.                                 if ((f%4)==0) e-=vdata->view_font->tf_XSize;
  1315.  
  1316.                                 for (a=0;a<2;a++) {
  1317.                                         view_viewhilite(vdata,
  1318.                                                 d,(off-vdata->view_text_offset)*vdata->view_font->tf_YSize,e-1,
  1319.                                                 (off-vdata->view_text_offset)*vdata->view_font->tf_YSize+(vdata->view_font->tf_YSize-1));
  1320.                                         d=(46+c)*vdata->view_font->tf_XSize;
  1321.                                         e=(46+f)*vdata->view_font->tf_XSize;
  1322.                                 }
  1323.                                 vdata->view_pick_offset=-1;
  1324.                                 vdata->view_pick_charoffset=bpos;
  1325.                                 vdata->view_search_offset=off;
  1326.                                 vdata->view_search_charoffset=c+1;
  1327.                         }
  1328.                         else {
  1329.                                 a=bpos+1;
  1330.                                 goto dosearch;
  1331.                         }
  1332.                 }
  1333.                 else {
  1334.                         off+=search_found_lines;
  1335.                         bpos=search_last_line_pos+a;
  1336.                         if (vdata->view_pick_offset!=bpos && vdata->view_pick_charoffset!=off) {
  1337.                                 if (vdata->view_text_offset==vdata->view_last_line ||
  1338.                                         vdata->view_line_count<vdata->view_lines_per_screen ||
  1339.                                         off<vdata->view_text_offset+vdata->view_lines_per_screen ||
  1340.                                         off>vdata->view_last_line) {
  1341.  
  1342.                                         if (off>vdata->view_last_line) view_gobottom(vdata);
  1343.  
  1344.                                         vdata->view_search_charoffset=bpos;
  1345.                                         vdata->view_search_offset=off;
  1346.  
  1347.                                         view_viewhilite(vdata,
  1348.                                                 0,(off-vdata->view_text_offset)*vdata->view_font->tf_YSize,
  1349.                                                 vdata->view_char_width*vdata->view_font->tf_XSize,
  1350.                                                 (off-vdata->view_text_offset)*vdata->view_font->tf_YSize+(vdata->view_font->tf_YSize-1));
  1351.                                 }
  1352.                                 else {
  1353.                                         vdata->view_top_buffer_pos=bpos;
  1354.                                         vdata->view_text_offset=off;
  1355.                                         view_displayall(vdata);
  1356.                                         view_viewhilite(vdata,
  1357.                                                 0,0,
  1358.                                                 vdata->view_char_width*vdata->view_font->tf_XSize,
  1359.                                                 vdata->view_font->tf_YSize-1);
  1360.                                 }
  1361.                                 vdata->view_pick_offset=bpos;
  1362.                                 vdata->view_pick_charoffset=off;
  1363.                         }
  1364.                         else {
  1365.                                 for (a=bpos;a<vdata->view_file_size;a++) {
  1366.                                         if (vdata->view_text_buffer[a]==10)
  1367.                                                 break;
  1368.                                 }
  1369.                                 ++a; ++off;
  1370.                                 goto dosearch;
  1371.                         }
  1372.                 }
  1373.         }
  1374.         else {
  1375.                 view_clearsearch(vdata);
  1376.                 view_simplerequest(vdata,globstring[STR_STRING_NOT_FOUND],globstring[STR_CONTINUE],NULL);
  1377.         }
  1378.         view_unbusy(vdata);
  1379.         return;
  1380. }
  1381.  
  1382. void view_busy(vdata)
  1383. struct ViewData *vdata;
  1384. {
  1385.         if (!vdata->view_window->Pointer) SetBusyPointer(vdata->view_window);
  1386.         if (!vdata->view_window->FirstRequest) {
  1387.                 InitRequester(&vdata->view_busy_request);
  1388.                 Request(&vdata->view_busy_request,vdata->view_window);
  1389.         }
  1390. }
  1391.  
  1392. void view_unbusy(vdata)
  1393. struct ViewData *vdata;
  1394. {
  1395.         ClearPointer(vdata->view_window);
  1396.         if (vdata->view_window->FirstRequest)
  1397.                 EndRequest(&vdata->view_busy_request,vdata->view_window);
  1398. }
  1399.  
  1400. void view_doscroll(vdata,dy,w)
  1401. struct ViewData *vdata;
  1402. int dy,w;
  1403. {
  1404.         if (!vdata->view_display_as_ansi)
  1405.                 SetWrMsk(vdata->view_rastport,vdata->view_colour_table[PEN_TEXT]);
  1406.         ScrollRaster(vdata->view_rastport,0,dy,
  1407.                 vdata->view_display_left,
  1408.                 vdata->view_display_top,
  1409.                 vdata->view_display_left+w,
  1410.                 vdata->view_display_top+vdata->view_display_height-1);
  1411.         if (!vdata->view_display_as_ansi)
  1412.                 SetWrMsk(vdata->view_rastport,0xff);
  1413. }
  1414.  
  1415. view_lineup(vdata)
  1416. struct ViewData *vdata;
  1417. {
  1418.         if (vdata->view_text_offset==0) return(0);
  1419.         --vdata->view_text_offset;
  1420.         if (vdata->view_scroll_dir==1)
  1421.                 view_display(vdata,1,1);
  1422.         else view_display(vdata,1,0);
  1423.         vdata->view_scroll_dir=-1;
  1424.         return(1);
  1425. }
  1426.  
  1427. view_linedown(vdata)
  1428. struct ViewData *vdata;
  1429. {
  1430.         if (vdata->view_text_offset>=vdata->view_last_line) return(0);
  1431.         ++vdata->view_text_offset;
  1432.         vdata->view_scroll_dir=1;
  1433.         view_display(vdata,1,0);
  1434.         return(1);
  1435. }
  1436.  
  1437. void view_status_text(vdata,str)
  1438. struct ViewData *vdata;
  1439. char *str;
  1440. {
  1441.         SetAPen(vdata->view_rastport,vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND]);
  1442.         RectFill(vdata->view_rastport,
  1443.                 2,
  1444.                 vdata->view_status_bar_ypos,
  1445.                 vdata->view_window->Width-((vdata->view_font->tf_XSize*18)+3),
  1446.                 vdata->view_window->Height-2);
  1447.  
  1448.         view_pensrp(vdata);
  1449.  
  1450.         if (str) {
  1451.                 Move(vdata->view_rastport,2,vdata->view_status_bar_ypos+vdata->view_font->tf_Baseline);
  1452.                 Text(vdata->view_rastport,str,strlen(str));
  1453.         }
  1454. }
  1455.  
  1456. void view_printtext(vdata,state)
  1457. struct ViewData *vdata;
  1458. int state;
  1459. {
  1460.         int out,a,tb;
  1461.         char temp[60],*str;
  1462.         unsigned char buf1[80];
  1463.  
  1464.         status_haveaborted=0;
  1465.  
  1466.         if (state==0 && !vdata->view_display_as_hex) {
  1467.                 struct DOpusArgsList print_args;
  1468.  
  1469.                 print_args.single_file=vdata->view_path_name;
  1470.                 print_args.file_window=-1;
  1471.                 print_args.file_list=NULL;
  1472.                 print_args.last_select=NULL;
  1473.  
  1474.                 dopus_print(0,&print_args,0,vdata->view_port_name,vdata);
  1475.                 return;
  1476.         }
  1477.  
  1478.         if (!(out=Open("PRT:",MODE_NEWFILE))) {
  1479.                 view_simplerequest(vdata,globstring[STR_CANT_OPEN_PRINTER],globstring[STR_CONTINUE],NULL);
  1480.                 return;
  1481.         }
  1482.         if (!vdata->view_display_as_hex) {
  1483.                 char *print_ptr;
  1484.                 int print_size;
  1485.  
  1486.                 if (vdata->view_bottom_buffer_pos>=vdata->view_file_size) {
  1487.                         print_size=vdata->view_file_size;
  1488.                         print_ptr=vdata->view_text_buffer;
  1489.                 }
  1490.                 else {
  1491.                         for (a=vdata->view_bottom_buffer_pos;a<vdata->view_file_size;a++) {
  1492.                                 if (vdata->view_text_buffer[a]==10) break;
  1493.                         }
  1494.                         print_size=a-vdata->view_top_buffer_pos+1;
  1495.                         print_ptr=&vdata->view_text_buffer[vdata->view_top_buffer_pos];
  1496.                 }
  1497.  
  1498.                 if ((Write(out,print_ptr,print_size))<print_size) {
  1499.                         Close(out);
  1500.                         lsprintf(temp,globstring[STR_ERROR_PRINTING_FILE],IoErr());
  1501.                         view_simplerequest(vdata,temp,globstring[STR_CONTINUE],NULL);
  1502.                         return;
  1503.                 }
  1504.         }
  1505.         else {
  1506.                 if (state==0) {
  1507.                         str=vdata->view_text_buffer;
  1508.                         for (a=0;a<vdata->view_line_count;a++) {
  1509.                                 view_makeuphex(vdata,str,buf1,a);
  1510.                                 if ((Write(out,(char *)buf1,63))<63) {
  1511.                                         Close(out);
  1512.                                         lsprintf(temp,globstring[STR_ERROR_PRINTING_FILE],IoErr());
  1513.                                         view_simplerequest(vdata,temp,globstring[STR_CONTINUE],NULL);
  1514.                                         return;
  1515.                                 }
  1516.                                 str+=16;
  1517.                                 if (status_haveaborted) break;
  1518.                         }
  1519.                 }
  1520.                 else {
  1521.                         str=&vdata->view_text_buffer[vdata->view_text_offset*16];
  1522.                         tb=vdata->view_text_offset*16;
  1523.                         for (a=0;a<vdata->view_lines_per_screen;a++) {
  1524.                                 view_makeuphex(vdata,str,buf1,vdata->view_text_offset+a);
  1525.                                 if ((Write(out,(char *)buf1,63))<63) {
  1526.                                         Close(out);
  1527.                                         lsprintf(temp,globstring[STR_ERROR_PRINTING_FILE],IoErr());
  1528.                                         view_simplerequest(vdata,temp,globstring[STR_CONTINUE],NULL);
  1529.                                         return;
  1530.                                 }
  1531.                                 str+=16; tb+=16;
  1532.                                 if (tb>vdata->view_file_size || status_haveaborted) break;
  1533.                         }
  1534.                 }
  1535.         }
  1536.         Close(out);
  1537.         return;
  1538. }
  1539.  
  1540. void view_checkprint(vdata,code)
  1541. struct ViewData *vdata;
  1542. int code;
  1543. {
  1544.         view_busy(vdata);
  1545.         if ((code==0 && !vdata->view_display_as_hex) ||
  1546.                 (view_simplerequest(vdata,globstring[STR_READY_PRINTER],
  1547.                         str_okaystring,str_cancelstring,NULL))) view_printtext(vdata,code);
  1548.         view_unbusy(vdata);
  1549. }
  1550.  
  1551. void view_makeuphex(vdata,hex,textbuf,line)
  1552. struct ViewData *vdata;
  1553. char *hex;
  1554. unsigned char *textbuf;
  1555. int line;
  1556. {
  1557.         unsigned char buf2[17];
  1558.         unsigned int buf3[17];
  1559.         int at,b,c,e;
  1560.  
  1561.         if (vdata->view_last_char && hex>=vdata->view_last_char)
  1562.                 b=vdata->view_last_charpos;
  1563.         else b=16;
  1564.         for (at=0;at<b;at++) {
  1565.                 if (!isprint(hex[at])) buf2[at]='.';
  1566.                 else buf2[at]=hex[at];
  1567.                 buf3[at]=(unsigned int)((unsigned char)hex[at]);
  1568.         }
  1569.         if (vdata->view_last_char && hex>=vdata->view_last_char) {
  1570.                 for (at=b;at<16;at++) {
  1571.                         buf2[at]=' ';
  1572.                         buf3[at]=0;
  1573.                 }
  1574.                 e=b/4; c=10+(b*2)+e;
  1575.         }
  1576.         else c=-1;
  1577.         buf2[16]=0;
  1578.         lsprintf((char *)textbuf,
  1579.                 "%08lx: %02lx%02lx%02lx%02lx %02lx%02lx%02lx%02lx %02lx%02lx%02lx%02lx \
  1580. %02lx%02lx%02lx%02lx %s\n",line*16,
  1581.                 buf3[0],buf3[1],buf3[2],buf3[3],buf3[4],buf3[5],buf3[6],buf3[7],
  1582.                 buf3[8],buf3[9],buf3[10],buf3[11],buf3[12],buf3[13],buf3[14],buf3[15],
  1583.                 buf2);
  1584.         if (c>-1) {
  1585.                 for (b=c;b<46;b++)
  1586.                         textbuf[b]=' ';
  1587.         }
  1588. }
  1589.  
  1590. void view_togglescroll(vdata)
  1591. struct ViewData *vdata;
  1592. {
  1593.         if (vdata->view_scroll) {
  1594.                 vdata->view_scroll=0;
  1595.                 ClearPointer(vdata->view_window);
  1596.         }
  1597.         else if (vdata->view_line_count>vdata->view_lines_per_screen) {
  1598.                 vdata->view_scroll=1;
  1599.                 setnullpointer(vdata->view_window);
  1600.         }
  1601. }
  1602.  
  1603. void view_setupscreen(vdata)
  1604. struct ViewData *vdata;
  1605. {
  1606.         int a;
  1607.  
  1608.         SetAPen(vdata->view_rastport,vdata->view_colour_table[PEN_TEXTBACKGROUND]);
  1609.         RectFill(vdata->view_rastport,
  1610.                 vdata->view_display_left,
  1611.                 vdata->view_display_top,
  1612.                 vdata->view_display_right,
  1613.                 vdata->view_display_bottom);
  1614.  
  1615.         Do3DBox(vdata->view_rastport,
  1616.                 2,
  1617.                 vdata->view_status_bar_ypos,
  1618.                 vdata->view_window->Width-((vdata->view_font->tf_XSize*18)+4),
  1619.                 vdata->view_font->tf_YSize,
  1620.                 vdata->view_colour_table[PEN_SHINE],
  1621.                 vdata->view_colour_table[PEN_SHADOW]);
  1622.  
  1623.         view_status_text(vdata,NULL);
  1624.         SetDrMd(vdata->view_rastport,JAM2);
  1625.  
  1626.         for (a=0;a<9;a++) {
  1627.                 vdata->view_gadgets[a].NextGadget=&vdata->view_gadgets[a+1];
  1628.                 vdata->view_gadgets[a].LeftEdge=
  1629.                         (vdata->view_window->Width-(vdata->view_font->tf_XSize*18))+
  1630.                         (a*vdata->view_font->tf_XSize*2);
  1631.                 vdata->view_gadgets[a].TopEdge=vdata->view_window->Height-(vdata->view_font->tf_YSize+2);
  1632.                 vdata->view_gadgets[a].Width=vdata->view_font->tf_XSize*2;
  1633.                 vdata->view_gadgets[a].Height=vdata->view_font->tf_YSize+2;
  1634.                 vdata->view_gadgets[a].Flags=GFLG_GADGHCOMP;
  1635.                 vdata->view_gadgets[a].Activation=(a<2)?GACT_IMMEDIATE|GACT_RELVERIFY:GACT_RELVERIFY;
  1636.                 vdata->view_gadgets[a].GadgetType=GTYP_BOOLGADGET;
  1637.                 vdata->view_gadgets[a].GadgetID=a;
  1638.  
  1639.                 Do3DBox(vdata->view_rastport,
  1640.                         vdata->view_gadgets[a].LeftEdge+2,
  1641.                         vdata->view_status_bar_ypos,
  1642.                         (vdata->view_font->tf_XSize*2)-4,vdata->view_font->tf_YSize,
  1643.                         vdata->view_colour_table[PEN_SHINE],
  1644.                         vdata->view_colour_table[PEN_SHADOW]);
  1645.  
  1646.                 SetAPen(vdata->view_rastport,vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND]);
  1647.                 RectFill(vdata->view_rastport,
  1648.                         vdata->view_gadgets[a].LeftEdge+2,
  1649.                         vdata->view_status_bar_ypos,
  1650.                         vdata->view_gadgets[a].LeftEdge+(vdata->view_gadgets[a].Width-3),
  1651.                         vdata->view_window->Height-2);
  1652.                 SetAPen(vdata->view_rastport,vdata->view_colour_table[VIEWPEN_STATUSTEXT]);
  1653.                 SetBPen(vdata->view_rastport,vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND]);
  1654.  
  1655.                 if (a>1) {
  1656.                         Move(vdata->view_rastport,
  1657.                                 vdata->view_gadgets[a].LeftEdge+
  1658.                                         ((vdata->view_gadgets[a].Width-vdata->view_font->tf_XSize)/2),
  1659.                                 vdata->view_status_bar_ypos+vdata->view_font->tf_Baseline);
  1660.                         Text(vdata->view_rastport,&globstring[STR_VIEW_BUTTONS][a-2],1);
  1661.                 }
  1662.         }
  1663.         for (a=0;a<2;a++) {
  1664.                 DoArrow(vdata->view_rastport,
  1665.                         vdata->view_gadgets[a].LeftEdge+2,
  1666.                         vdata->view_window->Height-vdata->view_font->tf_YSize,
  1667.                         (vdata->view_font->tf_XSize*2)-4,vdata->view_font->tf_YSize-2,
  1668.                         vdata->view_colour_table[VIEWPEN_STATUSTEXT],
  1669.                         vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND],a);
  1670.         }
  1671.         SetFont(vdata->view_rastport,vdata->view_font);
  1672. }
  1673.  
  1674. void view_viewhilite(vdata,x,y,x1,y1)
  1675. struct ViewData *vdata;
  1676. int x,y,x1,y1;
  1677. {
  1678.         struct viewhilite *hi;
  1679.  
  1680.         if (!(hi=AllocMem(sizeof(struct viewhilite),MEMF_CLEAR))) return;
  1681.         if (vdata->view_current_hilite) vdata->view_current_hilite->next=hi;
  1682.         else vdata->view_first_hilite=hi;
  1683.         vdata->view_current_hilite=hi;
  1684.         hi->x=x+vdata->view_display_left;
  1685.         hi->y=y+vdata->view_display_top;
  1686.         hi->x1=x1+vdata->view_display_left;
  1687.         hi->y1=y1+vdata->view_display_top;
  1688.         SetDrMd(vdata->view_rastport,COMPLEMENT);
  1689.         RectFill(vdata->view_rastport,hi->x,hi->y,hi->x1,hi->y1);
  1690.         SetDrMd(vdata->view_rastport,JAM1);
  1691. }
  1692.  
  1693. void view_clearhilite(vdata,show)
  1694. struct ViewData *vdata;
  1695. int show;
  1696. {
  1697.         struct viewhilite *hi,*next;
  1698.  
  1699.         hi=vdata->view_first_hilite;
  1700.         if (show) SetDrMd(vdata->view_rastport,COMPLEMENT);
  1701.         while (hi) {
  1702.                 next=hi->next;
  1703.                 if (show) RectFill(vdata->view_rastport,hi->x,hi->y,hi->x1,hi->y1);
  1704.                 FreeMem(hi,sizeof(struct viewhilite));
  1705.                 hi=next;
  1706.         }
  1707.         vdata->view_first_hilite=vdata->view_current_hilite=NULL;
  1708.         if (show) SetDrMd(vdata->view_rastport,JAM1);
  1709. }
  1710.  
  1711. void view_fix_scroll_gadget(vdata)
  1712. struct ViewData *vdata;
  1713. {
  1714.         int a,b,c,d;
  1715.  
  1716.         if ((a=GetSliderPos(&vdata->view_gadgets[VIEW_SCROLLGADGET],
  1717.                 vdata->view_line_count,
  1718.                 vdata->view_lines_per_screen))==vdata->view_text_offset) return;
  1719.  
  1720.         d=vdata->view_text_offset-a;
  1721.         vdata->view_scroll_bar=0;
  1722.  
  1723.         if (d>0 && d<vdata->view_lines_per_screen/2) {
  1724.                 while (d--) view_lineup(vdata);
  1725.         }
  1726.         else if (d<0 && d>-(vdata->view_lines_per_screen/2)) {
  1727.                 while (d++) view_linedown(vdata);
  1728.         }
  1729.         else if (vdata->view_display_as_hex) {
  1730.                 vdata->view_text_offset=a;
  1731.                 if (vdata->view_text_offset>vdata->view_last_line)
  1732.                         vdata->view_text_offset=vdata->view_last_line;
  1733.                 view_displayall(vdata);
  1734.         }
  1735.         else {
  1736.                 SetBusyPointer(vdata->view_window);
  1737.                 if (a>vdata->view_last_line) a=vdata->view_last_line;
  1738.                 if (vdata->view_text_offset<a) {
  1739.                         if (a-vdata->view_text_offset<vdata->view_last_line-a) {
  1740.                                 for (b=vdata->view_text_offset;b<a;b++) {
  1741.                                         for (c=vdata->view_top_buffer_pos;c<vdata->view_file_size;c++) {
  1742.                                                 if (vdata->view_text_buffer[c]==10)
  1743.                                                         break;
  1744.                                         }
  1745.                                         vdata->view_top_buffer_pos=c+1;
  1746.                                 }
  1747.                         }
  1748.                         else {
  1749.                                 vdata->view_text_offset=vdata->view_last_line;
  1750.                                 vdata->view_top_buffer_pos=vdata->view_file_size;
  1751.                                 for (c=0;c<vdata->view_lines_per_screen;c++) {
  1752.                                         for (b=vdata->view_top_buffer_pos-2;b>=0;b--) {
  1753.                                                 if (vdata->view_text_buffer[b]==10)
  1754.                                                         break;
  1755.                                         }
  1756.                                         vdata->view_top_buffer_pos=b+1;
  1757.                                 }
  1758.                                 for (b=a;b<vdata->view_text_offset;b++) {
  1759.                                         for (c=vdata->view_top_buffer_pos-2;c>=0;c--) {
  1760.                                                 if (vdata->view_text_buffer[c]==10)
  1761.                                                         break;
  1762.                                         }
  1763.                                         vdata->view_top_buffer_pos=c+1;
  1764.                                 }
  1765.                         }
  1766.                 }
  1767.                 else {
  1768.                         if (vdata->view_text_offset-a<a) {
  1769.                                 for (b=a;b<vdata->view_text_offset;b++) {
  1770.                                         for (c=vdata->view_top_buffer_pos-2;c>=0;c--) {
  1771.                                                 if (vdata->view_text_buffer[c]==10) break;
  1772.                                         }
  1773.                                         vdata->view_top_buffer_pos=c+1;
  1774.                                 }
  1775.                         }
  1776.                         else {
  1777.                                 vdata->view_top_buffer_pos=0;
  1778.                                 for (b=0;b<a;b++) {
  1779.                                         for (c=vdata->view_top_buffer_pos;c<vdata->view_file_size;c++) {
  1780.                                                 if (vdata->view_text_buffer[c]==10)
  1781.                                                         break;
  1782.                                         }
  1783.                                         vdata->view_top_buffer_pos=c+1;
  1784.                                 }
  1785.                         }
  1786.                 }
  1787.                 vdata->view_text_offset=a;
  1788.                 view_displayall(vdata);
  1789.                 ClearPointer(vdata->view_window);
  1790.         }
  1791.         vdata->view_scroll_bar=1;
  1792. }
  1793.  
  1794. void view_clearsearch(vdata)
  1795. struct ViewData *vdata;
  1796. {
  1797.         vdata->view_search_offset=
  1798.                 vdata->view_search_charoffset=
  1799.                 vdata->view_pick_offset=
  1800.                 vdata->view_pick_charoffset=-1;
  1801. }
  1802.  
  1803. void view_readkeys(req,keys)
  1804. struct IOStdReq *req;
  1805. APTR keys;
  1806. {
  1807.         if (req) {
  1808.                 req->io_Length=13;
  1809.                 req->io_Data=(APTR)keys;
  1810.                 req->io_Command=KBD_READMATRIX;
  1811.                 DoIO((struct IORequest *)req);
  1812.         }
  1813. }
  1814.  
  1815. view_simplerequest(struct ViewData *vdata,char *txt,...)
  1816. {
  1817.         char *gads[4],*cancelgad=NULL,*gad;
  1818.         int a=1,r,rets[3],num;
  1819.         va_list ap;
  1820.         struct DOpusSimpleRequest request;
  1821.  
  1822.         va_start(ap,txt); r=1; num=0;
  1823.         for (a=0;a<3;a++) {
  1824.                 if (!(gad=(char *)va_arg(ap,char *))) break;
  1825.                 if (a==1) cancelgad=gad;
  1826.                 else {
  1827.                         gads[num]=gad;
  1828.                         rets[num++]=r++;
  1829.                 }
  1830.         }
  1831.         if (cancelgad) {
  1832.                 gads[num]=cancelgad;
  1833.                 rets[num]=0;
  1834.                 a=num+1;
  1835.         }
  1836.         for (;a<4;a++) gads[a]=NULL;
  1837.  
  1838.         request.hi=vdata->view_colour_table[PEN_SHINE];
  1839.         request.lo=vdata->view_colour_table[PEN_SHADOW];
  1840.         request.fg=vdata->view_colour_table[VIEWPEN_STATUSTEXT];
  1841.         request.bg=vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND];
  1842.  
  1843.         request.strbuf=NULL;
  1844.  
  1845.         return(dorequest(&request,txt,gads,rets,vdata->view_window));
  1846. }
  1847.  
  1848. view_whatsit(vdata,txt,max,buffer)
  1849. struct ViewData *vdata;
  1850. char *txt;
  1851. int max;
  1852. char *buffer;
  1853. {
  1854.         char *gads[3];
  1855.         int rets[2];
  1856.         struct DOpusSimpleRequest request;
  1857.  
  1858.         gads[0]=str_okaystring; rets[0]=1;
  1859.         gads[1]=str_cancelstring; rets[1]=0;
  1860.         gads[2]=NULL;
  1861.  
  1862.         request.hi=vdata->view_colour_table[PEN_SHINE];
  1863.         request.lo=vdata->view_colour_table[PEN_SHADOW];
  1864.         request.fg=vdata->view_colour_table[VIEWPEN_STATUSTEXT];
  1865.         request.bg=vdata->view_colour_table[VIEWPEN_STATUSBACKGROUND];
  1866.  
  1867.         request.strbuf=buffer;
  1868.         request.strlen=max;
  1869.         request.flags=0;
  1870.         return(dorequest(&request,txt,gads,rets,vdata->view_window));
  1871. }
  1872.