TSP: The Transport Sample Protocol



Main Page | Modules | Alphabetical List | Data Structures | File List | Data Fields | Globals | Related Pages

gdisp_sampledSymbols.c

Go to the documentation of this file.
00001 
00043 /*
00044  * System includes.
00045  */
00046 #include <stdio.h>
00047 #include <stdlib.h>
00048 #include <assert.h>
00049 #include <string.h>
00050 
00051 
00052 /*
00053  * GDISP+ includes.
00054  */
00055 #include "gdisp_kernel.h"
00056 #include "gdisp_prototypes.h"
00057 
00058 
00059 /*
00060  --------------------------------------------------------------------
00061                              STATIC ROUTINES
00062  --------------------------------------------------------------------
00063 */
00064 
00065 #define GD_TREE_NB_COLUMNS 2
00066 #define GD_TREE_SPACING    3
00067 #define GD_TREE_COLUMN     0 /* the tree is at the first column */
00068 
00069 /*
00070  * The the style of of node.
00071  * This routine is set up as a recursive callback.
00072  */
00073 static void
00074 gdisp_changeNodeStyle(GtkCTree     *cTree,
00075                       GtkCTreeNode *cNode,
00076                       gpointer      data)
00077 {
00078 
00079   if (data != (gpointer)NULL)
00080     gtk_ctree_node_set_row_style(cTree,
00081                                  cNode,
00082                                  (GtkStyle*)data);
00083 
00084 }
00085 
00086 
00087 /*
00088  * Row selection callback.
00089  * Recursively change the style of all nodes.
00090  */
00091 static void
00092 gdisp_treeSelectRowCallback(GtkCTree     *cTree,
00093                             GtkCTreeNode *cNode,
00094                             gint          column,
00095                             gpointer      data)
00096 {
00097 
00098   Kernel_T *kernel = (Kernel_T*)data;
00099 
00100   /*
00101    * Recursively change the style of all sub-nodes.
00102    */
00103   gtk_ctree_pre_recursive(cTree,
00104                           cNode,
00105                           gdisp_changeNodeStyle,
00106                           (gpointer)kernel->widgets.selectedNodeStyle);
00107 
00108 }
00109  
00110 
00111 /*
00112  * Row unselection callback.
00113  * Recursively change the style of all nodes.
00114  */
00115 static void
00116 gdisp_treeUnselectRowCallback(GtkCTree     *cTree,
00117                               GtkCTreeNode *cNode,
00118                               gint          column,
00119                               gpointer      data)
00120 {
00121 
00122   Kernel_T *kernel = (Kernel_T*)data;
00123 
00124   /*
00125    * Recursively change the style of all sub-nodes.
00126    */
00127   gtk_ctree_pre_recursive(cTree,
00128                           cNode,
00129                           gdisp_changeNodeStyle,
00130                           (gpointer)kernel->widgets.unselectedNodeStyle);
00131 
00132 }
00133  
00134 
00135 /*
00136  * Expand the node that has been selected.
00137  */
00138 static void
00139 gdisp_expandNodeCallback(GtkCTree     *cTree,
00140                          GtkCTreeNode *cNode,
00141                          gpointer      data)
00142 {
00143 
00144   /*
00145    * Nothing by now.
00146    */
00147 
00148 }
00149 
00150 
00151 /*
00152  * Collapse the node that has been selected.
00153  */
00154 static void
00155 gdisp_collapseNodeCallback(GtkCTree     *cTree,
00156                            GtkCTreeNode *cNode,
00157                            gpointer      data)
00158 {
00159 
00160   /*
00161    * Nothing by now.
00162    */
00163 
00164 }
00165 
00166 
00167 /*
00168  * Get a child node according to its name.
00169  */
00170 static GtkCTreeNode*
00171 gdisp_getChildAccordingToItsName ( Kernel_T     *kernel,
00172                                    GtkCTreeNode *parentNode,
00173                                    gchar        *requestedChildName )
00174 {
00175 
00176   GtkWidget    *cTree          =    (GtkWidget*)NULL;
00177   GtkCTreeRow  *parentNodeRow  =  (GtkCTreeRow*)NULL;
00178   GtkCTreeNode *parentChild    = (GtkCTreeNode*)NULL;
00179   GtkCTreeNode *requestedChild = (GtkCTreeNode*)NULL;
00180   gchar        *childName      =        (gchar*)NULL;
00181 
00182   /*
00183    * Deduce node row from node.
00184    */
00185   cTree = kernel->widgets.sampledSymbolHTree;
00186   parentNodeRow = GTK_CTREE_ROW(parentNode);
00187 
00188   /*
00189    * Loop over all children.
00190    */
00191   parentChild = parentNodeRow->children;
00192 
00193   while (requestedChild == (GtkCTreeNode*)NULL &&
00194          parentChild    != (GtkCTreeNode*)NULL    ) {
00195 
00196     childName = (gchar*)gtk_ctree_node_get_row_data(GTK_CTREE(cTree),
00197                                                     parentChild);
00198 
00199     if (childName != (gchar*)NULL &&
00200         strcmp(childName,requestedChildName) == 0) {
00201 
00202       requestedChild = parentChild;
00203 
00204     }
00205     else {
00206 
00207       parentChild = GTK_CTREE_NODE_NEXT(parentChild);
00208 
00209     }
00210 
00211   }
00212 
00213   return requestedChild;
00214 
00215 }
00216 
00217 
00218 /*
00219  * Create a provider node.
00220  */
00221 static GtkWidget*
00222 gdisp_createHierarchicalTree ( Kernel_T *kernel )
00223 {
00224 
00225   GtkWidget *cTree;
00226   gchar     *cTitles[GD_TREE_NB_COLUMNS] = { "Properties", "Information" };
00227 
00228 
00229   /*
00230    * Create the hierarchical tree.
00231    */
00232   cTree = gtk_ctree_new_with_titles(GD_TREE_NB_COLUMNS,
00233                                     GD_TREE_COLUMN,
00234                                     cTitles);
00235 
00236   /*
00237    * The style of the lines that link all nodes.
00238    * GTK_CTREE_LINES_NONE,
00239    * GTK_CTREE_LINES_SOLID,
00240    * GTK_CTREE_LINES_DOTTED,
00241    * GTK_CTREE_LINES_TABBED.
00242    */
00243   gtk_ctree_set_line_style(GTK_CTREE(cTree),
00244                            GTK_CTREE_LINES_DOTTED);
00245 
00246   /*
00247    * The style of all expanders.
00248    * The expander is the place where the user must clic in order to
00249    * expand or collapse nodes.
00250    * GTK_CTREE_EXPANDER_NONE,
00251    * GTK_CTREE_EXPANDER_SQUARE,
00252    * GTK_CTREE_EXPANDER_TRIANGLE,
00253    * GTK_CTREE_EXPANDER_CIRCULAR.
00254    */
00255   gtk_ctree_set_expander_style(GTK_CTREE(cTree),
00256                                GTK_CTREE_EXPANDER_SQUARE);
00257 
00258   /*
00259    * Set up button actions.
00260    * Left button selects, expands or collapses nodes.
00261    * All other do nothing.
00262    * GTK_BUTTON_IGNORED = 0,
00263    * GTK_BUTTON_SELECTS = 1 << 0,
00264    * GTK_BUTTON_DRAGS   = 1 << 1,
00265    * GTK_BUTTON_EXPANDS = 1 << 2.
00266    */
00267   gtk_clist_set_button_actions(GTK_CLIST(cTree),
00268                                0, /* left button   */
00269                                GTK_BUTTON_EXPANDS | GTK_BUTTON_SELECTS);
00270 
00271   gtk_clist_set_button_actions(GTK_CLIST(cTree),
00272                                1, /* middle button */
00273                                GTK_BUTTON_IGNORED);
00274 
00275   gtk_clist_set_button_actions(GTK_CLIST(cTree),
00276                                2, /* right button  */
00277                                GTK_BUTTON_IGNORED);
00278 
00279 
00280   /*
00281    * Connect all mandatory signals.
00282    */
00283   gtk_signal_connect (GTK_OBJECT(cTree),
00284                       "tree-expand",
00285                       gdisp_expandNodeCallback,
00286                       (gpointer)kernel); 
00287 
00288   gtk_signal_connect (GTK_OBJECT(cTree),
00289                       "tree-collapse",
00290                       gdisp_collapseNodeCallback,
00291                       (gpointer)kernel); 
00292 
00293   gtk_signal_connect (GTK_OBJECT(cTree),
00294                       "tree-select-row",
00295                       gdisp_treeSelectRowCallback,
00296                       (gpointer)kernel); 
00297 
00298   gtk_signal_connect (GTK_OBJECT(cTree),
00299                       "tree-unselect-row",
00300                       gdisp_treeUnselectRowCallback,
00301                       (gpointer)kernel); 
00302 
00303   /*
00304    * Show the tree.
00305    */
00306   gtk_widget_show(cTree);
00307 
00308   return cTree;
00309 
00310 }
00311 
00312 
00313 /*
00314  * Create a node that will contain all provider information.
00315  */
00316 static void
00317 gdisp_createProviderNode(Kernel_T      *kernel,
00318                          GtkWidget     *parent,
00319                          GtkWidget     *tree,
00320                          Provider_T    *provider,
00321                          GtkCTreeNode **providerNode,
00322                          GtkCTreeNode **sampledSymbolNode)
00323 {
00324 
00325   gchar        *pNames [GD_TREE_NB_COLUMNS] = { (gchar*)NULL,  (gchar*)NULL };
00326   GtkCTreeNode *iNode                       = (GtkCTreeNode*)NULL;
00327   GtkCTreeNode *sNode                       = (GtkCTreeNode*)NULL;
00328   Pixmap_T     *pPixmap                     = (Pixmap_T*)NULL;
00329 
00330   /*
00331    * The name of the node is the URL of the provider.
00332    * Get back provider pixmap according to its identity.
00333    */
00334   pNames[0] = provider->pUrl->str;
00335 
00336   pPixmap = gdisp_getProviderIdPixmap(kernel,
00337                                       parent,
00338                                       provider->pIdentity);
00339 
00340   provider->pNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00341                                           (GtkCTreeNode*)NULL, /* parent  */
00342                                           (GtkCTreeNode*)NULL, /* sibling */
00343                                           pNames,
00344                                           GD_TREE_SPACING,
00345                                           pPixmap->pixmap,
00346                                           pPixmap->mask,
00347                                           pPixmap->pixmap,
00348                                           pPixmap->mask,
00349                                           FALSE, /* is a leave  */
00350                                           TRUE); /* is expanded */
00351 
00352   gtk_ctree_node_set_row_data(GTK_CTREE(tree),
00353                               provider->pNode,
00354                               (gpointer)provider);
00355 
00356   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00357                                 provider->pNode,
00358                                 FALSE); /* not selectable */
00359 
00360   /*
00361    * Insert information node.
00362    */
00363   pNames[0] = "Information";
00364 
00365   pPixmap = gdisp_getPixmapById(kernel,
00366                                 GD_PIX_info,
00367                                 parent);
00368 
00369   iNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00370                                 provider->pNode, /* provider is the parent */
00371                                 (GtkCTreeNode*)NULL, /* no sibling node */
00372                                 pNames,
00373                                 GD_TREE_SPACING,
00374                                 pPixmap->pixmap,
00375                                 pPixmap->mask,
00376                                 pPixmap->pixmap,
00377                                 pPixmap->mask,
00378                                 FALSE, /* is a leave  */
00379                                 FALSE); /* is expanded */
00380 
00381   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00382                                 iNode,
00383                                 FALSE); /* not selectable */
00384 
00385   /*
00386    * Insert sampled symbol node.
00387    */
00388   pNames[0] = "Sampled Symbols";
00389   sNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00390                                 provider->pNode, /* provider is the parent */
00391                                 (GtkCTreeNode*)NULL, /* no sibling node */
00392                                 pNames,
00393                                 GD_TREE_SPACING,
00394                                 kernel->widgets.collapsedNodePixmap->pixmap,
00395                                 kernel->widgets.collapsedNodePixmap->mask,
00396                                 kernel->widgets.expandedNodePixmap->pixmap,
00397                                 kernel->widgets.expandedNodePixmap->mask,
00398                                 FALSE, /* is a leave  */
00399                                 FALSE); /* is expanded */
00400 
00401   gtk_ctree_node_set_row_data(GTK_CTREE(tree),
00402                               sNode,
00403                               (gpointer)"sAnchor");
00404 
00405   gtk_ctree_node_set_text(GTK_CTREE(tree),
00406                           sNode,
00407                           0, /* column */
00408                           pNames[0]);
00409 
00410   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00411                                 sNode,
00412                                 FALSE); /* not selectable */
00413 
00414   if (gdisp_getProviderNumber(kernel) == 1) {
00415 
00416     /*
00417      * Expand that node if there is only one provider.
00418      */
00419     gtk_ctree_expand(GTK_CTREE(tree),sNode);
00420 
00421   }
00422 
00423   /*
00424    * Return.
00425    */
00426   *providerNode      = provider->pNode;
00427   *sampledSymbolNode = sNode;
00428 
00429 }
00430 
00431 
00432 /*
00433  * Create a node that will contain all sampled symbol information.
00434  */
00435 static void
00436 gdisp_createSymbolNode(Kernel_T     *kernel,
00437                        GtkWidget    *tree,
00438                        GtkCTreeNode *sampledSymbolNode,
00439                        Symbol_T     *symbol)
00440 {
00441 
00442   GtkCTreeNode *iNode                       = (GtkCTreeNode*)NULL;
00443   gchar         iInfo  [128];
00444   gchar        *iNames [GD_TREE_NB_COLUMNS] = { (gchar*)NULL,  (gchar*)NULL };
00445 
00446   /*
00447    * The name of the node is the name of the symbol.
00448    */
00449   iNames[0] = symbol->sInfo.name;
00450   symbol->sNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00451                                         sampledSymbolNode,
00452                                         (GtkCTreeNode*)NULL, /* no sibling */
00453                                         iNames,
00454                                         GD_TREE_SPACING,
00455                                         (GdkPixmap*)NULL,
00456                                         (GdkBitmap*)NULL,
00457                                         (GdkPixmap*)NULL,
00458                                         (GdkBitmap*)NULL,
00459                                         FALSE, /* is a leave  */
00460                                         FALSE); /* is expanded */
00461 
00462   gtk_ctree_node_set_row_data(GTK_CTREE(tree),
00463                               symbol->sNode,
00464                               (gpointer)symbol);
00465 
00466   /*
00467    * Insert information node : PERIOD.
00468    */
00469   iNames[0] = "Period";
00470   iNames[1] = iInfo;
00471   sprintf(iNames[1],"%d",symbol->sInfo.period);
00472 
00473   iNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00474                                 symbol->sNode, /* symbol node is the parent */
00475                                 (GtkCTreeNode*)NULL, /* no sibling node */
00476                                 iNames,
00477                                 GD_TREE_SPACING,
00478                                 (GdkPixmap*)NULL,
00479                                 (GdkBitmap*)NULL,
00480                                 (GdkPixmap*)NULL,
00481                                 (GdkBitmap*)NULL,
00482                                 TRUE,   /* is a leave  */
00483                                 FALSE); /* is expanded */
00484 
00485   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00486                                 iNode,
00487                                 FALSE); /* not selectable */
00488 
00489 
00490   /*
00491    * Insert information node : PHASE.
00492    */
00493   iNames[0] = "Phase";
00494   iNames[1] = iInfo;
00495   sprintf(iNames[1],"%d",symbol->sInfo.phase);
00496 
00497   iNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00498                                 symbol->sNode, /* symbol node is the parent */
00499                                 (GtkCTreeNode*)NULL, /* no sibling node */
00500                                 iNames,
00501                                 GD_TREE_SPACING,
00502                                 (GdkPixmap*)NULL,
00503                                 (GdkBitmap*)NULL,
00504                                 (GdkPixmap*)NULL,
00505                                 (GdkBitmap*)NULL,
00506                                 TRUE,   /* is a leave  */
00507                                 FALSE); /* is expanded */
00508 
00509   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00510                                 iNode,
00511                                 FALSE); /* not selectable */
00512 
00513 
00514   /*
00515    * Insert information node : RANGE.
00516    */
00517   iNames[0] = "Range";
00518   iNames[1] = iInfo;
00519   sprintf(iNames[1],"[ n/a .. n/a ]");
00520 
00521   iNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00522                                 symbol->sNode, /* symbol node is the parent */
00523                                 (GtkCTreeNode*)NULL, /* no sibling node */
00524                                 iNames,
00525                                 GD_TREE_SPACING,
00526                                 (GdkPixmap*)NULL,
00527                                 (GdkBitmap*)NULL,
00528                                 (GdkPixmap*)NULL,
00529                                 (GdkBitmap*)NULL,
00530                                 TRUE,   /* is a leave  */
00531                                 FALSE); /* is expanded */
00532 
00533   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00534                                 iNode,
00535                                 FALSE); /* not selectable */
00536 
00537 
00538   /*
00539    * Insert information node : REFERENCE.
00540    */
00541   iNames[0] = "Reference";
00542   iNames[1] = iInfo;
00543   sprintf(iNames[1],"%d",symbol->sReference);
00544 
00545   iNode = gtk_ctree_insert_node(GTK_CTREE(tree),
00546                                 symbol->sNode, /* symbol node is the parent */
00547                                 (GtkCTreeNode*)NULL, /* no sibling node */
00548                                 iNames,
00549                                 GD_TREE_SPACING,
00550                                 (GdkPixmap*)NULL,
00551                                 (GdkBitmap*)NULL,
00552                                 (GdkPixmap*)NULL,
00553                                 (GdkBitmap*)NULL,
00554                                 TRUE,   /* is a leave  */
00555                                 FALSE); /* is expanded */
00556 
00557   gtk_ctree_node_set_selectable(GTK_CTREE(tree),
00558                                 iNode,
00559                                 FALSE); /* not selectable */
00560 
00561   gtk_ctree_node_set_row_data(GTK_CTREE(tree),
00562                               iNode,
00563                               (gpointer)"sReference");
00564 
00565 }
00566 
00567 
00568 /*
00569  * Update an existing symbol node.
00570  */
00571 static void
00572 gdisp_updateSymbolNode ( Kernel_T  *kernel,
00573                          GtkWidget *cTree,
00574                          Symbol_T  *symbol )
00575 {
00576 
00577   GtkCTreeNode *referenceNode = (GtkCTreeNode*)NULL;
00578   GString      *messageString =      (GString*)NULL;
00579   gchar         buffer[128];
00580 
00581   /*
00582    * The reference information is the only one to be refreshed.
00583    * Get back the reference node.
00584    */
00585   referenceNode = gdisp_getChildAccordingToItsName(kernel,
00586                                                    symbol->sNode,
00587                                                    "sReference");
00588 
00589   if (referenceNode == (GtkCTreeNode*)NULL) {
00590 
00591     /* should never happen, because I did create this node !! */
00592     messageString = g_string_new((gchar*)NULL);
00593     g_string_sprintf(messageString,
00594                      "%s symbol has no reference node.",
00595                      symbol->sInfo.name);
00596     kernel->outputFunc(kernel,messageString,GD_ERROR);
00597 
00598   }
00599   else {
00600 
00601     sprintf(buffer,"%d",symbol->sReference);
00602     gtk_ctree_node_set_text(GTK_CTREE(cTree),
00603                             referenceNode,
00604                             1, /* column */
00605                             buffer);
00606 
00607   }
00608 
00609 }
00610 
00611 
00612 /*
00613  * Finalise hierarchical tree.
00614  */
00615 static void
00616 gdisp_finaliseHierarchicalTree ( Kernel_T  *kernel,
00617                                  GtkWidget *cTree )
00618 {
00619 
00620   guint optimalWidth = 0;
00621 
00622   /*
00623    * Do not known what this 'stub' is...
00624    */
00625   gtk_ctree_set_show_stub(GTK_CTREE(cTree),
00626                           TRUE);
00627 
00628   /*
00629    * Change tree global aspect.
00630    */
00631   gtk_clist_set_row_height(GTK_CLIST(cTree), /* CLIST, and not CTREE !! */
00632                            15);
00633 
00634   gtk_ctree_set_indent(GTK_CTREE(cTree),
00635                        16);
00636 
00637   /*
00638    * Compute first column optimal length.
00639    */
00640   optimalWidth = gtk_clist_optimal_column_width(GTK_CLIST(cTree),
00641                                                 0 /* first column */);
00642   gtk_clist_set_column_width(GTK_CLIST(cTree),
00643                              0, /* first column */
00644                              optimalWidth);
00645 
00646 }
00647 
00648 
00649 /*
00650  * Graphically show the status of all sampled symbols.
00651  */
00652 static void
00653 gdisp_poolSampledSymbolList ( Kernel_T *kernel )
00654 {
00655 
00656   GtkWidget        *cTree            =    (GtkWidget*)NULL;
00657   GString          *messageString    =      (GString*)NULL;
00658   GList            *providerItem     =        (GList*)NULL;
00659   Provider_T       *provider         =   (Provider_T*)NULL;
00660   Symbol_T         *symbol           =     (Symbol_T*)NULL;
00661   GtkCTreeNode     *pSymbolAnchor    = (GtkCTreeNode*)NULL;
00662 
00663   gint              pSampleCpt       =                   0;
00664   SampleList_T     *pSampleList      = (SampleList_T*)NULL;
00665   guint             pSampleMax       =                   0;
00666 
00667 
00668   /* ------------------------ PER PROVIDER ---------------------- */
00669 
00670   cTree = kernel->widgets.sampledSymbolHTree;
00671 
00672   /*
00673    * When removing a node, GTK main loop activate the "unselect"
00674    * callback, that performs a post recursive action on a node
00675    * that has been destroyed.
00676    * Avoid that shame by temporarily blocking the signal emission.
00677    */
00678   gtk_signal_handler_block_by_func(GTK_OBJECT(cTree),
00679                                    gdisp_treeUnselectRowCallback,
00680                                    (gpointer)kernel); 
00681 
00682   /*
00683    * Loop over all providers.
00684    */
00685   providerItem = g_list_first(kernel->providerList);
00686   while (providerItem != (GList*)NULL) {
00687 
00688     provider  = (Provider_T*)providerItem->data;
00689 
00690     /*
00691      * Look for symbol anchor.
00692      */
00693     pSymbolAnchor = gdisp_getChildAccordingToItsName(kernel,
00694                                                      provider->pNode,
00695                                                      "sAnchor");
00696 
00697     if (pSymbolAnchor == (GtkCTreeNode*)NULL) {
00698 
00699       /* should never happen, because I did create this node !! */
00700       messageString = g_string_new((gchar*)NULL);
00701       g_string_sprintf(messageString,
00702                        "%s provider has no anchor for symbols.",
00703                        provider->pUrl->str);
00704       kernel->outputFunc(kernel,messageString,GD_ERROR);
00705 
00706     }
00707     else {
00708 
00709       /* --------------------- PER SAMPLED SYMBOLS ---------------- */
00710 
00711       /*
00712        * Loop over all sampled symbol of the current provider.
00713        */
00714       pSampleList = &provider->pSampleList;
00715       pSampleMax  = pSampleList->len;
00716 
00717       for (pSampleCpt=0; pSampleCpt<pSampleMax; pSampleCpt++) {
00718 
00719         /*
00720          * Get in touch with the symbol through the global index.
00721          */
00722         symbol = &provider->pSymbolList[pSampleList->val[pSampleCpt].index];
00723 
00724         /*
00725          * If referenced... ie, used by graphic plots...
00726          */
00727         if (symbol->sReference > 0) {
00728 
00729           /*
00730            * Create the hierarchy for that symbol, if not already done.
00731            */
00732           if (symbol->sNode == (GtkCTreeNode*)NULL) {
00733 
00734             gdisp_createSymbolNode(kernel,
00735                                    cTree,
00736                                    pSymbolAnchor,
00737                                    symbol);
00738 
00739           }
00740           else {
00741 
00742             gdisp_updateSymbolNode(kernel,
00743                                    cTree,
00744                                    symbol);
00745 
00746           }
00747 
00748         } /* sReference > 0 */
00749 
00750         else {
00751 
00752           if (symbol->sNode != (GtkCTreeNode*)NULL) {
00753 
00754             gtk_ctree_remove_node(GTK_CTREE(cTree),
00755                                   symbol->sNode);
00756 
00757             symbol->sNode = (GtkCTreeNode*)NULL;
00758 
00759           }
00760 
00761         } /* sReference == 0 */
00762 
00763       } /* loop over sampled symbols */
00764 
00765     } /* found sAnchor */
00766 
00767     /*
00768      * Next provider.
00769      */
00770     providerItem = g_list_next(providerItem);
00771 
00772   } /* loop over all providers */
00773 
00774   /*
00775    * Finalise.
00776    */
00777   gdisp_finaliseHierarchicalTree(kernel,
00778                                  cTree);
00779 
00780   /*
00781    * Activate again the unselect handler.
00782    */
00783   gtk_signal_handler_unblock_by_func(GTK_OBJECT(cTree),
00784                                      gdisp_treeUnselectRowCallback,
00785                                      (gpointer)kernel);
00786 
00787 }
00788 
00789 
00790 
00791 /*
00792  --------------------------------------------------------------------
00793                              PUBLIC ROUTINES
00794  --------------------------------------------------------------------
00795 */
00796 
00797 
00798 /*
00799  * These two procedures deal with sampled symbol list.
00800  * In order to graphically show all sampled symbols, a procedure
00801  * is registered in order to pool sampled symbol list.
00802  * The procedure is registered when the sampled symbol page is show
00803  * in the databook. The procedure is unregistered when other pages are
00804  * shown in the databook.
00805  */
00806 void
00807 gdisp_sampledSymbolTimer ( Kernel_T  *kernel,
00808                            gboolean   timerIsStarted )
00809 {
00810 
00811 #if defined(SAMPLED_SYMBOL_DEBUG)
00812 
00813   fprintf(stdout,
00814           "Sampled Symbol Timer : %s\n",
00815           timerIsStarted == TRUE ? "STARTED" : "STOPPED");
00816   fflush (stdout);
00817 
00818 #endif
00819 
00820   switch (timerIsStarted) {
00821 
00822   case TRUE :
00823 
00824     /* refresh immediately */
00825     gdisp_poolSampledSymbolList(kernel);
00826 
00827     (*kernel->registerAction)(kernel,
00828                               gdisp_poolSampledSymbolList);
00829 
00830     break;
00831 
00832   case FALSE :
00833 
00834     /* stop refreshing thread status */
00835     (*kernel->unRegisterAction)(kernel,
00836                                 gdisp_poolSampledSymbolList);
00837 
00838     break;
00839 
00840   }
00841 
00842 }
00843 
00844 
00845 /*
00846  * Create GDISP+ sampled symbol list.
00847  */
00848 void
00849 gdisp_createSampledSymbolList ( Kernel_T  *kernel,
00850                                 GtkWidget *parent )
00851 {
00852 
00853   GtkWidget        *sFrame           =    (GtkWidget*)NULL;
00854   GtkWidget        *scrolledWindow   =    (GtkWidget*)NULL;
00855   GtkWidget        *cTree            =    (GtkWidget*)NULL;
00856   GtkCTreeNode     *pNode            = (GtkCTreeNode*)NULL;
00857   GtkCTreeNode     *sNode            = (GtkCTreeNode*)NULL;
00858   GdkFont          *selectedFont     =      (GdkFont*)NULL;
00859   GdkFont          *unselectedFont   =      (GdkFont*)NULL;
00860 
00861   GList            *providerItem     =        (GList*)NULL;
00862   Provider_T       *provider         =   (Provider_T*)NULL;
00863 
00864 
00865   /* ------------------------ FRAME WITH LABEL ------------------------ */
00866 
00867   /*
00868    * Create a Frame that will contain a scrolled window for sampled symbols.
00869    * Align the label at the left of the frame.
00870    * Set the style of the frame.
00871    */
00872   sFrame = gtk_frame_new(" Sampled Symbols (for information only)");
00873   gtk_frame_set_label_align(GTK_FRAME(sFrame),0.1,0.0);
00874   gtk_frame_set_shadow_type(GTK_FRAME(sFrame),GTK_SHADOW_ETCHED_IN);
00875 
00876   gtk_container_add(GTK_CONTAINER(parent),sFrame);
00877   gtk_widget_show(sFrame);
00878 
00879 
00880   /* ------- SCROLLED WINDOW FOR THE LIST OF SAMPLED SYMBOLS --------- */
00881 
00882   /*
00883    * This is the scrolled window to put the List widget inside.
00884    */
00885   scrolledWindow = gtk_scrolled_window_new(NULL /* H Adjustment */,
00886                                            NULL /* V Adjustment */);
00887   gtk_container_border_width(GTK_CONTAINER(scrolledWindow),5);
00888   gtk_container_add(GTK_CONTAINER(sFrame),scrolledWindow); 
00889   gtk_widget_show(scrolledWindow);
00890 
00891 
00892   /* --------- HIERARCHICAL TREE FOR HANDLING ALL PROVIDERS --------- */
00893 
00894   cTree = gdisp_createHierarchicalTree(kernel);
00895   gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolledWindow),
00896                                         cTree);
00897   kernel->widgets.sampledSymbolHTree = cTree;
00898 
00899 
00900   /* ------------------------ NODE PIXMAPS --------------------- */
00901 
00902   /*
00903    * Create expanded/collapsed node pixmap & mask.
00904    */
00905   kernel->widgets.expandedNodePixmap =
00906     gdisp_getPixmapById(kernel,
00907                         GD_PIX_expandedNode,
00908                         GTK_WIDGET(scrolledWindow));
00909 
00910   kernel->widgets.collapsedNodePixmap =
00911     gdisp_getPixmapById(kernel,
00912                         GD_PIX_collapseNode,
00913                         GTK_WIDGET(scrolledWindow));
00914 
00915   /* ------------------------ PER PROVIDER ---------------------- */
00916 
00917   providerItem = g_list_first(kernel->providerList);
00918   while (providerItem != (GList*)NULL) {
00919 
00920     provider = (Provider_T*)providerItem->data;
00921 
00922     /* ----------------- PROVIDER NODE CREATION ------------------ */
00923 
00924     /*
00925      * Create a node that will contain all provider information.
00926      */
00927     gdisp_createProviderNode(kernel,
00928                              scrolledWindow,
00929                              cTree,
00930                              provider,
00931                              &pNode,
00932                              &sNode);
00933 
00934     /*
00935      * Next provider.
00936      */
00937     providerItem = g_list_next(providerItem);
00938 
00939   }
00940 
00941 
00942   /*
00943    * Create the styles that contain the correct font
00944    * for node selection / unselection.
00945    */
00946 #define GD_SELECTED_FONT   "-adobe-helvetica-bold-r-normal--12-*-*-*-*-*-*-*"
00947 #define GD_UNSELECTED_FONT "-adobe-helvetica-medium-r-normal--12-*-*-*-*-*-*-*"
00948 
00949   selectedFont   = gdk_font_load(GD_SELECTED_FONT);
00950   unselectedFont = gdk_font_load(GD_UNSELECTED_FONT);
00951 
00952   if (selectedFont == (GdkFont*)NULL || unselectedFont == (GdkFont*)NULL) {
00953 
00954     if (selectedFont != (GdkFont*)NULL) {
00955       gdk_font_unref(selectedFont);
00956       selectedFont = (GdkFont*)NULL;
00957     }
00958 
00959     if (unselectedFont != (GdkFont*)NULL) {
00960       gdk_font_unref(unselectedFont);
00961       unselectedFont = (GdkFont*)NULL;
00962     }
00963 
00964   }
00965   else {
00966 
00967     kernel->widgets.selectedNodeStyle =
00968       gtk_style_copy(gtk_widget_get_default_style());
00969 
00970     kernel->widgets.selectedNodeStyle->font = selectedFont;
00971 #if defined(GD_TREE_WITH_COLOR)
00972     kernel->widgets.selectedNodeStyle->fg[GTK_STATE_NORMAL] =
00973       kernel->colors[_CYAN_];
00974 #endif
00975 
00976     kernel->widgets.unselectedNodeStyle =
00977       gtk_style_copy(gtk_widget_get_default_style());
00978 
00979     kernel->widgets.unselectedNodeStyle->font = unselectedFont;
00980 #if defined(GD_TREE_WITH_COLOR)
00981     kernel->widgets.unselectedNodeStyle->fg[GTK_STATE_NORMAL] =
00982       kernel->colors[_BLACK_];
00983 #endif
00984 
00985   }
00986 
00987   /*
00988    * Finalise.
00989    */
00990   gdisp_finaliseHierarchicalTree(kernel,
00991                                  cTree);
00992 
00993 }
00994 
00995 
00996 /*
00997  * Destroy GDISP+ sampled symbol list.
00998  */
00999 void
01000 gdisp_destroySampledSymbolList ( Kernel_T *kernel )
01001 {
01002 
01003   /*
01004    * No need to destroy tree specific fonts, because they
01005    * are destroyed during style destruction.
01006    */
01007 
01008   /*
01009    * Destroy tree specific styles.
01010    */
01011   gtk_style_unref(kernel->widgets.selectedNodeStyle);
01012   kernel->widgets.selectedNodeStyle = (GtkStyle*)NULL;
01013 
01014   gtk_style_unref(kernel->widgets.unselectedNodeStyle);
01015   kernel->widgets.unselectedNodeStyle = (GtkStyle*)NULL;
01016 
01017   /*
01018    * Destroy the tree.
01019    */
01020   kernel->widgets.expandedNodePixmap  = (Pixmap_T*)NULL;
01021   kernel->widgets.collapsedNodePixmap = (Pixmap_T*)NULL;
01022   kernel->widgets.sampledSymbolHTree  = (GtkWidget*)NULL;
01023  
01024 }
Framework Home Page.

Beware !! TSP wave is coming...