lttv/modules/gui/controlflow/drawitem.h

   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 #ifndef _DRAW_ITEM_H
  21 #define _DRAW_ITEM_H
  22
  23 #include <lttv/state.h>
  24 #include <lttv/hook.h>
  25
  26 typedef struct _DrawContext DrawContext;
  27 typedef struct _DrawInfo DrawInfo;
  28 typedef struct _ItemInfo ItemInfo;
  29
  30 typedef struct _IconStruct IconStruct;
  31
  32 typedef struct _DrawOperation DrawOperation;
  33
  34
  35 typedef struct _PropertiesText PropertiesText;
  36 typedef struct _PropertiesIcon PropertiesIcon;
  37 typedef struct _PropertiesLine PropertiesLine;
  38 typedef struct _PropertiesArc PropertiesArc;
  39 typedef struct _PropertiesBG PropertiesBG;
  40
  41 typedef enum _DrawableItems DrawableItems;
  42 enum _DrawableItems {
  43     ITEM_TEXT, ITEM_ICON, ITEM_LINE, ITEM_POINT, ITEM_BACKGROUND
  44 };
  45
  46 typedef enum _RelPosX {
  47   POS_START, POS_END
  48 } RelPosX;
  49
  50 typedef enum _RelPosY {
  51   OVER, MIDDLE, UNDER
  52 } RelPosY;
  53
  54
  55 /* The DrawContext keeps information about the current drawing position and
  56  * the previous one, so we can use both to draw lines.
  57  *
  58  * over : position for drawing over the middle line.
  59  * middle : middle line position.
  60  * under : position for drawing under the middle line.
  61  *
  62  * the modify_* are used to take into account that we should go forward
  63  * when we draw a text, an arc or an icon, while it's unneeded when we
  64  * draw a line or background.
  65  *
  66  * The modify_* positions are altered by the draw item functions.
  67  *
  68  */
  69
  70
  71 struct _DrawContext {
  72   GdkDrawable *drawable;
  73   GdkGC   *gc;
  74   PangoLayout *pango_layout;
  75
  76   struct {
  77     struct {
  78       gint x;
  79       struct {
  80         gint over;
  81         gint middle;
  82         gint under;
  83       } offset;
  84     } start;
  85
  86     struct {
  87       gint x;
  88       struct {
  89         gint over;
  90         gint middle;
  91         gint under;
  92       } offset;
  93     } end;
  94
  95     struct {
  96       gint over;
  97       gint middle;
  98       gint under;
  99     } y;
 100
 101   } drawinfo;
 102 };
 103
 104
 105
 106
 107 /*
 108  * Structure used to keep information about icons.
 109  */
 110 struct _IconStruct {
 111   GdkPixmap *pixmap;
 112   GdkBitmap *mask;
 113 };
 114
 115
 116 /*
 117  * The Item element is only used so the DrawOperation is modifiable by users.
 118  * During drawing, only the Hook is needed.
 119  */
 120 struct _DrawOperation {
 121   DrawableItems item;
 122   LttvHooks *hook;
 123 };
 124 #if 0
 125 /*
 126  * We define here each items that can be drawn, together with their
 127  * associated priority. Many item types can have the same priority,
 128  * it's only used for quicksorting the operations when we add a new one
 129  * to the array of operations to perform. Lower priorities are executed
 130  * first. So, for example, we may want to give background color a value
 131  * of 10 while a line would have 20, so the background color, which
 132  * is in fact a rectangle, does not hide the line.
 133  */
 134
 135 static int Items_Priorities[] = {
 136   50, /* ITEM_TEXT */
 137   40, /* ITEM_ICON */
 138   20, /* ITEM_LINE */
 139   30, /* ITEM_POINT */
 140   10  /* ITEM_BACKGROUND */
 141 };
 142 #endif //0
 143
 144 /*
 145  * Here are the different structures describing each item type that can be
 146  * drawn. They contain the information necessary to draw the item : not the
 147  * position (this is provided by the DrawContext), but the text, icon name,
 148  * line width, color; all the properties of the specific items.
 149  */
 150
 151 struct _PropertiesText {
 152   GdkColor  *foreground;
 153   GdkColor  *background;
 154   gint       size;
 155   gchar     *text;
 156   struct {
 157     RelPosX    x;
 158     RelPosY    y;
 159   } position;
 160 };
 161
 162
 163 struct _PropertiesIcon {
 164   gchar   *icon_name;
 165   gint    width;
 166   gint    height;
 167   struct {
 168     RelPosX    x;
 169     RelPosY    y;
 170   } position;
 171 };
 172
 173 struct _PropertiesLine {
 174   GdkColor  color;
 175   gint    line_width;
 176   GdkLineStyle  style;
 177   RelPosY    y;
 178 };
 179
 180 struct _PropertiesArc {
 181   GdkColor  *color;
 182   gint    size; /* We force circle by width = height */
 183   gboolean  filled;
 184   struct {
 185     RelPosX    x;
 186     RelPosY    y;
 187   } position;
 188 };
 189
 190 struct _PropertiesBG {
 191   GdkColor  *color;
 192 };
 193
 194
 195
 196 void draw_item( GdkDrawable *drawable,
 197     gint x,
 198     gint y,
 199     LttvTraceState *ts,
 200     LttvTracefileState *tfs,
 201     LttvIAttribute *attributes);
 202
 203 /*
 204  * The tree of attributes used to store drawing operations goes like this :
 205  *
 206  * event_types/
 207  *   "facility-event_type"
 208  * cpus/
 209  *   "cpu name"
 210  * mode_types/
 211  *   "execution mode"/
 212  *     submodes/
 213  *       "submode"
 214  * process_states/
 215  *   "state name"
 216  *
 217  * So if, for example, we want to add a hook to get called each time we
 218  * receive an event that is in state LTTV_STATE_SYSCALL, we put the
 219  * pointer to the GArray of DrawOperation in
 220  * process_states/ "name associated with LTTV_STATE_SYSCALL"
 221  */
 222
 223
 224 #if 0
 225 /*
 226  * The add_operation has to do a quick sort by priority to keep the operations
 227  * in the right order.
 228  */
 229 void add_operation( LttvIAttribute *attributes,
 230       gchar *pathname,
 231       DrawOperation *operation);
 232
 233 /*
 234  * The del_operation seeks the array present at pathname (if any) and
 235  * removes the DrawOperation if present. It returns 0 on success, -1
 236  * if it fails.
 237  */
 238 gint del_operation( LttvIAttribute *attributes,
 239       gchar *pathname,
 240       DrawOperation *operation);
 241
 242 /*
 243  * The clean_operations removes all operations present at a pathname.
 244  * returns 0 on success, -1 if it fails.
 245  */
 246 gint clean_operations(  LttvIAttribute *attributes,
 247       gchar *pathname );
 248
 249
 250 /*
 251  * The list_operations gives a pointer to the operation array associated
 252  * with the pathname. It will be NULL if no operation is present.
 253  */
 254 void list_operations( LttvIAttribute *attributes,
 255       gchar *pathname,
 256       GArray **operation);
 257
 258
 259
 260 /*
 261  * exec_operation executes the operations if present in the attributes, or
 262  * do nothing if not present.
 263  */
 264 void exec_operations( LttvIAttribute *attributes,
 265       gchar *pathname);
 266 #endif //0
 267
 268 /*
 269  * Here follow the prototypes of the hook functions used to draw the
 270  * different items.
 271  */
 272
 273 gboolean draw_text( void *hook_data, void *call_data);
 274 gboolean draw_icon( void *hook_data, void *call_data);
 275 gboolean draw_line( void *hook_data, void *call_data);
 276 gboolean draw_arc( void *hook_data, void *call_data);
 277 gboolean draw_bg( void *hook_data, void *call_data);
 278
 279
 280 #endif // _DRAW_ITEM_H