callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d052d038dfd2be56aeea5af5e2712f046d4b58a7
evolution/calendar/gui/print.c
Conrad Steenberg d34fc73590 Bug #586186 - Calendar print uses too small font
2012-08-30 10:27:29 +02:00

3749 lines
108 KiB
C
Raw Blame History

/*
* Evolution calendar - Print support
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with the program; if not, see <http://www.gnu.org/licenses/>
*
*
* Authors:
* Michael Zucchi <notzed@ximian.com>
* Federico Mena-Quintero <federico@ximian.com>
* Damon Chaplin <damon@ximian.com>
*
* Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <sys/stat.h>
#include <sys/time.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <e-util/e-util.h>
#include <e-util/e-print.h>
#include "e-cal-model.h"
#include "e-day-view.h"
#include "e-day-view-layout.h"
#include "e-week-view.h"
#include "e-week-view-layout.h"
#include "e-task-table.h"
#include "gnome-cal.h"
#include "print.h"
#include "art/jump.xpm"
typedef struct PrintCompItem PrintCompItem;
typedef struct PrintCalItem PrintCalItem;
struct PrintCompItem {
ECalClient *client;
ECalComponent *comp;
icaltimezone *zone;
gboolean use_24_hour_format;
};
struct PrintCalItem {
GnomeCalendar *gcal;
time_t start;
};
static gdouble
evo_calendar_print_renderer_get_width (GtkPrintContext *context,
PangoFontDescription *font,
const gchar *text)
{
PangoLayout *layout;
gint layout_width, layout_height;
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_font_description (layout, font);
pango_layout_set_text (layout, text, -1);
pango_layout_set_indent (layout, 0);
pango_layout_get_size (layout, &layout_width, &layout_height);
g_object_unref (layout);
return pango_units_to_double (layout_width);
}
static gdouble
evo_calendar_print_renderer_get_height (GtkPrintContext *context,
PangoFontDescription *font,
const gchar *text)
{
PangoLayout *layout;
gint layout_width, layout_height;
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_font_description (layout, font);
pango_layout_set_text (layout, text, -1);
pango_layout_set_indent (layout, 0);
pango_layout_get_size (layout, &layout_width, &layout_height);
g_object_unref (layout);
return pango_units_to_double (layout_height);
}
static gdouble
get_font_size (PangoFontDescription *font)
{
g_return_val_if_fail (font, 0.0);
return pango_units_to_double (pango_font_description_get_size (font));
}
static gint
get_day_view_time_divisions (void)
{
GSettings *settings;
gint time_divisions;
settings = g_settings_new ("org.gnome.evolution.calendar");
time_divisions = g_settings_get_int (settings, "time-divisions");
if (time_divisions < 5 || time_divisions > 30)
time_divisions = 30;
g_object_unref (settings);
return time_divisions;
}
/*
* Note that most dimensions are in points (1/72 of an inch) since that is
* what gnome-print uses.
*/
/* GtkHTML prints using a fixed margin. It has code to get the margins from
* gnome-print keys, but it's commented out. The corresponding code here
* doesn't seem to work either (getting zero margins), so we adopt
* gtkhtml's cheat. */
#define TEMP_MARGIN .05
/* The fonts to use */
#define FONT_FAMILY "Sans"
/* The font size to use for normal text. */
#define DAY_NORMAL_FONT_SIZE 12
#define WEEK_NORMAL_FONT_SIZE 12
#define MONTH_NORMAL_FONT_SIZE 8
#define WEEK_EVENT_FONT_SIZE 9
#define WEEK_SMALL_FONT_SIZE 8
/* The height of the header bar across the top of the Day, Week & Month views,
* which contains the dates shown and the 2 small calendar months. */
#define HEADER_HEIGHT 80
/* The width of the small calendar months, the space from the right edge of
* the header rectangle, and the space between the months. */
#define MIN_SMALL_MONTH_WIDTH 120
#define SMALL_MONTH_PAD 5
#define SMALL_MONTH_SPACING 20
/* The minimum number of rows we leave space for for the long events in the
* day view. */
#define DAY_VIEW_MIN_ROWS_IN_TOP_DISPLAY 2
/* The row height for long events in the day view. */
#define DAY_VIEW_ROW_HEIGHT 14
#define CALC_DAY_VIEW_ROWS(divis) ((60 / divis) * 24)
/* The width of the column with all the times in it. */
#define DAY_VIEW_TIME_COLUMN_WIDTH 36
/* The space on the right of each event. */
#define DAY_VIEW_EVENT_X_PAD 8
/* Allowance for small errors in floating point comparisons. */
#define EPSILON 0.01
/* The weird month of September 1752, where 3 Sep through 13 Sep were
* eliminated due to the Gregorian reformation. */
static const gint sept_1752[42] = {
0, 0, 1, 2, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23,
24, 25, 26, 27, 28, 29, 30,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0
};
#define SEPT_1752_START 2 /* Start day within month */
#define SEPT_1752_END 20 /* End day within month */
struct pdinfo
{
gint days_shown;
time_t day_starts[E_DAY_VIEW_MAX_DAYS + 1];
GArray *long_events;
GArray *events[E_DAY_VIEW_MAX_DAYS];
gint start_hour;
gint end_hour;
gint start_minute_offset;
gint end_minute_offset;
gint rows;
gint mins_per_row;
guint8 cols_per_row[CALC_DAY_VIEW_ROWS (1)];
gboolean use_24_hour_format;
icaltimezone *zone;
};
struct psinfo
{
gint days_shown;
time_t day_starts[E_WEEK_VIEW_MAX_WEEKS * 7 + 1];
GArray *events;
gint rows_per_cell;
gint rows_per_compressed_cell;
gint display_start_weekday;
gboolean multi_week_view;
gint weeks_shown;
gint month;
gboolean compress_weekend;
gboolean use_24_hour_format;
gdouble row_height;
gdouble header_row_height;
icaltimezone *zone;
};
/* Convenience function to help the transition to timezone functions.
* It converts a time_t to a struct tm. */
static void
convert_timet_to_struct_tm (time_t time,
icaltimezone *zone,
struct tm *tm)
{
struct icaltimetype tt;
/* Convert it to an icaltimetype. */
tt = icaltime_from_timet_with_zone (time, FALSE, zone);
/* Fill in the struct tm. */
tm->tm_year = tt.year - 1900;
tm->tm_mon = tt.month - 1;
tm->tm_mday = tt.day;
tm->tm_hour = tt.hour;
tm->tm_min = tt.minute;
tm->tm_sec = tt.second;
tm->tm_isdst = tt.is_daylight;
tm->tm_wday = time_day_of_week (tt.day, tt.month - 1, tt.year);
}
/* Fills the 42-element days array with the day numbers for the specified
* month. Slots outside the bounds of the month are filled with zeros.
* The starting and ending indexes of the days are returned in the start
* and end arguments. */
static void
build_month (ECalModel *model,
gint month,
gint year,
gint *days,
gint *start,
gint *end)
{
gint i;
gint d_month, d_week, week_start_day;
/* Note that months are zero-based, so September is month 8 */
if ((year == 1752) && (month == 8)) {
memcpy (days, sept_1752, 42 * sizeof (gint));
if (start)
*start = SEPT_1752_START;
if (end)
*end = SEPT_1752_END;
return;
}
for (i = 0; i < 42; i++)
days[i] = 0;
d_month = time_days_in_month (year, month);
/* Get the start weekday in the month, 0=Sun to 6=Sat. */
d_week = time_day_of_week (1, month, year);
/* Get the configuration setting specifying which weekday we put on
* the left column, 0=Sun to 6=Sat. */
week_start_day = e_cal_model_get_week_start_day (model);
/* Figure out which square we want to put the 1 in. */
d_week = (d_week + 7 - week_start_day) % 7;
for (i = 0; i < d_month; i++)
days[d_week + i] = i + 1;
if (start)
*start = d_week;
if (end)
*end = d_week + d_month - 1;
}
static PangoFontDescription *
get_font_for_size (gdouble height,
PangoWeight weight)
{
PangoFontDescription *desc;
gint size;
#define MAGIC_SCALE_FACTOR (0.86)
size = pango_units_from_double (height * MAGIC_SCALE_FACTOR);
desc = pango_font_description_new ();
pango_font_description_set_size (desc, size);
pango_font_description_set_weight (desc, weight);
pango_font_description_set_family_static (desc, FONT_FAMILY);
return desc;
}
/* Prints a rectangle, with or without a border, filled or outline, and
* possibly with triangular arrows at one or both horizontal edges.
* width = width of border, -ve means no border.
* red,green,blue = bgcolor to fill, -ve means no fill.
* left_triangle_width, right_triangle_width = width from edge of rectangle to
* point of triangle, or -ve for no triangle. */
static void
print_border_with_triangles (GtkPrintContext *pc,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2,
gdouble line_width,
gdouble red,
gdouble green,
gdouble blue,
gdouble left_triangle_width,
gdouble right_triangle_width)
{
cairo_t *cr = gtk_print_context_get_cairo_context (pc);
cairo_save (cr);
/* Fill in the interior of the rectangle, if desired. */
if (red >= -EPSILON && green >= -EPSILON && blue >= -EPSILON) {
cairo_move_to (cr, x1, y1);
if (left_triangle_width > 0.0)
cairo_line_to (cr, x1 - left_triangle_width,
(y1 + y2) / 2);
cairo_line_to (cr, x1, y2);
cairo_line_to (cr, x2, y2);
if (right_triangle_width > 0.0)
cairo_line_to (cr, x2 + right_triangle_width, (y1 + y2) / 2);
cairo_line_to (cr, x2, y1);
cairo_close_path (cr);
cairo_set_source_rgb (cr, red, green, blue);
cairo_fill (cr);
cairo_restore (cr);
cairo_save (cr);
}
/* Draw the outline, if desired. */
if (line_width >= EPSILON) {
cr = gtk_print_context_get_cairo_context (pc);
cairo_move_to (cr, x1, y1);
if (left_triangle_width > 0.0)
cairo_line_to (cr, x1 - left_triangle_width,
(y1 + y2) / 2);
cairo_line_to (cr, x1, y2);
cairo_line_to (cr, x2, y2);
if (right_triangle_width > 0.0)
cairo_line_to (cr, x2 + right_triangle_width,
(y1 + y2) / 2);
cairo_line_to (cr, x2, y1);
cairo_close_path (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_set_line_width (cr, line_width);
cairo_stroke (cr);
}
cairo_restore (cr);
}
/* Prints a rectangle, with or without a border, and filled or outline.
* width = width of border, -ve means no border.
* fillcolor = shade of fill, -ve means no fill. */
static void
print_border_rgb (GtkPrintContext *pc,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2,
gdouble line_width,
gdouble red,
gdouble green,
gdouble blue)
{
print_border_with_triangles (
pc, x1, x2, y1, y2, line_width,
red, green, blue, -1.0, -1.0);
}
static void
print_border (GtkPrintContext *pc,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2,
gdouble line_width,
gdouble fillcolor)
{
print_border_rgb (
pc, x1, x2, y1, y2, line_width,
fillcolor, fillcolor, fillcolor);
}
static void
print_rectangle (GtkPrintContext *context,
gdouble x,
gdouble y,
gdouble width,
gdouble height,
gdouble red,
gdouble green,
gdouble blue)
{
cairo_t *cr = gtk_print_context_get_cairo_context (context);
cairo_save (cr);
cairo_rectangle (cr, x, y, width, height);
cairo_set_source_rgb (cr, red, green, blue);
cairo_fill (cr);
cairo_restore (cr);
}
/* Recreate the layout by shrinking the text string if we have a line that's
* too high.
*/
static PangoLayout *
shrink_text_to_line (PangoLayout *layout,
gint layout_width,
gint layout_height,
GtkPrintContext *context,
PangoFontDescription *desc,
const gchar *text,
PangoAlignment alignment,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2)
{
gint new_length;
if (layout_width == 0 || x2 - x1 < EPSILON)
return layout; /* Do nothing */
new_length = (gint) floor (pango_units_from_double (x2 - x1) /
(gdouble) layout_width * (gdouble) strlen (text));
if (new_length < strlen(text)) {
g_object_unref (layout); /* Destroy old layout */
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_font_description (layout, desc);
pango_layout_set_alignment (layout, alignment);
pango_layout_set_text (layout, text, new_length);
}
return layout;
}
/* Prints 1 line of aligned text in a box. It is centered vertically, and
* the horizontal alignment can be either PANGO_ALIGN_LEFT, PANGO_ALIGN_RIGHT,
* or PANGO_ALIGN_CENTER. Text is truncated if too long for cell. */
static gdouble
print_text_line (GtkPrintContext *context,
PangoFontDescription *desc,
const gchar *text,
PangoAlignment alignment,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2,
gboolean shrink)
{
PangoLayout *layout;
gint layout_width, layout_height;
cairo_t *cr;
cr = gtk_print_context_get_cairo_context (context);
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_font_description (layout, desc);
pango_layout_set_alignment (layout, alignment);
pango_layout_set_text (layout, text, -1);
/* Grab the width before expanding the layout. */
pango_layout_get_size (layout, &layout_width, &layout_height);
if (shrink && layout_width > pango_units_from_double (x2 - x1)) /* Too wide */
layout = shrink_text_to_line (layout, layout_width, layout_height,
context, desc, text, alignment,
x1, x2, y1, y2);
pango_layout_set_width (layout, pango_units_from_double (x2 - x1));
cairo_save (cr);
/* Set a clipping rectangle. */
cairo_move_to (cr, x1, y1);
cairo_rectangle (cr, x1, y1, x2 - x1, y2 - y1);
cairo_clip (cr);
cairo_new_path (cr);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_move_to (cr, x1, y1);
pango_cairo_show_layout (cr, layout);
cairo_stroke (cr);
cairo_restore (cr);
g_object_unref (layout);
return pango_units_to_double (layout_width);
}
/* Prints 1 or more lines of aligned text in a box. It is centered vertically, and
the horizontal alignment can be either PANGO_ALIGN_LEFT, PANGO_ALIGN_RIGHT,
or PANGO_ALIGN_CENTER. */
static double
print_text (GtkPrintContext *context,
PangoFontDescription *desc,
const gchar *text,
PangoAlignment alignment,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2)
{
return print_text_line (context, desc,
text, alignment,
x1, x2, y1, y2, FALSE);
}
/* gets/frees the font for you, as a bold font */
static gdouble
print_text_size_bold (GtkPrintContext *context,
const gchar *text,
PangoAlignment alignment,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2)
{
PangoFontDescription *font;
gdouble w;
font = get_font_for_size (ABS (y2 - y1) * 0.5, PANGO_WEIGHT_BOLD);
w = print_text (context, font, text, alignment, x1, x2, y1, y2);
pango_font_description_free (font);
return w;
}
/* gets/frees the font for you, as a bold font - absolute size parameter */
static double
print_text_abs_bold (GtkPrintContext *context,
const gchar *text,
gdouble font_size,
PangoAlignment alignment,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble y2)
{
PangoFontDescription *font;
gdouble w;
font = get_font_for_size (font_size, PANGO_WEIGHT_BOLD);
w = print_text_line (context, font, text, alignment, x1, x2, y1, y2, TRUE);
pango_font_description_free (font);
return w;
}
static void
titled_box (GtkPrintContext *context,
const gchar *text,
PangoFontDescription *font,
PangoAlignment alignment,
gdouble *x1,
gdouble *y1,
gdouble *x2,
gdouble *y2,
gdouble linewidth)
{
gdouble size;
size = evo_calendar_print_renderer_get_height (context, font, text);
print_border (context, *x1, *x2, *y1, *y1 + size + 2, linewidth, 0.9);
print_border (context, *x1, *x2, *y1 + size + 2, *y2, linewidth, -1.0);
*x1 += 2;
*x2 -= 2;
*y2 += 2;
print_text (context, font, text, alignment, *x1, *x2, *y1 + 1.0, *y1 + size);
*y1 += size + 2;
}
static gboolean
get_show_week_numbers (void)
{
EShell *shell;
EShellSettings *shell_settings;
shell = e_shell_get_default ();
shell_settings = e_shell_get_shell_settings (shell);
return e_shell_settings_get_boolean (
shell_settings, "cal-show-week-numbers");
}
enum datefmt {
DATE_MONTH = 1 << 0,
DATE_DAY = 1 << 1,
DATE_DAYNAME = 1 << 2,
DATE_YEAR = 1 << 3
};
static const gchar *days[] = {
N_("1st"), N_("2nd"), N_("3rd"), N_("4th"), N_("5th"),
N_("6th"), N_("7th"), N_("8th"), N_("9th"), N_("10th"),
N_("11th"), N_("12th"), N_("13th"), N_("14th"), N_("15th"),
N_("16th"), N_("17th"), N_("18th"), N_("19th"), N_("20th"),
N_("21st"), N_("22nd"), N_("23rd"), N_("24th"), N_("25th"),
N_("26th"), N_("27th"), N_("28th"), N_("29th"), N_("30th"),
N_("31st")
};
/*
format the date 'nicely' and consistently for various headers
*/
static gchar *
format_date (struct tm *tm,
gint flags,
gchar *buffer,
gint bufflen)
{
gchar fmt[64];
fmt[0] = 0;
if (flags & DATE_DAYNAME) {
strcat (fmt, "%A");
}
if (flags & DATE_DAY) {
if (flags & DATE_DAYNAME)
strcat (fmt, " ");
strcat (fmt, gettext (days[tm->tm_mday - 1]));
}
if (flags & DATE_MONTH) {
if (flags & (DATE_DAY | DATE_DAYNAME))
strcat (fmt, " ");
strcat (fmt, "%B");
if ((flags & (DATE_DAY | DATE_YEAR)) == (DATE_DAY | DATE_YEAR))
strcat (fmt, ",");
}
if (flags & DATE_YEAR) {
if (flags & (DATE_DAY | DATE_DAYNAME | DATE_MONTH))
strcat (fmt, " ");
strcat (fmt, "%Y");
}
e_utf8_strftime (buffer, bufflen, fmt, tm);
buffer[bufflen - 1] = '\0';
return buffer;
}
static gboolean
instance_cb (ECalComponent *comp,
time_t instance_start,
time_t instance_end,
gpointer data)
{
gboolean *found = ((ECalModelGenerateInstancesData *) data)->cb_data;
*found = TRUE;
return FALSE;
}
const gchar *daynames[] =
/* Translators: These are workday abbreviations, e.g. Su=Sunday and Th=thursday */
{ N_("Su"), N_("Mo"), N_("Tu"), N_("We"),
N_("Th"), N_("Fr"), N_("Sa") };
static gdouble
calc_small_month_width (GtkPrintContext *context,
gdouble for_height)
{
PangoFontDescription *font_bold;
gdouble res = 0.0;
gint ii;
font_bold = get_font_for_size (for_height / 7.4, PANGO_WEIGHT_BOLD);
res = MAX (evo_calendar_print_renderer_get_width (
context, font_bold, "23"), res);
for (ii = 0; ii < 7; ii++) {
res = MAX (evo_calendar_print_renderer_get_width (
context, font_bold, _(daynames[ii])), res);
}
pango_font_description_free (font_bold);
/* res is max cell width, so multiply it with column
* count plus some space between columns. */
res = (res + 1.0) * (7 + (get_show_week_numbers () ? 1 : 0)) - 1.0;
if (res < MIN_SMALL_MONTH_WIDTH)
res = MIN_SMALL_MONTH_WIDTH;
return res;
}
/*
print out the month small, embolden any days with events.
*/
static void
print_month_small (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t month,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gint titleflags,
time_t greystart,
time_t greyend,
gint bordertitle)
{
icaltimezone *zone;
PangoFontDescription *font, *font_bold, *font_normal;
ECalModel *model;
time_t now, next;
gint x, y;
gint days[42];
gint day, weekday, week_start_day;
gchar buf[100];
struct tm tm;
gdouble font_size;
gdouble header_size, col_width, row_height, text_xpad, w;
gdouble cell_top, cell_bottom, cell_left, cell_right, text_right;
gboolean week_numbers;
cairo_t *cr;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
week_numbers = get_show_week_numbers ();
/* Print the title, e.g. 'June 2001', in the top 16% of the area. */
convert_timet_to_struct_tm (month, zone, &tm);
format_date (&tm, titleflags, buf, 100);
header_size = ABS (y2 - y1) * 0.16;
font = get_font_for_size (header_size, PANGO_WEIGHT_BOLD);
if (bordertitle)
print_border (context, x1, x2, y1, y1 + header_size, 1.0, 0.9);
print_text (context, font, buf, PANGO_ALIGN_CENTER, x1, x2,
y1, y1 + header_size);
pango_font_description_free (font);
y1 += header_size;
col_width = (x2 - x1) / (7 + (week_numbers ? 1 : 0));
/* The top row with the day abbreviations gets an extra bit of
* vertical space around it. */
row_height = ABS (y2 - y1) / 7.4;
/* First we need to calculate a reasonable font size. We start with a
* rough guess of just under the height of each row. */
font_size = row_height;
/* get month days */
convert_timet_to_struct_tm (month, zone, &tm);
build_month (model, tm.tm_mon, tm.tm_year + 1900, days, NULL, NULL);
font_normal = get_font_for_size (font_size, PANGO_WEIGHT_NORMAL);
font_bold = get_font_for_size (font_size, PANGO_WEIGHT_BOLD);
/* Get a reasonable estimate of the largest number we will need,
* and use it to calculate the offset from the right edge of the
* cell that we should put the numbers. */
w = evo_calendar_print_renderer_get_width (context, font_bold, "23");
text_xpad = (col_width - w) / 2;
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
/* Print the abbreviated day names across the top in bold. */
week_start_day = e_cal_model_get_week_start_day (model);
weekday = week_start_day;
for (x = 0; x < 7; x++) {
print_text (
context, font_bold,
_(daynames[weekday]), PANGO_ALIGN_RIGHT,
x1 + (x + (week_numbers ? 1 : 0)) * col_width,
x1 + (x + 1 + (week_numbers ? 1 : 0)) * col_width,
y1, y1 + row_height * 1.4);
weekday = (weekday + 1) % 7;
}
y1 += row_height * 1.4;
now = time_month_begin_with_zone (month, zone);
for (y = 0; y < 6; y++) {
cell_top = y1 + y * row_height;
cell_bottom = cell_top + row_height;
if (week_numbers) {
cell_left = x1;
/* We add a 0.05 to make sure the cells meet up with
* each other. Otherwise you sometimes get lines
* between them which looks bad. Maybe I'm not using
* coords in the way gnome-print expects. */
cell_right = cell_left + col_width + 0.05;
text_right = cell_right - text_xpad;
/* last week can be empty */
for (x = 0; x < 7; x++) {
day = days[y * 7 + x];
if (day != 0)
break;
}
if (day != 0) {
time_t week_begin;
week_begin = time_week_begin_with_zone (
now, week_start_day, zone);
convert_timet_to_struct_tm (
week_begin, zone, &tm);
/* Month in e_calendar_item_get_week_number
* is also zero-based. */
sprintf (
buf, "%d",
e_calendar_item_get_week_number (
NULL, tm.tm_mday, tm.tm_mon,
tm.tm_year + 1900));
print_text (
context, font_normal,
buf, PANGO_ALIGN_RIGHT,
cell_left, text_right,
cell_top, cell_bottom);
}
}
for (x = 0; x < 7; x++) {
cell_left = x1 + (x + (week_numbers ? 1 : 0)) * col_width;
/* We add a 0.05 to make sure the cells meet up with
* each other. Otherwise you sometimes get lines
* between them which looks bad. Maybe I'm not using
* coords in the way gnome-print expects. */
cell_right = cell_left + col_width + 0.05;
text_right = cell_right - text_xpad;
day = days[y * 7 + x];
if (day != 0) {
gboolean found = FALSE;
sprintf (buf, "%d", day);
/* this is a slow messy way to do this ... but easy ... */
e_cal_model_generate_instances_sync (gnome_calendar_get_model (gcal), now,
time_day_end_with_zone (now, zone),
instance_cb, &found);
font = found ? font_bold : font_normal;
next = time_add_day_with_zone (now, 1, zone);
if ((now >= greystart && now < greyend)
|| (greystart >= now && greystart < next)) {
print_border (context,
cell_left, cell_right,
cell_top, cell_bottom,
-1.0, 0.75);
}
print_text (context, font, buf, PANGO_ALIGN_RIGHT,
cell_left, text_right,
cell_top, cell_bottom);
now = next;
}
}
}
pango_font_description_free (font_normal);
pango_font_description_free (font_bold);
}
/* wraps text into the print context, not taking up more than its allowed space */
static gdouble
bound_text (GtkPrintContext *context,
PangoFontDescription *font,
const gchar *text,
gint len,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2,
gboolean can_wrap,
gdouble *last_page_start,
gint *pages)
{
PangoLayout *layout;
gint layout_width, layout_height;
cairo_t *cr;
cr = gtk_print_context_get_cairo_context (context);
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_font_description (layout, font);
pango_layout_set_text (layout, text, len);
pango_layout_set_width (layout, pango_units_from_double (x2 - x1));
if (can_wrap)
pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
pango_layout_get_size (layout, &layout_width, &layout_height);
if (last_page_start &&
y1 + pango_units_to_double (layout_height) >
y2 + (*last_page_start)) {
/* draw this on new page */
if (pages)
*pages = *pages + 1;
*last_page_start = *last_page_start + y2;
y1 = *last_page_start + 10.0;
}
if (!last_page_start || (y1 >= 0.0 && y1 < y2)) {
cairo_save (cr);
/* Set a clipping rectangle. */
cairo_move_to (cr, x1, y1);
cairo_rectangle (cr, x1, y1, x2 - x1, y2 - y1);
cairo_clip (cr);
cairo_new_path (cr);
cairo_move_to (cr, x1, y1);
pango_cairo_show_layout (cr, layout);
cairo_stroke (cr);
cairo_restore (cr);
}
g_object_unref (layout);
return y1 + pango_units_to_double (layout_height);
}
/* Draw the borders, lines, and times down the left of the day view. */
static void
print_day_background (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t whence,
struct pdinfo *pdi,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
ECalModel *model;
PangoFontDescription *font_hour, *font_minute;
gdouble yinc, y;
gdouble width = DAY_VIEW_TIME_COLUMN_WIDTH;
gdouble font_size, max_font_size, hour_font_size, minute_font_size;
gchar buf[20];
const gchar *minute;
gboolean use_24_hour;
gint i, hour, row;
gdouble hour_minute_x, hour_minute_width;
cairo_t *cr;
model = gnome_calendar_get_model (gcal);
use_24_hour = e_cal_model_get_use_24_hour_format (model);
/* Fill the time column in light-gray. */
print_border (context, left, left + width, top, bottom, -1.0, 0.9);
/* Draw the border around the entire view. */
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
print_border (context, left, right, top, bottom, 1.0, -1.0);
/* Draw the vertical line on the right of the time column. */
cr = gtk_print_context_get_cairo_context (context);
cairo_set_line_width (cr, 0.0);
cairo_move_to (cr, left + width, bottom);
cairo_line_to (cr, left + width, top);
cairo_stroke (cr);
/* Calculate the row height. */
if (top > bottom)
yinc = (top - bottom) / (pdi->end_hour - pdi->start_hour);
else
yinc = (bottom - top) / (pdi->end_hour - pdi->start_hour);
/* Get the 2 fonts we need. */
font_size = yinc * 0.6;
max_font_size = width * 0.45;
hour_font_size = MIN (font_size, max_font_size);
font_hour = get_font_for_size (hour_font_size, PANGO_WEIGHT_BOLD);
font_size = yinc * 0.33;
max_font_size = width * 0.2;
minute_font_size = MIN (font_size, max_font_size);
font_minute = get_font_for_size (minute_font_size, PANGO_WEIGHT_BOLD);
hour_minute_width = evo_calendar_print_renderer_get_width (
context, font_minute, use_24_hour ? "00" : _("am"));
if (!use_24_hour)
hour_minute_width =
MAX (hour_minute_width,
evo_calendar_print_renderer_get_width (
context, font_minute, _("pm")));
row = 0;
hour_minute_x = left + width - hour_minute_width - 3;
for (i = pdi->start_hour; i < pdi->end_hour; i++) {
y = top + yinc * (row + 1);
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
if (use_24_hour) {
hour = i;
minute = "00";
} else {
if (i < 12)
minute = _("am");
else
minute = _("pm");
hour = i % 12;
if (hour == 0)
hour = 12;
}
/* the hour label/minute */
sprintf (buf, "%d", hour);
print_text (context, font_hour, buf, PANGO_ALIGN_RIGHT,
left, hour_minute_x,
y - yinc, y - yinc + hour_font_size);
print_text (context, font_minute, minute, PANGO_ALIGN_LEFT,
hour_minute_x, left + width - 3,
y - yinc, y - yinc + minute_font_size);
/* Draw the horizontal line between hours, across the entire
width of the day view. */
cr = gtk_print_context_get_cairo_context (context);
cairo_move_to (cr, left, y);
cairo_line_to (cr, right, y);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
/* Draw the horizontal line for the 1/2-hours, across the
* entire width except for part of the time column. */
cairo_move_to (cr, left + width * 0.6, y - yinc / 2);
cairo_line_to (cr, right, y - yinc / 2);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
row++;
}
pango_font_description_free (font_hour);
pango_font_description_free (font_minute);
}
/* This adds one event to the view, adding it to the appropriate array. */
static gint
print_day_add_event (ECalModelComponent *comp_data,
time_t start,
time_t end,
icaltimezone *zone,
gint days_shown,
time_t *day_starts,
GArray *long_events,
GArray **events)
{
EDayViewEvent event;
gint day, offset;
struct icaltimetype start_tt, end_tt;
#if 0
g_print ("Day view lower: %s", ctime (&day_starts[0]));
g_print ("Day view upper: %s", ctime (&day_starts[days_shown]));
g_print ("Event start: %s", ctime (&start));
g_print ("Event end : %s\n", ctime (&end));
#endif
/* Check that the event times are valid. */
g_return_val_if_fail (start <= end, -1);
g_return_val_if_fail (start < day_starts[days_shown], -1);
g_return_val_if_fail (end > day_starts[0], -1);
start_tt = icaltime_from_timet_with_zone (start, FALSE, zone);
end_tt = icaltime_from_timet_with_zone (end, FALSE, zone);
event.comp_data = comp_data;
event.start = start;
event.end = end;
event.canvas_item = NULL;
/* Calculate the start & end minute, relative to the top of the
* display. */
/*offset = day_view->first_hour_shown * 60
+ day_view->first_minute_shown;*/
offset = 0;
event.start_minute = start_tt.hour * 60 + start_tt.minute - offset;
event.end_minute = end_tt.hour * 60 + end_tt.minute - offset;
event.start_row_or_col = 0;
event.num_columns = 0;
/* Find out which array to add the event to. */
for (day = 0; day < days_shown; day++) {
if (start >= day_starts[day] && end <= day_starts[day + 1]) {
/* Special case for when the appointment ends at
* midnight, i.e. the start of the next day. */
if (end == day_starts[day + 1]) {
/* If the event last the entire day, then we
* skip it here so it gets added to the top
* canvas. */
if (start == day_starts[day])
break;
event.end_minute = 24 * 60;
}
g_array_append_val (events[day], event);
return day;
}
}
/* The event wasn't within one day so it must be a long event,
* i.e. shown in the top canvas. */
g_array_append_val (long_events, event);
return E_DAY_VIEW_LONG_EVENT;
}
static gboolean
print_day_details_cb (ECalComponent *comp,
time_t istart,
time_t iend,
gpointer data)
{
ECalModelGenerateInstancesData *mdata = (ECalModelGenerateInstancesData *) data;
struct pdinfo *pdi = (struct pdinfo *) mdata->cb_data;
print_day_add_event (mdata->comp_data, istart, iend,
pdi->zone, pdi->days_shown, pdi->day_starts,
pdi->long_events, pdi->events);
return TRUE;
}
static void
free_event_array (GArray *array)
{
EDayViewEvent *event;
gint event_num;
for (event_num = 0; event_num < array->len; event_num++) {
event = &g_array_index (array, EDayViewEvent, event_num);
if (event->canvas_item)
g_object_run_dispose (G_OBJECT (event->canvas_item));
}
g_array_set_size (array, 0);
}
static const gchar *
get_type_as_string (icalparameter_cutype cutype)
{
const gchar *res;
switch (cutype) {
case ICAL_CUTYPE_NONE: res = NULL; break;
case ICAL_CUTYPE_INDIVIDUAL: res = _("Individual"); break;
case ICAL_CUTYPE_GROUP: res = _("Group"); break;
case ICAL_CUTYPE_RESOURCE: res = _("Resource"); break;
case ICAL_CUTYPE_ROOM: res = _("Room"); break;
default: res = _("Unknown"); break;
}
return res;
}
static const gchar *
get_role_as_string (icalparameter_role role)
{
const gchar *res;
switch (role) {
case ICAL_ROLE_NONE: res = NULL; break;
case ICAL_ROLE_CHAIR: res = _("Chair"); break;
case ICAL_ROLE_REQPARTICIPANT: res = _("Required Participant"); break;
case ICAL_ROLE_OPTPARTICIPANT: res = _("Optional Participant"); break;
case ICAL_ROLE_NONPARTICIPANT: res = _("Non-Participant"); break;
default: res = _("Unknown"); break;
}
return res;
}
static gdouble
print_attendees (GtkPrintContext *context,
PangoFontDescription *font,
cairo_t *cr,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom,
ECalComponent *comp,
gint page_nr,
gint *pages)
{
GSList *attendees = NULL, *l;
g_return_val_if_fail (context != NULL, top);
g_return_val_if_fail (font != NULL, top);
g_return_val_if_fail (cr != NULL, top);
e_cal_component_get_attendee_list (comp, &attendees);
for (l = attendees; l; l = l->next) {
ECalComponentAttendee *attendee = l->data;
if (attendee && attendee->value && *attendee->value) {
GString *text;
const gchar *tmp;
tmp = get_type_as_string (attendee->cutype);
text = g_string_new (tmp ? tmp : "");
if (tmp)
g_string_append (text, " ");
if (attendee->cn && *attendee->cn)
g_string_append (text, attendee->cn);
else {
/* it's usually in form of "mailto:email@domain" */
tmp = strchr (attendee->value, ':');
g_string_append (text, tmp ? tmp + 1 : attendee->value);
}
tmp = get_role_as_string (attendee->role);
if (tmp) {
g_string_append (text, " (");
g_string_append (text, tmp);
g_string_append (text, ")");
}
if (top > bottom) {
top = 10.0;
cairo_show_page (cr);
}
top = bound_text (
context, font, text->str, -1, left + 40.0,
top, right, bottom, FALSE, NULL, pages);
g_string_free (text, TRUE);
}
}
e_cal_component_free_attendee_list (attendees);
return top;
}
static gchar *
get_summary_with_location (icalcomponent *icalcomp)
{
const gchar *summary, *location;
gchar *text;
g_return_val_if_fail (icalcomp != NULL, NULL);
summary = icalcomponent_get_summary (icalcomp);
if (summary == NULL)
summary = "";
location = icalcomponent_get_location (icalcomp);
if (location && *location) {
text = g_strdup_printf ("%s (%s)", summary, location);
} else {
text = g_strdup (summary);
}
return text;
}
static void
print_day_long_event (GtkPrintContext *context,
PangoFontDescription *font,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom,
gdouble row_height,
EDayViewEvent *event,
struct pdinfo *pdi,
ECalModel *model)
{
gdouble x1, x2, y1, y2;
gdouble left_triangle_width = -1.0, right_triangle_width = -1.0;
gchar *text;
gchar buffer[32];
struct tm date_tm;
gdouble red, green, blue;
if (!is_comp_data_valid (event))
return;
/* If the event starts before the first day being printed, draw a
* triangle. (Note that I am assuming we are just showing 1 day at
* the moment.) */
if (event->start < pdi->day_starts[0])
left_triangle_width = 4;
/* If the event ends after the last day being printed, draw a
* triangle. */
if (event->end > pdi->day_starts[1])
right_triangle_width = 4;
x1 = left + 10;
x2 = right - 10;
y1 = top + event->start_row_or_col * row_height + 1;
y2 = y1 + row_height - 1;
red = green = blue = 0.95;
e_cal_model_get_rgb_color_for_component (
model, event->comp_data, &red, &green, &blue);
print_border_with_triangles (context, x1, x2, y1, y2, 0.5, red, green, blue,
left_triangle_width,
right_triangle_width);
/* If the event starts after the first day being printed, we need to
* print the start time. */
if (event->start > pdi->day_starts[0]) {
date_tm.tm_year = 2001;
date_tm.tm_mon = 0;
date_tm.tm_mday = 1;
date_tm.tm_hour = event->start_minute / 60;
date_tm.tm_min = event->start_minute % 60;
date_tm.tm_sec = 0;
date_tm.tm_isdst = -1;
e_time_format_time (&date_tm, pdi->use_24_hour_format, FALSE,
buffer, sizeof (buffer));
x1 += 4;
x1 += print_text (context, font, buffer, PANGO_ALIGN_LEFT, x1, x2, y1, y2);
}
/* If the event ends before the end of the last day being printed,
* we need to print the end time. */
if (event->end < pdi->day_starts[1]) {
date_tm.tm_year = 2001;
date_tm.tm_mon = 0;
date_tm.tm_mday = 1;
date_tm.tm_hour = event->end_minute / 60;
date_tm.tm_min = event->end_minute % 60;
date_tm.tm_sec = 0;
date_tm.tm_isdst = -1;
e_time_format_time (&date_tm, pdi->use_24_hour_format, FALSE,
buffer, sizeof (buffer));
x2 -= 4;
x2 -= print_text (context, font, buffer, PANGO_ALIGN_RIGHT, x1, x2, y1, y2);
}
/* Print the text. */
text = get_summary_with_location (event->comp_data->icalcomp);
x1 += 4;
x2 -= 4;
print_text_line (context, font, text, PANGO_ALIGN_CENTER, x1, x2, y1, y2, TRUE);
g_free (text);
}
static void
print_day_event (GtkPrintContext *context,
PangoFontDescription *font,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom,
EDayViewEvent *event,
struct pdinfo *pdi,
ECalModel *model)
{
gdouble x1, x2, y1, y2, col_width, row_height;
gint start_offset, end_offset, start_row, end_row;
gchar *text, start_buffer[32], end_buffer[32];
gboolean display_times = FALSE;
struct tm date_tm;
gdouble red, green, blue;
if (!is_comp_data_valid (event))
return;
if ((event->start_minute >= pdi->end_minute_offset)
|| (event->end_minute <= pdi->start_minute_offset))
return;
start_offset = event->start_minute - pdi->start_minute_offset;
end_offset = event->end_minute - pdi->start_minute_offset;
start_row = start_offset / pdi->mins_per_row;
start_row = MAX (0, start_row);
end_row = (end_offset - 1) / pdi->mins_per_row;
end_row = MIN (pdi->rows - 1, end_row);
col_width = (right - left) /
pdi->cols_per_row[event->start_minute / pdi->mins_per_row];
if (start_offset != start_row * pdi->mins_per_row
|| end_offset != (end_row + 1) * pdi->mins_per_row)
display_times = TRUE;
x1 = left + event->start_row_or_col * col_width;
x2 = x1 + event->num_columns * col_width - DAY_VIEW_EVENT_X_PAD;
row_height = (bottom - top) / pdi->rows;
y1 = top + start_row * row_height;
y2 = top + (end_row + 1) * row_height;
#if 0
g_print ("Event: %g,%g %g,%g\n row_height: %g start_row: %i top: %g rows: %i\n",
x1, y1, x2, y2, row_height, start_row, top, pdi->rows);
#endif
red = green = blue = 0.95;
e_cal_model_get_rgb_color_for_component (
model, event->comp_data, &red, &green, &blue);
print_border_rgb (context, x1, x2, y1, y2, 1.0, red, green, blue);
text = get_summary_with_location (event->comp_data->icalcomp);
if (display_times) {
gchar *t = NULL;
date_tm.tm_year = 2001;
date_tm.tm_mon = 0;
date_tm.tm_mday = 1;
date_tm.tm_hour = event->start_minute / 60;
date_tm.tm_min = event->start_minute % 60;
date_tm.tm_sec = 0;
date_tm.tm_isdst = -1;
e_time_format_time (&date_tm, pdi->use_24_hour_format, FALSE,
start_buffer, sizeof (start_buffer));
date_tm.tm_hour = event->end_minute / 60;
date_tm.tm_min = event->end_minute % 60;
e_time_format_time (&date_tm, pdi->use_24_hour_format, FALSE,
end_buffer, sizeof (end_buffer));
t = text;
text = g_strdup_printf ("%s - %s %s ", start_buffer,
end_buffer, text);
g_free (t);
}
bound_text (context, font, text, -1, x1 + 2, y1, x2 - 2, y2, FALSE, NULL, NULL);
g_free (text);
}
static void
print_day_details (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t whence,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
ECalModel *model;
icaltimezone *zone;
EDayViewEvent *event;
PangoFontDescription *font;
time_t start, end;
struct pdinfo pdi = { 0 };
gint rows_in_top_display, i, rows_with_30_mins;
gdouble font_size, max_font_size;
cairo_t *cr;
GdkPixbuf *pixbuf = NULL;
#define LONG_DAY_EVENTS_TOP_SPACING 4
#define LONG_DAY_EVENTS_BOTTOM_SPACING 2
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
start = time_day_begin_with_zone (whence, zone);
end = time_day_end_with_zone (start, zone);
pdi.days_shown = 1;
pdi.day_starts[0] = start;
pdi.day_starts[1] = end;
pdi.long_events = g_array_new (FALSE, FALSE, sizeof (EDayViewEvent));
pdi.events[0] = g_array_new (FALSE, FALSE, sizeof (EDayViewEvent));
pdi.start_hour = e_cal_model_get_work_day_start_hour (model);
pdi.end_hour = e_cal_model_get_work_day_end_hour (model);
if (e_cal_model_get_work_day_end_minute (model) != 0)
pdi.end_hour++;
pdi.mins_per_row = get_day_view_time_divisions ();
pdi.rows = (pdi.end_hour - pdi.start_hour) * (60 / pdi.mins_per_row);
pdi.start_minute_offset = pdi.start_hour * 60;
pdi.end_minute_offset = pdi.end_hour * 60;
pdi.use_24_hour_format = e_cal_model_get_use_24_hour_format (model);
pdi.zone = e_cal_model_get_timezone (model);
/* Get the events from the server. */
e_cal_model_generate_instances_sync (model, start, end, print_day_details_cb, &pdi);
qsort (pdi.long_events->data, pdi.long_events->len,
sizeof (EDayViewEvent), e_day_view_event_sort_func);
qsort (pdi.events[0]->data, pdi.events[0]->len,
sizeof (EDayViewEvent), e_day_view_event_sort_func);
/* Also print events outside of work hours */
if (pdi.events[0]->len > 0) {
struct icaltimetype tt;
event = &g_array_index (pdi.events[0], EDayViewEvent, 0);
tt = icaltime_from_timet_with_zone (event->start, FALSE, zone);
if (tt.hour < pdi.start_hour)
pdi.start_hour = tt.hour;
pdi.start_minute_offset = pdi.start_hour * 60;
event = &g_array_index (pdi.events[0], EDayViewEvent, pdi.events[0]->len - 1);
tt = icaltime_from_timet_with_zone (event->end, FALSE, zone);
if (tt.hour > pdi.end_hour || tt.hour == 0) {
pdi.end_hour = tt.hour ? tt.hour : 24;
if (tt.minute > 0)
pdi.end_hour++;
}
pdi.end_minute_offset = pdi.end_hour * 60;
pdi.rows = (pdi.end_hour - pdi.start_hour) * (60 / pdi.mins_per_row);
}
/* Lay them out the long events, across the top of the page. */
e_day_view_layout_long_events (pdi.long_events, pdi.days_shown,
pdi.day_starts, &rows_in_top_display);
/*Print the long events. */
font = get_font_for_size (12, PANGO_WEIGHT_NORMAL);
/* We always leave space for DAY_VIEW_MIN_ROWS_IN_TOP_DISPLAY in the
* top display, but we may have more rows than that, in which case
* the main display area will be compressed. */
/* Limit long day event to half the height of the panel */
rows_in_top_display = MIN (MAX (rows_in_top_display,
DAY_VIEW_MIN_ROWS_IN_TOP_DISPLAY),
(bottom - top) * 0.5 / DAY_VIEW_ROW_HEIGHT);
if (rows_in_top_display > pdi.long_events->len)
rows_in_top_display = pdi.long_events->len;
for (i = 0; i < rows_in_top_display && i < pdi.long_events->len; i++) {
event = &g_array_index (pdi.long_events, EDayViewEvent, i);
print_day_long_event (
context, font, left, right,
top + LONG_DAY_EVENTS_TOP_SPACING, bottom,
DAY_VIEW_ROW_HEIGHT, event, &pdi, model);
}
if (rows_in_top_display < pdi.long_events->len) {
/* too many events */
cairo_t *cr = gtk_print_context_get_cairo_context (context);
gint x, y;
if (!pixbuf) {
const gchar **xpm = (const gchar **) jump_xpm;
/* this ugly thing is here only to get rid of compiler warning
* about unused 'jump_xpm_focused' */
if (pixbuf)
xpm = (const gchar **) jump_xpm_focused;
pixbuf = gdk_pixbuf_new_from_xpm_data (xpm);
}
/* Right align - 10 comes from print_day_long_event too */
x = right - gdk_pixbuf_get_width (pixbuf) * 0.5 - 10;
/* Placing '...' over the last all day event entry printed. '-1 -1' comes
from print_long_day_event (top / bottom spacing in each cell) */
y = top + LONG_DAY_EVENTS_TOP_SPACING
+ DAY_VIEW_ROW_HEIGHT * (i - 1)
+ (DAY_VIEW_ROW_HEIGHT - 1 - 1) * 0.5;
cairo_save (cr);
cairo_scale (cr, 0.5, 0.5);
gdk_cairo_set_source_pixbuf (cr, pixbuf, x * 2.0, y * 2.0);
cairo_paint (cr);
cairo_restore (cr);
}
if (!rows_in_top_display)
rows_in_top_display++;
/* Draw the border around the long events. */
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
print_border (
context, left, right,
top, top + rows_in_top_display * DAY_VIEW_ROW_HEIGHT +
LONG_DAY_EVENTS_TOP_SPACING + LONG_DAY_EVENTS_BOTTOM_SPACING,
1.0, -1.0);
/* Adjust the area containing the main display. */
top += rows_in_top_display * DAY_VIEW_ROW_HEIGHT
+ LONG_DAY_EVENTS_TOP_SPACING
+ LONG_DAY_EVENTS_BOTTOM_SPACING;
/* Draw the borders, lines, and times down the left. */
print_day_background (context, gcal, whence, &pdi,
left, right, top, bottom);
/* Now adjust to get rid of the time column. */
left += DAY_VIEW_TIME_COLUMN_WIDTH;
/* lay out the short events, within the day. */
e_day_view_layout_day_events (pdi.events[0], CALC_DAY_VIEW_ROWS (pdi.mins_per_row),
pdi.mins_per_row, pdi.cols_per_row, -1);
/* use font like with 30 minutes time division */
rows_with_30_mins = (pdi.end_hour - pdi.start_hour) * (60 / 30);
/* print the short events. */
if (top > bottom )
max_font_size = ((top - bottom) / rows_with_30_mins) - 4;
else
max_font_size = ((bottom - top ) / rows_with_30_mins) - 4;
font_size = MIN (DAY_NORMAL_FONT_SIZE, max_font_size);
font = get_font_for_size (font_size, PANGO_WEIGHT_NORMAL);
for (i = 0; i < pdi.events[0]->len; i++) {
event = &g_array_index (pdi.events[0], EDayViewEvent, i);
print_day_event (context, font, left, right, top, bottom,
event, &pdi, model);
}
/* Free everything. */
if (pixbuf)
g_object_unref (pixbuf);
free_event_array (pdi.long_events);
pango_font_description_free (font);
g_array_free (pdi.long_events, TRUE);
free_event_array (pdi.events[0]);
g_array_free (pdi.events[0], TRUE);
}
/* Returns TRUE if the event is a one-day event (i.e. not a long event). */
static gboolean
print_is_one_day_week_event (EWeekViewEvent *event,
EWeekViewEventSpan *span,
time_t *day_starts)
{
if (event->start == day_starts[span->start_day]
&& event->end == day_starts[span->start_day + 1])
return FALSE;
if (span->num_days == 1
&& event->start >= day_starts[span->start_day]
&& event->end <= day_starts[span->start_day + 1])
return TRUE;
return FALSE;
}
static void
print_week_long_event (GtkPrintContext *context,
PangoFontDescription *font,
struct psinfo *psi,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble row_height,
EWeekViewEvent *event,
EWeekViewEventSpan *span,
gchar *text,
gdouble red,
gdouble green,
gdouble blue)
{
gdouble left_triangle_width = -1.0, right_triangle_width = -1.0;
struct tm date_tm;
gchar buffer[32];
/* If the event starts before the first day of the span, draw a
* triangle to indicate it continues. */
if (event->start < psi->day_starts[span->start_day])
left_triangle_width = 4;
/* If the event ends after the last day of the span, draw a
* triangle. */
if (event->end > psi->day_starts[span->start_day + span->num_days])
right_triangle_width = 4;
print_border_with_triangles (
context, x1 + 6, x2 - 6, y1, y1 + row_height, 0.0, red, green, blue,
left_triangle_width, right_triangle_width);
x1 += 6;
x2 -= 6;
/* If the event starts after the first day being printed, we need to
* print the start time. */
if (event->start > psi->day_starts[span->start_day]) {
date_tm.tm_year = 2001;
date_tm.tm_mon = 0;
date_tm.tm_mday = 1;
date_tm.tm_hour = event->start_minute / 60;
date_tm.tm_min = event->start_minute % 60;
date_tm.tm_sec = 0;
date_tm.tm_isdst = -1;
e_time_format_time (&date_tm, psi->use_24_hour_format, FALSE,
buffer, sizeof (buffer));
x1 += 2;
x1 += print_text_line (
context, font, buffer, PANGO_ALIGN_LEFT,
x1, x2 - 2, y1, y1 + row_height, TRUE);
}
/* If the event ends before the end of the last day being printed,
* we need to print the end time. */
if (event->end < psi->day_starts[span->start_day + span->num_days]) {
date_tm.tm_year = 2001;
date_tm.tm_mon = 0;
date_tm.tm_mday = 1;
date_tm.tm_hour = event->end_minute / 60;
date_tm.tm_min = event->end_minute % 60;
date_tm.tm_sec = 0;
date_tm.tm_isdst = -1;
e_time_format_time (&date_tm, psi->use_24_hour_format, FALSE,
buffer, sizeof (buffer));
x2 -= 2;
x2 -= print_text_line (
context, font, buffer, PANGO_ALIGN_RIGHT,
x1 + 2, x2, y1, y1 + row_height, TRUE);
}
x1 += 2;
x2 -= 2;
print_text_line (context, font, text, PANGO_ALIGN_CENTER, x1, x2, y1, y1 + row_height, TRUE);
}
static void
print_week_day_event (GtkPrintContext *context,
PangoFontDescription *font,
struct psinfo *psi,
gdouble x1,
gdouble x2,
gdouble y1,
gdouble row_height,
EWeekViewEvent *event,
EWeekViewEventSpan *span,
gchar *text,
gdouble red,
gdouble green,
gdouble blue)
{
struct tm date_tm;
gchar buffer[32];
date_tm.tm_year = 2001;
date_tm.tm_mon = 0;
date_tm.tm_mday = 1;
date_tm.tm_hour = event->start_minute / 60;
date_tm.tm_min = event->start_minute % 60;
date_tm.tm_sec = 0;
date_tm.tm_isdst = -1;
e_time_format_time (&date_tm, psi->use_24_hour_format, FALSE,
buffer, sizeof (buffer));
print_rectangle (context, x1 + 1, y1, x2 - x1 - 2, row_height, red, green, blue);
x1 += print_text_line (
context, font, buffer, PANGO_ALIGN_LEFT,
x1 + 2, x2 - 3, y1, y1 + row_height, TRUE) + 4;
if (psi->weeks_shown <= 2) {
date_tm.tm_hour = event->end_minute / 60;
date_tm.tm_min = event->end_minute % 60;
e_time_format_time (&date_tm, psi->use_24_hour_format, FALSE,
buffer, sizeof (buffer));
x1 += print_text_line (
context, font, buffer, PANGO_ALIGN_LEFT,
x1, x2 - 3, y1, y1 + row_height, TRUE) + 4;
}
print_text_line (
context, font, text, PANGO_ALIGN_LEFT,
x1, x2 - 3, y1, y1 + row_height, TRUE);
}
static void
print_week_event (GtkPrintContext *context,
PangoFontDescription *font,
struct psinfo *psi,
gdouble left,
gdouble top,
gdouble cell_width,
gdouble cell_height,
ECalModel *model,
EWeekViewEvent *event,
GArray *spans)
{
EWeekViewEventSpan *span;
gint span_num;
gchar *text;
gint num_days, start_x, start_y, start_h, end_x, end_y, end_h;
gdouble x1, x2, y1;
gdouble red, green, blue;
GdkPixbuf *pixbuf = NULL;
if (!is_comp_data_valid (event))
return;
text = get_summary_with_location (event->comp_data->icalcomp);
for (span_num = 0; span_num < event->num_spans; span_num++) {
span = &g_array_index (spans, EWeekViewEventSpan,
event->spans_index + span_num);
if (e_week_view_layout_get_span_position
(event, span,
psi->rows_per_cell,
psi->rows_per_compressed_cell,
psi->display_start_weekday,
psi->multi_week_view,
psi->compress_weekend,
&num_days)) {
e_week_view_layout_get_day_position
(span->start_day,
psi->multi_week_view,
psi->weeks_shown,
psi->display_start_weekday,
psi->compress_weekend,
&start_x, &start_y, &start_h);
if (num_days == 1) {
end_x = start_x;
end_y = start_y;
end_h = start_h;
} else {
e_week_view_layout_get_day_position
(span->start_day + num_days - 1,
psi->multi_week_view,
psi->weeks_shown,
psi->display_start_weekday,
psi->compress_weekend,
&end_x, &end_y, &end_h);
}
x1 = left + start_x * cell_width;
x2 = left + (end_x + 1) * cell_width;
y1 = top + start_y * cell_height
+ psi->header_row_height
+ span->row * (psi->row_height + 2);
red = .9;
green = .9;
blue = .9;
e_cal_model_get_rgb_color_for_component (
model, event->comp_data, &red, &green, &blue);
if (print_is_one_day_week_event (event, span,
psi->day_starts)) {
print_week_day_event (context, font, psi,
x1, x2, y1, psi->row_height,
event, span, text, red, green, blue);
} else {
print_week_long_event (context, font, psi,
x1, x2, y1, psi->row_height,
event, span, text, red, green, blue);
}
} else {
cairo_t *cr = gtk_print_context_get_cairo_context (context);
e_week_view_layout_get_day_position
(span->start_day,
psi->multi_week_view,
psi->weeks_shown,
psi->display_start_weekday,
psi->compress_weekend,
&start_x, &start_y, &start_h);
y1 = top + start_y * cell_height
+ psi->header_row_height
+ psi->rows_per_cell * (psi->row_height + 2);
if (span->row >= psi->rows_per_compressed_cell && psi->compress_weekend) {
gint end_day_of_week =
(psi->display_start_weekday +
span->start_day) % 7;
if (end_day_of_week == 5 || end_day_of_week == 6) {
/* Sat or Sun */
y1 = top + start_y * cell_height
+ psi->header_row_height
+ psi->rows_per_compressed_cell * (psi->row_height + 2);
}
}
if (!pixbuf) {
const gchar **xpm = (const gchar **) jump_xpm;
/* this ugly thing is here only to get rid of compiler warning
* about unused 'jump_xpm_focused' */
if (pixbuf)
xpm = (const gchar **) jump_xpm_focused;
pixbuf = gdk_pixbuf_new_from_xpm_data (xpm);
}
x1 = left + (start_x + 1) * cell_width - 6 -
gdk_pixbuf_get_width (pixbuf) * 0.5;
cairo_save (cr);
cairo_scale (cr, 0.5, 0.5);
gdk_cairo_set_source_pixbuf (cr, pixbuf, x1 * 2.0, y1 * 2.0);
cairo_paint (cr);
cairo_restore (cr);
}
}
if (pixbuf)
g_object_unref (pixbuf);
g_free (text);
}
static void
print_week_view_background (GtkPrintContext *context,
PangoFontDescription *font,
struct psinfo *psi,
gdouble left,
gdouble top,
gdouble cell_width,
gdouble cell_height)
{
struct tm tm;
gint day, day_x, day_y, day_h;
gdouble x1, x2, y1, y2, font_size, fillcolor;
const gchar *format_string;
gchar buffer[128];
cairo_t *cr;
font_size = get_font_size (font);
for (day = 0; day < psi->days_shown; day++) {
e_week_view_layout_get_day_position
(day, psi->multi_week_view, psi->weeks_shown,
psi->display_start_weekday, psi->compress_weekend,
&day_x, &day_y, &day_h);
x1 = left + day_x * cell_width;
x2 = left + (day_x + 1) * cell_width;
y1 = top + day_y * cell_height;
y2 = y1 + day_h * cell_height;
convert_timet_to_struct_tm (psi->day_starts[day], psi->zone, &tm);
/* In the month view we draw a grey background for the end
* of the previous month and the start of the following. */
fillcolor = -1.0;
if (psi->multi_week_view && (tm.tm_mon != psi->month))
fillcolor = 0.9;
print_border (context, x1, x2, y1, y2, 1.0, fillcolor);
if (psi->multi_week_view) {
if (tm.tm_mday == 1)
format_string = _("%d %B");
else
format_string = "%d";
} else {
cr = gtk_print_context_get_cairo_context (context);
cairo_move_to (cr, x1 + 0.1 * cell_width,
y1 + psi->header_row_height - 4);
cairo_line_to (cr, x2,
y1 + psi->header_row_height - 4);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_set_line_width (cr, 0.5);
cairo_stroke (cr);
/* strftime format %A = full weekday name, %d = day of
* month, %B = full month name. You can change the
* order but don't change the specifiers or add
* anything. */
format_string = _("%A %d %B");
}
e_utf8_strftime (buffer, sizeof (buffer), format_string, &tm);
print_text_line (context, font, buffer, PANGO_ALIGN_RIGHT,
x1, x2 - 4, y1 + 2, y1 + 2 + font_size, TRUE);
}
}
/* This adds one event to the view, adding it to the appropriate array. */
static gboolean
print_week_summary_cb (ECalComponent *comp,
time_t start,
time_t end,
gpointer data)
{
EWeekViewEvent event;
struct icaltimetype start_tt, end_tt;
ECalModelGenerateInstancesData *mdata = (ECalModelGenerateInstancesData *) data;
struct psinfo *psi = (struct psinfo *) mdata->cb_data;
/* Check that the event times are valid. */
#if 0
g_print ("View start:%li end:%li Event start:%li end:%li\n",
psi->day_starts[0], psi->day_starts[psi->days_shown],
start, end);
#endif
g_return_val_if_fail (start <= end, TRUE);
g_return_val_if_fail (start < psi->day_starts[psi->days_shown], TRUE);
g_return_val_if_fail (end > psi->day_starts[0], TRUE);
start_tt = icaltime_from_timet_with_zone (start, FALSE, psi->zone);
end_tt = icaltime_from_timet_with_zone (end, FALSE, psi->zone);
event.comp_data = g_object_ref (mdata->comp_data);
event.start = start;
event.end = end;
event.spans_index = 0;
event.num_spans = 0;
event.start_minute = start_tt.hour * 60 + start_tt.minute;
event.end_minute = end_tt.hour * 60 + end_tt.minute;
if (event.end_minute == 0 && start != end)
event.end_minute = 24 * 60;
g_array_append_val (psi->events, event);
return TRUE;
}
static void
print_week_summary (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t whence,
gboolean multi_week_view,
gint weeks_shown,
gint month,
gdouble font_size,
gdouble font_size_background,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
icaltimezone *zone;
EWeekViewEvent *event;
struct psinfo psi = { 0 };
time_t day_start;
gint rows_per_day[E_WEEK_VIEW_MAX_WEEKS * 7], day, event_num;
GArray *spans;
PangoFontDescription *font, *font_background;
gdouble cell_width, cell_height;
ECalModel *model;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
psi.days_shown = weeks_shown * 7;
psi.events = g_array_new (FALSE, FALSE, sizeof (EWeekViewEvent));
psi.multi_week_view = multi_week_view;
psi.weeks_shown = weeks_shown;
psi.month = month;
psi.zone = zone;
/* Get a few config settings. */
if (multi_week_view)
psi.compress_weekend = e_cal_model_get_compress_weekend (model);
else
psi.compress_weekend = TRUE;
psi.use_24_hour_format = e_cal_model_get_use_24_hour_format (model);
/* We convert this from (0 = Sun, 6 = Sat) to (0 = Mon, 6 = Sun). */
psi.display_start_weekday = e_cal_model_get_week_start_day (model);
psi.display_start_weekday = (psi.display_start_weekday + 6) % 7;
/* If weekends are compressed then we can't start on a Sunday. */
if (psi.compress_weekend && psi.display_start_weekday == 6)
psi.display_start_weekday = 5;
day_start = time_day_begin_with_zone (whence, zone);
for (day = 0; day <= psi.days_shown; day++) {
psi.day_starts[day] = day_start;
day_start = time_add_day_with_zone (day_start, 1, zone);
}
/* Get the events from the server. */
e_cal_model_generate_instances_sync (model,
psi.day_starts[0], psi.day_starts[psi.days_shown],
print_week_summary_cb, &psi);
qsort (psi.events->data, psi.events->len,
sizeof (EWeekViewEvent), e_week_view_event_sort_func);
/* Layout the events. */
spans = e_week_view_layout_events (psi.events, NULL,
psi.multi_week_view,
psi.weeks_shown,
psi.compress_weekend,
psi.display_start_weekday,
psi.day_starts, rows_per_day);
/* Calculate the size of the cells. */
if (multi_week_view) {
cell_width = (right - left) / (psi.compress_weekend ? 6 : 7);
cell_height = (bottom - top) / (weeks_shown * 2);
} else {
cell_width = (right - left) / 2;
cell_height = (bottom - top) / 6;
}
/* Calculate the row height, using the normal font and with room for
* space or a rectangle around it. */
psi.row_height = font_size * 1.2;
psi.header_row_height = font_size * 1.5;
/* Calculate how many rows we can fit into each type of cell. */
psi.rows_per_cell = ((cell_height * 2) - psi.header_row_height)
/ (psi.row_height + 2);
psi.rows_per_compressed_cell = (cell_height - psi.header_row_height)
/ (psi.row_height + 2);
/* Draw the grid and the day names/numbers. */
font_background = get_font_for_size (font_size_background, PANGO_WEIGHT_NORMAL);
print_week_view_background (context, font_background, &psi, left, top,
cell_width, cell_height);
pango_font_description_free (font_background);
/* Print the events. */
font = get_font_for_size (font_size, PANGO_WEIGHT_NORMAL);
for (event_num = 0; event_num < psi.events->len; event_num++) {
event = &g_array_index (psi.events, EWeekViewEvent, event_num);
print_week_event (context, font, &psi, left, top,
cell_width, cell_height, model, event, spans);
}
pango_font_description_free (font);
/* Free everything. */
for (event_num = 0; event_num < psi.events->len; event_num++) {
event = &g_array_index (psi.events, EWeekViewEvent, event_num);
g_object_unref (event->comp_data);
}
g_array_free (psi.events, TRUE);
g_array_free (spans, TRUE);
}
static void
print_month_summary (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t whence,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
icaltimezone *zone;
time_t date;
struct tm tm;
struct icaltimetype tt;
gchar buffer[100];
ECalModel *model;
PangoFontDescription *font;
gboolean compress_weekend;
gint columns, col, weekday, month, weeks;
gdouble font_size, cell_width, x1, x2, y1, y2;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
weekday = e_cal_model_get_week_start_day (model);
compress_weekend = e_cal_model_get_compress_weekend (model);
date = 0;
weeks = 6;
if (gnome_calendar_get_view (gcal) == GNOME_CAL_MONTH_VIEW) {
GnomeCalendarViewType view_type;
ECalendarView *calendar_view;
EWeekView *week_view;
view_type = gnome_calendar_get_view (gcal);
calendar_view = gnome_calendar_get_calendar_view (gcal, view_type);
week_view = E_WEEK_VIEW (calendar_view);
if (week_view && week_view->multi_week_view
&& !(week_view->weeks_shown >= 4 &&
g_date_valid (&week_view->first_day_shown))) {
weeks = week_view->weeks_shown;
date = whence;
}
}
/* Remember which month we want. */
tt = icaltime_from_timet_with_zone (whence, FALSE, zone);
month = tt.month - 1;
/* Find the start of the month, and then the start of the week on
* or before that day. */
if (!date)
date = time_month_begin_with_zone (whence, zone);
date = time_week_begin_with_zone (date, weekday, zone);
/* If weekends are compressed then we can't start on a Sunday. */
if (compress_weekend && weekday == 0)
date = time_add_day_with_zone (date, -1, zone);
/* do day names ... */
/* We are only interested in outputting the weekday here, but we want
* to be able to step through the week without worrying about
* overflows making strftime choke, so we move near to the start of
* the month. */
convert_timet_to_struct_tm (date, zone, &tm);
tm.tm_mday = (tm.tm_mday % 7) + 7;
font = get_font_for_size (MONTH_NORMAL_FONT_SIZE, PANGO_WEIGHT_BOLD);
font_size = get_font_size (font);
columns = compress_weekend ? 6 : 7;
cell_width = (right - left) / columns;
y1 = top;
y2 = top + font_size * 1.5;
for (col = 0; col < columns; col++) {
if (tm.tm_wday == 6 && compress_weekend)
g_snprintf (
buffer, sizeof (buffer), "%s/%s",
e_get_weekday_name (G_DATE_SATURDAY, TRUE),
e_get_weekday_name (G_DATE_SUNDAY, TRUE));
else
g_snprintf (
buffer, sizeof (buffer), "%s",
e_get_weekday_name (
tm.tm_wday ? tm.tm_wday : 7, FALSE));
x1 = left + cell_width * col;
x2 = x1 + cell_width;
print_border (context, x1, x2, y1, y2, 1.0, -1.0);
print_text_line (context, font, buffer, PANGO_ALIGN_CENTER, x1, x2, y1, y2, TRUE);
tm.tm_mday++;
tm.tm_wday = (tm.tm_wday + 1) % 7;
}
pango_font_description_free (font);
top = y2;
print_week_summary (context, gcal, date, TRUE, weeks, month,
MONTH_NORMAL_FONT_SIZE, MONTH_NORMAL_FONT_SIZE,
left, right, top, bottom);
}
static void
print_todo_details (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t start,
time_t end,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
PangoFontDescription *font_summary;
gdouble y, yend, x, xend;
struct icaltimetype *tt;
GtkWidget *task_table;
ETable *table;
ECalModel *model;
gint rows, row;
cairo_t *cr;
/* We get the tasks directly from the TaskPad ETable. This means we
* get them filtered & sorted for free. */
task_table = gnome_calendar_get_task_table (gcal);
table = E_TABLE (task_table);
g_return_if_fail (table != NULL);
model = e_task_table_get_model (E_TASK_TABLE (task_table));
font_summary = get_font_for_size (12, PANGO_WEIGHT_NORMAL);
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_set_line_width (cr, 0.0);
top +=2;
titled_box (context, _("Tasks"), font_summary, PANGO_ALIGN_CENTER,
&left, &top, &right, &bottom, 1.0);
y = top;
yend = bottom - 2;
rows = e_table_model_row_count (E_TABLE_MODEL (model));
for (row = 0; row < rows; row++) {
ECalModelComponent *comp_data;
ECalComponent *comp;
ECalComponentText summary;
gint model_row;
model_row = e_table_view_to_model_row (table, row);
comp_data = e_cal_model_get_component_at (model, model_row);
if (!comp_data)
continue;
comp = e_cal_component_new ();
e_cal_component_set_icalcomponent (
comp, icalcomponent_new_clone (comp_data->icalcomp));
e_cal_component_get_summary (comp, &summary);
if (!summary.value) {
g_object_unref (comp);
continue;
}
x = left;
xend = right - 2;
if (y > bottom) {
g_object_unref (comp);
break;
}
/* Print the box to put the tick in. */
print_border (context, x + 2, x + 8, y + 6, y + 15, 0.1, -1.0);
/* If the task is complete, print a tick in the box. */
e_cal_component_get_completed (comp, &tt);
if (tt) {
e_cal_component_free_icaltimetype (tt);
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
cairo_move_to (cr, x + 3, y + 11);
cairo_line_to (cr, x + 5, y + 14);
cairo_line_to (cr, x + 7, y + 5.5);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
}
y = bound_text (context, font_summary, summary.value, -1,
x + 14, y + 4, xend, yend, FALSE, NULL, NULL);
y += get_font_size (font_summary) - 5;
cr = gtk_print_context_get_cairo_context (context);
cairo_move_to (cr, x, y);
cairo_line_to (cr, xend, y);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
g_object_unref (comp);
}
pango_font_description_free (font_summary);
}
static void
print_day_view (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t date)
{
ECalModel *model;
GtkPageSetup *setup;
icaltimezone *zone;
gint i, days = 1;
gdouble todo, l, week_numbers_inc, small_month_width;
gchar buf[100];
gdouble width, height;
struct tm tm;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
setup = gtk_print_context_get_page_setup (context);
width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS);
small_month_width = calc_small_month_width (context, HEADER_HEIGHT);
week_numbers_inc = get_show_week_numbers () ? small_month_width / 7.0 : 0;
for (i = 0; i < days; i++) {
todo = width * 0.75;
/* Print the main view with all the events in. */
print_day_details (context, gcal, date,
0.0, todo - 2.0, HEADER_HEIGHT + 4,
height);
/* Print the TaskPad down the right. */
print_todo_details (context, gcal, 0, INT_MAX,
todo, width, HEADER_HEIGHT + 4,
height);
/* Print the filled border around the header. */
print_border (context, 0.0, width,
0.0, HEADER_HEIGHT + 4, 1.0, 0.9);
/* Print the 2 mini calendar-months. */
l = width - SMALL_MONTH_PAD -
(small_month_width + week_numbers_inc) * 2 -
SMALL_MONTH_SPACING;
print_month_small (context, gcal, date,
l, 2, l + small_month_width + week_numbers_inc, HEADER_HEIGHT + 2,
DATE_MONTH | DATE_YEAR, date, date, FALSE);
l += SMALL_MONTH_SPACING + small_month_width + week_numbers_inc;
print_month_small (context, gcal,
time_add_month_with_zone (date, 1, zone),
l, 2, l + small_month_width + week_numbers_inc, HEADER_HEIGHT + 2,
DATE_MONTH | DATE_YEAR, 0, 0, FALSE);
/* Print the date, e.g. '8th May, 2001'. */
convert_timet_to_struct_tm (date, zone, &tm);
format_date (&tm, DATE_DAY | DATE_MONTH | DATE_YEAR,
buf, 100);
print_text_size_bold (context, buf, PANGO_ALIGN_LEFT,
4, todo, 4,
4 + 24);
/* Print the day, e.g. 'Tuesday'. */
format_date (&tm, DATE_DAYNAME, buf, 100);
print_text_size_bold (context, buf, PANGO_ALIGN_LEFT,
4, todo,
HEADER_HEIGHT + 9,
HEADER_HEIGHT + 9 + 18);
date = time_add_day_with_zone (date, 1, zone);
}
}
static void
print_work_week_background (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t whence,
struct pdinfo *pdi,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
ECalModel *model;
PangoFontDescription *font_hour, *font_minute;
gdouble yinc, y;
gdouble width = DAY_VIEW_TIME_COLUMN_WIDTH;
gdouble day_width;
gdouble font_size, max_font_size, hour_font_size, minute_font_size;
gchar buf[20];
const gchar *minute;
const gint LONG_EVENT_OFFSET = 6;
gboolean use_24_hour;
gint i, hour, row;
gdouble hour_minute_xl, hour_minute_xr;
cairo_t *cr;
model = gnome_calendar_get_model (gcal);
use_24_hour = e_cal_model_get_use_24_hour_format (model);
/* Fill the left time column in light-gray. */
print_border (context, left, left + width, top, bottom, -1.0, 0.9);
/* Fill the right time column in light-gray */
print_border (context, right - width, right, top, bottom, -1.0, 0.9);
/* Draw the border around the entire view. */
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
print_border (context, left, right, top, bottom, 1.0, -1.0);
/* Draw the vertical line on the right of the time column. */
cr = gtk_print_context_get_cairo_context (context);
cairo_set_line_width (cr, 0.0);
cairo_move_to (cr, left + width, bottom);
cairo_line_to (cr, left + width, top);
cairo_stroke (cr);
cairo_move_to (cr, right - width, bottom);
cairo_line_to (cr, right - width, top);
cairo_stroke (cr);
/* Calculate the row height. */
if (top > bottom)
yinc = (top - bottom) / (pdi->end_hour - pdi->start_hour);
else
yinc = (bottom - top) / (pdi->end_hour - pdi->start_hour);
/* Get the 2 fonts we need. */
font_size = yinc * 0.6;
max_font_size = width * 0.45;
hour_font_size = MIN (font_size, max_font_size);
font_hour = get_font_for_size (hour_font_size, PANGO_WEIGHT_BOLD);
font_size = yinc * 0.33;
max_font_size = width * 0.2;
minute_font_size = MIN (font_size, max_font_size);
font_minute = get_font_for_size (minute_font_size, PANGO_WEIGHT_BOLD);
hour_minute_xr = evo_calendar_print_renderer_get_width (
context, font_minute, use_24_hour ? "00" : _("am"));
if (!use_24_hour)
hour_minute_xr =
MAX (hour_minute_xr,
evo_calendar_print_renderer_get_width (
context, font_minute, _("pm")));
row = 0;
hour_minute_xl = left + width - hour_minute_xr - 3;
hour_minute_xr = right - hour_minute_xr - 3;
for (i = pdi->start_hour; i < pdi->end_hour; i++) {
y = top + yinc * (row + 1);
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
if (use_24_hour) {
hour = i;
minute = "00";
} else {
if (i < 12)
minute = _("am");
else
minute = _("pm");
hour = i % 12;
if (hour == 0)
hour = 12;
}
/* the hour label/minute */
sprintf (buf, "%d", hour);
print_text (context, font_hour, buf, PANGO_ALIGN_RIGHT,
left, hour_minute_xl,
y - yinc, y - yinc + hour_font_size);
print_text (context, font_minute, minute, PANGO_ALIGN_LEFT,
hour_minute_xl, left + width - 3,
y - yinc, y - yinc + minute_font_size);
/* To the right */
print_text (context, font_hour, buf, PANGO_ALIGN_RIGHT,
right - width, hour_minute_xr,
y - yinc, y - yinc + hour_font_size);
print_text (context, font_minute, minute, PANGO_ALIGN_LEFT,
hour_minute_xr, right - 3,
y - yinc, y - yinc + minute_font_size);
/* Draw the horizontal line between hours, across the entire
width of the day view. */
cr = gtk_print_context_get_cairo_context (context);
cairo_move_to (cr, left, y);
cairo_line_to (cr, right, y);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
/* Draw the horizontal line for the 1/2-hours, across the
* entire width except for part of the time column. */
cairo_move_to (cr, left + width * 0.6, y - yinc / 2);
cairo_line_to (cr, right, y - yinc / 2);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
row++;
}
/* Draw the vertical lines for the days */
day_width = (right - left - 2 *width) / pdi->days_shown;
for (i = 0; i < pdi->days_shown - 1; ++i) {
cr = gtk_print_context_get_cairo_context (context);
cairo_move_to (cr, left + width + day_width * (i + 1), top);
cairo_line_to (cr, left + width + day_width * (i + 1), bottom);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
}
/* And now the ones from the border to the hours, looks weird otherwise */
cr = gtk_print_context_get_cairo_context (context);
cairo_move_to (cr, left, HEADER_HEIGHT);
cairo_line_to (cr, left, HEADER_HEIGHT + DAY_VIEW_ROW_HEIGHT + LONG_EVENT_OFFSET);
cairo_move_to (cr, right, HEADER_HEIGHT);
cairo_line_to (cr, right, HEADER_HEIGHT + DAY_VIEW_ROW_HEIGHT + LONG_EVENT_OFFSET);
cairo_stroke (cr);
pango_font_description_free (font_hour);
pango_font_description_free (font_minute);
}
static void
print_work_week_day_details (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t whence,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom,
struct pdinfo *_pdi)
{
ECalModel *model;
icaltimezone *zone;
EDayViewEvent *event;
PangoFontDescription *font;
time_t start, end;
struct pdinfo pdi = { 0 };
gint rows_in_top_display, i, rows_with_30_mins;
gdouble font_size, max_font_size;
cairo_t *cr;
GdkPixbuf *pixbuf = NULL;
#define LONG_DAY_EVENTS_TOP_SPACING 4
#define LONG_DAY_EVENTS_BOTTOM_SPACING 2
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
start = time_day_begin_with_zone (whence, zone);
end = time_day_end_with_zone (start, zone);
pdi.days_shown = 1;
pdi.day_starts[0] = start;
pdi.day_starts[1] = end;
pdi.long_events = g_array_new (FALSE, FALSE, sizeof (EDayViewEvent));
pdi.events[0] = g_array_new (FALSE, FALSE, sizeof (EDayViewEvent));
pdi.start_hour = e_cal_model_get_work_day_start_hour (model);
pdi.end_hour = e_cal_model_get_work_day_end_hour (model);
if (e_cal_model_get_work_day_end_minute (model) != 0)
pdi.end_hour++;
pdi.mins_per_row = get_day_view_time_divisions ();
pdi.rows = (pdi.end_hour - pdi.start_hour) * (60 / pdi.mins_per_row);
pdi.start_minute_offset = pdi.start_hour * 60;
pdi.end_minute_offset = pdi.end_hour * 60;
pdi.use_24_hour_format = e_cal_model_get_use_24_hour_format (model);
pdi.zone = e_cal_model_get_timezone (model);
/* Get the events from the server. */
e_cal_model_generate_instances_sync (model, start, end, print_day_details_cb, &pdi);
qsort (pdi.long_events->data, pdi.long_events->len,
sizeof (EDayViewEvent), e_day_view_event_sort_func);
qsort (pdi.events[0]->data, pdi.events[0]->len,
sizeof (EDayViewEvent), e_day_view_event_sort_func);
pdi.start_hour = MIN (pdi.start_hour, _pdi->start_hour);
pdi.end_hour = MAX (pdi.end_hour, _pdi->end_hour);
/* TODO: This should be redundant */
/* Also print events outside of work hours */
if (pdi.events[0]->len > 0) {
struct icaltimetype tt;
event = &g_array_index (pdi.events[0], EDayViewEvent, 0);
tt = icaltime_from_timet_with_zone (event->start, FALSE, zone);
if (tt.hour < pdi.start_hour)
pdi.start_hour = tt.hour;
pdi.start_minute_offset = pdi.start_hour * 60;
event = &g_array_index (pdi.events[0], EDayViewEvent, pdi.events[0]->len - 1);
tt = icaltime_from_timet_with_zone (event->end, FALSE, zone);
if (tt.hour > pdi.end_hour || tt.hour == 0) {
pdi.end_hour = tt.hour ? tt.hour : 24;
if (tt.minute > 0)
pdi.end_hour++;
}
pdi.end_minute_offset = pdi.end_hour * 60;
pdi.rows = (pdi.end_hour - pdi.start_hour) * (60 / pdi.mins_per_row);
}
/* Lay them out the long events, across the top of the page. */
e_day_view_layout_long_events (pdi.long_events, pdi.days_shown,
pdi.day_starts, &rows_in_top_display);
/*Print the long events. */
font = get_font_for_size (12, PANGO_WEIGHT_NORMAL);
/* We always leave space for DAY_VIEW_MIN_ROWS_IN_TOP_DISPLAY in the
* top display, but we may have more rows than that, in which case
* the main display area will be compressed. */
/* Limit long day event to half the height of the panel */
rows_in_top_display = MIN (MAX (rows_in_top_display,
DAY_VIEW_MIN_ROWS_IN_TOP_DISPLAY),
(bottom - top) * 0.5 / DAY_VIEW_ROW_HEIGHT);
if (rows_in_top_display > pdi.long_events->len)
rows_in_top_display = pdi.long_events->len;
for (i = 0; i < rows_in_top_display && i < pdi.long_events->len; i++) {
event = &g_array_index (pdi.long_events, EDayViewEvent, i);
print_day_long_event (
context, font, left, right,
top + LONG_DAY_EVENTS_TOP_SPACING, bottom,
DAY_VIEW_ROW_HEIGHT, event, &pdi, model);
}
if (rows_in_top_display < pdi.long_events->len) {
/* too many events */
cairo_t *cr = gtk_print_context_get_cairo_context (context);
gint x, y;
if (!pixbuf) {
const gchar **xpm = (const gchar **) jump_xpm;
/* this ugly thing is here only to get rid of compiler warning
* about unused 'jump_xpm_focused' */
if (pixbuf)
xpm = (const gchar **) jump_xpm_focused;
pixbuf = gdk_pixbuf_new_from_xpm_data (xpm);
}
/* Right align - 10 comes from print_day_long_event too */
x = right - gdk_pixbuf_get_width (pixbuf) * 0.5 - 10;
/* Placing '...' over the last all day event entry printed. '-1 -1' comes
from print_long_day_event (top / bottom spacing in each cell) */
y = top + LONG_DAY_EVENTS_TOP_SPACING
+ DAY_VIEW_ROW_HEIGHT * (i - 1)
+ (DAY_VIEW_ROW_HEIGHT - 1 - 1) * 0.5;
cairo_save (cr);
cairo_scale (cr, 0.5, 0.5);
gdk_cairo_set_source_pixbuf (cr, pixbuf, x * 2.0, y * 2.0);
cairo_paint (cr);
cairo_restore (cr);
}
if (!rows_in_top_display)
rows_in_top_display++;
/* Draw the border around the long events. */
cr = gtk_print_context_get_cairo_context (context);
cairo_set_source_rgb (cr, 0, 0, 0);
print_border (
context, left, right,
top, top + rows_in_top_display * DAY_VIEW_ROW_HEIGHT +
LONG_DAY_EVENTS_TOP_SPACING + LONG_DAY_EVENTS_BOTTOM_SPACING,
1.0, -1.0);
/* Adjust the area containing the main display. */
top += rows_in_top_display * DAY_VIEW_ROW_HEIGHT
+ LONG_DAY_EVENTS_TOP_SPACING
+ LONG_DAY_EVENTS_BOTTOM_SPACING;
/* lay out the short events, within the day. */
e_day_view_layout_day_events (pdi.events[0], CALC_DAY_VIEW_ROWS (pdi.mins_per_row),
pdi.mins_per_row, pdi.cols_per_row, -1);
/* use font like with 30 minutes time division */
rows_with_30_mins = (pdi.end_hour - pdi.start_hour) * (60 / 30);
/* print the short events. */
if (top > bottom )
max_font_size = ((top - bottom) / rows_with_30_mins) - 4;
else
max_font_size = ((bottom - top ) / rows_with_30_mins) - 4;
font_size = MIN (DAY_NORMAL_FONT_SIZE, max_font_size);
font = get_font_for_size (font_size, PANGO_WEIGHT_NORMAL);
for (i = 0; i < pdi.events[0]->len; i++) {
event = &g_array_index (pdi.events[0], EDayViewEvent, i);
print_day_event (context, font, left,
right, top, bottom, event, &pdi, model);
}
/* Free everything. */
if (pixbuf)
g_object_unref (pixbuf);
free_event_array (pdi.long_events);
pango_font_description_free (font);
g_array_free (pdi.long_events, TRUE);
free_event_array (pdi.events[0]);
g_array_free (pdi.events[0], TRUE);
}
/* Figure out what the overal hour limits are */
static gboolean
print_work_week_view_cb (ECalComponent *comp,
time_t istart,
time_t iend,
gpointer data)
{
ECalModelGenerateInstancesData *mdata = (ECalModelGenerateInstancesData *) data;
struct pdinfo *pdi = (struct pdinfo *) mdata->cb_data;
struct icaltimetype tt;
tt = icaltime_from_timet_with_zone (istart, FALSE, pdi->zone);
pdi->start_hour = MIN (pdi->start_hour, tt.hour);
tt = icaltime_from_timet_with_zone (iend, FALSE, pdi->zone);
/* If we're past the hour, use the next one */
pdi->end_hour = MAX (pdi->end_hour, tt.minute ? tt.hour + 1 : tt.hour);
return TRUE;
}
static void
print_work_week_view (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t date)
{
GtkPageSetup *setup;
icaltimezone *zone;
time_t when, start, end;
gdouble width, height, l;
gdouble small_month_width;
gdouble weeknum_inc;
gint i, days = 5;
gchar buf[100];
const gint LONG_EVENT_OFFSET = 6;
struct pdinfo pdi = { 0 };
struct tm tm;
gdouble day_width, day_x;
ECalModel *model;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
setup = gtk_print_context_get_page_setup (context);
width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS);
small_month_width = calc_small_month_width (context, HEADER_HEIGHT);
weeknum_inc = get_show_week_numbers () ? small_month_width / 7.0 : 0;
/* We always start on a Monday */
start = time_week_begin_with_zone (date, 1, zone);
end = time_add_day_with_zone (start, days, zone);
pdi.days_shown = days;
pdi.start_hour = e_cal_model_get_work_day_start_hour (model);
pdi.end_hour = e_cal_model_get_work_day_end_hour (model);
pdi.zone = zone;
e_cal_model_generate_instances_sync (model, start, end, print_work_week_view_cb, &pdi);
print_work_week_background (context, gcal, date, &pdi, 0.0, width,
HEADER_HEIGHT + DAY_VIEW_ROW_HEIGHT + LONG_EVENT_OFFSET,
height);
print_border (context, 0.0, width, 0.0, HEADER_HEIGHT, 1.0, 0.9);
/* Print the 2 mini calendar-months. */
l = width - SMALL_MONTH_PAD - (small_month_width + weeknum_inc) * 2 -
SMALL_MONTH_SPACING;
print_month_small (context, gcal, start,
l, 4, l + small_month_width + weeknum_inc, HEADER_HEIGHT + 4,
DATE_MONTH | DATE_YEAR, start, end, FALSE);
l += SMALL_MONTH_SPACING + small_month_width + weeknum_inc;
print_month_small (context, gcal,
time_add_month_with_zone (start, 1, zone),
l, 4, l + small_month_width + weeknum_inc, HEADER_HEIGHT + 4,
DATE_MONTH | DATE_YEAR, 0, 0, FALSE);
/* Print the start day of the week, e.g. '7th May 2001'. */
convert_timet_to_struct_tm (start, zone, &tm);
format_date (&tm, DATE_DAY | DATE_MONTH | DATE_YEAR, buf, 100);
print_text_size_bold (context, buf, PANGO_ALIGN_LEFT,
3, width,
4, 4 + 24);
/* Print the end day of the week, e.g. '13th May 2001'. */
/* We need to substract one or the wrong day will be printed */
convert_timet_to_struct_tm (
time_add_day_with_zone (end, -1, zone), zone, &tm);
format_date (&tm, DATE_DAY | DATE_MONTH | DATE_YEAR, buf, 100);
print_text_size_bold (context, buf, PANGO_ALIGN_LEFT,
3, width,
24 + 3, 24 + 3 + 24);
/* Now print each days' events */
day_width = (width - 2 *DAY_VIEW_TIME_COLUMN_WIDTH) / days;
when = start;
for (i = 0; i < days; ++i) {
day_x = DAY_VIEW_TIME_COLUMN_WIDTH + day_width * i;
/* Print the day, e.g. 'Tuesday'. */
convert_timet_to_struct_tm (when, zone, &tm);
format_date (&tm, DATE_DAYNAME, buf, 100);
print_text_size_bold (context, buf, PANGO_ALIGN_LEFT,
day_x + 4, day_x + day_width,
HEADER_HEIGHT + 4, HEADER_HEIGHT + 4 + 18);
print_work_week_day_details (context, gcal, when,
day_x, day_x + day_width,
HEADER_HEIGHT, height, &pdi);
when = time_add_day_with_zone (when, 1, zone);
}
}
static void
print_week_view (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t date)
{
GtkPageSetup *setup;
ECalModel *model;
icaltimezone *zone;
gdouble l, week_numbers_inc, small_month_width;
gchar buf[100];
time_t when;
gint week_start_day;
struct tm tm;
gdouble width, height;
setup = gtk_print_context_get_page_setup (context);
width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS);
small_month_width = calc_small_month_width (context, HEADER_HEIGHT);
week_numbers_inc = get_show_week_numbers () ? small_month_width / 7.0 : 0;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
convert_timet_to_struct_tm (date, zone, &tm);
week_start_day = e_cal_model_get_week_start_day (model);
when = time_week_begin_with_zone (date, week_start_day, zone);
/* If the week starts on a Sunday, we have to show the Saturday first,
* since the weekend is compressed. */
if (week_start_day == 0) {
if (tm.tm_wday == 6)
when = time_add_day_with_zone (when, 6, zone);
else
when = time_add_day_with_zone (when, -1, zone);
}
/* Print the main week view. */
print_week_summary (context, gcal, when, FALSE, 1, 0,
WEEK_EVENT_FONT_SIZE, WEEK_SMALL_FONT_SIZE,
0.0, width,
HEADER_HEIGHT + 20, height);
/* Print the border around the main view. */
print_border (context, 0.0, width, HEADER_HEIGHT ,
height, 1.0, -1.0);
/* Print the border around the header area. */
print_border (context, 0.0, width,
0.0, HEADER_HEIGHT + 2.0 + 20, 1.0, 0.9);
/* Print the 2 mini calendar-months. */
l = width - SMALL_MONTH_PAD - (small_month_width + week_numbers_inc) * 2
- SMALL_MONTH_SPACING;
print_month_small (context, gcal, when,
l, 4, l + small_month_width + week_numbers_inc, HEADER_HEIGHT + 10,
DATE_MONTH | DATE_YEAR, when,
time_add_week_with_zone (when, 1, zone), FALSE);
l += SMALL_MONTH_SPACING + small_month_width + week_numbers_inc;
print_month_small (context, gcal,
time_add_month_with_zone (when, 1, zone),
l, 4, l + small_month_width + week_numbers_inc, HEADER_HEIGHT + 10,
DATE_MONTH | DATE_YEAR, when,
time_add_week_with_zone (when, 1, zone), FALSE);
/* Print the start day of the week, e.g. '7th May 2001'. */
convert_timet_to_struct_tm (when, zone, &tm);
format_date (&tm, DATE_DAY | DATE_MONTH | DATE_YEAR, buf, 100);
print_text_abs_bold (context, buf, WEEK_NORMAL_FONT_SIZE, PANGO_ALIGN_LEFT,
3, width, 4, 4 + 24);
/* Print the end day of the week, e.g. '13th May 2001'. */
when = time_add_day_with_zone (when, 6, zone);
convert_timet_to_struct_tm (when, zone, &tm);
format_date (&tm, DATE_DAY | DATE_MONTH | DATE_YEAR, buf, 100);
print_text_abs_bold (context, buf, WEEK_NORMAL_FONT_SIZE, PANGO_ALIGN_LEFT,
3, width, 24 + 3, 24 + 3 + 24);
}
static void
print_month_view (GtkPrintContext *context,
GnomeCalendar *gcal,
time_t date)
{
ECalModel *model;
GtkPageSetup *setup;
icaltimezone *zone;
gchar buf[100];
gdouble width, height;
gdouble l, week_numbers_inc, small_month_width;
struct tm tm;
model = gnome_calendar_get_model (gcal);
zone = e_cal_model_get_timezone (model);
setup = gtk_print_context_get_page_setup (context);
width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS);
small_month_width = calc_small_month_width (context, HEADER_HEIGHT);
week_numbers_inc = get_show_week_numbers () ? small_month_width / 7.0 : 0;
/* Print the main month view. */
print_month_summary (context, gcal, date, 0.0, width, HEADER_HEIGHT, height);
/* Print the border around the header. */
print_border (context, 0.0, width, 0.0, HEADER_HEIGHT + 10, 1.0, 0.9);
l = width - SMALL_MONTH_PAD - small_month_width - week_numbers_inc;
/* Print the 2 mini calendar-months. */
print_month_small (context, gcal,
time_add_month_with_zone (date, 1, zone),
l, 4, l + small_month_width + week_numbers_inc, HEADER_HEIGHT + 4,
DATE_MONTH | DATE_YEAR, 0, 0, FALSE);
print_month_small (context, gcal,
time_add_month_with_zone (date, -1, zone),
SMALL_MONTH_PAD, 4, SMALL_MONTH_PAD + small_month_width + week_numbers_inc, HEADER_HEIGHT + 4,
DATE_MONTH | DATE_YEAR, 0, 0, FALSE);
/* Print the month, e.g. 'May 2001'. */
convert_timet_to_struct_tm (date, zone, &tm);
format_date (&tm, DATE_MONTH | DATE_YEAR, buf, 100);
print_text_size_bold (context, buf, PANGO_ALIGN_CENTER,
3, width - 3,
3, 3 + 24);
}
static gboolean
same_date (struct tm tm1,
time_t t2,
icaltimezone *zone)
{
struct tm tm2;
convert_timet_to_struct_tm (t2, zone, &tm2);
return
tm1.tm_mday == tm2.tm_mday &&
tm1.tm_mon == tm2.tm_mon &&
tm1.tm_year == tm2.tm_year;
}
static void
write_label_piece (time_t t,
time_t *start_cmp,
icaltimezone *zone,
gboolean use_24_hour_format,
gchar *buffer,
gint size,
gchar *stext,
const gchar *etext)
{
struct tm tmp_tm;
gint len;
convert_timet_to_struct_tm (t, zone, &tmp_tm);
if (stext != NULL)
strcat (buffer, stext);
len = strlen (buffer);
if (start_cmp && same_date (tmp_tm, *start_cmp, zone))
e_time_format_time (
&tmp_tm, use_24_hour_format,
FALSE, &buffer[len], size - len);
else
e_time_format_date_and_time (
&tmp_tm, use_24_hour_format, FALSE,
FALSE, &buffer[len], size - len);
if (etext != NULL)
strcat (buffer, etext);
}
static icaltimezone *
get_zone_from_tzid (ECalClient *client,
const gchar *tzid)
{
icaltimezone *zone;
/* Note that the timezones may not be on the server, so we try to get
* the builtin timezone with the TZID first. */
zone = icaltimezone_get_builtin_timezone_from_tzid (tzid);
if (!zone && tzid) {
GError *error = NULL;
if (!e_cal_client_get_timezone_sync (client, tzid, &zone, NULL, &error)) {
g_warning ("Couldn't get timezone '%s' from server: %s",
tzid ? tzid : "", error ? error->message : "Unknown error");
if (error)
g_error_free (error);
}
}
return zone;
}
static void
print_date_label (GtkPrintContext *context,
ECalComponent *comp,
ECalClient *client,
icaltimezone *zone,
gboolean use_24_hour_format,
gdouble left,
gdouble right,
gdouble top,
gdouble bottom)
{
icaltimezone *start_zone, *end_zone, *due_zone, *completed_zone;
ECalComponentDateTime datetime;
time_t start = 0, end = 0, complete = 0, due = 0;
static gchar buffer[1024];
e_cal_component_get_dtstart (comp, &datetime);
if (datetime.value) {
start_zone = get_zone_from_tzid (client, datetime.tzid);
if (!start_zone || datetime.value->is_date)
start_zone = zone;
start = icaltime_as_timet_with_zone (*datetime.value,
start_zone);
}
e_cal_component_free_datetime (&datetime);
e_cal_component_get_dtend (comp, &datetime);
if (datetime.value) {
end_zone = get_zone_from_tzid (client, datetime.tzid);
if (!end_zone || datetime.value->is_date)
end_zone = zone;
end = icaltime_as_timet_with_zone (*datetime.value,
end_zone);
}
e_cal_component_free_datetime (&datetime);
e_cal_component_get_due (comp, &datetime);
if (datetime.value) {
due_zone = get_zone_from_tzid (client, datetime.tzid);
if (!due_zone || datetime.value->is_date)
due_zone = zone;
due = icaltime_as_timet_with_zone (*datetime.value,
due_zone);
}
e_cal_component_free_datetime (&datetime);
e_cal_component_get_completed (comp, &datetime.value);
if (datetime.value) {
completed_zone = icaltimezone_get_utc_timezone ();
complete = icaltime_as_timet_with_zone (*datetime.value,
completed_zone);
e_cal_component_free_icaltimetype (datetime.value);
}
buffer[0] = '\0';
if (start > 0)
write_label_piece (
start, NULL, zone, use_24_hour_format,
buffer, 1024, NULL, NULL);
if (end > 0 && start > 0) {
write_label_piece (
end, &start, zone, use_24_hour_format,
/* Translators: This is part of "START to END" text,
* where START and END are date/times. */
buffer, 1024, _(" to "), NULL);
}
if (complete > 0) {
if (start > 0) {
write_label_piece (
complete, NULL, zone, use_24_hour_format,
/* Translators: This is part of "START to END
* (Completed COMPLETED)", where COMPLETED is a
* completed date/time. */
buffer, 1024, _(" (Completed "), ")");
} else {
write_label_piece (
complete, &start, zone, use_24_hour_format,
/* Translators: This is part of "Completed COMPLETED",
* where COMPLETED is a completed date/time. */
buffer, 1024, _("Completed "), NULL);
}
}
if (due > 0 && complete == 0) {
if (start > 0) {
write_label_piece (
due, NULL, zone, use_24_hour_format,
/* Translators: This is part of "START (Due DUE)",
* where START and DUE are dates/times. */
buffer, 1024, _(" (Due "), ")");
} else {
write_label_piece (
due, &start, zone, use_24_hour_format,
/* Translators: This is part of "Due DUE",
* where DUE is a date/time due the event
* should be finished. */
buffer, 1024, _("Due "), NULL);
}
}
print_text_size_bold (context, buffer, PANGO_ALIGN_LEFT,
left, right, top, top + 24);
}
static void
print_calendar_draw_page (GtkPrintOperation *operation,
GtkPrintContext *context,
gint page_nr,
PrintCalItem *pcali)
{
switch (gnome_calendar_get_view (pcali->gcal)) {
case GNOME_CAL_DAY_VIEW:
print_day_view (context, pcali->gcal, pcali->start);
break;
case GNOME_CAL_WORK_WEEK_VIEW:
print_work_week_view (context, pcali->gcal, pcali->start);
break;
case GNOME_CAL_WEEK_VIEW:
print_week_view (context, pcali->gcal, pcali->start);
break;
case GNOME_CAL_MONTH_VIEW:
print_month_view (context, pcali->gcal, pcali->start);
break;
default:
g_return_if_reached ();
}
}
void
print_calendar (GnomeCalendar *gcal,
GtkPrintOperationAction action,
time_t start)
{
GtkPrintOperation *operation;
PrintCalItem pcali;
g_return_if_fail (gcal != NULL);
g_return_if_fail (GNOME_IS_CALENDAR (gcal));
if (gnome_calendar_get_view (gcal) == GNOME_CAL_MONTH_VIEW) {
GnomeCalendarViewType view_type;
ECalendarView *calendar_view;
EWeekView *week_view;
view_type = gnome_calendar_get_view (gcal);
calendar_view = gnome_calendar_get_calendar_view (gcal, view_type);
week_view = E_WEEK_VIEW (calendar_view);
if (week_view && week_view->multi_week_view &&
week_view->weeks_shown >= 4 &&
g_date_valid (&week_view->first_day_shown)) {
GDate date = week_view->first_day_shown;
struct icaltimetype start_tt;
g_date_add_days (&date, 7);
start_tt = icaltime_null_time ();
start_tt.is_date = TRUE;
start_tt.year = g_date_get_year (&date);
start_tt.month = g_date_get_month (&date);
start_tt.day = g_date_get_day (&date);
start = icaltime_as_timet (start_tt);
} else if (week_view && week_view->multi_week_view) {
start = week_view->day_starts[0];
}
}
pcali.gcal = (GnomeCalendar *) gcal;
pcali.start = start;
operation = e_print_operation_new ();
gtk_print_operation_set_n_pages (operation, 1);
g_signal_connect (
operation, "draw_page",
G_CALLBACK (print_calendar_draw_page), &pcali);
gtk_print_operation_run (operation, action, NULL, NULL);
g_object_unref (operation);
}
/* returns number of required pages, when page_nr is -1 */
static gint
print_comp_draw_real (GtkPrintOperation *operation,
GtkPrintContext *context,
gint page_nr,
PrintCompItem *pci)
{
GtkPageSetup *setup;
PangoFontDescription *font;
ECalClient *client;
ECalComponent *comp;
ECalComponentVType vtype;
ECalComponentText text;
GSList *desc, *l;
GSList *contact_list, *elem;
const gchar *title, *categories, *location;
gchar *categories_string, *location_string, *summary_string;
gdouble header_size;
cairo_t *cr;
gdouble width, height, page_start;
gdouble top;
gint pages = 1;
setup = gtk_print_context_get_page_setup (context);
width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
height = gtk_page_setup_get_page_height (setup, GTK_UNIT_POINTS);
top = 0.0;
/* Either draw only the right page or do not draw
* anything when calculating number of pages. */
if (page_nr != -1)
top = top - ((page_nr) * height);
else
top = height;
page_start = top;
/* PrintCompItem structure contains elements to be used
* with the Print Context , obtained in comp_draw_page
*/
client = pci->client;
comp = pci->comp;
vtype = e_cal_component_get_vtype (comp);
/* We should only be asked to print VEVENTs, VTODOs, or VJOURNALs. */
if (vtype == E_CAL_COMPONENT_EVENT)
title = _("Appointment");
else if (vtype == E_CAL_COMPONENT_TODO)
title = _("Task");
else if (vtype == E_CAL_COMPONENT_JOURNAL)
title = _("Memo");
else
return pages;
cr = gtk_print_context_get_cairo_context (context);
/* Print the title in a box at the top of the page. */
font = get_font_for_size (18, PANGO_WEIGHT_BOLD);
header_size = 40;
if (page_nr == 0) {
print_border (context, 0.0, width, 0.0, header_size,
1.0, 0.9);
print_text (context, font, title, PANGO_ALIGN_CENTER, 0.0, width,
0.1, header_size - 0.1);
pango_font_description_free (font);
}
top += header_size + 30;
/* Summary */
font = get_font_for_size (18, PANGO_WEIGHT_BOLD);
e_cal_component_get_summary (comp, &text);
summary_string = g_strdup_printf (_("Summary: %s"), text.value);
top = bound_text (context, font, summary_string, -1, 0.0, top, width,
height, FALSE, &page_start, &pages);
g_free (summary_string);
/* Location */
e_cal_component_get_location (comp, &location);
if (location && location[0]) {
location_string = g_strdup_printf (_("Location: %s"),
location);
top = bound_text (context, font, location_string, -1, 0.0,
top + 3, width, height, FALSE, &page_start, &pages);
g_free (location_string);
}
/* Date information */
if (page_nr == 0)
print_date_label (
context, comp, client,
pci->zone, pci->use_24_hour_format,
0.0, width, top + 3, top + 15);
top += 20;
/* Attendees */
if ((page_nr == 0) && e_cal_component_has_attendees (comp)) {
top = bound_text (
context, font, _("Attendees: "), -1, 0.0,
top, width, height, FALSE, &page_start, &pages);
pango_font_description_free (font);
font = get_font_for_size (12, PANGO_WEIGHT_NORMAL);
top = print_attendees (
context, font, cr, 0.0, width,
top, height, comp, page_nr, &pages);
top += get_font_size (font) - 6;
}
pango_font_description_free (font);
font = get_font_for_size (12, PANGO_WEIGHT_NORMAL);
/* For a VTODO we print the Status, Priority, % Complete and URL. */
if (vtype == E_CAL_COMPONENT_TODO) {
icalproperty_status status;
const gchar *status_string = NULL;
gint *percent;
gint *priority;
const gchar *url;
/* Status */
e_cal_component_get_status (comp, &status);
if (status != ICAL_STATUS_NONE) {
switch (status) {
case ICAL_STATUS_NEEDSACTION:
status_string = _("Not Started");
break;
case ICAL_STATUS_INPROCESS:
status_string = _("In Progress");
break;
case ICAL_STATUS_COMPLETED:
status_string = _("Completed");
break;
case ICAL_STATUS_CANCELLED:
status_string = _("Canceled");
break;
default:
break;
}
if (status_string) {
gchar *status_text = g_strdup_printf (_("Status: %s"),
status_string);
top = bound_text (context, font, status_text, -1,
0.0, top, width, height, FALSE, &page_start, &pages);
top += get_font_size (font) - 6;
g_free (status_text);
}
}
/* Priority */
e_cal_component_get_priority (comp, &priority);
if (priority && *priority >= 0) {
gchar *pri_text;
pri_text = g_strdup_printf (
_("Priority: %s"),
e_cal_util_priority_to_string (*priority));
top = bound_text (
context, font, pri_text, -1,
0.0, top, width, height, FALSE,
&page_start, &pages);
top += get_font_size (font) - 6;
g_free (pri_text);
}
if (priority)
e_cal_component_free_priority (priority);
/* Percent Complete */
e_cal_component_get_percent (comp, &percent);
if (percent) {
gchar *percent_string;
percent_string = g_strdup_printf (_("Percent Complete: %i"), *percent);
e_cal_component_free_percent (percent);
top = bound_text (context, font, percent_string, -1,
0.0, top, width, height, FALSE, &page_start, &pages);
top += get_font_size (font) - 6;
}
/* URL */
e_cal_component_get_url (comp, &url);
if (url && url[0]) {
gchar *url_string = g_strdup_printf (_("URL: %s"),
url);
top = bound_text (context, font, url_string, -1,
0.0, top, width, height, TRUE, &page_start, &pages);
top += get_font_size (font) - 6;
g_free (url_string);
}
}
/* Categories */
e_cal_component_get_categories (comp, &categories);
if (categories && categories[0]) {
categories_string = g_strdup_printf (_("Categories: %s"),
categories);
top = bound_text (context, font, categories_string, -1,
0.0, top, width, height, TRUE, &page_start, &pages);
top += get_font_size (font) - 6;
g_free (categories_string);
}
/* Contacts */
e_cal_component_get_contact_list (comp, &contact_list);
if (contact_list) {
GString *contacts = g_string_new (_("Contacts: "));
for (elem = contact_list; elem; elem = elem->next) {
ECalComponentText *t = elem->data;
/* Put a comma between contacts. */
if (elem != contact_list)
g_string_append (contacts, ", ");
g_string_append (contacts, t->value);
}
e_cal_component_free_text_list (contact_list);
top = bound_text (context, font, contacts->str, -1,
0.0, top, width, height, TRUE, &page_start, &pages);
top += get_font_size (font) - 6;
g_string_free (contacts, TRUE);
}
top += 16;
/* Description */
e_cal_component_get_description_list (comp, &desc);
for (l = desc; l != NULL; l = l->next) {
ECalComponentText *ptext = l->data;
const gchar *line, *next_line;
for (line = ptext->value; line != NULL; line = next_line) {
next_line = strchr (line, '\n');
top = bound_text (
context, font, line,
next_line ? next_line - line : -1,
0.0, top + 3, width, height, TRUE,
&page_start, &pages);
if (next_line) {
next_line++;
if (!*next_line)
next_line = NULL;
}
}
}
e_cal_component_free_text_list (desc);
pango_font_description_free (font);
return pages;
}
static void
print_comp_draw_page (GtkPrintOperation *operation,
GtkPrintContext *context,
gint page_nr,
PrintCompItem *pci)
{
print_comp_draw_real (operation, context, page_nr, pci);
}
static void
print_comp_begin_print (GtkPrintOperation *operation,
GtkPrintContext *context,
PrintCompItem *pci)
{
gint pages;
pages = print_comp_draw_real (operation, context, -1, pci);
gtk_print_operation_set_n_pages (operation, pages);
}
void
print_comp (ECalComponent *comp,
ECalClient *cal_client,
icaltimezone *zone,
gboolean use_24_hour_format,
GtkPrintOperationAction action)
{
GtkPrintOperation *operation;
PrintCompItem pci;
g_return_if_fail (E_IS_CAL_COMPONENT (comp));
pci.comp = comp;
pci.client = cal_client;
pci.zone = zone;
pci.use_24_hour_format = use_24_hour_format;
operation = e_print_operation_new ();
gtk_print_operation_set_n_pages (operation, 1);
g_signal_connect (
operation, "begin-print",
G_CALLBACK (print_comp_begin_print), &pci);
g_signal_connect (
operation, "draw-page",
G_CALLBACK (print_comp_draw_page), &pci);
gtk_print_operation_run (operation, action, NULL, NULL);
g_object_unref (operation);
}
static void
print_title (GtkPrintContext *context,
const gchar *text,
gdouble page_width)
{
PangoFontDescription *desc;
PangoLayout *layout;
cairo_t *cr;
cr = gtk_print_context_get_cairo_context (context);
desc = pango_font_description_from_string (FONT_FAMILY " Bold 18");
layout = gtk_print_context_create_pango_layout (context);
pango_layout_set_text (layout, text, -1);
pango_layout_set_font_description (layout, desc);
pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
pango_layout_set_width (layout, pango_units_from_double (page_width));
cairo_save (cr);
cairo_move_to (cr, 0.0, 0.0);
pango_cairo_show_layout (cr, layout);
cairo_translate (cr, 0.0, 18);
cairo_save (cr);
cairo_restore (cr);
g_object_unref (layout);
pango_font_description_free (desc);
}
struct print_opts {
EPrintable *printable;
const gchar *print_header;
};
static void
print_table_draw_page (GtkPrintOperation *operation,
GtkPrintContext *context,
gint page_nr,
struct print_opts *opts)
{
GtkPageSetup *setup;
gdouble width;
setup = gtk_print_context_get_page_setup (context);
width = gtk_page_setup_get_page_width (setup, GTK_UNIT_POINTS);
do {
/* TODO Allow the user to customize the title. */
print_title (context, opts->print_header, width);
if (e_printable_data_left (opts->printable))
e_printable_print_page (
opts->printable, context, width, 24, TRUE);
} while (e_printable_data_left (opts->printable));
g_free (opts);
}
void
print_table (ETable *table,
const gchar *dialog_title,
const gchar *print_header,
GtkPrintOperationAction action)
{
GtkPrintOperation *operation;
EPrintable *printable;
struct print_opts *opts;
printable = e_table_get_printable (table);
g_object_ref_sink (printable);
e_printable_reset (printable);
operation = e_print_operation_new ();
gtk_print_operation_set_n_pages (operation, 1);
opts = g_malloc (sizeof (struct print_opts));
opts->printable = printable;
opts->print_header = print_header;
g_signal_connect (
operation, "draw_page",
G_CALLBACK (print_table_draw_page), opts);
gtk_print_operation_run (operation, action, NULL, NULL);
g_object_unref (operation);
}
Reference in New Issue View Git Blame Copy Permalink