xref: /haiku/src/kits/interface/ColumnTypes.cpp (revision 4bd0c1066b227cec4b79883bdef697c7a27f2e90) 
1 /*******************************************************************************
2 /
3 /	File:			ColumnTypes.h
4 /
5 /   Description:    Experimental classes that implement particular column/field
6 /					data types for use in BColumnListView.
7 /
8 /	Copyright 2000+, Be Incorporated, All Rights Reserved
9 /
10 *******************************************************************************/
11 
12 #include "ColumnTypes.h"
13 
14 #include <View.h>
15 
16 #include <parsedate.h>
17 #include <stdio.h>
18 
19 
20 #define kTEXT_MARGIN	8
21 
22 
23 const int64 kKB_SIZE = 1024;
24 const int64 kMB_SIZE = 1048576;
25 const int64 kGB_SIZE = 1073741824;
26 const int64 kTB_SIZE = kGB_SIZE * kKB_SIZE;
27 
28 const char* kSIZE_FORMATS[] = {
29 	"%.2f %s",
30 	"%.1f %s",
31 	"%.f %s",
32 	"%.f%s",
33 	0
34 };
35 
36 
37 BTitledColumn::BTitledColumn(const char* title, float width, float minWidth,
38 	float maxWidth, alignment align)
39 	:
40 	BColumn(width, minWidth, maxWidth, align),
41 	fTitle(title)
42 {
43 	font_height fh;
44 
45 	be_plain_font->GetHeight(&fh);
46 	fFontHeight = fh.descent + fh.leading;
47 }
48 
49 
50 void
51 BTitledColumn::DrawTitle(BRect rect, BView* parent)
52 {
53 	float width = rect.Width() - (2 * kTEXT_MARGIN);
54 	BString out_string(fTitle);
55 
56 	parent->TruncateString(&out_string, B_TRUNCATE_END, width + 2);
57 	DrawString(out_string.String(), parent, rect);
58 }
59 
60 
61 void
62 BTitledColumn::GetColumnName(BString* into) const
63 {
64 	*into = fTitle;
65 }
66 
67 
68 void
69 BTitledColumn::DrawString(const char* string, BView* parent, BRect rect)
70 {
71 	float width = rect.Width() - (2 * kTEXT_MARGIN);
72 	float y;
73 	BFont font;
74 	font_height	finfo;
75 
76 	parent->GetFont(&font);
77 	font.GetHeight(&finfo);
78 	y = rect.top + finfo.ascent
79 		+ (rect.Height() - ceilf(finfo.ascent + finfo.descent)) / 2.0f;
80 
81 	switch (Alignment()) {
82 		default:
83 		case B_ALIGN_LEFT:
84 			parent->MovePenTo(rect.left + kTEXT_MARGIN, y);
85 			break;
86 
87 		case B_ALIGN_CENTER:
88 			parent->MovePenTo(rect.left + kTEXT_MARGIN
89 				+ ((width - font.StringWidth(string)) / 2), y);
90 			break;
91 
92 		case B_ALIGN_RIGHT:
93 			parent->MovePenTo(rect.right - kTEXT_MARGIN
94 				- font.StringWidth(string), y);
95 			break;
96 	}
97 
98 	parent->DrawString(string);
99 }
100 
101 
102 void
103 BTitledColumn::SetTitle(const char* title)
104 {
105 	fTitle.SetTo(title);
106 }
107 
108 
109 void
110 BTitledColumn::Title(BString* forTitle) const
111 {
112 	if (forTitle)
113 		forTitle->SetTo(fTitle.String());
114 }
115 
116 
117 float
118 BTitledColumn::FontHeight() const
119 {
120 	return fFontHeight;
121 }
122 
123 
124 float
125 BTitledColumn::GetPreferredWidth(BField *_field, BView* parent) const
126 {
127 	return parent->StringWidth(fTitle.String()) + 2 * kTEXT_MARGIN;
128 }
129 
130 
131 // #pragma mark - BStringField
132 
133 
134 BStringField::BStringField(const char* string)
135 	:
136 	fWidth(0),
137 	fString(string),
138 	fClippedString(string)
139 {
140 }
141 
142 
143 void
144 BStringField::SetString(const char* val)
145 {
146 	fString = val;
147 	fClippedString = "";
148 	fWidth = 0;
149 }
150 
151 
152 const char*
153 BStringField::String() const
154 {
155 	return fString.String();
156 }
157 
158 
159 void
160 BStringField::SetWidth(float width)
161 {
162 	fWidth = width;
163 }
164 
165 
166 float
167 BStringField::Width()
168 {
169 	return fWidth;
170 }
171 
172 
173 void
174 BStringField::SetClippedString(const char* val)
175 {
176 	fClippedString = val;
177 }
178 
179 
180 bool
181 BStringField::HasClippedString() const
182 {
183 	return !fClippedString.IsEmpty();
184 }
185 
186 
187 const char*
188 BStringField::ClippedString()
189 {
190 	return fClippedString.String();
191 }
192 
193 
194 // #pragma mark - BStringColumn
195 
196 
197 BStringColumn::BStringColumn(const char* title, float width, float minWidth,
198 	float maxWidth, uint32 truncate, alignment align)
199 	:
200 	BTitledColumn(title, width, minWidth, maxWidth, align),
201 	fTruncate(truncate)
202 {
203 }
204 
205 
206 void
207 BStringColumn::DrawField(BField* _field, BRect rect, BView* parent)
208 {
209 	float width = rect.Width() - (2 * kTEXT_MARGIN);
210 	BStringField* field = static_cast<BStringField*>(_field);
211 	float fieldWidth = field->Width();
212 	bool updateNeeded = width != fieldWidth;
213 
214 	if (updateNeeded) {
215 		BString out_string(field->String());
216 		float preferredWidth = parent->StringWidth(out_string.String());
217 		if (width < preferredWidth) {
218 			parent->TruncateString(&out_string, fTruncate, width + 2);
219 			field->SetClippedString(out_string.String());
220 		} else
221 			field->SetClippedString("");
222 		field->SetWidth(width);
223 	}
224 
225 	DrawString(field->HasClippedString()
226 		? field->ClippedString()
227 		: field->String(), parent, rect);
228 }
229 
230 
231 float
232 BStringColumn::GetPreferredWidth(BField *_field, BView* parent) const
233 {
234 	BStringField* field = static_cast<BStringField*>(_field);
235 	return parent->StringWidth(field->String()) + 2 * kTEXT_MARGIN;
236 }
237 
238 
239 int
240 BStringColumn::CompareFields(BField* field1, BField* field2)
241 {
242 	return ICompare(((BStringField*)field1)->String(),
243 		(((BStringField*)field2)->String()));
244 }
245 
246 
247 bool
248 BStringColumn::AcceptsField(const BField *field) const
249 {
250 	return static_cast<bool>(dynamic_cast<const BStringField*>(field));
251 }
252 
253 
254 // #pragma mark - BDateField
255 
256 
257 BDateField::BDateField(time_t* time)
258 	:
259 	fTime(*localtime(time)),
260 	fUnixTime(*time),
261 	fSeconds(0),
262 	fClippedString(""),
263 	fWidth(0)
264 {
265 	fSeconds = mktime(&fTime);
266 }
267 
268 
269 void
270 BDateField::SetWidth(float width)
271 {
272 	fWidth = width;
273 }
274 
275 
276 float
277 BDateField::Width()
278 {
279 	return fWidth;
280 }
281 
282 
283 void
284 BDateField::SetClippedString(const char* string)
285 {
286 	fClippedString = string;
287 }
288 
289 
290 const char*
291 BDateField::ClippedString()
292 {
293 	return fClippedString.String();
294 }
295 
296 
297 time_t
298 BDateField::Seconds()
299 {
300 	return fSeconds;
301 }
302 
303 
304 time_t
305 BDateField::UnixTime()
306 {
307 	return fUnixTime;
308 }
309 
310 
311 // #pragma mark - BDateColumn
312 
313 
314 BDateColumn::BDateColumn(const char* title, float width, float minWidth,
315 	float maxWidth, alignment align)
316 	:
317 	BTitledColumn(title, width, minWidth, maxWidth, align),
318 	fTitle(title)
319 {
320 }
321 
322 
323 const char *kTIME_FORMATS[] = {
324 	"%A, %B %d %Y, %I:%M:%S %p",	// Monday, July 09 1997, 05:08:15 PM
325 	"%a, %b %d %Y, %I:%M:%S %p",	// Mon, Jul 09 1997, 05:08:15 PM
326 	"%a, %b %d %Y, %I:%M %p",		// Mon, Jul 09 1997, 05:08 PM
327 	"%b %d %Y, %I:%M %p",			// Jul 09 1997, 05:08 PM
328 	"%m/%d/%y, %I:%M %p",			// 07/09/97, 05:08 PM
329 	"%m/%d/%y",						// 07/09/97
330 	NULL
331 };
332 
333 
334 void
335 BDateColumn::DrawField(BField* _field, BRect rect, BView* parent)
336 {
337 	float width = rect.Width() - (2 * kTEXT_MARGIN);
338 	BDateField* field = (BDateField*)_field;
339 
340 	if (field->Width() != rect.Width()) {
341 		char dateString[256];
342 		time_t currentTime = field->UnixTime();
343 		tm time_data;
344 		BFont font;
345 
346 		parent->GetFont(&font);
347 		localtime_r(&currentTime, &time_data);
348 
349 		for (int32 index = 0; ; index++) {
350 			if (!kTIME_FORMATS[index])
351 				break;
352 
353 			strftime(dateString, 256, kTIME_FORMATS[index], &time_data);
354 			if (font.StringWidth(dateString) <= width)
355 				break;
356 		}
357 
358 		if (font.StringWidth(dateString) > width) {
359 			BString out_string(dateString);
360 
361 			parent->TruncateString(&out_string, B_TRUNCATE_MIDDLE, width + 2);
362 			strcpy(dateString, out_string.String());
363 		}
364 		field->SetClippedString(dateString);
365 		field->SetWidth(width);
366 	}
367 
368 	DrawString(field->ClippedString(), parent, rect);
369 }
370 
371 
372 int
373 BDateColumn::CompareFields(BField* field1, BField* field2)
374 {
375 	return((BDateField*)field1)->Seconds() - ((BDateField*)field2)->Seconds();
376 }
377 
378 
379 // #pragma mark - BSizeField
380 
381 
382 BSizeField::BSizeField(off_t size)
383 	:
384 	fSize(size)
385 {
386 }
387 
388 
389 void
390 BSizeField::SetSize(off_t size)
391 {
392 	fSize = size;
393 }
394 
395 
396 off_t
397 BSizeField::Size()
398 {
399 	return fSize;
400 }
401 
402 
403 // #pragma mark - BSizeColumn
404 
405 
406 BSizeColumn::BSizeColumn(const char* title, float width, float minWidth,
407 	float maxWidth, alignment align)
408 	:
409 	BTitledColumn(title, width, minWidth, maxWidth, align)
410 {
411 }
412 
413 
414 void
415 BSizeColumn::DrawField(BField* _field, BRect rect, BView* parent)
416 {
417 	char str[256];
418 	float width = rect.Width() - (2 * kTEXT_MARGIN);
419 	BFont font;
420 	BString string;
421 	off_t size = ((BSizeField*)_field)->Size();
422 
423 	parent->GetFont(&font);
424 	if (size < kKB_SIZE) {
425 		sprintf(str, "%" B_PRId64 " bytes", size);
426 		if (font.StringWidth(str) > width)
427 			sprintf(str, "%" B_PRId64 " B", size);
428 	} else {
429 		const char*	suffix;
430 		float float_value;
431 		if (size >= kTB_SIZE) {
432 			suffix = "TB";
433 			float_value = (float)size / kTB_SIZE;
434 		} else if (size >= kGB_SIZE) {
435 			suffix = "GB";
436 			float_value = (float)size / kGB_SIZE;
437 		} else if (size >= kMB_SIZE) {
438 			suffix = "MB";
439 			float_value = (float)size / kMB_SIZE;
440 		} else {
441 			suffix = "KB";
442 			float_value = (float)size / kKB_SIZE;
443 		}
444 
445 		for (int32 index = 0; ; index++) {
446 			if (!kSIZE_FORMATS[index])
447 				break;
448 
449 			sprintf(str, kSIZE_FORMATS[index], float_value, suffix);
450 			// strip off an insignificant zero so we don't get readings
451 			// such as 1.00
452 			char *period = 0;
453 			char *tmp (NULL);
454 			for (tmp = str; *tmp; tmp++) {
455 				if (*tmp == '.')
456 					period = tmp;
457 			}
458 			if (period && period[1] && period[2] == '0') {
459 				// move the rest of the string over the insignificant zero
460 				for (tmp = &period[2]; *tmp; tmp++)
461 					*tmp = tmp[1];
462 			}
463 			if (font.StringWidth(str) <= width)
464 				break;
465 		}
466 	}
467 
468 	string = str;
469 	parent->TruncateString(&string, B_TRUNCATE_MIDDLE, width + 2);
470 	DrawString(string.String(), parent, rect);
471 }
472 
473 
474 int
475 BSizeColumn::CompareFields(BField* field1, BField* field2)
476 {
477 	return ((BSizeField*)field1)->Size() - ((BSizeField*)field2)->Size();
478 }
479 
480 
481 // #pragma mark - BIntegerField
482 
483 
484 BIntegerField::BIntegerField(int32 number)
485 	:
486 	fInteger(number)
487 {
488 }
489 
490 
491 void
492 BIntegerField::SetValue(int32 value)
493 {
494 	fInteger = value;
495 }
496 
497 
498 int32
499 BIntegerField::Value()
500 {
501 	return fInteger;
502 }
503 
504 
505 // #pragma mark - BIntegerColumn
506 
507 
508 BIntegerColumn::BIntegerColumn(const char* title, float width, float minWidth,
509 	float maxWidth, alignment align)
510 	:
511 	BTitledColumn(title, width, minWidth, maxWidth, align)
512 {
513 }
514 
515 
516 void
517 BIntegerColumn::DrawField(BField *field, BRect rect, BView* parent)
518 {
519 	char formatted[256];
520 	float width = rect.Width() - (2 * kTEXT_MARGIN);
521 	BString string;
522 
523 	sprintf(formatted, "%d", (int)((BIntegerField*)field)->Value());
524 
525 	string = formatted;
526 	parent->TruncateString(&string, B_TRUNCATE_MIDDLE, width + 2);
527 	DrawString(string.String(), parent, rect);
528 }
529 
530 
531 int
532 BIntegerColumn::CompareFields(BField *field1, BField *field2)
533 {
534 	return (((BIntegerField*)field1)->Value() - ((BIntegerField*)field2)->Value());
535 }
536 
537 
538 // #pragma mark - GraphColumn
539 
540 
541 GraphColumn::GraphColumn(const char* name, float width, float minWidth,
542 	float maxWidth, alignment align)
543 	:
544 	BIntegerColumn(name, width, minWidth, maxWidth, align)
545 {
546 }
547 
548 
549 void
550 GraphColumn::DrawField(BField* field, BRect rect, BView* parent)
551 {
552 	int number = ((BIntegerField*)field)->Value();
553 
554 	if (number > 100)
555 		number = 100;
556 	else if (number < 0)
557 		number = 0;
558 
559 	BRect graphRect(rect);
560 	graphRect.InsetBy(5, 3);
561 	parent->StrokeRect(graphRect);
562 	if (number > 0) {
563 		graphRect.InsetBy(1, 1);
564 		float value = graphRect.Width() * (float)number / 100;
565 		graphRect.right = graphRect.left + value;
566 		parent->SetHighColor(0, 0, 190);
567 		parent->FillRect(graphRect);
568 	}
569 
570 	parent->SetDrawingMode(B_OP_INVERT);
571 	parent->SetHighColor(128, 128, 128);
572 	char numberString[256];
573 	sprintf(numberString, "%d%%", number);
574 
575 	float width = be_plain_font->StringWidth(numberString);
576 	parent->MovePenTo(rect.left + rect.Width() / 2 - width / 2, rect.bottom - FontHeight());
577 	parent->DrawString(numberString);
578 }
579 
580 
581 // #pragma mark - BBitmapField
582 
583 
584 BBitmapField::BBitmapField(BBitmap* bitmap)
585 	:
586 	fBitmap(bitmap)
587 {
588 }
589 
590 
591 const BBitmap*
592 BBitmapField::Bitmap()
593 {
594 	return fBitmap;
595 }
596 
597 
598 void
599 BBitmapField::SetBitmap(BBitmap* bitmap)
600 {
601 	fBitmap = bitmap;
602 }
603 
604 
605 // #pragma mark - BBitmapColumn
606 
607 
608 BBitmapColumn::BBitmapColumn(const char* title, float width, float minWidth,
609 	float maxWidth, alignment align)
610 	:
611 	BTitledColumn(title, width, minWidth, maxWidth, align)
612 {
613 }
614 
615 
616 void
617 BBitmapColumn::DrawField(BField* field, BRect rect, BView* parent)
618 {
619 	BBitmapField* bitmapField = static_cast<BBitmapField*>(field);
620 	const BBitmap* bitmap = bitmapField->Bitmap();
621 
622 	if (bitmap != NULL) {
623 		float x = 0.0;
624 		BRect r = bitmap->Bounds();
625 		float y = rect.top + ((rect.Height() - r.Height()) / 2);
626 
627 		switch (Alignment()) {
628 			default:
629 			case B_ALIGN_LEFT:
630 				x = rect.left + kTEXT_MARGIN;
631 				break;
632 
633 			case B_ALIGN_CENTER:
634 				x = rect.left + ((rect.Width() - r.Width()) / 2);
635 				break;
636 
637 			case B_ALIGN_RIGHT:
638 				x = rect.right - kTEXT_MARGIN - r.Width();
639 				break;
640 		}
641 		// setup drawing mode according to bitmap color space,
642 		// restore previous mode after drawing
643 		drawing_mode oldMode = parent->DrawingMode();
644 		if (bitmap->ColorSpace() == B_RGBA32
645 			|| bitmap->ColorSpace() == B_RGBA32_BIG) {
646 			parent->SetDrawingMode(B_OP_ALPHA);
647 			parent->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_OVERLAY);
648 		} else {
649 			parent->SetDrawingMode(B_OP_OVER);
650 		}
651 
652 		parent->DrawBitmap(bitmap, BPoint(x, y));
653 
654 		parent->SetDrawingMode(oldMode);
655 	}
656 }
657 
658 
659 int
660 BBitmapColumn::CompareFields(BField* /*field1*/, BField* /*field2*/)
661 {
662 	// Comparing bitmaps doesn't really make sense...
663 	return 0;
664 }
665 
666 
667 bool
668 BBitmapColumn::AcceptsField(const BField *field) const
669 {
670 	return static_cast<bool>(dynamic_cast<const BBitmapField*>(field));
671 }
672