ltt/branches/poly/lttv/modules/gui/lttvwindow/lttvwindow/viewer.h

   1 /* This file is part of the Linux Trace Toolkit Graphic User Interface
   2  * Copyright (C) 2003-2004 Xiangxiu Yang, 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 This file is what every viewer plugin writer should refer to.
  21
  22
  23 Module Related API
  24
  25 A viewer plugin is, before anything, a plugin. As a dynamically loadable
  26 module, it thus has an init and a destroy function called whenever it is
  27 loaded/initialized and unloaded/destroyed. A graphical module depends on
  28 lttvwindow for construction of its viewer instances. In order to achieve this,
  29 it must register its constructor function to the main window along with
  30 button description or text menu entry description. A module keeps a list of
  31 every viewer that currently sits in memory so it can destroy them before the
  32 module gets unloaded/destroyed.
  33
  34 The contructor registration to the main windows adds button and menu entry
  35 to each main window, thus allowing instanciation of viewers.
  36
  37
  38 Main Window
  39
  40 The main window is a container that offers menus, buttons and a notebook. Some
  41 of those menus and buttons are part of the core of the main window, others
  42 are dynamically added and removed when modules are loaded/unloaded.
  43
  44 The notebook contains as much tabs as wanted. Each tab is linked with a
  45 set of traces (traceset). Each trace contains many tracefiles (one per cpu).
  46 A trace corresponds to a kernel being traced. A traceset corresponds to
  47 many traces read together. The time span of a traceset goes from the
  48 earliest start of all the traces to the latest end of all the traces.
  49
  50 Inside each tab are added the viewers. When they interact with the main
  51 window through the lttvwindow API, they affect the other viewers located
  52 in the same tab as they are.
  53
  54 The insertion of many viewers in a tab permits a quick look at all the
  55 information wanted in a glance. The main window does merge the read requests
  56 from all the viewers in the same tab in a way that every viewer will get exactly
  57 the events it asked for, while the event reading loop and state update are
  58 shared. It improves performance of events delivery to the viewers.
  59
  60
  61
  62 Viewer Instance Related API
  63
  64 The lifetime of a viewer is as follows. The viewer constructor function is
  65 called each time an instance view is created (one subwindow of this viewer
  66 type is created by the user either by clicking on the menu item or the button
  67 corresponding to the viewer). Thereafter, the viewer gets hooks called for
  68 different purposes by the window containing it. These hooks are detailed
  69 below. It also has to deal with GTK Events. Finally, it can be destructed by
  70 having its top level widget unreferenced by the main window or by any
  71 GTK Event causing a "destroy-event" signal on the its top widget. Another
  72 possible way for it do be destroyed is if the module gets unloaded. The module
  73 unload function will have to emit a "destroy" signal on each top level widget
  74 of all instances of its viewers.
  75
  76
  77 Notices from Main Window
  78
  79 time_window : This is the time interval visible on the viewer's tab. Every
  80               viewer that cares about being synchronised by respect to the
  81               time with other viewers should register to this notification.
  82               They should redraw all or part of their display when this occurs.
  83
  84 traceset :    This notification is called whenever a trace is added/removed
  85               from the traceset. As it affects all the data displayed by the
  86               viewer, it sould redraw itself totally.
  87
  88 filter :      FIXME : describe..
  89
  90 current_time: Being able to zoom nearer a specific time or highlight a specific
  91               time on every viewer in synchronicity implies that the viewer
  92               has to shown a visual sign over the drawing or select an event
  93               when it receives this notice. It should also inform the main
  94               window with the appropriate report API function when a user
  95               selects a specific time as being the current time.
  96
  97 dividor :     This notice links the positions of the horizontal dividors
  98               between the graphic display zone of every viewer and their Y axis,
  99               typically showing processes, cpus, ...
 100
 101
 102 FIXME : Add background computation explanation here
 103 background_init: prepare for background computation (comes after show_end).
 104 process_trace for background: done in small chunks in gtk_idle, hooks called.
 105 background_end: remove the hooks and perhaps update the window.
 106
 107
 108 Reporting Changes to the Main Window
 109
 110 In most cases, the enclosing window knows about updates such as described in the
 111 Notification section higher. There are a few cases, however, where updates are
 112 caused by actions known by a view instance. For example, clicking in a view may
 113 update the current time; all viewers within the same window must be told about
 114 the new current time to change the currently highlighted time point. A viewer
 115 reports such events by calling lttvwindow_report_current_time on its lttvwindow.
 116 The lttvwindow will consequently call current_time_notify for each of its
 117 contained viewers.
 118
 119
 120 Available report methods are :
 121
 122 lttvwindow_report_status : reports the text of the status bar.
 123 lttvwindow_report_time_window : reports the new time window.
 124 lttvwindow_report_current_time : reports the new current time.
 125 lttvwindow_report_dividor : reports the new horizontal dividor's position.
 126 lttvwindow_report_focus : One on the widgets in the viewer has the keyboard's
 127                           focus from GTK.
 128
 129
 130
 131 Requesting Events to Main Window
 132
 133 Events can be requested by passing a EventsRequest structure to the main window.
 134 They will be delivered later when the next g_idle functions will be called.
 135 Event delivery is done by calling the event hook for this event ID, or the
 136 main event hooks. A pointer to the EventsRequest structure is passed as
 137 hook_data to the event hooks of the viewers.
 138
 139 EventsRequest consists in
 140 - a pointer to the viewer specific data structure
 141 - a start timestamp or position
 142 - a stop_flag, ending the read process when set to TRUE
 143 - a end timestamp and/or position and/or number of events to read
 144 - hook lists to call for traceset/trace/tracefile begin and end, and for each
 145   event (event hooks and event_by_id hooks).
 146
 147 The main window will deliver events for every EventRequests it has pending
 148 through an algorithm that guarantee that all events requested, and only them,
 149 will be delivered to the viewer between the call of the tracefile_begin hooks
 150 and the call of the tracefile_end hooks.
 151
 152 If a viewer wants to stop the event request at a certain point inside the event
 153 hooks, it has to set the stop_flag to TRUE and return TRUE from the hook
 154 function. Then return value will stop the process traceset. Then, the main
 155 window will look for the stop_flag and remove the EventRequests from its lists,
 156 calling the process_traceset_end for this request (it removes hooks from the
 157 context and calls the after hooks).
 158
 159 It no stop_flag is rose, the end timestamp, end position or number of events to
 160 read has to be reached to determine the end of the request. Otherwise,
 161 the end of traceset does determine it.
 162
 163
 164 GTK Events
 165
 166 Events and Signals
 167
 168 GTK is quite different from the other graphical toolkits around there. The main
 169 difference resides in that there are many X Windows inside one GtkWindow,
 170 instead of just one. That means that X events are delivered by the glib main
 171 loop directly to the widget corresponding to the GdkWindow affected by the X
 172 event.
 173
 174 Event delivery to a widget emits a signal on that widget. Then, if a handler
 175 is connected to this widget's signal, it will be executed. There are default
 176 handlers for signals, connected at class instantiation time. There is also
 177 the possibility to connect other handlers to these signals, which is what
 178 should be done in most cases when a viewer needs to interact with X in any
 179 way.
 180
 181
 182
 183 Signal emission and propagation is described there :
 184
 185 http://www.gtk.org/tutorial/sec-signalemissionandpropagation.html
 186
 187 For further information on the GTK main loop (now a wrapper over glib main loop)
 188 see :
 189
 190 http://developer.gnome.org/doc/API/2.0/gtk/gtk-General.html
 191 http://developer.gnome.org/doc/API/2.0/glib/glib-The-Main-Event-Loop.html
 192
 193
 194 For documentation on event handling in GTK/GDK, see :
 195
 196 http://developer.gnome.org/doc/API/2.0/gdk/gdk-Events.html
 197 http://developer.gnome.org/doc/API/2.0/gdk/gdk-Event-Structures.html
 198
 199
 200 Signals can be connected to handlers, emitted, propagated, blocked,
 201 stopped. See :
 202
 203 http://developer.gnome.org/doc/API/2.0/gobject/gobject-Signals.html
 204
 205
 206
 207
 208 The "expose_event"
 209
 210 Provides the exposed region in the GdkEventExpose structure.
 211
 212 There are two ways of dealing with exposures. The first one is to directly draw
 213 on the screen and the second one is to draw in a pixmap buffer, and then to
 214 update the screen when necessary.
 215
 216 In the first case, the expose event will be responsible for registering hooks to
 217 process_traceset and require time intervals to the main window. So, in this
 218 scenario, if a part of the screen is damaged, the trace has to be read to
 219 redraw the screen.
 220
 221 In the second case, with a pixmap buffer, the expose handler is only responsible
 222 of showing the pixmap buffer on the screen. If the pixmap buffer has never
 223 been filled with a drawing, the expose handler may ask for it to be filled.
 224
 225 The interest of using events request to the main window instead of reading the
 226 events directly from the trace comes from the fact that the main window
 227 does merge requests from the different viewers in the same tab so that the
 228 read loop and the state update is shared. As viewers will, in the common
 229 scenario, request the same events, only one pass through the trace that will
 230 call the right hooks for the right intervals will be done.
 231
 232 When the traceset read is over for a events request, the traceset_end hook is
 233 called. It has the responsibility of finishing the drawing if some parts
 234 still need to be drawn and to show it on the screen (if the viewer uses a pixmap
 235 buffer).
 236
 237 It can add dotted lines and such visual effects to enhance the user's
 238 experience.
 239
 240
 241 FIXME : explain other important events
 242
 243 */
 244
 245
 246 #ifndef VIEWER_H
 247 #define VIEWER_H
 248
 249 /*! \file viewer.h
 250  * \brief API used by the graphical viewers to interact with their top window.
 251  *
 252  * Main window (lttvwindow module) is the place to contain and display viewers.
 253  * Viewers (lttv plugins) interact with main window through this API.
 254  * This header file should be included in each graphic module.
 255  *
 256  */
 257
 258 #include <gtk/gtk.h>
 259 #include <ltt/ltt.h>
 260 #include <ltt/time.h>
 261 #include <lttv/hook.h>
 262 #include <lttv/tracecontext.h>
 263 #include <lttv/stats.h>
 264 #include <lttvwindow/common.h>
 265 //FIXME (not ready yet) #include <lttv/filter.h>
 266
 267
 268 /* Module Related API */
 269
 270
 271 /* constructor a the viewer */
 272 //FIXME explain LttvTracesetSelector and key
 273 typedef GtkWidget * (*lttvwindow_viewer_constructor)
 274                 (Tab *tab, LttvTracesetSelector * s, char *key);
 275
 276
 277 /**
 278  * Function to register a view constructor so that main window can generate
 279  * a menu item and a toolbar item for the viewer in order to generate a new
 280  * instance easily. A menu entry and toolbar item will be added to each main
 281  * window.
 282  *
 283  * It should be called by init function of the module.
 284  *
 285  * @param menu_path path of the menu item. NULL : no menu entry.
 286  * @param menu_text text of the menu item.
 287  * @param pixmap Image shown on the toolbar item. NULL : no button.
 288  * @param tooltip tooltip of the toolbar item.
 289  * @param view_constructor constructor of the viewer.
 290  */
 291
 292 void lttvwindow_register_constructor
 293                             (char *  menu_path,
 294                              char *  menu_text,
 295                              char ** pixmap,
 296                              char *  tooltip,
 297                              lttvwindow_viewer_constructor view_constructor);
 298
 299
 300 /**
 301  * Function to unregister the viewer's constructor, release the space
 302  * occupied by menu_path, menu_text, pixmap, tooltip and constructor of the
 303  * viewer.
 304  *
 305  * It will be called when a module is unloaded.
 306  *
 307  * @param view_constructor constructor of the viewer.
 308  */
 309
 310 void lttvwindow_unregister_constructor
 311                             (lttvwindow_viewer_constructor view_constructor);
 312
 313
 314
 315
 316 /* Viewer Instance Related API */
 317
 318 /**
 319  * Structure used as hook_data for the time_window_notify hook.
 320  */
 321 typedef struct _TimeWindowNotifyData {
 322   TimeWindow *new_time_window;
 323   TimeWindow *old_time_window;
 324 } TimeWindowNotifyData;
 325
 326
 327 /**
 328  * Function to register a hook function that will be called by the main window
 329  * when the time interval needs to be updated.
 330  *
 331  * This register function is typically called by the constructor of the viewer.
 332  *
 333  * @param tab the tab the viewer belongs to.
 334  * @param hook hook that sould be called by the main window when the time
 335  *             interval changes. This hook function takes a
 336  *             TimeWindowNotifyData* as call_data.
 337  * @param hook_data hook data associated with the hook function. It will
 338  *                  be typically a pointer to the viewer's data structure.
 339  */
 340
 341 void lttvwindow_register_time_window_notify(Tab *tab,
 342                                             LttvHook    hook,
 343                                             gpointer    hook_data);
 344
 345
 346 /**
 347  * Function to unregister the time_window notification hook.
 348  *
 349  * This unregister function is typically called by the destructor of the viewer.
 350  *
 351  * @param tab the tab the viewer belongs to.
 352  * @param hook hook that sould be called by the main window when the time
 353  *             interval changes. This hook function takes a
 354  *             TimeWindowNotifyData* as call_data.
 355  * @param hook_data hook data associated with the hook function. It will
 356  *                  be typically a pointer to the viewer's data structure.
 357  */
 358
 359 void lttvwindow_unregister_time_window_notify(Tab *tab,
 360                                               LttvHook    hook,
 361                                               gpointer    hook_data);
 362
 363
 364 /**
 365  * Function to register a hook function that will be called by the main window
 366  * when the traceset is changed. That means that the viewer must redraw
 367  * itself completely or check if it's affected by the particular change to the
 368  * traceset.
 369  *
 370  * This register function is typically called by the constructor of the viewer.
 371  *
 372  * @param tab the tab the viewer belongs to.
 373  * @param hook hook that should be called whenever a change to the traceset
 374  *             occurs. The call_data of this hook is a NULL pointer.
 375  * @param hook_data hook data associated with the hook function. It will
 376  *                  be typically a pointer to the viewer's data structure.
 377  */
 378
 379 void lttvwindow_register_traceset_notify(Tab *tab,
 380                                          LttvHook    hook,
 381                                          gpointer    hook_data);
 382
 383
 384 /**
 385  * Function to unregister the traceset_notify hook.
 386  *
 387  * @param tab the tab the viewer belongs to.
 388  * @param hook hook that should be called whenever a change to the traceset
 389  *             occurs. The call_data of this hook is a NULL pointer.
 390  * @param hook_data hook data associated with the hook function. It will
 391  *                  be typically a pointer to the viewer's data structure.
 392  */
 393
 394 void lttvwindow_unregister_traceset_notify(Tab *tab,
 395                                            LttvHook    hook,
 396                                            gpointer    hook_data);
 397
 398
 399 /**
 400  * Function to register a hook function for a viewer to set/update its
 401  * filter.
 402  *
 403  * FIXME : Add information about what a filter is as seen from a viewer and how
 404  * to use it.
 405  *
 406  * This register function is typically called by the constructor of the viewer.
 407  *
 408  * @param tab the tab the viewer belongs to.
 409  * @param hook hook function called by the main window when a filter change
 410  *             occurs.
 411  * @param hook_data hook data associated with the hook function. It will
 412  *                  be typically a pointer to the viewer's data structure.
 413  */
 414
 415 void lttvwindow_register_filter_notify(Tab *tab,
 416                                        LttvHook    hook,
 417                                        gpointer    hook_data);
 418
 419
 420 /**
 421  * Function to unregister a viewer's hook function which is used to
 422  * set/update the filter of the viewer.
 423  *
 424  * This unregistration is called by the destructor of the viewer.
 425  *
 426  * @param tab the tab the viewer belongs to.
 427  * @param hook hook function called by the main window when a filter change
 428  *             occurs.
 429  * @param hook_data hook data associated with the hook function. It will
 430  *                  be typically a pointer to the viewer's data structure.
 431  */
 432
 433 void lttvwindow_unregister_filter_notify(Tab *tab,
 434                                          LttvHook     hook,
 435                                          gpointer     hook_data);
 436
 437
 438 /**
 439  * Function to register a hook function for a viewer to set/update its
 440  * current time.
 441  *
 442  * @param tab the tab the viewer belongs to.
 443  * @param hook hook function of the viewer that updates the current time. The
 444  *             call_data is a LttTime* representing the new current time.
 445  * @param hook_data hook data associated with the hook function. It will
 446  *                  be typically a pointer to the viewer's data structure.
 447  */
 448
 449 void lttvwindow_register_current_time_notify(Tab *tab,
 450                                              LttvHook    hook,
 451                                              gpointer    hook_data);
 452
 453
 454 /**
 455  * Function to unregister a viewer's hook function which is used to
 456  * set/update the current time of the viewer.
 457  * @param tab the tab the viewer belongs to.
 458  * @param hook hook function of the viewer that updates the current time. The
 459  *             call_data is a LttTime* representing the new current time.
 460  * @param hook_data hook data associated with the hook function. It will
 461  *                  be typically a pointer to the viewer's data structure.
 462  */
 463
 464 void lttvwindow_unregister_current_time_notify(Tab *tab,
 465                                                LttvHook    hook,
 466                                                gpointer    hook_data);
 467
 468
 469 /**
 470  * Function to register a hook function for a viewer to set/update the
 471  * dividor of the hpane. It provides a way to make the horizontal
 472  * dividors of all the viewers linked together.
 473  *
 474  * @param tab the tab the viewer belongs to.
 475  * @param hook hook function of the viewer that will be called whenever a
 476  *             dividor changes in another viewer. The call_data of this hook
 477  *             is a gint*. The value of the integer is the new position of the
 478  *             hpane dividor.
 479  * @param hook_data hook data associated with the hook function. It will
 480  *                  be typically a pointer to the viewer's data structure.
 481  */
 482
 483 void lttvwindow_register_dividor(Tab *tab,
 484                                  LttvHook    hook,
 485                                  gpointer    hook_data);
 486
 487
 488 /**
 489  * Function to unregister a viewer's hook function which is used to
 490  * set/update hpane's dividor of the viewer.
 491  *
 492  * @param tab the tab the viewer belongs to.
 493  * @param hook hook function of the viewer that will be called whenever a
 494  *             dividor changes in another viewer. The call_data of this hook
 495  *             is a gint*. The value of the integer is the new position of the
 496  *             hpane dividor.
 497  * @param hook_data hook data associated with the hook function. It will
 498  *                  be typically a pointer to the viewer's data structure.
 499  */
 500
 501 void lttvwindow_unregister_dividor(Tab *tab,
 502                                    LttvHook    hook,
 503                                    gpointer    hook_data);
 504
 505
 506
 507 /**
 508  * This method reports the information to show on the status bar in the
 509  * main window.
 510  *
 511  * @param tab the tab the viewer belongs to.
 512  * @param info the message which will be shown in the status bar.
 513  */
 514
 515 void lttvwindow_report_status(Tab *tab, const char *info);
 516
 517
 518 /**
 519  * Function to set the time interval of the current tab.a
 520  *
 521  * @param tab the tab the viewer belongs to.
 522  * @param time_interval pointer to the time interval value.
 523  */
 524
 525 void lttvwindow_report_time_window(Tab *tab,
 526                                    const TimeWindow *time_window);
 527
 528 /**
 529  * Function to set the current time/event of the current tab.
 530  * It will be called by a viewer's signal handle associated with
 531  * the button-release-event signal
 532  * @param tab the tab the viewer belongs to.
 533  * @param time a pointer where time is stored.
 534  */
 535
 536 void lttvwindow_report_current_time(Tab *tab,
 537                                     const LttTime *time);
 538
 539
 540 /**
 541  * Function to set the position of the hpane's dividor (viewer).
 542  * It will typically be called by a viewer's signal handle associated
 543  * with the motion_notify_event event/signal.
 544  *
 545  * @param tab the tab the viewer belongs to.
 546  * @param position position of the hpane's dividor.
 547  */
 548
 549 void lttvwindow_report_dividor(Tab *tab, gint position);
 550
 551 /**
 552  * Function to set the focused viewer of the tab.
 553  * It will be called by a viewer's signal handle associated with
 554  * the grab_focus signal of all widgets in the viewer.
 555  *
 556  * @param tab the tab the viewer belongs to.
 557  * @param top_widget the top widget containing all the other widgets of the
 558  *                   viewer.
 559  */
 560 void lttvwindow_report_focus(Tab *tab,
 561                              GtkWidget  *top_widget);
 562
 563
 564 /* Structure sent to the events request hook */
 565                                                 /* Value considered as empty */
 566 typedef struct _EventsRequest {
 567   gpointer                     viewer_data;     /* Unset : NULL             */
 568   gboolean                     servicing;       /* service in progress: TRUE */
 569   LttTime                      start_time;/* Unset : { G_MAXUINT, G_MAXUINT }*/
 570   LttvTracesetContextPosition *start_position;  /* Unset : NULL             */
 571   gboolean                     stop_flag;       /* Continue:TRUE Stop:FALSE */
 572   LttTime                      end_time;/* Unset : { G_MAXUINT, G_MAXUINT } */
 573   guint                        num_events;      /* Unset : G_MAXUINT        */
 574   LttvTracesetContextPosition *end_position;    /* Unset : NULL             */
 575   LttvHooks                   *before_chunk_traceset; /* Unset : NULL       */
 576   LttvHooks                   *before_chunk_trace;    /* Unset : NULL       */
 577   LttvHooks                   *before_chunk_tracefile;/* Unset : NULL       */
 578   LttvHooks                   *event;           /* Unset : NULL             */
 579   LttvHooksById               *event_by_id;     /* Unset : NULL             */
 580   LttvHooks                   *after_chunk_tracefile; /* Unset : NULL       */
 581   LttvHooks                   *after_chunk_trace;     /* Unset : NULL       */
 582   LttvHooks                   *after_chunk_traceset;  /* Unset : NULL       */
 583   LttvHooks                   *before_request;  /* Unset : NULL             */
 584   LttvHooks                   *after_request    /* Unset : NULL             */
 585 } EventsRequest;
 586
 587
 588 /**
 589  * Function to request data in a specific time interval to the main window. The
 590  * event request servicing is differed until the glib idle functions are
 591  * called.
 592  *
 593  * The viewer has to provide hooks that should be associated with the event
 594  * request.
 595  *
 596  * Either start time or start position must be defined in a EventRequest
 597  * structure for it to be valid.
 598  *
 599  * end_time, end_position and num_events can all be defined. The first one
 600  * to occur will be used as end criterion.
 601  *
 602  * @param tab the tab the viewer belongs to.
 603  * @param events_requested Details about the event request.
 604  */
 605
 606 void lttvwindow_events_request(Tab                  *tab,
 607                                const EventsRequest  *events_request);
 608
 609 /**
 610  * Function to remove data requests related to a viewer.
 611  *
 612  * The existing requests's viewer gpointer is compared to the pointer
 613  * given in argument to establish which data request should be removed.
 614  *
 615  * @param tab the tab the viewer belongs to.
 616  * @param viewer a pointer to the viewer data structure
 617  */
 618
 619 void lttvwindow_events_request_remove_all(Tab            *tab,
 620                                           gconstpointer   viewer);
 621
 622
 623 typedef struct _BackgroundRequest {
 624   gchar *hook_path; /* Hook path in global attributes, where all standard hooks
 625                        are : i.e. /TraceState/Statistics/ModuleName */
 626   gchar *trace_path; /* path_to_trace */
 627 } BackgroundRequest;
 628
 629 typedef struct _BackgroundNotify {
 630   gchar                       *trace_path; /* path_to_trace */
 631   LttTime                      notify_time;
 632   LttvTracesetContextPosition *notify_position;
 633   LttvHooks                   *notify; /* Hook to call when the notify is
 634                                           passed, or at the end of trace */
 635 } BackgroundNotify;
 636
 637 /**
 638  * Function to request data from a specific trace
 639  *
 640  * @param bg_request Request specification
 641  */
 642
 643 void lttvwindow_background_request_queue(const BackgroundRequest  *bg_request);
 644
 645 /**
 646  * Register a callback to be called when requested data is passed in the next
 647  * queued background processing.
 648  *
 649  * @param bg_request Request specification
 650  */
 651
 652 void lttvwindow_background_notify_queue(const BackgroundNotify  *bg_notify);
 653
 654
 655 /**
 656  * Register a callback to be called when requested data is passed in the current
 657  * background processing.
 658  *
 659  * @param bg_request Request specification
 660  */
 661
 662 void lttvwindow_background_notify_current(const BackgroundNotify  *bg_notify);
 663
 664
 665 /**
 666  * Function to get the current time window of the current tab.
 667  *
 668  * @param tab the tab the viewer belongs to.
 669  * @return a pointer to the current tab's time interval.
 670  */
 671
 672 const TimeWindow *lttvwindow_get_time_window(Tab *tab);
 673
 674
 675 /**
 676  * Function to get the current time of the current tab.
 677  *
 678  * @param tab the tab the viewer belongs to.
 679  * @return a pointer to the current tab's current time.
 680  */
 681
 682 const LttTime *lttvwindow_get_current_time(Tab *tab);
 683
 684
 685 /**
 686  * Function to get the filter of the current tab.
 687  * @param main_win, the main window the viewer belongs to.
 688  * @param filter, a pointer to a filter.
 689  */
 690
 691 //FIXME
 692 typedef void lttv_filter;
 693 //FIXME
 694 const lttv_filter *lttvwindow_get_filter(Tab *tab);
 695
 696
 697 /**
 698  * Function to get the stats of the traceset
 699  * It must be non const so the viewer can modify it.
 700  * FIXME : a set/get pair of functions would be more appropriate here.
 701  * @param tab the tab the viewer belongs to.
 702  * @return A pointer to Traceset statistics.
 703  */
 704
 705 LttvTracesetStats* lttvwindow_get_traceset_stats(Tab *tab);
 706
 707 /**
 708  * Function to get the context of the traceset
 709  * It must be non const so the viewer can add and remove hooks from it.
 710  * @param tab the tab the viewer belongs to.
 711  * @return Context of the current tab.
 712  */
 713
 714
 715 LttvTracesetContext* lttvwindow_get_traceset_context(Tab *tab);
 716
 717
 718 #endif //VIEWER_H