lttng-xenomai/LinuxTraceToolkitViewer-0.8.61-xenoltt/lttv/modules/gui/controlflow/drawitem.c

   1 /* This file is part of the Linux Trace Toolkit viewer
   2  * Copyright (C) 2003-2004 Mathieu Desnoyers
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License Version 2 as
   6  * published by the Free Software Foundation;
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  16  * MA 02111-1307, USA.
  17  */
  18
  19
  20
  21 /******************************************************************************
  22  * drawitem.c
  23  *
  24  * This file contains methods responsible for drawing a generic type of data
  25  * in a drawable. Doing this generically will permit user defined drawing
  26  * behavior in a later time.
  27  *
  28  * This file provides an API which is meant to be reusable for all viewers that
  29  * need to show information in line, icon, text, background or point form in
  30  * a drawable area having time for x axis. The y axis, in the control flow
  31  * viewer case, is corresponding to the different processes, but it can be
  32  * reused integrally for cpu, and eventually locks, buffers, network
  33  * interfaces... What will differ between the viewers is the precise
  34  * information which interests us. We may think that the most useful
  35  * information for control flow are some specific events, like schedule
  36  * change, and processes'states. It may differ for a cpu viewer : the
  37  * interesting information could be more the execution mode of each cpu.
  38  * This API in meant to make viewer's writers life easier : it will become
  39  * a simple choice of icons and line types for the precise information
  40  * the viewer has to provide (agremented with keeping supplementary records
  41  * and modifying slightly the DrawContext to suit the needs.)
  42  *
  43  * We keep each data type in attributes, keys to specific information
  44  * being formed from the GQuark corresponding to the information received.
  45  * (facilities / facility_name / events / eventname.)
  46  * (cpus/cpu_name, process_states/ps_name,
  47  * execution_modes/em_name, execution_submodes/es_name).
  48  * The goal is then to provide a generic way to print information on the
  49  * screen for all this different information.
  50  *
  51  * Information can be printed as
  52  *
  53  * - text (text + color + size + position (over or under line)
  54  * - icon (icon filename, corresponding to a loaded icon, accessible through
  55  *   a GQuark. Icons are loaded statically at the guiControlFlow level during
  56  *   module initialization and can be added on the fly if not present in the
  57  *   GQuark.) The habitual place for xpm icons is in
  58  *   ${prefix}/share/LinuxTraceToolkit.) + position (over or under line)
  59  * - line (color, width, style)
  60  * - Arc (big points) (color, size)
  61  * - background color (color)
  62  *
  63  * An item is a leaf of the attributes tree. It is, in that case, including
  64  * all kind of events categories we can have. It then associates each category
  65  * with one or more actions (drawing something) or nothing.
  66  *
  67  * Each item has an array of hooks (hook list). Each hook represents an
  68  * operation to perform. We seek the array each time we want to
  69  * draw an item. We execute each operation in order. An operation type
  70  * is associated with each hook to permit user listing and modification
  71  * of these operations. The operation type is also used to find the
  72  * corresponding priority for the sorting. Operation type and priorities
  73  * are enum and a static int table.
  74  *
  75  * The array has to be sorted by priority each time we add a task in it.
  76  * A priority is associated with each operation type. It permits
  77  * to perform background color selection before line or text drawing. We also
  78  * draw lines before text, so the text appears over the lines.
  79  *
  80  * Executing all the arrays of operations for a specific event (which
  81  * implies information for state, event, cpu, execution mode and submode)
  82  * has to be done in a same DrawContext. The goal there is to keep the offset
  83  * of the text and icons over and under the middle line, so a specific
  84  * event could be printed as (  R Si 0 for running, scheduled in, cpu 0  ),
  85  * text being easy to replace with icons. The DrawContext is passed as
  86  * call_data for the operation hooks.
  87  *
  88  * We use the lttv global attributes to keep track of the loaded icons.
  89  * If we need an icon, we look for it in the icons / icon name pathname.
  90  * If found, we use the pointer to it. If not, we load the pixmap in
  91  * memory and set the pointer to the GdkPixmap in the attributes. The
  92  * structure pointed to contains the pixmap and the mask bitmap.
  93  *
  94  * Author : Mathieu Desnoyers, October 2003
  95  */
  96
  97 #ifdef HAVE_CONFIG_H
  98 #include <config.h>
  99 #endif
 100
 101 #include <glib.h>
 102 #include <gtk/gtk.h>
 103 #include <gdk/gdk.h>
 104 #include <lttv/hook.h>
 105 #include <lttv/attribute.h>
 106 #include <lttv/iattribute.h>
 107 #include <string.h>
 108
 109 #include <lttv/tracecontext.h>
 110 #include <lttv/state.h>
 111 #include <lttv/lttv.h>
 112
 113 #include "drawing.h"
 114 #include "drawitem.h"
 115
 116
 117 #define MAX_PATH_LEN 256
 118
 119 /* drawing hook functions */
 120 gboolean draw_text( void *hook_data, void *call_data)
 121 {
 122   PropertiesText *properties = (PropertiesText*)hook_data;
 123   DrawContext *draw_context = (DrawContext*)call_data;
 124
 125   PangoContext *context;
 126   PangoLayout *layout;
 127   PangoFontDescription *font_desc;// = pango_font_description_new();
 128   PangoRectangle ink_rect;
 129
 130   layout = draw_context->pango_layout;
 131
 132   context = pango_layout_get_context(layout);
 133   font_desc = pango_context_get_font_description(context);
 134
 135   pango_font_description_set_size(font_desc, properties->size*PANGO_SCALE);
 136   pango_layout_context_changed(layout);
 137
 138   pango_layout_set_text(layout, properties->text, -1);
 139   pango_layout_get_pixel_extents(layout, &ink_rect, NULL);
 140
 141   gint x=0, y=0;
 142   gint *offset=NULL;
 143   gboolean enough_space = FALSE;
 144   gint width = ink_rect.width;
 145
 146   switch(properties->position.x) {
 147     case POS_START:
 148       x = draw_context->drawinfo.start.x;
 149       switch(properties->position.y) {
 150         case OVER:
 151           offset = &draw_context->drawinfo.start.offset.over;
 152           x += draw_context->drawinfo.start.offset.over;
 153           y = draw_context->drawinfo.y.over;
 154           break;
 155         case MIDDLE:
 156           offset = &draw_context->drawinfo.start.offset.middle;
 157           x += draw_context->drawinfo.start.offset.middle;
 158           y = draw_context->drawinfo.y.middle;
 159           break;
 160         case UNDER:
 161           offset = &draw_context->drawinfo.start.offset.under;
 162           x += draw_context->drawinfo.start.offset.under;
 163           y = draw_context->drawinfo.y.under;
 164           break;
 165       }
 166       /* verify if there is enough space to draw */
 167       if(unlikely(x + width <= draw_context->drawinfo.end.x)) {
 168         enough_space = TRUE;
 169         *offset += width;
 170       }
 171       break;
 172     case POS_END:
 173       x = draw_context->drawinfo.end.x;
 174       switch(properties->position.y) {
 175         case OVER:
 176           offset = &draw_context->drawinfo.end.offset.over;
 177           x += draw_context->drawinfo.end.offset.over;
 178           y = draw_context->drawinfo.y.over;
 179           break;
 180         case MIDDLE:
 181           offset = &draw_context->drawinfo.end.offset.middle;
 182           x += draw_context->drawinfo.end.offset.middle;
 183           y = draw_context->drawinfo.y.middle;
 184           break;
 185         case UNDER:
 186           offset = &draw_context->drawinfo.end.offset.under;
 187           x += draw_context->drawinfo.end.offset.under;
 188           y = draw_context->drawinfo.y.under;
 189           break;
 190       }
 191       /* verify if there is enough space to draw */
 192       if(unlikely(x - width >= draw_context->drawinfo.start.x)) {
 193         enough_space = TRUE;
 194         *offset -= width;
 195       }
 196       break;
 197   }
 198
 199   if(unlikely(enough_space))
 200     gdk_draw_layout_with_colors(draw_context->drawable,
 201               draw_context->gc,
 202               x,
 203               y,
 204               layout, properties->foreground, properties->background);
 205
 206   return 0;
 207 }
 208
 209
 210 /* To speed up the process, search in already loaded icons list first. Only
 211  * load it if not present.
 212  */
 213 gboolean draw_icon( void *hook_data, void *call_data)
 214 {
 215   PropertiesIcon *properties = (PropertiesIcon*)hook_data;
 216   DrawContext *draw_context = (DrawContext*)call_data;
 217
 218   LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
 219   LttvAttributeValue value;
 220   gchar icon_name[MAX_PATH_LEN] = "icons/";
 221   IconStruct *icon_info;
 222
 223   strcat(icon_name, properties->icon_name);
 224
 225   g_assert(lttv_iattribute_find_by_path(attributes, icon_name,
 226       LTTV_POINTER, &value));
 227   if(unlikely(*(value.v_pointer) == NULL))
 228   {
 229     *(value.v_pointer) = icon_info = g_new(IconStruct,1);
 230
 231     icon_info->pixmap = gdk_pixmap_create_from_xpm(draw_context->drawable,
 232                           &icon_info->mask, NULL, properties->icon_name);
 233   }
 234   else
 235   {
 236     icon_info = *(value.v_pointer);
 237   }
 238
 239   gint x=0, y=0;
 240   gint *offset=NULL;
 241   gboolean enough_space = FALSE;
 242   gint width = properties->width;
 243
 244   switch(properties->position.x) {
 245     case POS_START:
 246       x = draw_context->drawinfo.start.x;
 247       switch(properties->position.y) {
 248         case OVER:
 249           offset = &draw_context->drawinfo.start.offset.over;
 250           x += draw_context->drawinfo.start.offset.over;
 251           y = draw_context->drawinfo.y.over;
 252           break;
 253         case MIDDLE:
 254           offset = &draw_context->drawinfo.start.offset.middle;
 255           x += draw_context->drawinfo.start.offset.middle;
 256           y = draw_context->drawinfo.y.middle;
 257           break;
 258         case UNDER:
 259           offset = &draw_context->drawinfo.start.offset.under;
 260           x += draw_context->drawinfo.start.offset.under;
 261           y = draw_context->drawinfo.y.under;
 262           break;
 263       }
 264       /* verify if there is enough space to draw */
 265       if(unlikely(x + width <= draw_context->drawinfo.end.x)) {
 266         enough_space = TRUE;
 267         *offset += width;
 268       }
 269       break;
 270     case POS_END:
 271       x = draw_context->drawinfo.end.x;
 272       switch(properties->position.y) {
 273         case OVER:
 274           offset = &draw_context->drawinfo.end.offset.over;
 275           x += draw_context->drawinfo.end.offset.over;
 276           y = draw_context->drawinfo.y.over;
 277           break;
 278         case MIDDLE:
 279           offset = &draw_context->drawinfo.end.offset.middle;
 280           x += draw_context->drawinfo.end.offset.middle;
 281           y = draw_context->drawinfo.y.middle;
 282           break;
 283         case UNDER:
 284           offset = &draw_context->drawinfo.end.offset.under;
 285           x += draw_context->drawinfo.end.offset.under;
 286           y = draw_context->drawinfo.y.under;
 287           break;
 288       }
 289       /* verify if there is enough space to draw */
 290       if(unlikely(x - width >= draw_context->drawinfo.start.x)) {
 291         enough_space = TRUE;
 292         *offset -= width;
 293       }
 294       break;
 295   }
 296
 297   if(unlikely(enough_space)) {
 298     gdk_gc_set_clip_mask(draw_context->gc, icon_info->mask);
 299
 300     gdk_gc_set_clip_origin(
 301         draw_context->gc,
 302         x,
 303         y);
 304     gdk_draw_drawable(draw_context->drawable,
 305         draw_context->gc,
 306         icon_info->pixmap,
 307         0, 0,
 308         x,
 309         y,
 310         properties->width, properties->height);
 311
 312     gdk_gc_set_clip_origin(draw_context->gc, 0, 0);
 313     gdk_gc_set_clip_mask(draw_context->gc, NULL);
 314   }
 315   return 0;
 316 }
 317
 318 gboolean draw_line( void *hook_data, void *call_data)
 319 {
 320   PropertiesLine *properties = (PropertiesLine*)hook_data;
 321   DrawContext *draw_context = (DrawContext*)call_data;
 322
 323   gdk_gc_set_foreground(draw_context->gc, &properties->color);
 324   //gdk_gc_set_rgb_fg_color(draw_context->gc, &properties->color);
 325   gdk_gc_set_line_attributes( draw_context->gc,
 326                               properties->line_width,
 327                               properties->style,
 328                               GDK_CAP_BUTT,
 329                               GDK_JOIN_MITER);
 330   //g_critical("DRAWING LINE : x1: %i, y1: %i, x2:%i, y2:%i",
 331   //    draw_context->previous->middle->x,
 332   //    draw_context->previous->middle->y,
 333   //    draw_context->drawinfo.middle.x,
 334   //    draw_context->drawinfo.middle.y);
 335
 336   gint x_begin=0, x_end=0, y=0;
 337
 338   x_begin = draw_context->drawinfo.start.x;
 339   x_end = draw_context->drawinfo.end.x;
 340
 341   switch(properties->y) {
 342     case OVER:
 343       y = draw_context->drawinfo.y.over;
 344       break;
 345     case MIDDLE:
 346       y = draw_context->drawinfo.y.middle;
 347       break;
 348     case UNDER:
 349       y = draw_context->drawinfo.y.under;
 350       break;
 351   }
 352
 353   drawing_draw_line(
 354     NULL, draw_context->drawable,
 355     x_begin,
 356     y,
 357     x_end,
 358     y,
 359     draw_context->gc);
 360
 361   return 0;
 362 }
 363
 364 gboolean draw_arc( void *hook_data, void *call_data)
 365 {
 366   PropertiesArc *properties = (PropertiesArc*)hook_data;
 367   DrawContext *draw_context = (DrawContext*)call_data;
 368
 369   gdk_gc_set_foreground(draw_context->gc, properties->color);
 370   //gdk_gc_set_rgb_fg_color(draw_context->gc, properties->color);
 371
 372   gint x=0, y=0;
 373   gint *offset=NULL;
 374   gboolean enough_space = FALSE;
 375   gint width = properties->size;
 376
 377   switch(properties->position.x) {
 378     case POS_START:
 379       x = draw_context->drawinfo.start.x;
 380       switch(properties->position.y) {
 381         case OVER:
 382           offset = &draw_context->drawinfo.start.offset.over;
 383           x += draw_context->drawinfo.start.offset.over;
 384           y = draw_context->drawinfo.y.over;
 385           break;
 386         case MIDDLE:
 387           offset = &draw_context->drawinfo.start.offset.middle;
 388           x += draw_context->drawinfo.start.offset.middle;
 389           y = draw_context->drawinfo.y.middle;
 390           break;
 391         case UNDER:
 392           offset = &draw_context->drawinfo.start.offset.under;
 393           x += draw_context->drawinfo.start.offset.under;
 394           y = draw_context->drawinfo.y.under;
 395           break;
 396       }
 397       /* verify if there is enough space to draw */
 398       if(unlikely(x + width <= draw_context->drawinfo.end.x)) {
 399         enough_space = TRUE;
 400         *offset += width;
 401       }
 402       break;
 403     case POS_END:
 404       x = draw_context->drawinfo.end.x;
 405       switch(properties->position.y) {
 406         case OVER:
 407           offset = &draw_context->drawinfo.end.offset.over;
 408           x += draw_context->drawinfo.end.offset.over;
 409           y = draw_context->drawinfo.y.over;
 410           break;
 411         case MIDDLE:
 412           offset = &draw_context->drawinfo.end.offset.middle;
 413           x += draw_context->drawinfo.end.offset.middle;
 414           y = draw_context->drawinfo.y.middle;
 415           break;
 416         case UNDER:
 417           offset = &draw_context->drawinfo.end.offset.under;
 418           x += draw_context->drawinfo.end.offset.under;
 419           y = draw_context->drawinfo.y.under;
 420           break;
 421       }
 422       /* verify if there is enough space to draw */
 423       if(unlikely(x - width >= draw_context->drawinfo.start.x)) {
 424         enough_space = TRUE;
 425         *offset -= width;
 426       }
 427       break;
 428   }
 429
 430   if(unlikely(enough_space))
 431     gdk_draw_arc(draw_context->drawable, draw_context->gc,
 432           properties->filled,
 433           x,
 434           y,
 435           properties->size, properties->size, 0, 360*64);
 436
 437   return 0;
 438 }
 439
 440 gboolean draw_bg( void *hook_data, void *call_data)
 441 {
 442   PropertiesBG *properties = (PropertiesBG*)hook_data;
 443   DrawContext *draw_context = (DrawContext*)call_data;
 444
 445   gdk_gc_set_foreground(draw_context->gc, properties->color);
 446   //gdk_gc_set_rgb_fg_color(draw_context->gc, properties->color);
 447
 448   //g_critical("DRAWING RECT : x: %i, y: %i, w:%i, h:%i, val1 :%i, val2:%i ",
 449   //    draw_context->previous->over->x,
 450   //    draw_context->previous->over->y,
 451   //    draw_context->drawinfo.over.x - draw_context->previous->over->x,
 452   //    draw_context->previous->under->y-draw_context->previous->over->y,
 453   //    draw_context->drawinfo.over.x,
 454   //    draw_context->previous->over->x);
 455   gdk_draw_rectangle(draw_context->drawable, draw_context->gc,
 456           TRUE,
 457           draw_context->drawinfo.start.x,
 458           draw_context->drawinfo.y.over,
 459           draw_context->drawinfo.end.x - draw_context->drawinfo.start.x,
 460           draw_context->drawinfo.y.under - draw_context->drawinfo.y.over);
 461
 462   return 0;
 463 }
 464
 465