File: scaledarea.h

package info (click to toggle)
mixviews 1.10-3
  • links: PTS
  • area: main
  • in suites: hamm
  • size: 2,440 kB
  • ctags: 6,314
  • sloc: cpp: 31,647; ansic: 2,100; makefile: 1,782; sh: 17
file content (132 lines) | stat: -rw-r--r-- 4,215 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
// scaledarea.h

/******************************************************************************
 *
 *  MiXViews - an X window system based sound & data editor/processor
 *
 *  Copyright (c) 1993, 1994 Regents of the University of California
 *
 *  Author:     Douglas Scott
 *  Date:       December 13, 1994
 *
 *  Permission to use, copy and modify this software and its documentation
 *  for research and/or educational purposes and without fee is hereby granted,
 *  provided that the above copyright notice appear in all copies and that
 *  both that copyright notice and this permission notice appear in
 *  supporting documentation. The author reserves the right to distribute this
 *  software and its documentation.  The University of California and the author
 *  make no representations about the suitability of this software for any 
 *  purpose, and in no event shall University of California be liable for any
 *  damage, loss of data, or profits resulting from its use.
 *  It is provided "as is" without express or implied warranty.
 *
 ******************************************************************************/


// BorderedArea is a class that allowed me to set an arbitrary empty space
// (Margin) on all four sides of a Canvas, so that all drawing operations would
// be automatically offset to fit.  There is probably a better way!
//
// ScaledArea is a BorderedArea to which one or more Scale objects is attached.
// As the vertical and horizontal scaling factors of the ScaledArea's drawing
// region change, the Scales are updated accordingly.  ScaledArea is the base
// class for all Graph subclasses.

#ifndef SCALEDAREA_H
#ifdef __GNUG__
#pragma interface
#endif
#define SCALEDAREA_H

#include <InterViews/interactor.h>
#include "margin.h"
#include "range.h"

class Perspective;
class Brush;
class Painter;

class BorderedArea : public Interactor {
public:
	BorderedArea();
	virtual ~BorderedArea();
	// redefined InterViews methods
	redefined void Update();
	// new methods
	virtual int currentHeight();
	virtual int currentWidth();
	virtual void setVertMargins(int top, int bottom) {
		myMargin->top = top; myMargin->bottom = bottom; 
	}
	virtual void setHorizMargins(int left, int right) {
		myMargin->left = left; myMargin->right = right;
	}
	virtual int topBorder() { return myMargin->top; }
	virtual int bottomBorder() { return myMargin->bottom; }
	int leftEdge() { return myMargin->left; }
	int rightEdge() { return xmax - myMargin->right + 2; }
	Margin* margin() { return myMargin; }
	Painter *getOutput() { return output; }
protected:
	// new methods
	int widthChanged() { return xmax != oldxmax; }
	int heightChanged() { return ymax != oldymax; }
	virtual boolean IsMapped();
	virtual boolean isResized();
	void resetDimensions() { oldxmax = xmax; oldymax = ymax; }
	virtual void doAdjust() {}
private:
	Margin *myMargin;
	int oldxmax, oldymax;
	void Init();
};

// ScaledArea is a BorderedArea dependent on a VScale

class Scale;

class ScaledArea : public BorderedArea {
	typedef BorderedArea Super;
public:
	ScaledArea(const Range &range, Scale *vs=nil);
	virtual ~ScaledArea();
	// redefined InterViews methods
	redefined void Reconfig();
	redefined void Update();
	// new methods
	virtual int vertOriginLocation();
	virtual int horizOriginLocation() { return leftEdge(); }
	virtual double currentHGrain();
	virtual double currentVGrain();
	virtual Range currentVerticalRange() {
		return verticalRange.check();
	}
	virtual Range verticalScaleRange() {
		return currentVerticalRange();
	}
	Range getReferenceRange() { return referenceRange; }
	void setReferenceRange(const Range &r);
	void attachVScale(Scale *s) { vscale = s; }
	void removeVScale(Scale *s) { if(vscale == s) vscale = nil; }
	Scale *vScale() { return vscale; }
protected:
	// redefined InterViews methods
	redefined void Resize();

	redefined void doAdjust();
	// new methods
	void checkScales();
	virtual void adjustVerticalRange();
	virtual double vertScaleFactor();
protected:
	// new members
	Scale *vscale;			// pointers to scales (if any)
private:
	friend class SimplePlot;
	Range referenceRange;		// fixed range
	Range verticalRange;		// variable visible range
private:
	void Init();
};

#endif