home *** CD-ROM | disk | FTP | other *** search
/ NeXTSTEP 3.3.4.17 [SPARC, PA-RISC] / nextstep33_risc.iso / NextLibrary / TeX / tex / src / texview / PageView.m < prev    next >
Encoding:
Text File  |  1992-07-15  |  19.7 KB  |  941 lines
  1. /* Generated by Interface Builder */
  2.  
  3. #import "PageView.h"
  4. #import "SheetView.h"
  5. #import "appkit/Scroller.h"
  6. #import "TeXviewObject.h"
  7. #import "TVWindow.h"
  8. #import <dpsclient/wraps.h>
  9. #import "dviAccessors.h"
  10. #import <strings.h>
  11. #import <appkit/Application.h>
  12. #import "ComScroll.h"
  13. #import <appkit/TextField.h>
  14. #import <mach/mach.h>
  15.  
  16. extern real screendpi ;
  17. extern int paranoia ;
  18. extern PageView *myPageView ;
  19. extern Window *tvWindow ;
  20. extern SheetView *myView ;
  21. extern TeXviewObject *myTeXviewObject ;
  22. extern shalfword rvvsize, rhhsize ;
  23. extern Boolean mocked ;
  24. extern NXRect *initsizewindow() ;
  25. extern initWasOnScreen() ;
  26. extern void error() ;
  27.  
  28. extern void reportname() ;
  29. extern void recalculate() ;
  30. extern void PSflush(), TPSinit() ;
  31. extern void makenewdoc() ;
  32.  
  33. const char *legit_types[] = { "dvi", "tex", "latex", "ltx", NULL } ;
  34.  
  35. @implementation PageView
  36.  
  37. + newFrame:(const NXRect *)theFrame
  38. {
  39.     NXRect tempRect ;
  40.  
  41.     self = [super newFrame:theFrame];
  42.     [self setHorizScrollerRequired:YES];
  43.     [self setVertScrollerRequired:YES];
  44. /*  [self setDynamicScrolling:YES];
  45.     [self setBackgroundGray:0.433];
  46.     [self setAutoresizeSubviews:YES];
  47.     [self setBorderType:NX_NOBORDER]; */
  48.     myPageView = self ;
  49.     myOpenPanel = nil ;
  50.     NX_X(&tempRect) = 0 ;
  51.     NX_Y(&tempRect) = 0 ;
  52.     NX_WIDTH(&tempRect) = 1036 ;
  53.     NX_HEIGHT(&tempRect) = 1336 ;
  54.     myView = [SheetView newFrame:&tempRect] ;
  55.     [self setDocView:myView] ;
  56.     reportname(NOFILETITLE) ;
  57.     [[self window] setExcludedFromWindowsMenu:YES] ;
  58.     TPSinit() ;
  59.     recalculate() ;
  60.     return self;
  61. }
  62.  
  63. - drawSelf:(NXRect *)rects :(int)rectCount
  64. {
  65.    [super drawSelf:rects:rectCount] ;
  66.    return self ;
  67. }
  68.  
  69. - setPageNum:anObject
  70. {
  71.    pageNum = anObject ;
  72.    return self;
  73. }
  74.  
  75. - setConsole:anObject
  76. {
  77.    NXRect *tr ;
  78.  
  79.    console = anObject ;
  80.    [[console window] setExcludedFromWindowsMenu:YES] ;
  81.    if (tr=initsizewindow(1)) {
  82.       [[(ComScroll *)console window] placeWindow:tr] ;
  83.       if (initWasOnScreen()) {
  84.          [[console window] orderFront:self] ;
  85.       } else {
  86.          [[console window] orderOut:self] ;
  87.       }
  88.    }
  89.    return self;
  90. }
  91.  
  92. - getConsole
  93. {
  94.    return console ;
  95. }
  96.  
  97. - setTex:anObject
  98. {
  99.    NXRect *tr ;
  100.  
  101.    tex = anObject ;
  102.    [[tex window] setExcludedFromWindowsMenu:YES] ;
  103.    if (tr=initsizewindow(2)) {
  104.       [[(ComScroll *)tex window] placeWindow:tr] ;
  105.       if (initWasOnScreen()) {
  106.          [[tex window] orderFront:self] ;
  107.       } else {
  108.          [[tex window] orderOut:self] ;
  109.       }
  110.    }
  111.    return self;
  112. }
  113.  
  114. - getTeX
  115. {
  116.    return tex ;
  117. }
  118.  
  119. - setCommand:anObject
  120. {
  121.    NXRect *tr ;
  122.  
  123.    command = anObject ;
  124.    [command setExcludedFromWindowsMenu:YES] ;
  125.    [command removeFromEventMask:(NX_KEYDOWNMASK | NX_KEYUPMASK)] ;
  126.    if (tr=initsizewindow(3)) {
  127.       [command moveTo:tr->origin.x:tr->origin.y] ;
  128.       if (initWasOnScreen()) {
  129.          [command orderFront:self] ;
  130.       } else {
  131.          [command orderOut:self] ;
  132.       }
  133.    }
  134.    return self;
  135. }
  136.  
  137. - getCommand
  138. {
  139.    return command ;
  140. }
  141.  
  142. - setPageStuff:anObject
  143. {
  144.    pageStuff = anObject ;
  145.    pageStuff = [pageStuff setContentView:nil] ;
  146.    [self addSubview:pageStuff] ;
  147.    [self tile] ;
  148.    return self ;
  149. }
  150.  
  151. - getPageStuff;
  152. {
  153.    return pageStuff ;
  154. }
  155.  
  156. - tile
  157. {
  158.    NXRect r1, r2 ;
  159.    Scroller *h ;
  160.  
  161.    [super tile] ;
  162.    if (pageStuff == 0)
  163.       return self ;
  164.    h = [self horizScroller] ;
  165.    [h getFrame:&r2] ;
  166.    [pageStuff getFrame:&r1] ;
  167.    r2.size.width -= r1.size.width ;
  168.    r1.origin.x = r2.size.width + r2.origin.x ;
  169.    r1.origin.y = r2.origin.y ;
  170.    [h setFrame:&r2] ;
  171.    [pageStuff setFrame:&r1] ;
  172.    return self ;
  173. }
  174.  
  175. - lastPage:sender
  176. {
  177.     dviLastPage() ;
  178.     return self;
  179. }
  180.  
  181. - openPanel
  182. { 
  183.   if (!myOpenPanel) myOpenPanel = [OpenPanel new];
  184.   return (myOpenPanel);
  185. }
  186.  
  187. - update
  188. {
  189.    if ([self needsDisplay])
  190.       [self display] ;
  191.    return self ;
  192. }
  193.  
  194. - openFile:sender
  195. {
  196.     if ([[self openPanel] runModalForTypes:legit_types]) 
  197.     dviOpenFile((char *)[[self openPanel] filename]) ;
  198.     return self;
  199. }
  200.  
  201. - reOpenFile:sender
  202. {
  203.     dviReOpenFile() ;
  204.     return self;
  205. }
  206.  
  207. - nextPage:sender
  208. {
  209.     dviNextPage() ;
  210.     return self;
  211. }
  212.  
  213. - firstPage:sender
  214. {
  215.     dviFirstPage() ;
  216.     return self;
  217. }
  218.  
  219. - zoomUnzoom:sender
  220. {
  221.    dviZoomUnzoom() ;
  222.    return self;
  223. }
  224.  
  225. - mockUnmock:sender
  226. {
  227.    dviMock(-1) ;
  228.    return self;
  229. }
  230.  
  231. - mock:sender
  232. {
  233.    dviMock(1) ;
  234.    return self ;
  235. }
  236.  
  237. - unMock:sender
  238. {
  239.    dviMock(0) ;
  240.    return self ;
  241. }
  242.  
  243. - setMockSwitch:anObject
  244. {
  245.    mockSwitch = anObject ;
  246.    [self upMock] ;
  247.    return self ;
  248. }
  249.  
  250. void upmock(void) {
  251.    [myPageView upMock] ;
  252. }
  253.  
  254. - upMock {
  255.    [mockSwitch setState:mocked] ;
  256.    return self ;
  257. }
  258.  
  259. - unzoom:sender
  260. {
  261.     [myTeXviewObject unzoom] ;
  262.     dviUnzoom() ;
  263.     return self;
  264. }
  265.  
  266. - prevPage:sender
  267. {
  268.     dviPrevPage() ;
  269.     return self;
  270. }
  271.  
  272. - zoom:sender
  273. {
  274.     [myTeXviewObject zoom] ;
  275.     dviZoom() ;
  276.     return self;
  277. }
  278.  
  279. - closeFile:sender
  280. {
  281.     dviCloseFile() ;
  282.     return self;
  283. }
  284.  
  285. - gotoPage:sender
  286. {
  287.     dviGotoPage((char *)[sender stringValueAt:0]) ;
  288.     return self;
  289. }
  290.  
  291. void getpagenum(s)
  292. char *s ;
  293. {
  294.    [myPageView getpagenum:s] ;
  295. }
  296.  
  297. - getpagenum:(char *)s
  298. {
  299.    strcpy(s, [pageNum stringValue]) ;
  300.    return self ;
  301. }
  302.  
  303.  
  304. - fireRandom:sender
  305. {
  306.     [myTeXviewObject firePage] ;
  307.     return self ;
  308. }
  309.  
  310. void pagereport(pagenum, seq)
  311. integer pagenum, seq ;
  312. {
  313.    char str[30] ;
  314.  
  315.    if (seq == 0)
  316.       sprintf(str, "%ld", pagenum) ;
  317.    else
  318.       sprintf(str, "%ld.%ld", pagenum, seq) ;
  319.    [myTeXviewObject setPageNum:str] ;
  320.    PSflush() ;
  321. }
  322.  
  323. char realnameoffile[255] ;
  324.  
  325. void reportname(s)
  326. char *s ;
  327. {
  328.    static char *oldname ;
  329.  
  330.    if (s) {
  331.       oldname = s ;
  332.       if (*s != '*' || s[1] != ' ')
  333.          strcpy(realnameoffile, s) ;
  334.       else
  335.          realnameoffile[0] = 0 ;
  336.    } else
  337.       realnameoffile[0] = 0 ;
  338.    [[myPageView window] setTitleAsFilename:oldname] ;
  339. }
  340.  
  341. - changeDPI:(id)sender
  342. {
  343.    [myTeXviewObject popIt:sender] ;
  344.    return self ;
  345. }
  346.  
  347. #define MILLION 1000000
  348.  
  349. static int lastxsize = MILLION, lastysize = MILLION ;
  350.  
  351. - noScrollUpdates
  352. {
  353.    [myPageView setDisplayOnScroll:NO] ;
  354.    [myPageView setCopyOnScroll:NO] ;
  355.    return self ;
  356. }
  357.  
  358. - scrollUpdates
  359. {
  360.    [myPageView setDisplayOnScroll:YES] ;
  361.    [myPageView setCopyOnScroll:YES] ;
  362.    return self ;
  363. }
  364.  
  365. - cachePosition:(int)x:(int)y
  366. {
  367.    NXSize s ;
  368.  
  369.    [self getContentSize:&s] ;
  370.    if (s.width + 16 > lastxsize)
  371.       xcache = 0.5 ;
  372.    else
  373.       xcache = [[self horizScroller] floatValue] ;
  374.    if (s.height + 16 > lastysize)
  375.       ycache = 0.5 ;
  376.    else
  377.       ycache = [[self vertScroller] floatValue] ;
  378.    if (lastxsize == MILLION) { /* cheat these values in */
  379.       xcache = 0.5 ;
  380.       ycache = 0.0 ;
  381.    }
  382.    return self ;
  383. }
  384.  
  385. static float scroller_to_pos(float x1, float x2, float s) {
  386.    if (x2 < x1)
  387.       return s * (x1 - x2) ;
  388.    else
  389.       return 0 ;
  390. }
  391.  
  392. - unCachePosition:(int)x:(int)y
  393. {
  394.    NXSize size ;
  395.    NXPoint t ;
  396.  
  397.    [self getContentSize:&size] ;
  398.    t.x = scroller_to_pos((float)x, size.width, xcache) ;
  399.    t.y = scroller_to_pos((float)y, size.height, 1.0-ycache) ;
  400.    [myView scrollPoint:&t] ;
  401.    lastxsize = x ;
  402.    lastysize = y ;
  403.    return self ;
  404. }
  405.  
  406. /* moves down about a screenful. */
  407.  
  408. - (int)moveDown:(int)shiftstate;
  409. {
  410.    NXSize s ;
  411.    NXPoint t ;
  412.    float ypos = [[self vertScroller] floatValue] ;
  413.    float xpos = [[self horizScroller] floatValue] ;
  414.    float f ;
  415.  
  416.    shiftstate = 1 << (2 * shiftstate) ;
  417.    [self getContentSize:&s] ;
  418.    if (ypos > 0.95 || s.height + 16 >= rvvsize)
  419.       return 0 ;
  420.    if (2 * s.height < rvvsize)
  421.       f = s.height / (rvvsize - s.height) - 0.02 ;
  422.    else
  423.       f = 1.0 ;
  424.    if (f < 0.02)
  425.       f = 0.02 ;
  426.    f /= shiftstate ;
  427.    ypos += f ;
  428.    if (ypos > 1.0)
  429.       ypos = 1.0 ;
  430.    t.y = scroller_to_pos((float)rvvsize, s.height, 1.0 - ypos) ;
  431.    t.x = scroller_to_pos((float)rhhsize, s.width, xpos) ;
  432.    [myView scrollPoint:&t] ;
  433.    return 1 ;
  434. }
  435.  
  436. /* moves up about a screenful. */
  437.  
  438. - (int)moveUp:(int)shiftstate;
  439. {
  440.    NXSize s ;
  441.    NXPoint t ;
  442.    float ypos = [[self vertScroller] floatValue] ;
  443.    float xpos = [[self horizScroller] floatValue] ;
  444.    float f ;
  445.  
  446.    shiftstate = 1 << (2 * shiftstate) ;
  447.    [self getContentSize:&s] ;
  448.    if (ypos < 0.05 || s.height + 16 >= rvvsize)
  449.       return 0 ;
  450.    if (2 * s.height < rvvsize)
  451.       f = s.height / (rvvsize - s.height) - 0.02 ;
  452.    else
  453.       f = 1.0 ;
  454.    if (f < 0.02)
  455.       f = 0.02 ;
  456.    f /= shiftstate ;
  457.    ypos -= f ;
  458.    if (ypos < 0.0)
  459.       ypos = 0.0 ;
  460.    t.y = scroller_to_pos((float)rvvsize, s.height, 1.0 - ypos) ;
  461.    t.x = scroller_to_pos((float)rhhsize, s.width, xpos) ;
  462.    [myView scrollPoint:&t] ;
  463.    return 1 ;
  464. }
  465.  
  466. - (int)moveRight:(int)shiftstate
  467. {
  468.    NXSize s ;
  469.    NXPoint t ;
  470.    float ypos = [[self vertScroller] floatValue] ;
  471.    float xpos = [[self horizScroller] floatValue] ;
  472.    float f ;
  473.  
  474.    shiftstate = 1 << (2 * shiftstate) ;
  475.    [self getContentSize:&s] ;
  476.    if (s.width + 16 >= rhhsize)
  477.       return 0 ;
  478.    if (2 * s.width < rhhsize)
  479.       f = s.width / (rhhsize - s.width) - 0.02 ;
  480.    else
  481.       f = 1.0 ;
  482.    if (f < 0.02)
  483.       f = 0.02 ;
  484.    f /= shiftstate ;
  485.    xpos += f ;
  486.    if (xpos > 1.0)
  487.       xpos = 1.0 ;
  488.    t.y = scroller_to_pos((float)rvvsize, s.height, 1.0 - ypos) ;
  489.    t.x = scroller_to_pos((float)rhhsize, s.width, xpos) ;
  490.    [myView scrollPoint:&t] ;
  491.    return 1 ;
  492. }
  493.  
  494. - (int)moveLeft:(int)shiftstate
  495. {
  496.    NXSize s ;
  497.    NXPoint t ;
  498.    float ypos = [[self vertScroller] floatValue] ;
  499.    float xpos = [[self horizScroller] floatValue] ;
  500.    float f ;
  501.  
  502.    shiftstate = 1 << (2 * shiftstate) ;
  503.    [self getContentSize:&s] ;
  504.    if (s.width + 16 >= rhhsize)
  505.       return 0 ;
  506.    if (2 * s.width < rhhsize)
  507.       f = s.width / (rhhsize - s.width) - 0.02 ;
  508.    else
  509.       f = 1.0 ;
  510.    if (f < 0.02)
  511.       f = 0.02 ;
  512.    f /= shiftstate ;
  513.    xpos -= f ;
  514.    if (xpos < 0.0)
  515.       xpos = 0.0 ;
  516.    t.y = scroller_to_pos((float)rvvsize, s.height, 1.0 - ypos) ;
  517.    t.x = scroller_to_pos((float)rhhsize, s.width, xpos) ;
  518.    [myView scrollPoint:&t] ;
  519.    return 1 ;
  520. }
  521.  
  522. - Bot:(int)quiet;
  523. {
  524.    NXSize s ;
  525.    NXPoint t ;
  526.    float xpos = [[self horizScroller] floatValue] ;
  527.  
  528.    if (quiet)
  529.       [self noScrollUpdates] ;
  530.    [self getContentSize:&s] ;
  531.    t.y = scroller_to_pos((float)rvvsize, s.height, 0.0) ;
  532.    t.x = scroller_to_pos((float)rhhsize, s.width, xpos) ;
  533.    [myView scrollPoint:&t] ;
  534.    if (quiet)
  535.       [self scrollUpdates] ;
  536.    return self ;
  537. }
  538.  
  539. - Top:(int)quiet;
  540. {
  541.    NXSize s ;
  542.    NXPoint t ;
  543.    float xpos = [[self horizScroller] floatValue] ;
  544.  
  545.    if (quiet)
  546.       [self noScrollUpdates] ;
  547.    [self getContentSize:&s] ;
  548.    t.y = scroller_to_pos((float)rvvsize, s.height, 1.0) ;
  549.    t.x = scroller_to_pos((float)rhhsize, s.width, xpos) ;
  550.    [myView scrollPoint:&t] ;
  551.    if (quiet)
  552.       [self scrollUpdates] ;
  553.    return self ;
  554. }
  555.  
  556. void bringupwindow(void) {
  557.    NXRect *tr ;
  558.  
  559.    if (tr = initsizewindow(0))
  560.       [[myPageView window] placeWindow:tr] ;
  561.    tvWindow = [myPageView window] ;
  562.    [[myPageView window] makeKeyAndOrderFront:0] ;
  563. }
  564.  
  565. - setPositionText:anObject
  566. {
  567.    positionText = anObject ;
  568.    return self ;
  569. }
  570.  
  571. - setPositionRadio:anObject
  572. {
  573.    positionRadio = anObject ;
  574.    return self ;
  575. }
  576.  
  577. static float units[] = { 1.0, 2.54, 72.27, 72.0, 84.725 } ;
  578. static int curunits = 0 ;
  579. static NXPoint posevent = {0.0, 0.0}, prevposevent = {0.0, 0.0} ;
  580. static char *unitnames[] = { "inches", "centimeters", "points",
  581.     "PostScript units", "pico-light-seconds", 0 } ;
  582. - changeUnits:sender
  583. {
  584.    curunits = (curunits + 1) ;
  585.    if (unitnames[curunits] == 0)
  586.       curunits = 0 ;
  587.    [self updatePosition] ;
  588.    return self ;
  589. }
  590.  
  591. - updatePosition
  592. {
  593.    NXPoint pagepos ;
  594.    NXPoint deltapos ;
  595.    char tempbuf[300] ;
  596.  
  597.    if (positionText && screendpi > 1.0) {
  598.       pagepos = posevent ;
  599.       deltapos = prevposevent ;
  600.       pagepos.x *= units[curunits] / screendpi ;
  601.       pagepos.y *= units[curunits] / screendpi ;
  602.       deltapos.x *= units[curunits] / screendpi ;
  603.       deltapos.y *= units[curunits] / screendpi ;
  604.       sprintf(tempbuf,
  605.               "Click at (%.3g,%.3g) is (%.3g,%.3g) from previous click in %s.",
  606.        pagepos.x, pagepos.y, pagepos.x - deltapos.x, pagepos.y - deltapos.y,
  607.        unitnames[curunits]) ;
  608.       [(TextField *)positionText setStringValue:tempbuf] ;
  609.    }
  610.    return self ;
  611. }
  612.  
  613. - reportPosition:(NXEvent *)event
  614. {
  615.    if (myView && positionText && screendpi > 1.0) {
  616.       prevposevent = posevent ;
  617.       posevent = (event->location) ;
  618.       posevent.x -= 8.0 ;
  619.       posevent.y -= 8.0 ;
  620.       [myView convertPoint:&posevent fromView:nil] ;
  621.       [self updatePosition] ;
  622.    }
  623.    return self ;
  624. }
  625.  
  626. - mouseDown: (NXEvent *) ptr
  627. {
  628.     NXPoint     newLoc, oldLoc;
  629.     NXEvent     *nextEvent;
  630.     int         oldMask;
  631.     NXRect      myRect;
  632.     int numdrags = 0 ;
  633.  
  634.     oldMask =
  635.         [window addToEventMask:(NX_LMOUSEUPMASK | NX_LMOUSEDRAGGEDMASK)];
  636.     [self lockFocus];
  637.  
  638.     oldLoc = ptr->location;
  639.     [self convertPoint:&oldLoc fromView:nil];
  640.  
  641.     nextEvent =
  642.         [NXApp getNextEvent:(NX_LMOUSEUPMASK | NX_LMOUSEDRAGGEDMASK)];
  643.     while (nextEvent->type == NX_LMOUSEDRAGGED){
  644.         numdrags++ ;
  645.         newLoc = nextEvent->location;
  646.         [self convertPoint:&newLoc fromView:nil];
  647.         [myView getVisibleRect:&myRect];
  648.         myRect.origin.x -= newLoc.x - oldLoc.x;
  649.         myRect.origin.y += newLoc.y - oldLoc.y;
  650.         [myView scrollRectToVisible: &myRect];
  651.         oldLoc = newLoc;
  652.         nextEvent =
  653.             [NXApp getNextEvent:(NX_LMOUSEUPMASK | NX_LMOUSEDRAGGEDMASK)];
  654.     }
  655.     [self unlockFocus];
  656.     [window setEventMask:oldMask];
  657.     if (numdrags == 0)
  658.        [self reportPosition:nextEvent] ;
  659.     return self;
  660. }
  661.  
  662. void writeconsole(const char *s) {
  663.    static char wcbuf[1024] ;
  664.    strcpy(wcbuf, s) ;
  665.    strcat(wcbuf, "\n") ;
  666.    [((ComScroll *)[myPageView getConsole]) addText:wcbuf] ;
  667. }
  668.  
  669. void mysystem(const char *s) {
  670.    if (paranoia)
  671.       system(s) ;
  672.    else
  673.       [((ComScroll *)[myPageView getConsole]) logCommand:s inBack:0] ;
  674. }
  675.  
  676. void consoletofront() {
  677.    [[((ComScroll *)[myPageView getConsole]) window] makeKeyAndOrderFront:0] ;
  678. }
  679.  
  680. void textofront() {
  681.    [[((ComScroll *)[myPageView getTeX]) window] makeKeyAndOrderFront:0] ;
  682. }
  683.  
  684. void commandup() {
  685.    [[myPageView getCommand] orderFront:0] ;
  686. }
  687.  
  688. void previewtofront() {
  689.    [[myPageView window] makeKeyAndOrderFront:0] ;
  690. }
  691.  
  692. void myasyncsystem(const char *s) {
  693.    textofront() ;
  694.    [((ComScroll *)[myPageView getTeX]) logCommand:s inBack:1] ;
  695. }
  696.  
  697. extern void reTeXit() ;
  698.  
  699. - TeXtexit:sender {
  700.    reTeXit("tex -v \"%s\"") ;
  701.    return self ;
  702. }
  703. - TeXlatexit:sender {
  704.    reTeXit("latex -v \"%s\"") ;
  705.    return self ;
  706. }
  707. - TeXslitexit:sender {
  708.    reTeXit("slitex -v \"%s\"") ;
  709.    return self ;
  710. }
  711. - TeXbibtexit:sender {
  712.    reTeXit("bibtex \"%s\"") ;
  713.    return self ;
  714. }
  715. - TeXamstexit:sender {
  716.    reTeXit("amstex -v \"%s\"") ;
  717.    return self ;
  718. }
  719. - openManual:sender {
  720.    dviOpenFile("/usr/tex/ntman.dvi") ;
  721.    return self ;
  722. }
  723. - TeXcustomexit:sender {
  724.    reTeXit("%C -v \"%s\"") ;
  725.    return self ;
  726. }
  727. - TeXdefaultexit:sender {
  728.    reTeXit("%L -v \"%s\"") ;
  729.    return self ;
  730. }
  731. - TeXmakeit:sender {
  732.    reTeXit("make \"%s.dvi\"") ;
  733.    return self ;
  734. }
  735. - clearBuffer:sender {
  736.    ComScroll *c = 0 ;
  737.  
  738.    if (console && [[(ComScroll *)console window] isKeyWindow])
  739.       c = console ;
  740.    else if (tex && [[(ComScroll *)tex window] isKeyWindow])
  741.       c = tex ;
  742.    if (c)
  743.       [c clear] ;
  744.    return self ;
  745. }
  746.  
  747. - appDidBecomeActive:(id)sender;
  748. {
  749. /* [tvWindow makeKeyAndOrderFront:self] ; */
  750.    return self ;
  751. }
  752.  
  753. - servercalled
  754. {
  755.    return self ;
  756. }
  757.  
  758. /*
  759.  *   What we do here is we try to find data of type NXFilenamePboardType,
  760.  *   and then open it up.
  761.  */
  762. - serverOpen:(id)pb userData:(const char *)userData error:(char **)msg {
  763.    char *data ;
  764.    int len ;
  765.    char *const *s ;
  766.    char *const *types = [pb types] ;
  767.  
  768.    [self servercalled] ;
  769.    for (s=types; *s; s++)
  770.       if (*s == NXFilenamePboardType)
  771.          break ;
  772.    dviSaveFormat(userData) ;
  773.    if (*s && [pb readType:NXFilenamePboardType data:&data length:&len]) {
  774.       dviOpenFile(data) ;
  775.       vm_deallocate(task_self(), (vm_address_t)data, len) ;
  776.    }
  777.    return self ;
  778. }
  779.  
  780. /*
  781.  *   The rest actually ignore the filename, since the user may be editing
  782.  *   an auxilliary file.
  783.  */
  784. - serverReopen:(id)pb userData:(const char *)userData error:(char **)msg {
  785.    [self servercalled] ;
  786.    [self reOpenFile:self] ;
  787.    return self ;
  788. }
  789.  
  790. - serverCommand:(id)pb userData:(const char *)userData error:(char **)msg {
  791.    [self servercalled] ;
  792.    reTeXit(userData) ;
  793.    return self ;
  794. }
  795.  
  796. - serverMakeEquation:(id)pb userData:(const char *)userData
  797.             error:(char **)msg {
  798.    char *data, *p ;
  799.    int len ;
  800.    char *const *s ;
  801.    char *const *types = [pb types] ;
  802.    FILE *f ;
  803.    char tempname[40] ;
  804.    char cmd[120] ;
  805.    extern char *mktemp() ;
  806.    extern void unlink() ;
  807.    extern int system() ;
  808.  
  809.    [self servercalled] ;
  810.    for (s=types; *s; s++)
  811.       if (*s == NXAsciiPboardType)
  812.          break ;
  813.    if (*s && [pb readType:NXAsciiPboardType data:&data length:&len]) {
  814.       strcpy(tempname, "TeXEQN.XXXXXX") ;
  815.       p = mktemp(tempname) ;
  816.       p = p + strlen(p) ;
  817.       strcpy(p, ".tex") ;
  818.       f = fopen(tempname, "w") ;
  819.       if (f == 0) {
  820.          *msg = "Couldn't open temporary file" ;
  821.          return self ;
  822.       }
  823.       fwrite(data, 1, len, f) ;
  824.       fputs("\n \\nopagenumbers \\bye\n", f) ;
  825.       fclose(f) ;
  826.       *p = 0 ;
  827.       sprintf(cmd, ((userData && *userData) ? userData :
  828.          "tex %s.tex ; dvips %s.dvi -E -n 1 -o %s.eps -P epsf"),
  829.           tempname, tempname, tempname) ;
  830.       system(cmd) ; /* we want to use mysystem */
  831.       strcpy(p, ".eps") ;
  832.       f = fopen(tempname, "r") ;
  833.       if (f) {
  834.          int nlen ;
  835.          char *mbuf ;
  836.          const char *nt[1] ;
  837.  
  838.          nt[0] = NXPostScriptPboardType ;
  839.          fseek(f, 0L, 2) ;
  840.          nlen = ftell(f) ;
  841.          fseek(f, 0L, 0) ;
  842.          mbuf = malloc(nlen) ;
  843.          if (mbuf == 0)
  844.             error("! no memory?") ;
  845.          fread(mbuf, 1, nlen, f) ;
  846.          [pb declareTypes:nt num:1 owner:NULL] ;
  847.          [pb writeType:NXPostScriptPboardType data:mbuf length:nlen] ;
  848.          free(mbuf) ;
  849.          fclose(f) ;
  850.       } else
  851.          *msg = "Output file didn't get created, somehow" ;
  852.       vm_deallocate(task_self(), (vm_address_t)data, len) ;
  853.       strcpy(p, ".dvi") ; unlink(tempname) ;
  854.       strcpy(p, ".log") ; unlink(tempname) ;
  855.       strcpy(p, ".tex") ; unlink(tempname) ;
  856.       strcpy(p, ".eps") ; unlink(tempname) ;
  857.    }
  858.    return self ;
  859. }
  860.  
  861. extern char basename[] ;
  862.  
  863. - validRequestorForSendType:(NXAtom)sendType andReturnType:(NXAtom)returnType {
  864.    printf("Someone's asking for %s but getting %s\n",
  865.       (sendType ? sendType : ""), (returnType ? returnType : "")) ;
  866.    if (sendType == NXFilenamePboardType && returnType == 0 && basename[0])
  867.       return self ;
  868.    else
  869.       return nil ;
  870. }
  871.  
  872. - (BOOL)writeSelectionToPasteboard:(Pasteboard *)pboard types:(NXAtom *)types
  873. /*
  874.  * If one of the requested types is one of the ones we handle,
  875.  * then we put our selection in the Pasteboard.
  876.  */
  877. {
  878.     while (types && *types) {
  879.     if (*types == NXFilenamePboardType)
  880.            break ;
  881.     types++;
  882.     }
  883.     if (types && *types && basename[0]) {
  884.         char tempname[1000] ;
  885.         strcpy(tempname, basename) ;
  886.         strcat(tempname, ".tex") ;
  887.         [pboard writeType:*types data:tempname length:(strlen(tempname))] ;
  888.     return YES;
  889.     } else {
  890.     return NO;
  891.     }
  892. }
  893.  
  894. extern char LastFormat[], CustomFormat[] ;
  895.  
  896. - setDefaultformat:sender {
  897.    defaultformat = sender ;
  898.    [self upDefaultformat:self] ;
  899.    return self ;
  900. }
  901. - setCustomformat:sender {
  902.    customformat = sender ;
  903.    [self upCustomformat:self] ;
  904.    return self ;
  905. }
  906. - newDefaultformat:sender {
  907.    char *p = (char *)[sender stringValueAt:0] ;
  908.    while (*p <= ' ' && *p)
  909.       p++ ;
  910.    strcpy(LastFormat, p) ;
  911.    p = LastFormat ;
  912.    while (*p > ' ')
  913.       p++ ;
  914.    *p = 0 ;
  915.    return self ;
  916. }
  917. - newCustomformat:sender {
  918.    char *p = (char *)[sender stringValueAt:0] ;
  919.    while (*p <= ' ' && *p)
  920.       p++ ;
  921.    strcpy(CustomFormat, p) ;
  922.    p = CustomFormat ;
  923.    while (*p > ' ')
  924.       p++ ;
  925.    *p = 0 ;
  926.    return self ;
  927. }
  928. - upDefaultformat:sender {
  929.    [(TextField *)defaultformat setStringValue:LastFormat] ;
  930.    return self ;
  931. }
  932. - upCustomformat:sender {
  933.    [(TextField *)customformat setStringValue:CustomFormat] ;
  934.    return self ;
  935. }
  936. void upformats(void) {
  937.    [myPageView upDefaultformat:0] ;
  938.    [myPageView upCustomformat:0] ;
  939. }
  940. @end
  941.