← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/htop/intrepid

« back to all changes in this revision

Viewing changes to Header.c

  • Committer: Bazaar Package Importer
  • Author(s): Bartosz Fenski
  • Date: 2004-11-27 10:10:17 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20041127101017-vwknw2ipfvxchno4
Tags: 0.5-1
http://bugs.debian.org/283212
* New upstream version.
  - fixes problem with wrongly displayed CPU bar (Closes: #283212)

Show diffs side-by-side

added added

removed removed

Lines of Context:
Header.c
 
1
/*
 
2
htop
 
3
(C) 2004 Hisham H. Muhammad
 
4
Released under the GNU GPL, see the COPYING file
 
5
in the source distribution for its full text.
 
6
*/
 
7
 
 
8
#include "Header.h"
 
9
#include "CPUMeter.h"
 
10
#include "MemoryMeter.h"
 
11
#include "SwapMeter.h"
 
12
#include "LoadMeter.h"
 
13
#include "LoadAverageMeter.h"
 
14
#include "UptimeMeter.h"
 
15
#include "ClockMeter.h"
 
16
#include "TasksMeter.h"
 
17
 
 
18
#include "debug.h"
 
19
#include <assert.h>
 
20
 
 
21
/*{
 
22
 
 
23
typedef enum HeaderSide_ {
 
24
   LEFT_HEADER,
 
25
   RIGHT_HEADER
 
26
} HeaderSide;
 
27
 
 
28
typedef struct Header_ {
 
29
   TypedVector* leftMeters;
 
30
   TypedVector* rightMeters;
 
31
   ProcessList* pl;
 
32
   bool margin;
 
33
   int height;
 
34
   int pad;
 
35
} Header;
 
36
 
 
37
}*/
 
38
 
 
39
Header* Header_new(ProcessList* pl) {
 
40
   Header* this = malloc(sizeof(Header));
 
41
   this->leftMeters = TypedVector_new(METER_CLASS, true, DEFAULT_SIZE);
 
42
   this->rightMeters = TypedVector_new(METER_CLASS, true, DEFAULT_SIZE);
 
43
   this->margin = true;
 
44
   this->pl = pl;
 
45
   return this;
 
46
}
 
47
 
 
48
void Header_delete(Header* this) {
 
49
   TypedVector_delete(this->leftMeters);
 
50
   TypedVector_delete(this->rightMeters);
 
51
   free(this);
 
52
}
 
53
 
 
54
void Header_createMeter(Header* this, char* name, HeaderSide side) {
 
55
   TypedVector* meters = side == LEFT_HEADER
 
56
                       ? this->leftMeters
 
57
                       : this->rightMeters;
 
58
 
 
59
   if (String_eq(name, "Swap")) {
 
60
      TypedVector_add(meters, SwapMeter_new(this->pl));
 
61
   } else if (String_eq(name, "Memory")) {
 
62
      TypedVector_add(meters, MemoryMeter_new(this->pl));
 
63
   } else if (String_eq(name, "Clock")) {
 
64
      TypedVector_add(meters, ClockMeter_new(this->pl));
 
65
   } else if (String_eq(name, "Load")) {
 
66
      TypedVector_add(meters, LoadMeter_new(this->pl));
 
67
   } else if (String_eq(name, "LoadAverage")) {
 
68
      TypedVector_add(meters, LoadAverageMeter_new(this->pl));
 
69
   } else if (String_eq(name, "Uptime")) {
 
70
      TypedVector_add(meters, UptimeMeter_new(this->pl));
 
71
   } else if (String_eq(name, "Tasks")) {
 
72
      TypedVector_add(meters, TasksMeter_new(this->pl));
 
73
   } else if (String_startsWith(name, "CPUAverage")) {
 
74
      TypedVector_add(meters, CPUMeter_new(this->pl, 0));
 
75
   } else if (String_startsWith(name, "CPU")) {
 
76
      int num;
 
77
      sscanf(name, "CPU(%d)", &num);
 
78
      TypedVector_add(meters, CPUMeter_new(this->pl, num));
 
79
   }
 
80
}
 
81
 
 
82
void Header_setMode(Header* this, int i, MeterMode mode, HeaderSide side) {
 
83
   TypedVector* meters = side == LEFT_HEADER
 
84
                       ? this->leftMeters
 
85
                       : this->rightMeters;
 
86
 
 
87
   Meter* meter = (Meter*) TypedVector_get(meters, i);
 
88
   Meter_setMode(meter, mode);
 
89
}
 
90
 
 
91
Meter* Header_getMeter(Header* this, int i, HeaderSide side) {
 
92
   TypedVector* meters = side == LEFT_HEADER
 
93
                       ? this->leftMeters
 
94
                       : this->rightMeters;
 
95
 
 
96
   return (Meter*) TypedVector_get(meters, i);
 
97
}
 
98
 
 
99
int Header_size(Header* this, HeaderSide side) {
 
100
   TypedVector* meters = side == LEFT_HEADER
 
101
                       ? this->leftMeters
 
102
                       : this->rightMeters;
 
103
 
 
104
   return TypedVector_size(meters);
 
105
}
 
106
 
 
107
char* Header_readMeterName(Header* this, int i, HeaderSide side) {
 
108
   TypedVector* meters = side == LEFT_HEADER
 
109
                       ? this->leftMeters
 
110
                       : this->rightMeters;
 
111
 
 
112
   Meter* meter = (Meter*) TypedVector_get(meters, i);
 
113
   return meter->name;
 
114
}
 
115
 
 
116
MeterMode Header_readMeterMode(Header* this, int i, HeaderSide side) {
 
117
   TypedVector* meters = side == LEFT_HEADER
 
118
                       ? this->leftMeters
 
119
                       : this->rightMeters;
 
120
 
 
121
   Meter* meter = (Meter*) TypedVector_get(meters, i);
 
122
   return meter->mode;
 
123
}
 
124
 
 
125
void Header_defaultMeters(Header* this) {
 
126
   for (int i = 1; i <= this->pl->processorCount; i++) {
 
127
      TypedVector_add(this->leftMeters, CPUMeter_new(this->pl, i));
 
128
   }
 
129
   TypedVector_add(this->leftMeters, MemoryMeter_new(this->pl));
 
130
   TypedVector_add(this->leftMeters, SwapMeter_new(this->pl));
 
131
   TypedVector_add(this->rightMeters, TasksMeter_new(this->pl));
 
132
   TypedVector_add(this->rightMeters, LoadAverageMeter_new(this->pl));
 
133
   TypedVector_add(this->rightMeters, UptimeMeter_new(this->pl));
 
134
}
 
135
 
 
136
void Header_draw(Header* this) {
 
137
   int height = this->height;
 
138
   int pad = this->pad;
 
139
   
 
140
   for (int y = 0; y < height; y++) {
 
141
      mvhline(y, 0, ' ', COLS);
 
142
   }
 
143
   for (int y = (pad / 2), i = 0; i < TypedVector_size(this->leftMeters); i++) {
 
144
      Meter* meter = (Meter*) TypedVector_get(this->leftMeters, i);
 
145
      meter->draw(meter, pad, y, COLS / 2 - (pad * 2 - 1) - 1);
 
146
      y += meter->h;
 
147
   }
 
148
   for (int y = (pad / 2), i = 0; i < TypedVector_size(this->rightMeters); i++) {
 
149
      Meter* meter = (Meter*) TypedVector_get(this->rightMeters, i);
 
150
      meter->draw(meter, COLS / 2 + pad, y, COLS / 2 - (pad * 2 - 1) - 1);
 
151
      y += meter->h;
 
152
   }
 
153
}
 
154
 
 
155
int Header_calculateHeight(Header* this) {
 
156
   int pad = this->margin ? 2 : 0;
 
157
   int leftHeight = pad;
 
158
   int rightHeight = pad;
 
159
 
 
160
   for (int i = 0; i < TypedVector_size(this->leftMeters); i++) {
 
161
      Meter* meter = (Meter*) TypedVector_get(this->leftMeters, i);
 
162
      leftHeight += meter->h;
 
163
   }
 
164
   for (int i = 0; i < TypedVector_size(this->rightMeters); i++) {
 
165
      Meter* meter = (Meter*) TypedVector_get(this->rightMeters, i);
 
166
      rightHeight += meter->h;
 
167
   }
 
168
   this->pad = pad;
 
169
   this->height = MAX(leftHeight, rightHeight);
 
170
   return this->height;
 
171
}