home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / DSMODS / WINDOWS.C < prev    next >
Encoding:
C/C++ Source or Header  |  2001-02-10  |  24.5 KB  |  824 lines
  1. /**************************************************************************/
  2. /*  FILE:  WINDOWS.C        PROGRAM TITLE: DeskSET II Alpha Version   */
  3. /*  Date Created: 12/15/87                          */ 
  4. /*  Last Modified: 01/26/89                          */
  5. /*                                      */
  6. /*  Description: Window Handler Routines                  */
  7. /*  Routines: o  open_windows() - open initial text and preview window      */
  8. /*          o  shut _windows()- close text and preview, if open      */
  9. /*            o  do_window()    - create a window and open it          */ 
  10. /*          o  top_window()   - top a window                  */
  11. /*          o  close_window() - close and delete a window          */
  12. /*          o  full_window()  - full size a window              */
  13. /*          o  arrow_window() - arrow handling of a window          */
  14. /*          o  hslide_window()- horizontal slider              */
  15. /*          o  vslide_window()- vertical slider of a window          */
  16. /*          o  size_window()  - size a window                  */
  17. /*          o  move_window()  - move a window                  */
  18. /*          o  slider_chk()   - Update Slider Info              */
  19. /*          o  get_work()     - Returns work area of window...          */
  20. /*          o  sliderv()    - size vertical slider bar          */
  21. /*          o  sliderh()    - size horizontal slider bar          */
  22. /*          o  wupline()    - up arrow function              */
  23. /*          o  wdnline()    - down arrow function              */
  24. /*          o  wrtline()    - right arrow function              */
  25. /*          o  wlftline()    - left arrow function              */
  26. /*          o  prev_cleanup() - Cleanup preview window          */
  27. /*          o  size_fit_handle- Calc page area for size to fit and alt  */
  28. /**************************************************************************/
  29.  
  30.  
  31. /**************************************************************************/
  32. /* INCLUDE FILES                              */
  33. /**************************************************************************/
  34. #include "define.h"
  35. #include "gemdefs.h"
  36. #include <obdefs.h>
  37. #include "deskset2.h"
  38. #include "alert.h"
  39.  
  40. /**************************************************************************/
  41. /* DEFINES                                  */
  42. /**************************************************************************/
  43. #define max(x,y)   (((x) > (y)) ? (x) :  (y))    /* Max function              */
  44. #define    min(x,y)   (((x) < (y)) ? (x) :  (y))    /* Min function          */
  45.  
  46. /**************************************************************************/
  47. /* EXTERNALS                                  */
  48. /**************************************************************************/
  49. extern int hpage_size;                /* width and height of    */
  50. extern int vpage_size;                /* paper in MU units      */
  51.  
  52. extern int pagew;                /* current page width and */
  53. extern int pageh;                /* height in pixels.      */
  54.  
  55. extern int shandle;                /* Screen Handle...      */
  56.  
  57. extern int view_size;                /* Current scale size...  */
  58. extern FDB page_MFDB;                /* MFDB of preview area   */
  59. extern int ptsin[];                /* PTSIN[] array...       */
  60. extern unsigned long gl_region_ptr;        /* Ptr to current active  */
  61.                         /* text region          */
  62. extern unsigned long gl_grregion_ptr;
  63. extern unsigned long region_ptr;
  64.  
  65. extern GRECT page_area;             /* GRECT of Preview MFDB  */
  66. extern GRECT page;
  67.  
  68. extern int BSTATE;
  69. extern int BREAL;
  70. extern int nada();
  71. extern int dummy;
  72. extern int pxy[];
  73. extern int blit_flag;
  74. extern int force_draw_flag;
  75. extern int ruler_flag;
  76. extern int xruler_offset;
  77. extern int yruler_offset;
  78. extern int cur_scale;
  79.  
  80. extern long TWart_ptr;                /* TW current article     */
  81.  
  82. extern OBJECT *ad_menu;
  83. extern int article_flag;
  84. extern char pfname[];                /* preview window title     */
  85. extern char basefname[];            /* base page window title*/
  86.  
  87. extern int unit_type;
  88. extern int active_prim;
  89.     
  90. /**************************************************************************/
  91. /* GLOBAL VARIABLES                              */
  92. /**************************************************************************/
  93. int txt_handle;                    /* text window handle     */
  94. int prev_handle;                /* preview window handle  */
  95.  
  96. GRECT curr;                    /* Current area of window */
  97. GRECT prev;                    /* Previous area of window*/
  98. GRECT full;                    /* Full-size of window      */
  99.  
  100. GRECT pwork;                    /* Preview work area...   */
  101. GRECT twork;                    /* txt work area...      */
  102. GRECT cpwork;                    /* work area of       */
  103.                         /* preview window      */
  104. GRECT dpwork;                    /* blit area of preview   */
  105.                         /* work window          */
  106.  
  107. GRECT scrn_area;                /* GRECT of ScreenMFDB... */
  108. GRECT clip2;                    /* GRECT of clip area...  */
  109.  
  110. long location = 0x0L;                /* Screen to Screen Blit  */
  111.  
  112.  
  113. char *winfo[][4] = {                /* Size Message          */
  114.          {" Size To Fit - Inches                ",
  115.           " Size To Fit - Picas                 ",
  116.           " Size To Fit - Centimeters           ",
  117.           " Size To Fit - Ciceros               "},
  118.  
  119.          {" 50% Size - Inches                   ",
  120.           " 50% Size - Picas                    ",
  121.           " 50% Size - Centimeters              ",
  122.           " 50% Size - Ciceros                  "},
  123.  
  124.          {" 75% Size - Inches                   ",
  125.           " 75% Size - Picas                    ",
  126.           " 75% Size - Centimeters              ",
  127.           " 75% Size - Ciceros                  "},
  128.  
  129.                  {" Actual Size - Inches                ",
  130.                   " Actual Size - Picas                 ",
  131.                   " Actual Size - Centimeters           ",
  132.                   " Actual Size - Ciceros               "},
  133.  
  134.                  {" 200% Size - Inches                  ",
  135.                   " 200% Size - Picas                   ",
  136.                   " 200% Size - Centimeters             ",
  137.                   " 200% Size - Ciceros                 "},
  138.  
  139.                  {" Alternate Pages - Left Page Active - Inches     ",
  140.                   " Alternate Pages - Left Page Active - Picas      ",
  141.                   " Alternate Pages - Left Page Active - Centimeters",
  142.                   " Alternate Pages - Left Page Active - Ciceros    "},
  143.  
  144.          {" Alternate Pages - Right Page Active - Inches     ",
  145.           " Alternate Pages - Right Page Active - Picas      ",
  146.           " Alternate Pages - Right Page Active - Centimeters",
  147.           " Alternate Pages - Right Page Active - Ciceros    "},
  148.  
  149.          {"  "," "," "," "}
  150.                 };
  151.  
  152.  
  153. char    *TWmesg[] = {                /* Text window Messages   */
  154.              "Article :",
  155.              " >> "
  156.             };
  157.  
  158. int (*arrow_funcs)();
  159. int (*slide_arrow)();
  160. int sliderv();
  161. int sliderh();
  162. int wupline();
  163. int wdnline();
  164. int wrtline();
  165. int wlfline();
  166.  
  167. int pixx,pixy;
  168. int xruler_offset;
  169. int yruler_offset;
  170.  
  171. /**************************************************************************/
  172. /* Function:    open_windows()                          */
  173. /* Description: Create and open preview and text window.                  */
  174. /* IN: none                                  */
  175. /* OUT: none                                  */
  176. /**************************************************************************/
  177. open_windows()
  178. {
  179.     int wind_type;
  180.     int tmp;
  181.  
  182.     wind_type = (NAME | INFO | FULLER | SIZER | MOVER |
  183.          UPARROW | DNARROW | VSLIDE | LFARROW |
  184.          RTARROW | HSLIDE);
  185.  
  186.     wind_get(0,WF_WORKXYWH,&full.g_x,&full.g_y,&full.g_w,&full.g_h);
  187.     txt_handle = wind_create(wind_type,full.g_x,full.g_y,full.g_w,full.g_h);
  188.     prev_handle= wind_create(wind_type,full.g_x,full.g_y,full.g_w,full.g_h);
  189.  
  190.     tmp = ((full.g_w/10)-2) + ((full.g_w/20)*9) + 24;
  191.  
  192.     if(txt_handle >= 0)
  193.     {
  194.     set_TWrows();
  195.        do_window(txt_handle,TWmesg[0],TWmesg[1],
  196.              tmp,full.g_y+1,(full.g_w/20)*9-30,(full.g_h/2));
  197.        get_work(txt_handle);
  198.     }
  199.  
  200.  
  201.     if(prev_handle >=0)
  202.     {
  203.        strcpy(pfname," Preview Window ");
  204.        strcpy(basefname," Base Page Window ");
  205.        do_window(prev_handle,pfname,winfo[7][unit_type],
  206.             (full.g_w/10)-2,full.g_y+1,(full.g_w/20)*9+20,full.g_h-7);
  207.        get_work(prev_handle);
  208.        update_preview_blit();
  209.     }
  210. }
  211.  
  212.  
  213.  
  214. /**************************************************************************/
  215. /* Function:    close_windows()                          */
  216. /* Description: Close and delete preview and text window.          */
  217. /* IN:  none                                  */
  218. /* OUT: none                                  */
  219. /**************************************************************************/
  220. shut_windows()
  221. {
  222.     if(txt_handle)
  223.     {
  224.     wind_close(txt_handle);
  225.     wind_delete(txt_handle);
  226.     }
  227.  
  228.     if(prev_handle)
  229.     {
  230.     wind_close(prev_handle);
  231.         wind_delete(prev_handle);
  232.     }
  233. }
  234.  
  235.  
  236.  
  237. /**************************************************************************/
  238. /* Function:    do_window()                          */
  239. /* Description: Open a window                          */
  240. /* IN:  wi_handle - window handle                      */
  241. /*    name      - name for title bar                      */
  242. /*    info      - text for info bar                      */
  243. /*    x,y,w,h   - size to open window to                  */
  244. /* OUT: none                                  */
  245. /**************************************************************************/
  246. do_window(wi_handle,name,info,x,y,w,h)
  247. int wi_handle;
  248. char *name;
  249. char *info;
  250. int x,y;
  251. int w,h;
  252. {
  253.       wind_set(wi_handle,WF_NAME,name,0,0);
  254.       wind_set(wi_handle,WF_INFO,info,0,0);
  255.       wind_set(wi_handle,WF_HSLIDE,1,0,0,0);
  256.       wind_set(wi_handle,WF_VSLIDE,1,0,0,0);
  257.       wind_set(wi_handle,WF_HSLSIZE,1000,0,0,0);
  258.       wind_set(wi_handle,WF_VSLSIZE,1000,0,0,0);
  259.       graf_growbox(10,10,20,20,x,y,w,h);
  260.       wind_open(wi_handle,x,y,w,h);
  261. }
  262.  
  263.  
  264.  
  265. /**************************************************************************/
  266. /* Function:    top_window()                            */
  267. /* Description: Top a window :-)                      */
  268. /* IN:  wi_handle - handle of window                      */
  269. /**************************************************************************/
  270. top_window(wi_handle,txtptr)
  271. int wi_handle;
  272. char *txtptr;
  273. {
  274.      register int i;
  275.  
  276.     if(wi_handle == txt_handle && article_flag == 1)
  277.     {
  278.        alert_cntre(ALERT25);    /* Article still open    */
  279.        return;
  280.     }
  281.     wind_set(wi_handle,WF_TOP,0,0,0,0);
  282.     if(wi_handle == txt_handle)
  283.     {
  284.        for(i = TFILE;i <= TOPTIONS;i++)
  285.         menu_ienable(ad_menu,0x8000|i,FALSE);    /* Disable menus */
  286.        menu_ienable(ad_menu,0x8000|TEXT,TRUE);
  287.        menu_ienable(ad_menu,OADDPRIM,FALSE);
  288.        menu_ienable(ad_menu,ODELPRIM,FALSE);
  289.        menu_ienable(ad_menu,OPCOORD,FALSE);
  290.        menu_ienable(ad_menu,OMOVEFNT,FALSE);
  291.        menu_ienable(ad_menu,OMOVEBAK,FALSE);
  292.  
  293.        menu_ienable(ad_menu,RUNLINK,FALSE);
  294.        menu_ienable(ad_menu,RDELETE,FALSE);
  295.        menu_ienable(ad_menu,RCOORD,FALSE);
  296.        menu_ienable(ad_menu,RMOVEFNT,FALSE);
  297.        menu_ienable(ad_menu,RMOVEBAK,FALSE);
  298.  
  299.        if (gl_region_ptr)
  300.             setTWArticle(gl_region_ptr,txtptr);
  301.     }
  302.     else
  303.     {
  304.        for(i = TFILE;i <= TOPTIONS;i++)
  305.         menu_ienable(ad_menu,0x8000|i,TRUE);
  306.        menu_ienable(ad_menu,0x8000|TEXT,FALSE);
  307.        if(TWart_ptr)
  308.             saveTWptrs();
  309.     }
  310.         active_prim = FALSE;
  311. }
  312.  
  313.  
  314.  
  315. /**************************************************************************/
  316. /* Function:    close_window()                          */
  317. /* Description: Close a window                          */
  318. /* IN: wi_handle - handle of window                      */
  319. /**************************************************************************/
  320. close_window(wi_handle)
  321. int wi_handle;
  322. {
  323.      wind_get(wi_handle,WF_CURRXYWH,&curr.g_x,&curr.g_y,&curr.g_w,&curr.g_h);
  324.      wind_close(wi_handle);
  325.      graf_shrinkbox(10,10,20,20,curr.g_x,curr.g_y,curr.g_w,curr.g_h);
  326.      wind_delete(wi_handle);
  327.  
  328.      if(wi_handle == txt_handle) txt_handle = FALSE;
  329.      else if(wi_handle == prev_handle) prev_handle = FALSE;
  330. }
  331.  
  332.  
  333.  
  334. /**************************************************************************/
  335. /* Function:    full_window()                          */
  336. /* Description: full size a window                      */
  337. /* IN: wi_handle - handle of window to full                  */
  338. /**************************************************************************/
  339. full_window(wi_handle)
  340. register int wi_handle;
  341. {
  342.      wind_get(wi_handle,WF_CURRXYWH,&curr.g_x,&curr.g_y,&curr.g_w,&curr.g_h);
  343.      wind_get(wi_handle,WF_FULLXYWH,&full.g_x,&full.g_y,&full.g_w,&full.g_h);
  344.  
  345.      if( rc_equal(&curr,&full))
  346.      {
  347.        wind_get(wi_handle,WF_PREVXYWH,&prev.g_x,&prev.g_y,&prev.g_w,&prev.g_h);
  348.        graf_shrinkbox(prev.g_x,prev.g_y,prev.g_w,prev.g_h,
  349.               full.g_x,full.g_y,full.g_w,full.g_h);
  350.        wind_set(wi_handle,WF_CURRXYWH,prev.g_x,prev.g_y,prev.g_w,prev.g_h);
  351.      }
  352.      else
  353.      {
  354.        graf_growbox(curr.g_x,curr.g_y,curr.g_w,curr.g_h,
  355.             full.g_x,full.g_y,full.g_w,full.g_h);
  356.        wind_set(wi_handle,WF_CURRXYWH,full.g_x,full.g_y,full.g_w,full.g_h);
  357.      }
  358.      get_work(wi_handle);
  359.      if(wi_handle == prev_handle)
  360.      {
  361.     if( (view_size == PSIZE)  ||
  362.         (view_size == PADJCNT))
  363.         {
  364.        gsx_moff();
  365.        size_fit_handle();
  366.        gsx_mon();
  367.        if(ruler_flag)
  368.         init_rulers();
  369.         }
  370.     else
  371.       prev_cleanup();
  372.      }
  373.     else TWslider_chk();
  374. }
  375.  
  376.  
  377.  
  378. /**************************************************************************/
  379. /* Function:     arrow_window()                          */
  380. /* Description:  arrow button control of a window              */
  381. /* NOTE: limits must be put in so that the arrows don't exceed them       */
  382. /* IN: wi_handle - handle of window                      */
  383. /*     action    - button pressed - arrow, slider, scroll bar          */
  384. /* OUT: none                                  */
  385. /**************************************************************************/
  386. arrow_window(wi_handle,action)
  387. int wi_handle;
  388. int action;
  389. {
  390.      int tmp_buff[8];
  391.      int event;
  392.  
  393.      if(wi_handle == txt_handle)        /* To TWindow handler */
  394.         return(TW_arrow(action));
  395.      
  396.      region_ptr = gl_region_ptr = gl_grregion_ptr = 0L;
  397.      if((wi_handle == prev_handle) && (view_size != PSIZE)
  398.                    && (view_size != PADJCNT))
  399.      {
  400.       set_clip(TRUE,&pwork);
  401.       scrntomu(16,16,&pixx,&pixy,1);        /* should be in do_view_size*/
  402.  
  403.  
  404.       arrow_funcs = &nada;
  405.       slide_arrow = &sliderv;
  406.  
  407.       switch(action)
  408.        {
  409.          case WA_UPPAGE:  
  410.            page_area.g_y = max(page_area.g_y - page_area.g_h,0L);
  411.            break;
  412.  
  413.          case WA_DNPAGE: 
  414. /*            page_area.g_y += page_area.g_h;*/
  415.            page_area.g_y = min(vpage_size - page_area.g_h,page_area.g_y + page_area.g_h);
  416.             break;
  417.  
  418.          case WA_UPLINE:
  419.            page_area.g_y = max(page_area.g_y - pixy,0L);
  420.                    arrow_funcs = &wupline;
  421.            break;
  422.  
  423.          case WA_DNLINE:
  424.            page_area.g_y += pixy;
  425.                    arrow_funcs = &wdnline;
  426.            break;
  427.  
  428.          case WA_LFPAGE:
  429.            page_area.g_x = max(page_area.g_x - page_area.g_w,0L);
  430.            break;
  431.  
  432.          case WA_RTPAGE:
  433. /*           page_area.g_x += page_area.g_w;*/
  434.            page_area.g_x = min(hpage_size - page_area.g_w,page_area.g_x + page_area.g_w);
  435.            break;
  436.  
  437.          case WA_LFLINE:
  438.            page_area.g_x = max(page_area.g_x - pixx,0L);
  439.                    arrow_funcs = &wlfline;
  440.            slide_arrow = &sliderh;
  441.            break;
  442.  
  443.          case WA_RTLINE:
  444.            page_area.g_x += pixx;
  445.            arrow_funcs = &wrtline;
  446.            slide_arrow = &sliderh;
  447.         break;
  448.        }
  449.        if( ((BREAL == 1) || (BREAL == 2))&& (arrow_funcs != &nada))
  450.        {
  451.        do
  452.         {
  453.         (*arrow_funcs)();
  454.         (*slide_arrow)();
  455.         do_blit();
  456.        }while( (BREAL == 1) || (BREAL == 2));
  457.        }
  458.        else
  459.        {
  460.           slider_chk();
  461.           do_blit();
  462.        }
  463.        BSTATE = 0;
  464.       
  465.            for(;;)    /* used to bleed off unwanted messages...*/
  466.            {
  467.         event = evnt_multi((MU_MESAG|MU_TIMER),
  468.                     0,0,0,
  469.                     0,0,0,0,0,
  470.                     0,0,0,0,0,
  471.                     tmp_buff,
  472.                     0,0,        /* timer == 0 */
  473.                     &dummy,&dummy,
  474.                     &dummy,&dummy,
  475.                     &dummy,&dummy);
  476.  
  477.         if(event == MU_TIMER)
  478.                 break;
  479.            }
  480.            BSTATE = 0;
  481.  
  482.     }
  483.     else
  484.     do_blit();
  485. }
  486.  
  487.  
  488.  
  489. /**************************************************************************/
  490. /* Function:     hslide_window()                      */
  491. /* Description:  Horizontal Slider Control                  */
  492. /* IN: wi_handle - handle of window                      */
  493. /*     position  - position of slider in window                  */
  494. /* OUT: none                                  */
  495. /**************************************************************************/
  496. hslide_window(wi_handle,position)
  497. int wi_handle;
  498. int position;
  499. {
  500.     if(wi_handle == prev_handle)
  501.     {
  502.     region_ptr = gl_region_ptr = gl_grregion_ptr = 0L;
  503.         if((view_size != PSIZE) && (view_size != PADJCNT))
  504.         {
  505.           page_area.g_x = scale_iv(position,hpage_size - page_area.g_w,1000);
  506.       sliderh();
  507.         }
  508.         send_redraw(prev_handle);
  509.     }
  510.     else TWhslide(position);
  511. }
  512.  
  513.  
  514.  
  515. /**************************************************************************/
  516. /* Function:     vslide_window()                      */
  517. /* Description:  Vertical Slider Control                  */
  518. /* IN: wi_handle - handle of window                      */
  519. /*     position  - position of slider in window                  */
  520. /* OUT: none                                  */
  521. /**************************************************************************/
  522. vslide_window(wi_handle,position)
  523. int wi_handle;
  524. int position;
  525. {
  526.     if(wi_handle == prev_handle)
  527.     {
  528.     region_ptr = gl_region_ptr = gl_grregion_ptr = 0L;
  529.     if((view_size != PSIZE) && (view_size != PADJCNT))
  530.     {
  531.       page_area.g_y = scale_iv(position,vpage_size - page_area.g_h,1000);
  532.       sliderv();
  533.         }
  534.     send_redraw(prev_handle);
  535.     }
  536.      else TWvslide(position);
  537. }
  538.  
  539.  
  540.  
  541. /**************************************************************************/
  542. /* Function:     size_window()                          */
  543. /* Description:  Window Sizer Routine                      */
  544. /* IN: info - handle, x,y,w,h of window                      */
  545. /* OUT: none                                  */
  546. /**************************************************************************/
  547. size_window(info)
  548. register int info[];
  549. {
  550.        wind_set(info[3],WF_CURRXYWH,info[4],info[5],info[6],info[7]);
  551.        get_work(info[3]);
  552.  
  553.        if(info[3] == txt_handle)
  554.        {
  555.       TWslider_chk();
  556.           wind_get(info[3],WF_PREVXYWH,&prev.g_x,&prev.g_y,&prev.g_w,&prev.g_h);
  557.           if((prev.g_w > info[6]) && (prev.g_h >= info[7]) ||
  558.           (prev.g_w >= info[6]) && (prev.g_h > info[7]) )
  559.               do_redraw(info);
  560.        }
  561.        else
  562.        {
  563.           if((view_size != PSIZE) && (view_size != PADJCNT))
  564.           {
  565.         set_clip(TRUE,&pwork);
  566.             wind_get(info[3],WF_PREVXYWH,&prev.g_x,&prev.g_y,
  567.                      &prev.g_w,&prev.g_h);
  568.         clear_window(prev_handle,2,1);
  569.  
  570.             wind_set(prev_handle,WF_VSLSIZE,scale_iv(1000,page_area.g_h,
  571.                               vpage_size),0,0,0);
  572.         wind_set(prev_handle,WF_HSLSIZE,scale_iv(1000,page_area.g_w,
  573.                               hpage_size),0,0,0);
  574.              sliderv();
  575.              sliderh();
  576.  
  577.             if((prev.g_w > info[6]) && (prev.g_h >= info[7]) ||
  578.             (prev.g_w >= info[6]) && (prev.g_h > info[7]) )
  579.             {
  580.                 send_redraw(prev_handle);
  581.             }
  582.  
  583.        }
  584.        else
  585.        {
  586.       gsx_moff();
  587.       size_fit_handle();
  588.       gsx_mon();
  589.       if(ruler_flag)
  590.         init_rulers();
  591.       send_redraw(prev_handle);
  592.        }
  593.       }
  594. }
  595.  
  596.  
  597.  
  598. /**************************************************************************/
  599. /* Function:     move_window()                          */
  600. /* Description:  Window Mover Routine                      */
  601. /* IN:  info  - handle,x,y,w,h of window                  */
  602. /**************************************************************************/
  603. move_window(info)
  604. register int info[];
  605. {
  606.     wind_set(info[3],WF_CURRXYWH,info[4],info[5],info[6],info[7]);
  607.     get_work(info[3]);
  608.         if(info[3] == prev_handle)
  609.         {
  610.        clear_window(prev_handle,2,1);
  611.            update_preview_blit();
  612.         }
  613. }
  614.  
  615.  
  616.  
  617. /**************************************************************************/
  618. /* Function:     slider_chk()                          */
  619. /* Description:  Slider Update                          */
  620. /* IN: none                                  */
  621. /* OUT: none                                  */
  622. /* GLOBAL:  page_area - modified to blit preview to screen          */
  623. /**************************************************************************/
  624. slider_chk()
  625. {
  626.    if( (view_size == PSIZE) || (view_size == PADJCNT))
  627.    {
  628.      page_area.g_x = page_area.g_y = 0;
  629.      wind_set(prev_handle,WF_VSLSIZE,1000,0,0,0);
  630.      wind_set(prev_handle,WF_HSLSIZE,1000,0,0,0);
  631.      wind_set(prev_handle,WF_VSLIDE,0,0,0,0);
  632.      wind_set(prev_handle,WF_HSLIDE,0,0,0,0);
  633.    }
  634.    else
  635.    {
  636.      wind_set(prev_handle,WF_VSLSIZE,scale_iv(1000,page_area.g_h,
  637.           vpage_size),0,0,0);
  638.      wind_set(prev_handle,WF_HSLSIZE,scale_iv(1000,page_area.g_w,
  639.           hpage_size),0,0,0);
  640.      sliderv();
  641.      sliderh();
  642.    }
  643. }
  644.  
  645.  
  646.  
  647.  
  648. /**************************************************************************/
  649. /* Function:     get_work()                          */
  650. /* Description:  Get work area of window                  */
  651. /* IN: handle - handle of window                      */
  652. /* OUT: none                                  */
  653. /* GLOBAL:  work area variables of window updated.              */
  654. /**************************************************************************/
  655. get_work(handle)
  656. int handle;
  657. {
  658.       if(prev_handle == handle)
  659.       {
  660.           wind_get(prev_handle,WF_WORKXYWH,&pwork.g_x,&pwork.g_y,
  661.                                       &pwork.g_w,&pwork.g_h);
  662.  
  663.       wind_get(prev_handle,WF_CURRXYWH,&cpwork.g_x,&cpwork.g_y,
  664.                        &cpwork.g_w,&cpwork.g_h);
  665.       dpwork.g_x = pwork.g_x;
  666.       dpwork.g_y = pwork.g_y;
  667.           
  668.       if(ruler_flag)
  669.       {
  670.         if(view_size == P200)
  671.             mutoscrn(324,288,&xruler_offset,&yruler_offset,1);
  672.         else
  673.             mutoscrn(648,576,&xruler_offset,&yruler_offset,1);
  674.         dpwork.g_x += xruler_offset;
  675.         dpwork.g_y += yruler_offset;
  676.           dpwork.g_w  = min(pwork.g_w-xruler_offset,pagew);
  677.           dpwork.g_h  = min(pwork.g_h-yruler_offset,pageh);
  678.       }
  679.           else
  680.           {     
  681.          dpwork.g_w = min(pwork.g_w,pagew);
  682.          dpwork.g_h = min(pwork.g_h,pageh);
  683.       }
  684.       
  685.       scrntomu(dpwork.g_w,dpwork.g_h,&page_area.g_w,&page_area.g_h,1);
  686.           update_preview_blit();
  687.       screen_clip();
  688.       }
  689.       else
  690.       if(txt_handle == handle)
  691.       {
  692.            wind_get(txt_handle,WF_WORKXYWH,&twork.g_x,&twork.g_y,
  693.                                    &twork.g_w,&twork.g_h);
  694.        setMrowcol();
  695.       }
  696. }
  697.  
  698.  
  699.  
  700.  
  701.  
  702. /**************************************************************************/
  703. /* Function: sliderv()                              */
  704. /* Description: size vertical slider bar                  */
  705. /**************************************************************************/
  706. sliderv()
  707. {
  708.      if(vpage_size < (page_area.g_y + page_area.g_h))
  709.         page_area.g_y = vpage_size - page_area.g_h;
  710.     
  711.      wind_set(prev_handle,WF_VSLIDE,scale_iv(1000,page_area.g_y,
  712.           vpage_size - page_area.g_h),0,0,0);
  713.  
  714. }
  715.  
  716.  
  717.  
  718.  
  719. /**************************************************************************/
  720. /* Function: sliderh()                              */
  721. /* Description: size horizontal slider bar                  */
  722. /**************************************************************************/
  723. sliderh()
  724. {
  725.    if(hpage_size < (page_area.g_x + page_area.g_w))
  726.         page_area.g_x = max(hpage_size - page_area.g_w,0);
  727.    if(page_area.g_w > hpage_size)
  728.         page_area.g_w = hpage_size;
  729.    wind_set(prev_handle,WF_HSLIDE,scale_iv(1000,page_area.g_x,
  730.           hpage_size - page_area.g_w),0,0,0); 
  731. }
  732.  
  733.  
  734.  
  735.  
  736.  
  737. /**************************************************************************/
  738. /* Function: wupline()                              */
  739. /* Description: up arrow function                      */
  740. /**************************************************************************/
  741. wupline()
  742. {
  743.    page_area.g_y = max(page_area.g_y - pixy,0L);
  744. }
  745.  
  746.  
  747.  
  748.  
  749. /**************************************************************************/
  750. /* Function: wdnline()                              */
  751. /* Description: down arrow function                      */
  752. /**************************************************************************/
  753. wdnline()
  754. {
  755.    page_area.g_y += pixy;
  756. }
  757.  
  758.  
  759.  
  760.  
  761.  
  762. /**************************************************************************/
  763. /* Function: wrtline()                              */
  764. /* Description: right arrow function                      */
  765. /**************************************************************************/
  766. wrtline()
  767. {
  768.    page_area.g_x += pixx;
  769. }
  770.  
  771.  
  772.  
  773.  
  774. /**************************************************************************/
  775. /* Function: wlfline()                              */
  776. /* Description: left arrow function                      */
  777. /**************************************************************************/
  778. wlfline()
  779. {
  780.    page_area.g_x = max(page_area.g_x - pixx,0L);
  781. }
  782.  
  783.  
  784.  
  785.  
  786.  
  787. /**************************************************************************/
  788. /* Function: prev_cleanup()                          */
  789. /* Description: Cleanup preview window                      */
  790. /**************************************************************************/
  791. prev_cleanup()
  792. {
  793.         clear_window(prev_handle,2,1);
  794.         slider_chk();
  795.     update_preview_blit();
  796. }
  797.  
  798.  
  799.  
  800.  
  801.  
  802. /**************************************************************************/
  803. /* Function: size_fit_handle()                          */
  804. /* Description: Calc page area for size to fit and PADJCNT          */
  805. /**************************************************************************/
  806. size_fit_handle()
  807. {
  808.        force_draw_flag = TRUE;
  809.            vsf_interior(shandle,0);
  810.        pdraw_fit(view_size);
  811.            zoom_setup();
  812.        cur_scale = get_scale_num(view_size);
  813.        get_work(prev_handle);
  814.        update_preview_blit();
  815.        set_clip(TRUE,&pwork);
  816. /*       gsx_moff();*/
  817.            vr_recfl(shandle,pxy);
  818.        clear_window(prev_handle,2,1);
  819. /*       gsx_mon();*/
  820.        slider_chk();
  821.        set_clip(TRUE,&dpwork);
  822. }
  823.  
  824.