home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / i / iv26_w_3.zip / EXAMPLES / IDRAW / STATE.C < prev    next >
C/C++ Source or Header  |  1980-01-05  |  8KB  |  303 lines
  1. /*
  2.  * Copyright (c) 1987, 1988, 1989 Stanford University
  3.  *
  4.  * Permission to use, copy, modify, distribute, and sell this software and its
  5.  * documentation for any purpose is hereby granted without fee, provided
  6.  * that the above copyright notice appear in all copies and that both that
  7.  * copyright notice and this permission notice appear in supporting
  8.  * documentation, and that the name of Stanford not be used in advertising or
  9.  * publicity pertaining to distribution of the software without specific,
  10.  * written prior permission.  Stanford makes no representations about
  11.  * the suitability of this software for any purpose.  It is provided "as is"
  12.  * without express or implied warranty.
  13.  *
  14.  * STANFORD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
  16.  * IN NO EVENT SHALL STANFORD BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
  19.  * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
  20.  * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21.  */
  22.  
  23. // $Header: state.c,v 1.13 90/01/25 16:27:27 interran Exp $
  24. // implements class State.
  25.  
  26. #include "ipaint.h"
  27. #include "istring.h"
  28. #include "listintrctr.h"
  29. #include "mapipaint.h"
  30. #include "page.h"
  31. #include "state.h"
  32. #include <InterViews/graphic.h>
  33. #include <InterViews/interactor.h>
  34. #include <InterViews/painter.h>
  35. #include <InterViews/transformer.h>
  36.  
  37. // State stores some Graphic and nonGraphic attributes.
  38.  
  39. State::State (Interactor* i, Page* p) {
  40.     drawingname = nil;
  41.     graphicstate = new FullGraphic;
  42.     graphicstate_t = new Transformer;
  43.     magnif = 1.0;
  44.     mapibrush = new MapIBrush(i, "brush");
  45.     mapifgcolor = new MapIColor(i, "fgcolor");
  46.     mapibgcolor = new MapIColor(i, "bgcolor");
  47.     mapifont = new MapIFont(i, "font");
  48.     mapipattern = new MapIPattern(i, "pattern");
  49.     modifstatus = Unmodified;
  50.     page = p;
  51.     textgs = new FullGraphic;
  52.     textgs_t = new Transformer;
  53.     textpainter = new Painter;
  54.     textpainter->Reference();
  55.     textpainter_t = new Transformer;
  56.     viewlist = new InteractorList;
  57.  
  58.     graphicstate->SetBrush(mapibrush->GetInitial());
  59.     graphicstate->SetColors(
  60.     mapifgcolor->GetInitial(), mapibgcolor->GetInitial()
  61.     );
  62.     graphicstate->FillBg(true);
  63.     graphicstate->SetFont(mapifont->GetInitial());
  64.     graphicstate->SetPattern(mapipattern->GetInitial());
  65.     graphicstate->SetTransformer(graphicstate_t);
  66.     textgs->SetTransformer(textgs_t);
  67.     textpainter->SetTransformer(textpainter_t);
  68. }
  69.  
  70. // ~State frees storage allocated to store members.
  71.  
  72. State::~State () {
  73.     delete drawingname;
  74.     delete graphicstate;
  75.     delete mapibrush;
  76.     delete mapifgcolor;
  77.     delete mapibgcolor;
  78.     delete mapifont;
  79.     delete mapipattern;
  80.     delete textgs;
  81.     Unref(textpainter);
  82.     delete viewlist;
  83. }
  84.  
  85. // The following functions add Page operations to State.
  86.  
  87. void State::Constrain (Coord& x, Coord& y) {
  88.     page->Constrain(x, y);
  89. }
  90.  
  91. void State::ToggleOrientation () {
  92.     page->ToggleOrientation();
  93. }
  94.  
  95. // The following functions return Graphic and nonGraphic attributes of
  96. // the State.
  97.  
  98. IBrush* State::GetBrush () {
  99.     return (IBrush*) graphicstate->GetBrush();
  100. }
  101.  
  102. IColor* State::GetFgColor () {
  103.     return (IColor*) graphicstate->GetFgColor();
  104. }
  105.  
  106. IColor* State::GetBgColor () {
  107.     return (IColor*) graphicstate->GetBgColor();
  108. }
  109.  
  110. const char* State::GetDrawingName () {
  111.     return drawingname;
  112. }
  113.  
  114. boolean State::GetFillBg () {
  115.     return graphicstate->BgFilled();
  116. }
  117.  
  118. IFont* State::GetFont () {
  119.     return (IFont*) graphicstate->GetFont();
  120. }
  121.  
  122. Graphic* State::GetGraphicGS () {
  123.     return graphicstate;
  124. }
  125.  
  126. boolean State::GetGridGravity () {
  127.     return page->GetGridGravity();
  128. }
  129.  
  130. double State::GetGridSpacing (boolean in_pixels) {
  131.     return page->GetGridSpacing(in_pixels);
  132. }
  133.  
  134. boolean State::GetGridVisibility () {
  135.     return page->GetGridVisibility();
  136. }
  137.  
  138. int State::GetLineHt () {
  139.     return lineHt;
  140. }
  141.  
  142. float State::GetMagnif () {
  143.     return magnif;
  144. }
  145.  
  146. MapIBrush* State::GetMapIBrush () {
  147.     return mapibrush;
  148. }
  149.  
  150. MapIColor* State::GetMapIFgColor () {
  151.     return mapifgcolor;
  152. }
  153.  
  154. MapIColor* State::GetMapIBgColor () {
  155.     return mapibgcolor;
  156. }
  157.  
  158. MapIFont* State::GetMapIFont () {
  159.     return mapifont;
  160. }
  161.  
  162. MapIPattern* State::GetMapIPattern () {
  163.     return mapipattern;
  164. }
  165.  
  166. ModifStatus State::GetModifStatus () {
  167.     return modifstatus;
  168. }
  169.  
  170. IPattern* State::GetPattern () {
  171.     return (IPattern*) graphicstate->GetPattern();
  172. }
  173.  
  174. Graphic* State::GetTextGS () {
  175.     return textgs;
  176. }
  177.  
  178. Painter* State::GetTextPainter () {
  179.     return textpainter;
  180. }
  181.  
  182. // The following functions set Graphic and nonGraphic attributes of
  183. // the State.
  184.  
  185. void State::SetBrush (IBrush* b) {
  186.     graphicstate->SetBrush(b);
  187. }
  188.  
  189. void State::SetFgColor (IColor* fg) {
  190.     graphicstate->SetColors(fg, graphicstate->GetBgColor());
  191. }
  192.  
  193. void State::SetBgColor (IColor* bg) {
  194.     graphicstate->SetColors(graphicstate->GetFgColor(), bg);
  195. }
  196.  
  197. void State::SetDrawingName (const char* name) {
  198.     delete drawingname;
  199.     drawingname = name ? strdup(name) : nil;
  200. }
  201.  
  202. void State::SetFillBg (boolean fill) {
  203.     graphicstate->FillBg(fill);
  204. }
  205.  
  206. void State::SetFont (IFont* f) {
  207.     graphicstate->SetFont(f);
  208. }
  209.  
  210. void State::SetGraphicT (Transformer& t) {
  211.     *graphicstate_t = t;
  212.     graphicstate_t->Invert();
  213.  
  214.     Transformer tnew;
  215.     float left, top;
  216.     graphicstate_t->InvTransform(textx, texty, left, top);
  217.     tnew.Scale(magnif, magnif);
  218.     tnew.Translate(left, top);
  219.     *textpainter_t = tnew;
  220.     tnew.Postmultiply(graphicstate_t);
  221.     *textgs_t = tnew;
  222. }
  223.  
  224. void State::SetGridGravity (boolean g) {
  225.     page->SetGridGravity(g);
  226. }
  227.  
  228. void State::SetGridSpacing (double s, boolean in_pixels) {
  229.     page->SetGridSpacing(s, in_pixels);
  230. }
  231.  
  232. void State::SetGridVisibility (boolean v) {
  233.     page->SetGridVisibility(v);
  234. }
  235.  
  236. void State::SetMagnif (float m) {
  237.     magnif = m;
  238. }
  239.  
  240. void State::SetModifStatus (ModifStatus m) {
  241.     modifstatus = m;
  242. }
  243.  
  244. void State::SetPattern (IPattern* p) {
  245.     graphicstate->SetPattern(p);
  246. }
  247.  
  248. void State::SetTextGS (Coord left, Coord top, Painter* output) {
  249.     PColor* fg = graphicstate->GetFgColor();
  250.     PFont* f = graphicstate->GetFont();
  251.     lineHt = ((IFont*) f)->GetLineHt();
  252.     textgs->SetColors(fg, textgs->GetBgColor());
  253.     textgs->SetFont(f);
  254.     textpainter->SetColors(*fg, output->GetBgColor());
  255.     textpainter->SetFont(*f);
  256.     graphicstate_t->Transform(float(left), float(top), textx, texty);
  257.  
  258.     Transformer t;
  259.     t.Scale(magnif, magnif);
  260.     t.Translate(left, top);
  261.     *textpainter_t = t;
  262.     t.Postmultiply(graphicstate_t);
  263.     *textgs_t = t;
  264. }
  265.  
  266. void State::SetTextGS (Graphic* gs, Painter* output) {
  267.     PColor* fg = gs->GetFgColor();
  268.     PFont* f = gs->GetFont();
  269.     lineHt = ((IFont*) f)->GetLineHt();
  270.     textgs->SetColors(fg, textgs->GetBgColor());
  271.     textgs->SetFont(f);
  272.     textpainter->SetColors(*fg, output->GetBgColor());
  273.     textpainter->SetFont(*f);
  274.     gs->TotalTransformation(*textpainter_t);
  275.     Transformer* t = gs->GetTransformer();
  276.     if (t != nil) {
  277.     t->Transform(0.0, 0.0, textx, texty);
  278.     }    
  279. }
  280.  
  281. // Attach informs us a view has attached itself to us.
  282.  
  283. void State::Attach (Interactor* i) {
  284.     viewlist->Append(new InteractorNode(i));
  285. }
  286.  
  287. // Detach informs us a view has detached itself from us.
  288.  
  289. void State::Detach (Interactor* i) {
  290.     if (viewlist->Find(i)) {
  291.     viewlist->DeleteCur();
  292.     }
  293. }
  294.  
  295. // UpdateViews informs all attached views we have changed our state.
  296.  
  297. void State::UpdateViews () {
  298.     for (viewlist->First(); !viewlist->AtEnd(); viewlist->Next()) {
  299.     Interactor* view = viewlist->GetCur()->GetInteractor();
  300.     view->Update();
  301.     }
  302. }
  303.