Table of Contents
API Reference
Example
Screenshots

API Reference

Table of Contents
ftk_eventviewer_new -- Create a new eventviewer instance.
ftk_eventviewer_resize -- Resize an existing eventviewer instance.
ftk_eventviewer_set_bg_rgb, ftk_eventviewer_set_bg_color -- Set the background color of an existing eventviewer instance.
ftk_eventviewer_set_timebase -- Set the value in seconds of the display width of an an existing eventviewer instance.
ftk_eventviewer_add_trace -- Add another trace to an an existing eventviewer instance.
ftk_eventviewer_set_trace_rgb, ftk_eventviewer_set_trace_color -- Set the color of an existing eventviewer trace.
ftk_eventviewer_set_trace_label -- Replace the label of a given trace in an existing eventviewer instance.
ftk_eventviewer_set_trace_linestyle -- Set the linestyle and linewidth of the specified trace.
ftk_eventviewer_marker_new -- Define the characteristics of a marker to be used by the viewer.
ftk_eventviewer_set_marker_rgb, ftk_eventviewer_set_marker_color -- Set the color of an existing eventviewer marker.
ftk_eventviewer_set_marker_label -- Replace the label of a given marker in an existing eventviewer instance. (NOTE: This function is not yet implemented.)
ftk_eventviewer_tie_new -- Create a new tie in an an existing eventviewer instance.
ftk_eventviewer_set_tie_rgb, ftk_eventviewer_set_tie_color -- Set the color of an existing eventviewer tie.
ftk_eventviewer_set_tie_linestyle -- Set the linestyle and linewidth of the specified tie.
ftk_eventviewer_append_event -- Append an event for display in the viewer.
ftk_eventviewer_append_simultaneous_events -- Append multiple simultaneous events for display in the viewer.
ftk_eventviewer_tie_events -- Visually link multiple existing events for display in the viewer.

ftk_eventviewer_new

Name

ftk_eventviewer_new -- Create a new eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

GtkWidget * ftk_eventviewer_new(void);

Description

ftk_eventviewer_new creates and initialises new eventviewer instance. The returned GtkWidget pointer is in fact a pointer to a FtkEventViewer structure which should be considered opaque. The returned widget pointer should be cast to an FtkEventViewer pointer using the FTK_EVENTVIEWER() macro and used as the first argument to all of the following functions.

ftk_eventviewer_resize

Name

ftk_eventviewer_resize, ftk_eventviewer_resize_e -- Resize an existing eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_resize(FtkEventViewer * eventviewer, gint width, gint height);

gboolean ftk_eventviewer_resize_e(FtkEventViewer * eventviewer, gint width, gint height, GError * err);

Table 1. ftk_eventviewer_resize Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
widthThe requested width of the viewer. The actual width may be accted by the window manager.
heightThe requested height of the viewer. The actual height may be accted by the window manager.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_resize attempts to resize the viewer instance referenced by the first argument to the width and height specified by the second and third arguments respectively. ftk_eventviewer_resize_e does the same thing but, if the fourth argument is non-null, will create a GError structure at the location specified by that argument. The GError * pointer passed to this function must be initialised to NULL; if it non-null when the function returns, an error has occurred and the GError structure must subsequently be freed using g_error_free.

Return value

Both of these functions return TRUE on success and FALSE on failure. In addition, if ftk_eventviewer_resize_e returns FALSE and has a valid non-null fourth argument, a GError structure will be created as described above.

ftk_eventviewer_set_bg_rgb, ftk_eventviewer_set_bg_color

Name

ftk_eventviewer_set_bg_rgb, ftk_eventviewer_set_bg_rgb_e, ftk_eventviewer_set_bg_color, ftk_eventviewer_set_bg_color_e -- Set the background color of an existing eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_bg_rgb(FtkEventViewer * eventviewer, gint red, gint green, gint blue);

gboolean ftk_eventviewer_set_bg_rgb_e(FtkEventViewer * eventviewer, gint red, gint green, gint blue, GError * err);

gboolean ftk_eventviewer_set_bg_color(FtkEventViewer * eventviewer, GdkColor * color);

gboolean ftk_eventviewer_set_bg_color_e(FtkEventViewer * eventviewer, GdkColor * color, GError * err);

Table 1. ftk_eventviewer_set_bg_rgb and ftk_eventviewer_set_bg_color Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
redThe red component of the requested color in a range of 0 to 65535.
greenThe green component of the requested color in a range of 0 to 65535.
blueThe blue component of the requested color in a range of 0 to 65535.
colorA pointer to a GdkColor structure containing the appropriate color components.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_bg_rgb and ftk_eventviewer_set_bg_color change the bacground color of the viewer instance referenced by the first argument. ftk_eventviewer_set_bg_rgb accepts color information in the second, third and fourth arguments as red, green and blue color components respectively. All three components must be in a range of 0 to 65535 inclusive. ftk_eventviewer_set_bg_color accepts color information in its second argument as a pointer to a GdkColor struct. (N.B., a GdkColor struct may be set from a descriptive string, e.g. "lightblue," using gdk_color_parse(), q.v.)

ftk_eventviewer_set_bg_rgb_e and ftk_eventviewer_set_bg_color_e are identical to ftk_eventviewer_set_bg_rgb and ftk_eventviewer_set_bg_color respectively except that they accept an additional error-reporting argument as described above.

Return value

All of these functions return TRUE on success and FALSE on failure. The _e versions of the functions work as described above.

ftk_eventviewer_set_timebase

Name

ftk_eventviewer_set_timebase, ftk_eventviewer_set_timebase_e -- Set the value in seconds of the display width of an an existing eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_timebase(FtkEventViewer * eventviewer, gdouble span);

gboolean ftk_eventviewer_set_timebase_e(FtkEventViewer * eventviewer, gdouble span, GError * err);

Table 1. ftk_eventviewer_timebase Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
spanThe width in seconds spanned by the viewer.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_timebase sets the width in seconds ofthe range of events to be displayed. That value corresponds to the interval in time between the left edge of the displayed information and the right edge, and may be modified by user interaction of other controls.

ftk_eventviewer_set_timebase_e is identical to ftk_eventviewer_set_timebase except that it accepts an additional error-reporting argument as described above.

Return value

These functions return TRUE on success and FALSE on failure. The _e version of the function works as described above.

ftk_eventviewer_add_trace

Name

ftk_eventviewer_add_trace, ftk_eventviewer_add_trace_e -- Add another trace to an an existing eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

gint ftk_eventviewer_add_trace(FtkEventViewer * eventviewer, gchar * label, gchar * description);

gint ftk_eventviewer_add_trace_e(FtkEventViewer * eventviewer, gchar * label, gchar * description, GError * err);

Table 1. ftk_eventviewer_add_trace Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
labelA label to be associated with the trace. (May be NULL.)
descriptionOptional additional information that may be associated with the trace, displayed when the pointer hovers over the label displayed in the viewer. May be NULL if unused.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_add_trace appends a new trace to the series of traces displayed by the viewer. The label argument is used to supply a label for the trace while the description argument supplies a string that appears as additional information to the user when the pointer pauses over the displayed label. The traces are displayed, top to bottom, in the order in which they are defined.

ftk_eventviewer_add_trace_e is identical to ftk_eventviewer_add_trace except that it accepts an additional error-reporting argument as described above.

Return value

On success, these functions return an integer greater than or equal to zero identifying the trace for future use. Within a given viewer, these values are unique, but they may not be unique in separate viewer instances. On failure, a negative value is returned. The _e version of the function works as described above.

ftk_eventviewer_set_trace_rgb, ftk_eventviewer_set_trace_color

Name

ftk_eventviewer_set_trace_rgb, ftk_eventviewer_set_trace_rgb_e, ftk_eventviewer_set_trace_color, ftk_eventviewer_set_trace_color_e -- Set the color of an existing eventviewer trace.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_trace_rgb(FtkEventViewer * eventviewer, gint trace, gint red, gint green, gint blue);

gboolean ftk_eventviewer_set_trace_rgb_e(FtkEventViewer * eventviewer, gint trace, gint red, gint green, gint blue, GError * err);

gboolean ftk_eventviewer_set_trace_color(FtkEventViewer * eventviewer, gint trace, GdkColor * color);

gboolean ftk_eventviewer_set_trace_color_e(FtkEventViewer * eventviewer, gint trace, GdkColor * color, GError * err);

Table 1. ftk_eventviewer_set_trace_rgb and ftk_eventviewer_set_trace_color Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
traceThe identifier of a trace previously defined by ftk_eventviewer_add_trace.
redThe red component of the requested color in a range of 0 to 65535.
greenThe green component of the requested color in a range of 0 to 65535.
blueThe blue component of the requested color in a range of 0 to 65535.
colorA pointer to a GdkColor structure containing the appropriate color components.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_trace_rgb and ftk_eventviewer_set_trace_color change the color in the viewer instance referenced by the first argument of the trace identified by second argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_add_trace or ftk_eventviewer_add_trace_e on the same viewer. ftk_eventviewer_set_trace_rgb accepts color information in the third, fourth and fifth arguments as red, green and blue color components respectively. All three components must be in a range of 0 to 65535 inclusive. ftk_eventviewer_set_trace_color accepts color information in its third argument as a pointer to a GdkColor struct. (N.B., a GdkColor struct may be set from a descriptive string, e.g. "lightblue," using gdk_color_parse(), q.v.)

ftk_eventviewer_set_trace_rgb_e and ftk_eventviewer_set_trace_color_e are identical to ftk_eventviewer_set_trace_rgb and ftk_eventviewer_set_trace_color respectively except that they accept an additional error-reporting argument as described above.

Return value

All of these functions return TRUE on success and FALSE on failure. The _e versions of the functions work as described above.

ftk_eventviewer_set_trace_label

Name

ftk_eventviewer_set_trace_label, ftk_eventviewer_set_trace_label_e -- Replace the label of a given trace in an existing eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_trace_label(FtkEventViewer * eventviewer, gint trace, gchar * label);

gboolean ftk_eventviewer_set_trace_label_e(FtkEventViewer * eventviewer, gint trace, gchar * label, GError * err);

Table 1. ftk_eventviewer_set_trace_label Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
traceThe identifier of a trace previously defined by ftk_eventviewer_add_trace.
labelA pointer to a string that, if non-NULL, will replace the existing trace label.
descriptionA pointer to a string that, if non-NULL, will replace the existing trace description. NOTE: This argument is not yet implemented.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_trace_label replaces the label associated with a trace identified by the second argument in the viewer identified by the first argument with the label specified by the third argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_add_trace or ftk_eventviewer_add_trace_e on the same viewer.

At some point, an additional description argument will be added to similarly replace the description string.

ftk_eventviewer_set_trace_label_e is identical to ftk_eventviewer_set_trace_label except that it accepts an additional error-reporting argument as described above.

Return value

Both of these functions return TRUE on success and FALSE on failure. The _e version of the function work as described above.

ftk_eventviewer_set_trace_linestyle

Name

ftk_eventviewer_set_trace_linestyle, ftk_eventviewer_set_trace_linestyle_e -- Set the linestyle and linewidth of the specified trace.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_trace_linestyle(FtkEventViewer * eventviewer, gint trace, gint linewidth, gint linestyle);

gboolean ftk_eventviewer_set_trace_linestyle_e(FtkEventViewer * eventviewer, gint trace, gint linewidth, gint linestyle, GError * err);

Table 1. ftk_eventviewer_set_trace_linestyle Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
traceThe identifier of a trace previously defined by ftk_eventviewer_add_trace.
linewidthThe width, in pixels, of the trace.
linestyleThe length in pixels of the dashes used to create the trace.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_trace_linstyle sets the line style and line width of the trace identified by the second argument in the viewer identified by the first argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_add_trace or ftk_eventviewer_add_trace_e on the same viewer.

The linewidth argument may either be a positive value specifying the width in pixels of the trace, or any negative value to specify the use of the dafault width. If the linestyle argument is negative, a solid trace will be created; if positive, a dashed trace consisting of segments of the specified length alternating with gaps of the same length will be created.

ftk_eventviewer_set_trace_linestyle_e is identical to ftk_eventviewer_set_trace_linestyle except that it accepts an additional error-reporting argument as described above.

Return value

Both of these functions return TRUE on success and FALSE on failure. The _e version of the function work as described above.

ftk_eventviewer_marker_new

Name

ftk_eventviewer_marker_new, ftk_eventviewer_marker_new_e -- Define the characteristics of a marker to be used by the viewer.

Synopsis

	  #include <ftkeventviewer.h>
	

gint ftk_eventviewer_marker_new(FtkEventViewer * eventviewer, FtkGlyph glyph, gchar * label, gchar * description);

gint ftk_eventviewer_marker_new_e(FtkEventViewer * eventviewer, FtkGlyph glyph, gchar * label, gchar * description, GError * err);

Table 1. ftk_eventviewer_marker_new Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
glyphAn enum value of type FtkGlyph indentifying which of the available glyphs to use in displaying the marker.
labelA label to be associated with the marker. (May be NULL.)
descriptionOptional additional information that may be associated with the marker, displayed when the pointer hovers over the marker or the corresponding legend displayed in the viewer. May be NULL if unused.
errA pointer to a GError struct pointer. May be NULL if unused.

Table 2. FtkGlyph Values.

EnumGlyphDescription
FTK_GLYPH_FILLED_CIRCLEA filled circle.
FTK_GLYPH_FILLED_SQUAREA filled square.
FTK_GLYPH_FILLED_UP_TRIANGLEA filled upwards-pointing triangle
FTK_GLYPH_FILLED_DOWN_TRIANGLEA filled downwards-pointing triangle.
FTK_GLYPH_FILLED_DIAMONDA filled diamond.
FTK_GLYPH_FILLED_FOUR_STARA filled four-pointed star.
FTK_GLYPH_OPEN_FOUR_STARAn open four-pointed star.
FTK_GLYPH_FILLED_FIVE_STARA filled five-pointed star.
FTK_GLYPH_AUTOMATIC A flag indicating that glyph selection and marker colors should be assigned automatically by the widget. The colors used are those shown in the figure below.

The predefined colors used by the viewer.

Figure 1.

Description

ftk_eventviewer_marker_new defines a marker to be used in the viewer. The glyph argument specifies which of the available geometric shapes will be drawn in the display to mark the location of an event, and the label argument is used to supply a label for the marker. The description argument supplies a string that appears as additional information to the user when the pointer pauses over a displayed event or the legend describing the significance of the events..

If the value of the glyph argument is FTK_GLYPH_AUTOMATIC, glyphs will automatically be assigned to markers in rotation. In addition, a color will autonatically be assigned to the marker from a pool of pre-defined color values. (The colors may also be set explicitly—see ftk_eventviewer_set_marker_rgb or ftk_eventviewer_set_marker_color.)

ftk_eventviewer_marker_new_e is identical to ftk_eventviewer_marker_new except that it accepts an additional error-reporting argument as described above.

Return value

On success, these functions return an integer greater than or equal to zero identifying the marker for future use. Within a given viewer, these values are unique, but they may not be unique in separate viewer instances. On failure, a negative value is returned. The _e version of the function works as described above.

ftk_eventviewer_set_marker_rgb, ftk_eventviewer_set_marker_color

Name

ftk_eventviewer_set_marker_rgb, ftk_eventviewer_set_marker_rgb_e, ftk_eventviewer_set_marker_color, ftk_eventviewer_set_marker_color_e -- Set the color of an existing eventviewer marker.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_marker_rgb(FtkEventViewer * eventviewer, gint marker, gint red, gint green, gint blue);

gboolean ftk_eventviewer_set_marker_rgb_e(FtkEventViewer * eventviewer, gint marker, gint red, gint green, gint blue, GError * err);

gboolean ftk_eventviewer_set_marker_color(FtkEventViewer * eventviewer, gint marker, GdkColor * color);

gboolean ftk_eventviewer_set_marker_color_e(FtkEventViewer * eventviewer, gint marker, GdkColor * color, GError * err);

Table 1. ftk_eventviewer_set_marker_rgb and ftk_eventviewer_set_marker_color Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
markerThe identifier of a marker previously defined by ftk_eventviewer_marker_new.
redThe red component of the requested color in a range of 0 to 65535.
greenThe green component of the requested color in a range of 0 to 65535.
blueThe blue component of the requested color in a range of 0 to 65535.
colorA pointer to a GdkColor structure containing the appropriate color components.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_marker_rgb and ftk_eventviewer_set_marker_color change the color in the viewer instance referenced by the first argument of the marker identified by second argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_marker_new or ftk_eventviewer_marker_new_e on the same viewer. ftk_eventviewer_set_marker_rgb accepts color information in the third, fourth and fifth arguments as red, green and blue color components respectively. All three components must be in a range of 0 to 65535 inclusive. ftk_eventviewer_set_marker_color accepts color information in its third argument as a pointer to a GdkColor struct. (N.B., a GdkColor struct may be set from a descriptive string, e.g. "lightblue," using gdk_color_parse(), q.v.)

ftk_eventviewer_set_marker_rgb_e and ftk_eventviewer_set_marker_color_e are identical to ftk_eventviewer_set_marker_rgb and ftk_eventviewer_set_marker_color respectively except that they accept an additional error-reporting argument as described above.

Return value

All of these functions return TRUE on success and FALSE on failure. The _e versions of the functions work as described above.

ftk_eventviewer_set_marker_label

Name

ftk_eventviewer_set_marker_label, ftk_eventviewer_set_marker_label_e -- Replace the label of a given marker in an existing eventviewer instance. (NOTE: This function is not yet implemented.)

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_marker_label(FtkEventViewer * eventviewer, gint marker, gchar * label);

gboolean ftk_eventviewer_set_marker_label_e(FtkEventViewer * eventviewer, gint marker, gchar * label, GError * err);

Table 1. ftk_eventviewer_set_marker_label Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
markerThe identifier of a marker previously defined by ftk_eventviewer_marker_new.
labelA pointer to a string that, if non-NULL, will replace the existing marker label.
descriptionA pointer to a string that, if non-NULL, will replace the existing marker description. NOTE: This argument is not yet implemented.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_marker_label replaces the label associated with a marker identified by the second argument in the viewer identified by the first argument with the label specified by the third argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_marker_new or ftk_eventviewer_marker_new_e on the same viewer.

At some point, an additional description argument will be added to similarly replace the description string.

ftk_eventviewer_set_marker_label_e is identical to ftk_eventviewer_set_marker_label except that it accepts an additional error-reporting argument as described above.

Return value

Both of these functions return TRUE on success and FALSE on failure. The _e version of the function work as described above.

ftk_eventviewer_tie_new

Name

ftk_eventviewer_tie_new, ftk_eventviewer_tie_new_e -- Create a new tie in an an existing eventviewer instance.

Synopsis

	  #include <ftkeventviewer.h>
	

gint ftk_eventviewer_tie_new(FtkEventViewer * eventviewer);

gint ftk_eventviewer_tie_new_e(FtkEventViewer * eventviewer, GError * err);

Table 1. ftk_tie_new Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_tie_new defines a new tie in a viewer. Ties are used in ftk_eventviewer_append_simultaneous_events to visually connect simultaneous events.

ftk_eventviewer_new_tie_e is identical to ftk_eventviewer_new_tie except that it accepts an additional error-reporting argument as described above.

Return value

On success, these functions return an integer greater than or equal to zero identifying the tie for future use. Within a given viewer, these values are unique, but they may not be unique in separate viewer instances. On failure, a negative value is returned. The _e version of the function works as described above.

ftk_eventviewer_set_tie_rgb, ftk_eventviewer_set_tie_color

Name

ftk_eventviewer_set_tie_rgb, ftk_eventviewer_set_tie_rgb_e, ftk_eventviewer_set_tie_color, ftk_eventviewer_set_tie_color_e -- Set the color of an existing eventviewer tie.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_tie_rgb(FtkEventViewer * eventviewer, gint tie, gint red, gint green, gint blue);

gboolean ftk_eventviewer_set_tie_rgb_e(FtkEventViewer * eventviewer, gint tie, gint red, gint green, gint blue, GError * err);

gboolean ftk_eventviewer_set_tie_color(FtkEventViewer * eventviewer, gint tie, GdkColor * color);

gboolean ftk_eventviewer_set_tie_color_e(FtkEventViewer * eventviewer, gint tie, GdkColor * color, GError * err);

Table 1. ftk_eventviewer_set_tie_rgb and ftk_eventviewer_set_tie_color Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
tieThe identifier of a tie previously defined by ftk_eventviewer_tie_new.
redThe red component of the requested color in a range of 0 to 65535.
greenThe green component of the requested color in a range of 0 to 65535.
blueThe blue component of the requested color in a range of 0 to 65535.
colorA pointer to a GdkColor structure containing the appropriate color components.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_tie_rgb and ftk_eventviewer_set_tie_color change the color in the viewer instance referenced by the first argument of the tie identified by second argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_tie_new or ftk_eventviewer_tie_new_e on the same viewer. ftk_eventviewer_set_tie_rgb accepts color information in the third, fourth and fifth arguments as red, green and blue color components respectively. All three components must be in a range of 0 to 65535 inclusive. ftk_eventviewer_set_tie_color accepts color information in its third argument as a pointer to a GdkColor struct. (N.B., a GdkColor struct may be set from a descriptive string, e.g. "lightblue," using gdk_color_parse(), q.v.)

ftk_eventviewer_set_tie_rgb_e and ftk_eventviewer_set_tie_color_e are identical to ftk_eventviewer_set_tie_rgb and ftk_eventviewer_set_tie_color respectively except that they accept an additional error-reporting argument as described above.

Return value

All of these functions return TRUE on success and FALSE on failure. The _e versions of the functions work as described above.

ftk_eventviewer_set_tie_linestyle

Name

ftk_eventviewer_set_tie_linestyle, ftk_eventviewer_set_tie_linestyle_e -- Set the linestyle and linewidth of the specified tie.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_set_tie_linestyle(FtkEventViewer * eventviewer, gint tie, gint linewidth, gint linestyle);

gboolean ftk_eventviewer_set_tie_linestyle_e(FtkEventViewer * eventviewer, gint tie, gint linewidth, gint linestyle, GError * err);

Table 1. ftk_eventviewer_set_tie_linestyle Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
tieThe identifier of a tie previously defined by ftk_eventviewer_tie_new.
linewidthThe width, in pixels, of the tie.
linestyleThe length in pixels of the dashes used to create the tie.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_set_tie_linstyle sets the line style and line width of the tie identified by the second argument in the viewer identified by the first argument. The second argument must be a value returned by a prior call to either ftk_eventviewer_tie_new or ftk_eventviewer_tie_new_e on the same viewer.

The linewidth argument may either be a positive value specifying the width in pixels of the tie, or any negative value to specify the use of the dafault width. If the linestyle argument is negative, a solid tie will be created; if positive, a dashed tie consisting of segments of the specified length alternating with gaps of the same length will be created.

ftk_eventviewer_set_tie_linestyle_e is identical to ftk_eventviewer_set_tie_linestyle except that it accepts an additional error-reporting argument as described above.

Return value

Both of these functions return TRUE on success and FALSE on failure. The _e version of the function work as described above.

ftk_eventviewer_append_event

Name

ftk_eventviewer_append_event, ftk_eventviewer_append_event_e -- Append an event for display in the viewer.

Synopsis

	  #include <ftkeventviewer.h>
	

gint ftk_eventviewer_append_event(FtkEventViewer * eventviewer, gint trace, gint marker, gchar * description);

gint ftk_eventviewer_append_event_e(FtkEventViewer * eventviewer, gint trace, gint marker, gchar * description, GError * err);

Table 1. ftk_eventviewer_append_event Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
traceThe identifier of a trace previously defined by ftk_eventviewer_add_trace.
markerThe identifier of a marker previously defined by ftk_eventviewer_marker_new.
descriptionOptional additional information that may be associated with the event, displayed when the pointer hovers over the event displayed in the viewer. May be NULL if unused.
errA pointer to a GError struct pointer. May be NULL if unused.

Description

ftk_eventviewer_append_event appends an event of the given marker type to the given trace, using in internally provided timestamp. The trace specification, the second argument, must be a value previously returned by ftk_eventviewer_add_trace; similarly, the marker argument must be a value returned by ftk_eventviewer_marker_new.

The internally generated timestamp has microsecond resolution.

ftk_eventviewer_append_event_e is identical to ftk_eventviewer_append_event except that it accepts an additional error-reporting argument as described above.

Return value

On success, both of these functions return a non-negative value identifying the appended event; on failure the return a negative one (-1). The _e version of the function work as described above.

ftk_eventviewer_append_simultaneous_events

Name

ftk_eventviewer_append_simultaneous_events, ftk_eventviewer_append_simultaneous_events_e -- Append multiple simultaneous events for display in the viewer.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_append_simultaneous_events(FtkEventViewer * eventviewer, gint tie, ...);

gboolean ftk_eventviewer_append_simultaneous_events_e(FtkEventViewer * eventviewer, gint tie, GError * err, ...);

Table 1. ftk_eventviewer_append_simultaneous_events Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
tieThe identifier of a tie previously defined by ftk_eventviewer_tie_new.
errA pointer to a GError struct pointer. May be NULL if unused.
...A variable-length list of any number of trace identifiers, marker identifiers, and description strings specifying an arbitrary number of simultaneously occurring events.

Description

ftk_eventviewer_append_simultaneous_events appends any number of events, all of which receive the same timestamp and thus are considered to have occurred simultaneously. The events to append are specified as a repeated list of parameters identical to those supplied to ftk_eventviewer_append_event_e: trace, marker, description. The end of the list is indicated by a trace argument of negative one (-1). The number of event-specifying parameters passed, exclusive of the terminal -1, must be a multiple of three; the results of any other condition are unpredictable. All three of these parameters are as described in the description of ftk_eventviewer_append_event_e.

ftk_eventviewer_append_simultaneous_events_e is identical to ftk_eventviewer_append_simultaneous_events except that it accepts an additional error-reporting argument as described above.

Return value

Both of these functions return TRUE on success and FALSE on failure. The _e version of the function work as described above.

ftk_eventviewer_tie_events

Name

ftk_eventviewer_tie_events, ftk_eventviewer_tie_events_e -- Visually link multiple existing events for display in the viewer.

Synopsis

	  #include <ftkeventviewer.h>
	

gboolean ftk_eventviewer_tie_events(FtkEventViewer * eventviewer, gint tie, ...);

gboolean ftk_eventviewer_tie_events_e(FtkEventViewer * eventviewer, gint tie, GError * err, ...);

Table 1. ftk_eventviewer_tie_events Arguments

ArgumentDescription
eventviewerA pointer to an opaque FtkEventViewer structure previously created using ftk_eventviewer_new.
tieThe identifier of a tie previously defined by ftk_eventviewer_tie_new.
errA pointer to a GError struct pointer. May be NULL if unused.
...A variable-length list of any number of event identifiers of an arbitrary number of existing events.

Description

ftk_eventviewer_tie_events lisuall links any number of existing events, regardless of simultaneity. The events to link are specified as a repeated list of event identifiers returned by ftk_eventviewer_append_event_e. The end of the list is indicated by an argument of negative one (-1).

ftk_eventviewer_tie_events_e is identical to ftk_eventviewer_tie_events except that it accepts an additional error-reporting argument as described above.

Return value

Both of these functions return TRUE on success and FALSE on failure. The _e version of the function work as described above.


Example

This is an example fake application that shows how to use the eventviewer API.

Example 1. An example fake application using eventviewer.

/* chlm */
#include <stdlib.h>
#define  _GNU_SOURCE
#include <math.h>
#include <signal.h>
#include <time.h>
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include <gtk/gtk.h>
#include <ftkeventviewer.h>

GtkWidget * eventviewer1;
GtkWidget * eventviewer2;
GtkWidget * frame2;

gint clone_tie;
gint term_tie;

FtkEventViewer * thread_viewer;
FtkEventViewer * event_viewer;

GdkColor bg_color;
GdkColor bg_color1;

typedef struct {
  gint marker_id;
  gint trace_id;
  char * label;
  char * string;
  char * tstring;
  GdkColor * color;
} plot_parms_s;

static plot_parms_s thread_parms[] = {
  {0, 0, "Parent",	"The parent process.",	"Mama proc"},
  {0, 0, "Thread 0",	NULL,			"Kid 0"},
  {0, 0, "Thread 1",	NULL,			"Kid 1"},
  {0, 0, "Thread 2",	NULL,			"Kid 2"},
};

enum {
  IDX_PARENT,
  IDX_THREAD0,
  IDX_THREAD1,
  IDX_THREAD2
};

static int threads_count = sizeof(thread_parms)/sizeof(plot_parms_s);

static plot_parms_s event_parms[] = {
  {0, 0, "clone",	"A clone event.",	"Bring in the clones."},
  {0, 0, "event A",	NULL},
  {0, 0, "event B",	NULL},
  {0, 0, "event C",	NULL},
  {0, 0, "term",	"A termination event.",	"Die!"},
};

enum {
  IDX_CLONE,
  IDX_EVENTA,
  IDX_EVENTB,
  IDX_EVENTC,
  IDX_TERM
};

static int events_count = sizeof(event_parms)/sizeof(plot_parms_s);

int max_event_nr;

int events_added = 1;
int sigs_sent = 0;
#define MAX_SIGS_SENT 30

GdkColor clone_tie_color	= {0, 65535, 32768, 32769};
GdkColor term_tie_color		= {0, 0, 32760, 32769};

static void
catch_sigalrm (int sig)
{
  GError * err = NULL;
  int rt = lrint (drand48() * 32.0);
  int et = lrint (drand48() * 15.0);

  if (NULL == eventviewer1) return;
  
#if 0
  fprintf (stderr, "catch_sigalrm %d\n", sigs_sent);
#endif


  if (sigs_sent++ >= MAX_SIGS_SENT)  {
    if (events_added) {
      fprintf (stderr, "stopping\n");
      struct itimerval value;
      struct itimerval ovalue;
      int clone_term_event;
      int parent_term_event;


      events_added = 0;
  
    
      clone_term_event =
	ftk_eventviewer_append_event (thread_viewer,
				      thread_parms[IDX_THREAD0].trace_id,
				      event_parms[IDX_TERM].marker_id,
				      "termination of thread 0");
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_THREAD0].marker_id,
				    "termination of thread 0");
    
      usleep (125000);
      parent_term_event =
	ftk_eventviewer_append_event (thread_viewer,
				      thread_parms[IDX_PARENT].trace_id,
				      event_parms[IDX_TERM].marker_id,
				      "termination of thread 0");
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_PARENT].marker_id,
				    "termination of thread 0");

      ftk_eventviewer_tie_events (thread_viewer,
				  term_tie,
				  clone_term_event,
				  parent_term_event,
				  -1);
      usleep (250000);
  
      clone_term_event =
	ftk_eventviewer_append_event (thread_viewer,
				      thread_parms[IDX_THREAD1].trace_id,
				      event_parms[IDX_TERM].marker_id,
				      "termination of thread 1");
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_THREAD1].marker_id,
				    "termination of thread 1");
    
      usleep (125000);
      parent_term_event =
	ftk_eventviewer_append_event (thread_viewer,
				      thread_parms[IDX_PARENT].trace_id,
				      event_parms[IDX_TERM].marker_id,
				      "termination of thread 1");
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_PARENT].marker_id,
				    "termination of thread 1");

      ftk_eventviewer_tie_events (thread_viewer,
				  term_tie,
				  clone_term_event,
				  parent_term_event,
				  -1);
      usleep (250000);
    
      clone_term_event =
	ftk_eventviewer_append_event (thread_viewer,
				      thread_parms[IDX_THREAD2].trace_id,
				      event_parms[IDX_TERM].marker_id,
				      "termination of thread 2");
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_THREAD2].marker_id,
				    "termination of thread 2");
      usleep (125000);
      parent_term_event =
	ftk_eventviewer_append_event (thread_viewer,
				      thread_parms[IDX_PARENT].trace_id,
				      event_parms[IDX_TERM].marker_id,
				      "termination of thread 2");
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_PARENT].marker_id,
				    "termination of thread 2");


      ftk_eventviewer_tie_events (thread_viewer,
				  term_tie,
				  clone_term_event,
				  parent_term_event,
				  -1);
      sleep (1);
      ftk_eventviewer_append_event (thread_viewer,
				    thread_parms[IDX_PARENT].trace_id,
				    event_parms[IDX_TERM].marker_id,
				    "termination of parent");
  
      ftk_eventviewer_append_event (event_viewer,
				    event_parms[IDX_TERM].trace_id,
				    thread_parms[IDX_PARENT].marker_id,
				    "termination of parent");



      

      signal (SIGALRM, catch_sigalrm);

      value.it_interval.tv_sec = 0;
      value.it_interval.tv_usec = 0;
      value.it_value.tv_sec = 0;
      value.it_value.tv_usec = 0;
      setitimer (ITIMER_REAL, &value, &ovalue);
      return;
    }
#if 1
    else {
      fprintf (stderr, "changing state\n");
      sigs_sent = -200;
      events_added = 1;
      ftk_eventviewer_set_bg_rgb (thread_viewer, 65535, 65535,  65535);
#if 0
      ftk_eventviewer_set_trace_rgb (FTK_EVENTVIEWER (eventviewer1),
				     traces[2],
				     65535, 28000,  0);
      ftk_eventviewer_set_trace_label (FTK_EVENTVIEWER (eventviewer1),
				       traces[1],
				       LABEL_TERM);

      /* width in pixels.  a width <= 0 implies default width. values 1 - 8 work ok */
      /* style is dash spec */
      ftk_eventviewer_set_trace_linestyle (FTK_EVENTVIEWER (eventviewer1),
					   traces[1],
					   3, 3);
#endif
      
      max_event_nr = 5;
    }
#endif
  }

  if (et <= max_event_nr) {
    int mi = 1 + (rt & 3);
    if (mi < 4) {
      
      int ti = (rt >> 2) & 3;
      ftk_eventviewer_append_event_e (FTK_EVENTVIEWER (eventviewer1),
				      thread_parms[ti].trace_id,
				      event_parms[mi].marker_id,
				      NULL,
				      &err);
      if (NULL != err) {
	fprintf (stderr, "Unable to append event: %s\n", err->message);
	g_error_free (err);
      }
      ftk_eventviewer_append_event_e (FTK_EVENTVIEWER (eventviewer2),
				      event_parms[mi].trace_id,
				      thread_parms[ti].marker_id,
				      NULL,
				      &err);
      if (NULL != err) {
	fprintf (stderr, "Unable to append event: %s\n", err->message);
	g_error_free (err);
      }
    }
  }
  signal (SIGALRM, catch_sigalrm);
}

static void
quit_cb (GtkButton * button, gpointer user_data)
{
  gtk_widget_destroy (frame2);
  eventviewer2 = NULL;
}

int main( int   argc,
          char *argv[] )
{
  GtkWidget *window;
  GtkWidget *vbox;
  GtkWidget *frame;
  gboolean rc;
  GError * err;
  
  gtk_init (&argc, &argv);

  srand48 (time (0));

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_signal_connect(GTK_OBJECT(window),
                     "destroy",
                     GTK_SIGNAL_FUNC(gtk_main_quit),
                     NULL);
  
  gtk_window_set_title (GTK_WINDOW (window), "Frysk Eventviewer");

#if 0
  {
    GdkColor color;

    if (gdk_color_parse ("purple", &color)) {
      fprintf (stderr, "purple = %#08x [%d %d %d]\n",
	       (int)color.pixel,
	       (int)color.red,
	       (int)color.green,
	       (int)color.blue);
    }
    else fprintf (stderr, "purple not found\n");
  }
#endif
  
  gdk_color_parse ("black", &bg_color);
  gdk_color_parse ("lightblue", &bg_color1);
  
  g_signal_connect (G_OBJECT (window), "destroy",
		    G_CALLBACK (exit), NULL);
  
  gtk_container_set_border_width (GTK_CONTAINER (window), 10);

  vbox = gtk_vbox_new(FALSE, 10);
  gtk_container_add(GTK_CONTAINER(window), vbox);
  gtk_widget_show(vbox);


  eventviewer1 = ftk_eventviewer_new ();
  //  ftk_eventviewer_resize (FTK_EVENTVIEWER (eventviewer1), 500, 150);
  gtk_widget_show (eventviewer1);

  eventviewer2 = ftk_eventviewer_new ();
  //  ftk_eventviewer_resize (FTK_EVENTVIEWER (eventviewer2), 500, 175);
  gtk_widget_show (eventviewer2);
  
  thread_viewer = FTK_EVENTVIEWER (eventviewer1);
  event_viewer  = FTK_EVENTVIEWER (eventviewer2);

  /* if not set, default is provided */
  ftk_eventviewer_set_bg_color (thread_viewer, &bg_color1);
  ftk_eventviewer_set_bg_color (event_viewer, &bg_color);
  
  ftk_eventviewer_set_timebase (thread_viewer, 20.0);
  ftk_eventviewer_set_timebase (event_viewer, 20.0);

  

  {
    int i;

    for (i = 0; i < events_count; i++) {		/* for every event type... */
      event_parms[i].marker_id =			/* create a marker in the thread view */
	ftk_eventviewer_marker_new (thread_viewer,	/* using auto glyph and color assgn   */
				    FTK_GLYPH_AUTOMATIC,
				    event_parms[i].label,
				    event_parms[i].string);
      event_parms[i].color =				/* retrieve the color      */
	ftk_eventviewer_get_marker_color (thread_viewer,
					  event_parms[i].marker_id);
      event_parms[i].trace_id =				/* create a trace in the event view   */
	ftk_eventviewer_add_trace (event_viewer, event_parms[i].label, event_parms[i].tstring);
      ftk_eventviewer_set_trace_color (event_viewer,
				       event_parms[i].trace_id,
				       event_parms[i].color);
    }
    
    for (i = 0; i < threads_count; i++) {		/* for every thread type... */
      thread_parms[i].marker_id =			/* create a marker in the event view */
	ftk_eventviewer_marker_new (event_viewer,
				    FTK_GLYPH_AUTOMATIC,
				    thread_parms[i].label,
				    thread_parms[i].string);
      thread_parms[i].color =				/* retrieve the color      */
	ftk_eventviewer_get_marker_color (event_viewer,
					  thread_parms[i].marker_id);
      thread_parms[i].trace_id =			/* create a trace in the thread view  */
	ftk_eventviewer_add_trace (thread_viewer, thread_parms[i].label, thread_parms[i].tstring);
      ftk_eventviewer_set_trace_color (thread_viewer,
				       thread_parms[i].trace_id,
				       thread_parms[i].color);
    }
  }

  /* just for the fun of it, change the linewidth and linestyle of some trace */
  /* width in pixels.  a width <= 0 implies default width. values 1 - 8 work ok */
  /* style is dash spec */
  ftk_eventviewer_set_trace_linestyle (thread_viewer,
				       thread_parms[IDX_PARENT].trace_id,
				       5,			/* width */
				       5);	/* style */
  
#ifdef USE_TIE_LABEL
  clone_tie = ftk_eventviewer_tie_new (thread_viewer, "clone");
#else
  clone_tie = ftk_eventviewer_tie_new (thread_viewer);
  term_tie = ftk_eventviewer_tie_new (thread_viewer);
#endif
  ftk_eventviewer_set_tie_color (thread_viewer, clone_tie, &clone_tie_color);
  ftk_eventviewer_set_tie_color (thread_viewer, term_tie,  &term_tie_color);
  ftk_eventviewer_set_tie_linestyle (thread_viewer, term_tie,  2, 2);

  ftk_eventviewer_append_simultaneous_events (thread_viewer,
					      clone_tie,
					      thread_parms[IDX_PARENT].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "a simultaneous w/ thread 0 clone",
					      thread_parms[IDX_THREAD0].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "b simultaneous w/ parent clone",
					      -1);

  ftk_eventviewer_append_simultaneous_events (event_viewer,
					      -1,
					      event_parms[IDX_CLONE].trace_id,
					      thread_parms[IDX_PARENT].marker_id,
					      "c simultaneous w/ thread 0 clone",
					      event_parms[IDX_CLONE].trace_id,
					      thread_parms[IDX_THREAD0].marker_id,
					      "d simultaneous w/ parent clone",
					      -1);
    
  usleep (250000);
  
  ftk_eventviewer_append_simultaneous_events (thread_viewer,
					      clone_tie,
					      thread_parms[IDX_PARENT].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "e simultaneous w/ thread 1\nand thread 2 clones",
					      thread_parms[IDX_THREAD2].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "f simultaneous w/ parent\nand thread 1 clones",
					      thread_parms[IDX_THREAD1].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "g simultaneous w/ parent\nand thread 2 clones",
					      -1);
  
  ftk_eventviewer_append_simultaneous_events (event_viewer,
					      -1,
					      event_parms[IDX_CLONE].trace_id,
					      thread_parms[IDX_PARENT].marker_id,
					      "h simultaneous w/ thread 1 clone",
					      event_parms[IDX_CLONE].trace_id,
					      thread_parms[IDX_THREAD1].marker_id,
					      "i simultaneous w/ parent clone",
					      -1);
    
  usleep (250000);
  
  ftk_eventviewer_append_simultaneous_events (thread_viewer,
					      clone_tie,
					      thread_parms[IDX_PARENT].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "j simultaneous w/ thread 2 clone",
					      thread_parms[IDX_THREAD2].trace_id,
					      event_parms[IDX_CLONE].marker_id,
					      "k simultaneous w/ parent clone",
					      -1);
  
  ftk_eventviewer_append_simultaneous_events (event_viewer,
					      -1,
					      event_parms[IDX_CLONE].trace_id,
					      thread_parms[IDX_PARENT].marker_id,
					      "l simultaneous w/ thread 2 clone",
					      event_parms[IDX_CLONE].trace_id,
					      thread_parms[IDX_THREAD2].marker_id,
					      "m simultaneous w/ parent clone",
					      -1);
    
  usleep (250000);


    
#if 0
  ftk_eventviewer_resize (thread_viewer, 600, 100);
#endif

  max_event_nr = 4;

  /* _e suffixed versions of the fcns tell you if something screwed up */
  err = NULL;
  if (NULL != err) {
    fprintf (stderr, "Unable to set update: %s\n", err->message);
    g_error_free (err);
    exit (1);
  }
    
  if (FALSE == rc) exit (2);

  frame = gtk_frame_new ("Events by thread");
  gtk_container_add (GTK_CONTAINER(frame), eventviewer1);
  gtk_widget_show (frame);
  gtk_box_pack_start_defaults (GTK_BOX (vbox), frame);

  frame2 = gtk_frame_new ("Threads by event");
  gtk_container_add (GTK_CONTAINER(frame2), eventviewer2);
  gtk_widget_show (frame2);
  gtk_box_pack_start_defaults (GTK_BOX (vbox), frame2);
  
  {
    GtkWidget * hbutton_box = gtk_hbutton_box_new();
    GtkWidget * quit_button
      = gtk_button_new_with_mnemonic ("_Quit");

    g_signal_connect (GTK_OBJECT(quit_button),"clicked",
                      (GtkSignalFunc) quit_cb, NULL);
    gtk_container_add (GTK_CONTAINER (hbutton_box), quit_button);
    gtk_widget_show_all (hbutton_box);

    gtk_box_pack_start (GTK_BOX (vbox), hbutton_box, FALSE, FALSE, 0);
  }

  gtk_widget_show (window);

  {
    struct itimerval value;
    struct itimerval ovalue;

    signal (SIGALRM, catch_sigalrm);

    value.it_interval.tv_sec = 0;
    value.it_interval.tv_usec = 500000;
    value.it_value.tv_sec = 0;
    value.it_value.tv_usec = 500000;
    setitimer (ITIMER_REAL, &value, &ovalue);
  }
 
  gtk_main ();
  
  return 0;
}

    

Screenshots

A sccreenshot from the above fake application.

Figure 2.

A sccreenshot from the above fake application showing a detail of linked simultaneous events.

Figure 3.

A sccreenshot from the above fake application showing a detail of linked non-simultaneous events.

Figure 4.