开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
view.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：23k
源码类别：

通讯编程

开发平台：

Visual C++

view.cc：源码内容
  1. /*
  2.  * Copyright (c) 1991,1993 Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  * This product includes software developed by the Computer Systems
  16.  * Engineering Group at Lawrence Berkeley Laboratory.
  17.  * 4. Neither the name of the University nor of the Laboratory may be used
  18.  *    to endorse or promote products derived from this software without
  19.  *    specific prior written permission.
  20.  *
  21.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  22.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  25.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31.  * SUCH DAMAGE.
  32.  *
  33.  * @(#) $Header: /cvsroot/nsnam/nam-1/view.cc,v 1.30 2003/10/11 22:56:51 xuanc Exp $ (LBL)
  34.  */
  36. #include <stdlib.h>
  37. #ifdef WIN32
  38. #include <windows.h>
  39. #endif
  41. #include <ctype.h>
  42. #include <math.h>
  44. #include <tclcl.h>
  45. #include "view.h"
  46. #include "bbox.h"
  47. #include "netview.h"
  48. #include "netmodel.h"
  49. #include "tclcl.h"
  50. #include "paint.h"
  51. #include "packet.h"
  53. // Create list of font names and sizes
  54. static char * fontName[NFONT] = {
  55.   "-adobe-times-medium-r-normal-*-8-*-*-*-*-*-*-*",
  56.   "-adobe-times-medium-r-normal-*-10-*-*-*-*-*-*-*",
  57.   "-adobe-times-medium-r-normal-*-12-*-*-*-*-*-*-*",
  58.   "-adobe-times-medium-r-normal-*-14-*-*-*-*-*-*-*",
  59.   "-adobe-times-medium-r-normal-*-18-*-*-*-*-*-*-*",
  60.   "-adobe-times-medium-r-normal-*-20-*-*-*-*-*-*-*",
  61.   "-adobe-times-medium-r-normal-*-24-*-*-*-*-*-*-*",
  62.   "-adobe-times-medium-r-normal-*-34-*-*-*-*-*-*-*"
  63. };
  66. // Convert a string to world coordinates
  67. int View::getCoord(char *strx, char *stry, float &dx, float &dy) {
  68. Tcl& tcl = Tcl::instance();
  70. double tx, ty;
  71. if ((Tk_GetScreenMM(tcl.interp(), tk_, strx, &tx) != TCL_OK) ||
  72.     (Tk_GetScreenMM(tcl.interp(), tk_, stry, &ty) != TCL_OK)) {
  73. return TCL_ERROR;
  74. }
  76. tx *= pixelsPerMM_;
  77. ty *= pixelsPerMM_;
  78. dx = tx, dy = ty;
  79. matrix_.imap(dx, dy);
  80. return TCL_OK;
  81. }
  83. void View::zoom(float mag)
  84. {
  85.         magnification_ *= mag;
  86.         resize(width_, height_);
  87. }
  89. //---------------------------------------------------------------------
  90. // void
  91. // View::resize(int width, int height)
  92. //   - resize the display canvas and setup the mapping between 
  93. //     world and screen coordinate systems
  94. //---------------------------------------------------------------------
  95. void View::resize(int width, int height) {
  96.   width_ = width;
  97.   height_ = height;
  99.   matrix_.clear();
  101.   BBox bb;
  103.   // a model can choose to use these values, or can set its own
  104.   // NetModel sets it to bb.clear(), while GraphView use this
  105.   bb.xmin = 0;
  106.   bb.ymin = 0;
  107.   bb.xmax = width;
  108.   bb.ymax = height;
  110.   // WorldBox refers to the boundaries for the network model world 
  111.   // Basically NetView and EditView used to return the bounding box
  112.   // for NetModel not for themselves so now BoundingBox returns
  113.   // values based on the canvas size and getWorldBox returns the 
  114.   // NetModel values.
  115.   getWorldBox(bb);
  116.  // BoundingBox(bb);
  118.   double x = (0.0 - panx_) * width;
  119.   double y = (0.0 - pany_) * height;
  120.   double w = width;
  121.   double h = height;
  122.   /*
  123.    * Set up a transform that maps bb -> canvas.  I.e,
  124.    * bb -> unit square -> allocation, but which retains
  125.    * the aspect ratio.  Also, add a margin.
  126.    */
  127.   double world_width = bb.xmax - bb.xmin;
  128.   double world_height = bb.ymax - bb.ymin;
  130.   
  131.   /* 
  132.    * Grow a margin if we asked for square aspect ratio.
  133.    */
  134.   double bbw;
  135.   double bbh;
  137.   if (aspect_ == SQUARE) {
  138.     bbw = 1.1 * world_width;
  139.     bbh = 1.1 * world_height;
  141.    // bbw = world_width;
  142.    // bbh = world_width*height/width;
  144.  //   if (bbh < world_height) {
  145.       // Need to scale in the other direction
  146.   //    bbw = world_height*width/height;
  147.    //   bbh = world_height;
  148.    // }
  149.   } else {
  150.     bbw = world_width;
  151.     bbh = world_height;
  152.   }
  154.   // Calculate the width and height for translating x and y axis
  155.   double tx = bb.xmin - 0.5 * (bbw - world_width);
  156.   double ty = bb.ymin - 0.5 * (bbh - world_height);
  157.   
  158.   // move base coordinate system to origin
  159.   matrix_.translate(-tx, -ty);
  160.   
  161.   // flip vertical axis because Y is backwards.
  162.   matrix_.scale(1.0, -1.0);
  163.   matrix_.translate(0., bbh);
  164.   
  165.   double ws = w / bbw;
  166.   double hs = h / bbh;
  167.   
  168.   // The matrix_.translate(x expression, y expression) takes care of
  169.   // scrolling when clicking on the scroll bars
  170.   if (aspect_ == SQUARE) {
  171.     if (ws <= hs) {
  172.       matrix_.scale(ws, ws);
  173.       matrix_.translate(x, y + 0.5 * (h - ws * bbh));
  174.     } else {
  175.       matrix_.scale(hs, hs);
  176.       matrix_.translate(x + 0.5 * (w - hs * bbw), y);
  177.     }
  178.   } else {
  179.     matrix_.scale(ws, hs);
  180.     matrix_.translate(x, y);
  181.   }
  183.   if (offscreen_ != 0)
  184.     Tk_FreePixmap(Tk_Display(tk_), offscreen_);
  186.   if ((width_<=0) || (height_<=0))
  187.     abort();
  189.   // Create a new offscreen canvas for double buffered drawing
  190.   offscreen_ = Tk_GetPixmap(Tk_Display(tk_), Tk_WindowId(tk_),
  191.                             width_, height_, Tk_Depth(tk_));
  194.   // Scale for any magnification
  195.   matrix_.scale(magnification_, magnification_);
  197.   if (xscroll_ != NULL) {
  198.     Tcl& tcl = Tcl::instance();
  199.     tcl.evalf("%s set %f %f", xscroll_, panx_, 
  200.                               panx_+(1.0/magnification_));
  201.   }
  203.   if (yscroll_ != NULL) {
  204.     Tcl& tcl = Tcl::instance();
  205.     tcl.evalf("%s set %f %f", yscroll_, pany_, 
  206.                               pany_+(1.0/magnification_));
  207.   }
  209.   pixelsPerMM_ = WidthOfScreen(Tk_Screen(tk_)) / 
  210.                  WidthMMOfScreen(Tk_Screen(tk_));
  212.   if (!bClip_) {
  213.     clip_.xmin = 0;
  214.     clip_.ymin = 0;
  215.     clip_.xmax = width_;
  216.     clip_.ymax = height_;
  217.   }
  218. }
  220. //---------------------------------------------------------------------
  221. // void
  222. // View::draw() 
  223. //   - Does double buffered drawing
  224. //     All objects are drawn to an offscreen area and then the whole
  225. //     offscreen area is copied to the current view --mehringe@isi.edu
  226. //   - render is in a sub class of View
  227. //---------------------------------------------------------------------
  228. void
  229. View::draw() {
  230. if (offscreen_ == 0) {
  231. return;
  232. }
  234. // Clear offscreen bitmap
  235. XFillRectangle(Tk_Display(tk_), offscreen_, background_,
  236.                0, 0, width_, height_);
  238. // Draw objects onto offscreen bitmap
  239. render();
  241. // Copy over offscreen bitmap to current view
  242. XCopyArea(Tk_Display(tk_), offscreen_, Tk_WindowId(tk_), background_,
  243.           0, 0, width_, height_, 0, 0);
  244. }
  246. //-----------------------------------------------------------------------
  247. //-----------------------------------------------------------------------
  248. View::View(const char* name, int aspect, int width, int height) :
  249. next_(NULL),
  250. magnification_(1.0),
  251. panx_(0.0),
  252. pany_(0.0), 
  253. aspect_(aspect),
  254. xscroll_(NULL),
  255. yscroll_(NULL),
  256. bClip_(0) {
  258. Tcl& tcl = Tcl::instance();
  259. tk_ = Tk_CreateWindowFromPath(tcl.interp(), tcl.tkmain(),
  260.                               (char *) name, 0);
  262. if (tk_) {
  263. Tk_SetClass(tk_, "NetView");
  264. /*XXX*/
  265. /* Specify preferred window size. */
  266. Tk_GeometryRequest(tk_, width, height);
  268. Tk_CreateEventHandler(tk_, ExposureMask|StructureNotifyMask,
  269.                       handle, (ClientData)this);
  271. Tk_MakeWindowExist(tk_);
  273. pixelsPerMM_ = WidthOfScreen(Tk_Screen(tk_)) / 
  274.                WidthMMOfScreen(Tk_Screen(tk_));
  275. } else {
  276. // Just an arbitrary initialization
  277. pixelsPerMM_ = 1;
  278. }
  280. width_ = height_ = 0;
  281. background_ = Paint::instance()->background_gc();
  282. offscreen_ = 0;
  283. load_fonts();
  284. }
  288. View::~View()
  289. {
  290. /* 
  291.  * Do not do Tk_DestroyWindow() stuff. Should *never* use
  292.  * delete <view> to destroy a view
  293.  */ 
  294. if (tk_ != 0) {
  295. if (offscreen_ != 0)
  296. Tk_FreePixmap(Tk_Display(tk_), offscreen_);
  297. free_fonts();
  298. }
  299. tk_ = 0;
  300. }
  302. //----------------------------------------------------------------------
  303. // void
  304. // View::BoundingBox(BBox& destination)
  305. //  
  306. //----------------------------------------------------------------------
  307. void
  308. View::BoundingBox(BBox& destination) {
  309.   fprintf(stderr,"View::BoundingBoxn");
  310. }
  312. void View::setClipRect(BBox &b) 
  313. {
  314. XRectangle rect;
  315. Paint* paint = Paint::instance();
  316. clip_ = b;
  317. bClip_ = 1;
  318. clip_.xmin = clip_.ymin = 0;
  319. clip_.xmax = (float)width_;
  320. clip_.ymax = (float)height_;
  321. b.xrect(rect);
  322. #ifndef WIN32
  323. for (int i = 0; i < paint->num_gc(); i++) {
  324. XSetClipRectangles(Tk_Display(tk_), paint->paint_to_gc(i),
  325.    0, 0, &rect, 1, Unsorted);
  326. }
  327. #endif
  328. }
  330. void View::clearClipRect()
  331. {
  332. Paint* paint = Paint::instance();
  333. #ifndef WIN32
  334. for (int i = 0; i < paint->num_gc(); i++) {
  335. // XXX Or should I set it to the whole window???
  336. XSetClipRectangles(Tk_Display(tk_), paint->paint_to_gc(i),
  337.    0, 0, None, 1, Unsorted);
  338. }
  339. #endif
  340. bClip_ = 0;
  341. }
  343. void View::setFunction(int func)
  344. {
  345. Paint* paint = Paint::instance();
  346. for (int i = 0; i < paint->num_gc(); i++) 
  347. XSetFunction(Tk_Display(tk_), paint->paint_to_gc(i), func);
  348. }
  350. /* Handler for the Expose, DestroyNotify and ConfigureNotify events. */
  351. void View::handle(ClientData cd, XEvent* ep)
  352. {
  353. View* nv = (View*)cd;
  355. switch (ep->type) {
  356. case Expose:
  357. if (ep->xexpose.count == 0)
  358. /*XXX*/
  359. nv->draw();
  360. break;
  362. case DestroyNotify:
  363. /*XXX kill ourself */
  364. /*XXX: this should kill the viewer! */
  365. /*XXX how about use delete this? */
  366. if (nv->tk_ != 0) {
  367. if (nv->offscreen_ != 0)
  368. Tk_FreePixmap(Tk_Display(nv->tk_), 
  369.       nv->offscreen_);
  370. nv->free_fonts();
  371. }
  372. nv->tk_ = 0;
  373. delete nv;
  374. break;
  376. case ConfigureNotify:
  377. if (nv->width_ != ep->xconfigure.width ||
  378.     nv->height_ != ep->xconfigure.height) {
  379.   //if it gets smaller, there will be no expose event,
  380.   //so we have to draw it outselves - mjh
  381.   int smaller=0;
  382.   if ((nv->width_ >= ep->xconfigure.width) &&
  383.       (nv->height_ >= ep->xconfigure.height))
  384.     smaller=1;
  385.   nv->resize(ep->xconfigure.width,
  386.      ep->xconfigure.height);
  387.   if (smaller)
  388.     nv->draw();
  389. }
  390. break;
  391. }
  392. }
  394. int View::command(ClientData cd, Tcl_Interp* tcl, int argc, CONST84 char **argv)
  395. {
  396.   NetView *nv = (NetView *)cd;
  397.   if (argc < 2) {
  398.     Tcl_AppendResult(tcl, """, argv[0], "": arg mismatch", 0);
  399.     return (TCL_ERROR);
  400.   }
  401.   if (strcmp(argv[1], "xscroll") == 0) {
  402.     if (argc == 3) {
  403.       nv->xscroll_=new char[strlen(argv[2])+1];
  404.       strcpy(nv->xscroll_, argv[2]);
  405.       return TCL_OK;
  406.     } else {
  407.       Tcl_AppendResult(tcl, """, argv[0],
  408.                        "": arg mismatch", 0);
  409.       return TCL_ERROR;
  410.     }
  411.   }
  412.   if (strcmp(argv[1], "yscroll") == 0) {
  413.     if (argc == 3) {
  414.       nv->yscroll_=new char[strlen(argv[2])+1];
  415.       strcpy(nv->yscroll_, argv[2]);
  416.       return TCL_OK;
  417.     } else {
  418.       Tcl_AppendResult(tcl, """, argv[0],
  419.                        "": arg mismatch", 0);
  420.       return TCL_ERROR;
  421.     }
  422.   }
  423.   if (strcmp(argv[1], "zoom") == 0) {
  424.     if (argc == 3) {
  425.       float mag=atof(argv[2]);
  426.       if (mag>1.0) {
  427. nv->panx_+=(1.0-1.0/mag)/(2.0*nv->magnification_);
  428. nv->pany_+=(1.0-1.0/mag)/(2.0*nv->magnification_);
  429.       } else {
  430. nv->panx_-=(1.0-mag)/(2.0*nv->magnification_*mag);
  431. nv->pany_-=(1.0-mag)/(2.0*nv->magnification_*mag);
  432.       }
  433.       nv->zoom(mag);
  434.       nv->draw();
  435.       //nv->pan(panx, pany);
  436.       return TCL_OK;
  437.     } else {
  438.       Tcl_AppendResult(tcl, """, argv[0],
  439.        "": arg mismatch", 0);
  440.       return TCL_ERROR;
  441.     }
  442.   }
  443.   if ((strcmp(argv[1], "xview") == 0) ||
  444.       (strcmp(argv[1], "yview") == 0)) {
  445.     if ((argc==4) && (strcmp(argv[2], "moveto")==0)) {
  446.       if (strcmp(argv[1], "xview") == 0)
  447. nv->panx_=atof(argv[3]);
  448.       else
  449. nv->pany_=atof(argv[3]);
  450.       nv->resize(nv->width_, nv->height_);
  451.       nv->draw();
  453.     } else if ((argc==5) && (strcmp(argv[2], "scroll")==0)) {
  454.       float step = atof(argv[3]);
  456.       if (strcmp(argv[4], "units")==0) {
  457. step *= 0.05/nv->magnification_;
  458.       } else if (strcmp(argv[4], "pages")==0) {
  459. step *= 0.8/nv->magnification_;
  460.       } else if (strcmp(argv[4], "world")==0) {
  461.         // Used for canvas grab style dragging
  462.        // float x0, y0, x_step, y_step;
  463.        // nv->matrix_.map(0.0, 0.0, x0, y0);
  464.       //  if (strcmp(argv[1], "xview") == 0) {
  465.       //    nv->matrix_.map(step, 0.0, x_step, y_step);
  466.       //    step = x0 - x_step;
  467.       //  } else {
  468.       //    nv->matrix_.map(step, 0.0, x_step, y_step);
  469.       //    step = y0 - y_step;
  470.       //  }
  471.         step /= nv->magnification_;
  472.       }  
  474.       if (strcmp(argv[1], "xview") == 0)
  475. nv->panx_ += step;
  476.       else
  477. nv->pany_ += step;
  479.     //  fprintf(stderr, "View::command pan %f,%fn",nv->panx_,nv->pany_);
  481.       nv->resize(nv->width_, nv->height_);
  482.       nv->draw();
  484.     } else if ((argc == 7) && (strcmp(argv[2], "grab") == 0)) {
  485.       float x_start, y_start;
  486.       float world_x_start, world_y_start;
  488.       nv->matrix_.imap(atof(argv[3]), atof(argv[4]),
  489.                        world_x_start, world_y_start); 
  490.       x_start = atof(argv[3]);
  491.       y_start = atof(argv[3]);
  494.     } else {
  495.       Tcl_AppendResult(tcl, """, argv[0],
  496.        "": arg mismatch", 0);
  497.       return TCL_ERROR;
  498.     }
  499.     return TCL_OK;
  500.   }
  501.   Tcl_AppendResult(tcl, """, argv[0], "": unknown arg: ", argv[1], 0);
  502.   return (TCL_ERROR);
  503. }
  506. void 
  507. View::line(float x0, float y0, float x1, float y1, int paint)
  508. {
  509. int ax, ay;
  510. matrix_.map(x0, y0, ax, ay);
  511. int bx, by;
  512. matrix_.map(x1, y1, bx, by);
  513. GC gc = Paint::instance()->paint_to_gc(paint);
  514. XDrawLine(Tk_Display(tk_), offscreen_, gc, ax, ay, bx, by);
  515. }
  517. void View::rect(float x0, float y0, float x1, float y1, int paint)
  518. {
  519. int x, y;
  520. matrix_.map(x0, y0, x, y);
  521. int xx, yy;
  522. matrix_.map(x1, y1, xx, yy);
  524. int w = xx - x;
  525. if (w < 0) {
  526. x = xx;
  527. w = -w;
  528. }
  529. int h = yy - y;
  530. if (h < 0) {
  531. h = -h;
  532. y = yy;
  533. }
  534. GC gc = Paint::instance()->paint_to_gc(paint);
  535. XDrawRectangle(Tk_Display(tk_), offscreen_, gc, x, y, w, h);
  536. }
  538. void View::polygon(const float* x, const float* y, int n, int paint)
  539. {
  540. /*XXX*/
  541. XPoint pts[10];
  543. for (int i = 0; i < n; ++i) {
  544. float tx, ty;
  545. matrix_.map(x[i], y[i], tx, ty);
  546. pts[i].x = int(tx);
  547. pts[i].y = int(ty);
  548. }
  549. pts[n] = pts[0];
  550. GC gc = Paint::instance()->paint_to_gc(paint);
  551. XDrawLines(Tk_Display(tk_), offscreen_, gc, pts, n + 1,
  552.    CoordModeOrigin);
  553. }
  555. void View::fill(const float* x, const float* y, int n, int paint)
  556. {
  557. /*XXX*/
  558. XPoint pts[10];
  560. for (int i = 0; i < n; ++i) {
  561. float tx, ty;
  562. matrix_.map(x[i], y[i], tx, ty);
  563. pts[i].x = int(tx);
  564. pts[i].y = int(ty);
  565. }
  566. pts[n] = pts[0];
  567. GC gc = Paint::instance()->paint_to_gc(paint);
  568. XFillPolygon(Tk_Display(tk_), offscreen_, gc, pts, n + 1,
  569.      Convex, CoordModeOrigin);
  570. }
  572. //----------------------------------------------------------------------
  573. //
  574. //----------------------------------------------------------------------
  575. void View::circle(float x, float y, float r, int paint) {
  576.   int tx, ty;     // Translated x and y
  577.   int tr, dummy;  // Translated radius
  578.   
  579.   // Map world coordinates to current view coordinates
  580.   matrix_.map(x, y, tx, ty);
  581.   matrix_.map(x + r, y, tr, dummy);
  583. //  fprintf(stderr, "View::circle x %f y %f tx %d ty %dn", x,y,tx,ty);
  585.   // XDrawArc starts from the corner so we have to 
  586.   // move the tx and ty coordinates from the center
  587.   // of the circle to the corner
  588.   tr -= tx;
  589.   tx -= tr;
  590.   ty -= tr;
  591.   
  592.   // We want tr to be the diameter of the arc
  593.   tr *= 2;
  594.   GC gc = Paint::instance()->paint_to_gc(paint);
  595.   XDrawArc(Tk_Display(tk_), offscreen_, gc, tx, ty, tr, tr, 0, 64 * 360);
  596. }
  598. //----------------------------------------------------------------------
  599. // void 
  600. // View::load_fonts()
  601. //   - Set the font structures using values in 'fontName'(defined above)
  602. //----------------------------------------------------------------------
  603. void 
  604. View::load_fonts() {
  605. Tcl_Interp* tcl;
  606. nfont_ = 0;
  608. if (tk_) {
  609. tcl = Tcl::instance().interp();
  610. // Load each font described in fontName[]
  611. for (int i = 0; i < NFONT; ++i) {
  612. fonts_[nfont_] = Tk_GetFont(tcl, tk_, fontName[i]);
  613. if (fonts_[nfont_] == 0) {
  614. fprintf(stderr, "Unable to load font: %sn",fontName[i]);
  615. continue;
  616. }
  617. font_gc_[nfont_] = Paint::instance()->text_gc(Tk_FontId(fonts_[nfont_]));
  618. ++nfont_;
  619. }
  620. if (nfont_ == 0) {
  621. fprintf(stderr, "nam: warning no fonts foundn");
  622. } else {
  623. default_font_ = TIMES_14POINT;
  624. }
  625. }
  626. }
  628. void View::free_fonts()
  629. {
  630. /*XXX Tk_FreeFontStruct*/
  631. for (int i = 0; i < NFONT; i++) {
  632. Tk_FreeFont(fonts_[i]);
  633. }
  634. }
  636. //----------------------------------------------------------------------
  637. // int
  638. // View::lookup_font(int d)
  639. //   - returns the index into the fonts_ array that is smaller in size
  640. //     than d
  641. //   - returns -1 if nfont_ is 0 which indicates that no fonts have been
  642. //     loaded
  643. //----------------------------------------------------------------------
  644. int
  645. View::lookup_font(int d) {
  646. int i = nfont_;
  647. while (--i > 0) {
  648. Tk_Font f = fonts_[i];
  649. Tk_FontMetrics p;
  650. Tk_GetFontMetrics(f, &p);
  651. if (d >= p.ascent + p.descent) {
  652. return (i);
  653.     } 
  654. }
  655. if (nfont_) {
  656. return 0;
  657. }
  659. return -1;
  660. }
  662. //----------------------------------------------------------------------
  663. // int
  664. // View::getStringScreenWidth(char * text, double screen_height)
  665. //   - Calculate the width of a string in screen coordinates based upon
  666. //     the font size selected by the height of the string
  667. //----------------------------------------------------------------------
  668. int
  669. View::getStringScreenWidth(const char * text, int screen_height) {
  670. int font_id;
  671. font_id = lookup_font(screen_height);
  672. if (font_id != -1) {
  673. return Tk_TextWidth(fonts_[lookup_font(screen_height)],
  674. text, strlen(text));
  675. } else { 
  676. return 0;
  677. }
  679. }
  682. //----------------------------------------------------------------------
  683. // double
  684. // View::getStringWidth(char * text, double world_height)
  685. //   - calculates a strings width and returns it in world size
  686. //----------------------------------------------------------------------
  687. double
  688. View::getStringWidth(const char * text, double world_height) {
  689.   float x_min, x_max, y_min, y_max, discarded;
  690.   double world_width;
  691.   int screen_height, screen_width;
  692.   
  693.   matrix_.map(0.0, 0.0, discarded, y_min);
  694.   matrix_.map(0.0, world_height, discarded, y_max);
  695.   screen_height = (int) ceil(y_min - y_max);
  697.   screen_width = getStringScreenWidth(text, screen_height);
  698.   matrix_.imap(0.0, 0.0, x_min, discarded);
  699.   matrix_.imap((float) screen_width, 0.0, x_max, discarded);
  700.   world_width = x_max - x_min;
  702.   return world_width;
  703. }
  705. //----------------------------------------------------------------------
  706. //
  707. //----------------------------------------------------------------------
  708. int
  709. View::getStringHeight(char * text) {
  710.   return 0; 
  711. }
  714. //-----------------------------------------------------------------------
  715. // void
  716. // View::string(float fx, float fy, float dim, const char* s, 
  717. //              int anchor, const char* color)
  718. //     - This draws a string on the view
  719. //     - Whoever wrote this code should be shot.  For anyone who is
  720. //       working on nam in the future. Read this:
  721. //         PUT SOME COMMENTS IN YOUR CODE!!!
  722. //         and I don't mean comments like this is a hack or this
  723. //         code is bad.  
  724. //         Also, USE DESCRIPTIVE VARIBALE NAMES!!! Don't use just i or
  725. //         f or d, dlow, dhigh or just p.  What the does that stand for?
  726. //     - This code is driving me insane because I have to rewrite and 
  727. //       comment everything just to understand what the hell the person 
  728. //       before me was trying to do.    
  729. //----------------------------------------------------------------------
  730. void
  731. View::string(float fx, float fy, float dim, const char* s, 
  732.                   int anchor, const char* color) {
  733. if (nfont_ <= 0)
  734. return;
  736. int dummy;
  737. int dlow, dhigh;
  738. //Tcl& tcl = Tcl::instance();
  740. /*XXX this could be cached*/
  741. matrix_.map(0., 0., dummy, dlow);
  742. matrix_.map(0., 0.9 * dim, dummy, dhigh);
  743. int d = dhigh - dlow;
  744. if (d < 0)
  745. d = -d;
  746. int font = lookup_font(d);
  747. Tk_Font f = fonts_[font];
  748. Tk_FontMetrics p;
  749. Tk_GetFontMetrics(f, &p);
  751. int h = p.ascent;
  752. int len = strlen(s);
  753. int w = Tk_TextWidth(f, s, len);
  755. int x, y;
  756. matrix_.map(fx, fy, x, y);
  758. /* XXX still need to adjust for mismatch between d and actual height*/
  760. switch (anchor) {
  762. case ANCHOR_CENTER:
  763. x -= w / 2;
  764. y += h / 2;
  765. break;
  767. case ANCHOR_NORTH:
  768. x -= w / 2;
  769. y += d;
  770. break;
  772. case ANCHOR_SOUTH:
  773. x -= w / 2;
  774. y -= h/2;
  775. break;
  777. case ANCHOR_WEST:
  778. y += h / 2;
  779. break;
  781. case ANCHOR_EAST:
  782. x -= w;
  783. y += h / 2;
  784. break;
  785. }
  787. // XXX Very very very bad hack. Should go through Paint::text_gc()!!
  788. //Colormap cmap;
  789. //Tk_Uid colorname;
  790. GC fgc = font_gc_[font]; // Font gc
  791. if (color != NULL) {
  792. fgc = Paint::instance()->text_gc(Tk_FontId(fonts_[font]), color);
  793. }
  795. Tk_DrawChars(Tk_Display(tk_), offscreen_, fgc, f, s, len, x, y);
  796. if (color != NULL) {
  797. Tk_FreeGC(Tk_Display(tk_), fgc);
  798. }
  799. // XXX We don't free the color allocated above. Hope it won't 
  800. // be a problem!
  801. }
  804. //----------------------------------------------------------------------
  805. //
  806. //----------------------------------------------------------------------
  807. int
  808. View::string(const char * text, double world_x, double world_y,
  809.              double size, const char * color) {
  810.   int screen_x, screen_y, font_index;
  811.   Tk_Font font;
  812.   Tk_FontMetrics font_metrics;
  813.   int width;
  814.   GC font_gc;
  815.   int dummy, y_min, y_max;
  817.   width = 0;
  818.   if (nfont_ > 0) {
  819.     matrix_.map(world_x, world_y, screen_x, screen_y);
  821.     // Find screen height of box
  822.     matrix_.map(0., 0., dummy, y_min);
  823.     matrix_.map(0., 0.9 * size, dummy, y_max);
  824.     int height = y_max - y_min ;
  825.     if (height < 0) {
  826.       height = -1*height;
  827.     }
  828.     font_index = lookup_font(height);
  830.     //font_index = TIMES_14POINT;
  831.     font = fonts_[font_index];
  832.     Tk_GetFontMetrics(font, &font_metrics);
  834.     font_gc = font_gc_[font_index]; // Font gc
  835.     if (color) { 
  836.       font_gc = Paint::instance()->text_gc(Tk_FontId(font), color);
  837.     }
  839.   width = Tk_TextWidth(font, text, strlen(text));
  841.     Tk_DrawChars(Tk_Display(tk_), offscreen_, font_gc, font, text, 
  842.                  strlen(text), screen_x, screen_y);
  844.     if (color) {
  845.       Tk_FreeGC(Tk_Display(tk_), font_gc);
  846.     }
  847.   }
  848.   return width;
  849. }
  852. //----------------------------------------------------------------------
  853. //----------------------------------------------------------------------
  854. void
  855. View::boxedString(const char * text, double world_x, double world_y,
  856.                   double vertical_size, int paint, 
  857.                   const char * color) {
  858.   float box_width, text_width, height;
  859.   float x_padding, y_padding;
  861.   height = 0;
  863.   box_width = getStringWidth(text, vertical_size);
  864.   text_width = getStringWidth(text, 0.9*vertical_size);
  866.   x_padding = (box_width - text_width)/2.0;
  867.   y_padding = 0.05*vertical_size;
  868.   string(text, world_x + x_padding, world_y + y_padding, 0.9*vertical_size, color);
  870.   rect(world_x, world_y, world_x + box_width, world_y + vertical_size, paint);  
  871. }
  872.   
  873.