This documentation is not the Latest Release.
A Discrete-Event Network Simulator
API
display-functions.cc
Go to the documentation of this file.
1 /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
2 /*
3  * This program is free software; you can redistribute it and/or modify
4  * it under the terms of the GNU General Public License version 2 as
5  * published by the Free Software Foundation;
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software
14  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15  *
16  * Authors: Faker Moatamri <faker.moatamri@sophia.inria.fr>
17  * Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
18  */
19 #include "display-functions.h"
20 #include "raw-text-config.h"
21 #include "ns3/config.h"
22 #include "ns3/string.h"
23 #include "ns3/pointer.h"
24 
25 namespace ns3 {
30 void
31 cell_data_function_col_1 (GtkTreeViewColumn *col, GtkCellRenderer *renderer,
32  GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
33 {
34  ModelNode *node;
35  gtk_tree_model_get (model, iter, COL_NODE, &node, -1);
36  if (node->type == ModelNode::NODE_ATTRIBUTE)
37  {
38  StringValue str;
39  node->object->GetAttribute (node->name, str);
40  g_object_set (renderer, "text", str.Get ().c_str (), (char*) 0);
41  g_object_set (renderer, "editable", TRUE, (char*) 0);
42  }
43  else
44  {
45  g_object_set (renderer, "text", "", (char*) 0);
46  g_object_set (renderer, "editable", FALSE, (char*) 0);
47  }
48 }
53 void
54 cell_data_function_col_0 (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
55  GtkTreeIter *iter, gpointer user_data)
56 {
57  ModelNode *node;
58  gtk_tree_model_get (model, iter, COL_NODE, &node, -1);
59  g_object_set (renderer, "editable", FALSE, (char*) 0);
60  switch (node->type)
61  {
62  case ModelNode::NODE_OBJECT:
63  g_object_set (renderer, "text", node->object->GetInstanceTypeId ().GetName ().c_str (), (char*) 0);
64  break;
65  case ModelNode::NODE_POINTER:
66  g_object_set (renderer, "text", node->name.c_str (), (char*) 0);
67  break;
68  case ModelNode::NODE_VECTOR:
69  g_object_set (renderer, "text", node->name.c_str (), (char*) 0);
70  break;
71  case ModelNode::NODE_VECTOR_ITEM:
72  {
73  std::stringstream oss;
74  oss << node->index;
75  g_object_set (renderer, "text", oss.str ().c_str (), (char*) 0);
76  }
77  break;
78  case ModelNode::NODE_ATTRIBUTE:
79  g_object_set (renderer, "text", node->name.c_str (), (char*) 0);
80  break;
81  }
82 }
83 
87 void
88 cell_edited_callback (GtkCellRendererText *cell, gchar *path_string,
89  gchar *new_text, gpointer user_data)
90 {
91  GtkTreeModel *model = GTK_TREE_MODEL (user_data);
92  GtkTreeIter iter;
93  gtk_tree_model_get_iter_from_string (model, &iter, path_string);
94  ModelNode *node;
95  gtk_tree_model_get (model, &iter, COL_NODE, &node, -1);
96  NS_ASSERT (node->type == ModelNode::NODE_ATTRIBUTE);
97  node->object->SetAttribute (node->name, StringValue (new_text));
98 }
99 
104 int
105 get_col_number_from_tree_view_column (GtkTreeViewColumn *col)
106 {
107  GList *cols;
108  int num;
109  g_return_val_if_fail (col != 0, -1);
110  g_return_val_if_fail (col->tree_view != 0, -1);
111  cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (col->tree_view));
112  num = g_list_index (cols, (gpointer) col);
113  g_list_free (cols);
114  return num;
115 }
116 
121 gboolean
122 cell_tooltip_callback (GtkWidget *widget, gint x, gint y, gboolean keyboard_tip,
123  GtkTooltip *tooltip, gpointer user_data)
124 {
125  GtkTreeModel *model;
126  GtkTreeIter iter;
127  GtkTreeViewColumn * column;
128  if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget), &x, &y,
129  keyboard_tip, &model, 0, &iter))
130  {
131  return FALSE;
132  }
133  if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), x, y, 0, &column, 0, 0))
134  {
135  return FALSE;
136  }
137  int col = get_col_number_from_tree_view_column (column);
138 
139  ModelNode *node;
140  gtk_tree_model_get (model, &iter, COL_NODE, &node, -1);
141 
142  switch (node->type)
143  {
144  case ModelNode::NODE_OBJECT:
145  if (col == 0)
146  {
147  std::string tip = "This object is of type "
148  + node->object->GetInstanceTypeId ().GetName ();
149  gtk_tooltip_set_text (tooltip, tip.c_str ());
150  return TRUE;
151  }
152  break;
153  case ModelNode::NODE_POINTER:
154  if (col == 0)
155  {
156  PointerValue ptr;
157  node->object->GetAttribute (node->name, ptr);
158  std::string tip = "This object is of type "
159  + ptr.GetObject ()->GetInstanceTypeId ().GetName ();
160  gtk_tooltip_set_text (tooltip, tip.c_str ());
161  return TRUE;
162  }
163  break;
164  case ModelNode::NODE_VECTOR:
165  break;
166  case ModelNode::NODE_VECTOR_ITEM:
167  if (col == 0)
168  {
169  std::string tip = "This object is of type "
170  + node->object->GetInstanceTypeId ().GetName ();
171  gtk_tooltip_set_text (tooltip, tip.c_str ());
172  return TRUE;
173  }
174  break;
175  case ModelNode::NODE_ATTRIBUTE:
176  {
177  uint32_t attrIndex = 0;
178  TypeId tid;
179  for (tid = node->object->GetInstanceTypeId (); tid.HasParent (); tid
180  = tid.GetParent ())
181  {
182  for (uint32_t i = 0; i < tid.GetAttributeN (); ++i)
183  {
184  if (tid.GetAttribute (i).name == node->name)
185  {
186  attrIndex = i;
187  goto out;
188  }
189  }
190  }
191 out: if (col == 0)
192  {
193  std::string tip = tid.GetAttribute (attrIndex).help;
194  gtk_tooltip_set_text (tooltip, tip.c_str ());
195  }
196  else
197  {
198  struct TypeId::AttributeInformation info = tid.GetAttribute (attrIndex);
199  Ptr<const AttributeChecker> checker = info.checker;
200  std::string tip;
201  tip = "This attribute is of type " + checker->GetValueTypeName ();
202  if (checker->HasUnderlyingTypeInformation ())
203  {
204  tip += " " + checker->GetUnderlyingTypeInformation ();
205  }
206  gtk_tooltip_set_text (tooltip, tip.c_str ());
207  }
208  return TRUE;
209  }
210  break;
211  }
212  return FALSE;
213 }
214 
219 GtkWidget *
220 create_view (GtkTreeStore *model)
221 {
222  GtkTreeViewColumn *col;
223  GtkCellRenderer *renderer;
224  GtkWidget *view;
225 
226  view = gtk_tree_view_new ();
227  g_object_set (view, "has-tooltip", TRUE, (char*) 0);
228  g_signal_connect (view, "query-tooltip", (GCallback) cell_tooltip_callback, 0);
229 
230  gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), GTK_TREE_VIEW_GRID_LINES_BOTH);
231  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
232 
233  col = gtk_tree_view_column_new ();
234  gtk_tree_view_column_set_title (col, "Object Attributes");
235  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
236  renderer = gtk_cell_renderer_text_new ();
237  gtk_tree_view_column_pack_start (col, renderer, TRUE);
238  gtk_tree_view_column_set_cell_data_func (col, renderer, cell_data_function_col_0, 0, 0);
239  g_object_set (renderer, "editable", FALSE, (char*) 0);
240 
241  col = gtk_tree_view_column_new ();
242  gtk_tree_view_column_set_title (col, "Attribute Value");
243  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
244  renderer = gtk_cell_renderer_text_new ();
245  g_signal_connect (renderer, "edited", (GCallback) cell_edited_callback, model);
246  gtk_tree_view_column_pack_start (col, renderer, TRUE);
247  gtk_tree_view_column_set_cell_data_func (col, renderer, cell_data_function_col_1, 0, 0);
248 
249  gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (model));
250 
251  g_object_unref (model); /* destroy model automatically with view */
252 
253  return view;
254 }
255 
260 void
261 save_clicked (GtkButton *button, gpointer user_data)
262 {
263  GtkWidget *parent_window = GTK_WIDGET (user_data);
264  GtkWidget *dialog;
265 
266  dialog = gtk_file_chooser_dialog_new ("Save File", GTK_WINDOW (parent_window), GTK_FILE_CHOOSER_ACTION_SAVE,
267  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE,
268  GTK_RESPONSE_ACCEPT, (char *) 0);
269  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
270  TRUE);
271 
272  gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "config.txt");
273 
274  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
275  {
276  char *filename;
277 
278  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
279  RawTextConfigSave config;
280  config.SetFilename (filename);
281  config.Attributes ();
282  g_free (filename);
283  }
284 
285  gtk_widget_destroy (dialog);
286 }
287 
291 void
292 load_clicked (GtkButton *button, gpointer user_data)
293 {
294  GtkWidget *parent_window = GTK_WIDGET (user_data);
295  GtkWidget *dialog;
296 
297  dialog = gtk_file_chooser_dialog_new ("Open File", GTK_WINDOW (parent_window), GTK_FILE_CHOOSER_ACTION_OPEN,
298  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
299  GTK_RESPONSE_ACCEPT, (char *) 0);
300 
301  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
302  {
303  char *filename;
304 
305  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
306  RawTextConfigLoad config;
307  config.SetFilename (filename);
308  config.Attributes ();
309  }
310 
311  gtk_widget_destroy (dialog);
312 }
313 
317 void
318 exit_clicked_callback (GtkButton *button, gpointer user_data)
319 {
320  gtk_main_quit ();
321  gtk_widget_hide (GTK_WIDGET (user_data));
322 }
323 
327 gboolean
328 delete_event_callback (GtkWidget *widget, GdkEvent *event, gpointer user_data)
329 {
330  gtk_main_quit ();
331  gtk_widget_hide (GTK_WIDGET (user_data));
332  return TRUE;
333 }
334 
338 gboolean
339 clean_model_callback (GtkTreeModel *model, GtkTreePath *path,
340  GtkTreeIter *iter, gpointer data)
341 {
342  ModelNode *node;
343  gtk_tree_model_get (GTK_TREE_MODEL (model), iter, COL_NODE, &node, -1);
344  delete node;
345  gtk_tree_store_set (GTK_TREE_STORE (model), iter, COL_NODE, (ModelNode*) 0,
346  -1);
347  return FALSE;
348 }
349 
350 /************************** display functions used by default configurator **********************/
355 void
356 cell_data_function_col_1_config_default (GtkTreeViewColumn *col, GtkCellRenderer *renderer,
357  GtkTreeModel *model, GtkTreeIter *iter,
358  gpointer user_data)
359 {
360  ModelTypeid *node;
361  gtk_tree_model_get (model, iter, COL_TYPEID, &node, -1);
362  if (node->type == ModelTypeid::NODE_ATTRIBUTE)
363  {
364  g_object_set (renderer, "text", node->defaultValue.c_str (), (char*) 0);
365  g_object_set (renderer, "editable", TRUE, (char*) 0);
366  }
367  else
368  {
369  g_object_set (renderer, "text", "", (char*) 0);
370  g_object_set (renderer, "editable", FALSE, (char*) 0);
371  }
372 }
376 void
377 cell_data_function_col_0_config_default (GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model,
378  GtkTreeIter *iter, gpointer user_data)
379 {
380  ModelTypeid *node;
381  gtk_tree_model_get (model, iter, COL_NODE, &node, -1);
382  g_object_set (renderer, "editable", FALSE, (char*) 0);
383  switch (node->type)
384  {
385  case ModelTypeid::NODE_TYPEID:
386  g_object_set (renderer, "text", node->tid.GetName ().c_str (), (char*) 0);
387  break;
388  case ModelTypeid::NODE_ATTRIBUTE:
389  g_object_set (renderer, "text", node->name.c_str (), (char*) 0);
390  break;
391  }
392 }
393 
394 
400 void
401 cell_edited_callback_config_default (GtkCellRendererText *cell, gchar *path_string,
402  gchar *new_text, gpointer user_data)
403 {
404  GtkTreeModel *model = GTK_TREE_MODEL (user_data);
405  GtkTreeIter iter;
406  gtk_tree_model_get_iter_from_string (model, &iter, path_string);
407  ModelTypeid *node;
408  gtk_tree_model_get (model, &iter, COL_NODE, &node, -1);
409  NS_ASSERT (node->type == ModelTypeid::NODE_ATTRIBUTE);
410  if (Config::SetDefaultFailSafe (node->tid.GetAttributeFullName (node->index),StringValue (new_text)))
411  {
412  node->defaultValue = new_text;
413  }
414 }
415 
422 gboolean
423 cell_tooltip_callback_config_default (GtkWidget *widget, gint x, gint y,
424  gboolean keyboard_tip, GtkTooltip *tooltip, gpointer user_data)
425 {
426  GtkTreeModel *model;
427  GtkTreeIter iter;
428  GtkTreeViewColumn * column;
429  if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget), &x, &y,
430  keyboard_tip, &model, 0, &iter))
431  {
432  return FALSE;
433  }
434  if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), x, y, 0, &column, 0, 0))
435  {
436  return FALSE;
437  }
438  int col = get_col_number_from_tree_view_column (column);
439 
440  ModelTypeid *node;
441  gtk_tree_model_get (model, &iter, COL_NODE, &node, -1);
442 
443  switch (node->type)
444  {
445  case ModelTypeid::NODE_TYPEID:
446  if (col == 0)
447  {
448  std::string tip = "This object is of type " + node->tid.GetName ();
449  gtk_tooltip_set_text (tooltip, tip.c_str ());
450  return TRUE;
451  }
452  break;
453  case ModelTypeid::NODE_ATTRIBUTE:
454  {
455  uint32_t attrIndex = node->index;
456  if (col == 0)
457  {
458  std::string tip = node->tid.GetAttribute (attrIndex).help;
459  gtk_tooltip_set_text (tooltip, tip.c_str ());
460  }
461  else
462  {
463  Ptr<const AttributeChecker> checker = node->tid.GetAttribute (attrIndex).checker;
464  std::string tip;
465  tip = "This attribute is of type " + checker->GetValueTypeName ();
466  if (checker->HasUnderlyingTypeInformation ())
467  {
468  tip += " " + checker->GetUnderlyingTypeInformation ();
469  }
470  gtk_tooltip_set_text (tooltip, tip.c_str ());
471  }
472  return TRUE;
473  }
474  break;
475  }
476  return FALSE;
477 }
478 
483 void
484 save_clicked_default (GtkButton *button, gpointer user_data)
485 {
486  GtkWidget *parent_window = GTK_WIDGET (user_data);
487  GtkWidget *dialog;
488 
489  dialog = gtk_file_chooser_dialog_new ("Save File", GTK_WINDOW (parent_window), GTK_FILE_CHOOSER_ACTION_SAVE,
490  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE,
491  GTK_RESPONSE_ACCEPT, (char *) 0);
492  gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog),
493  TRUE);
494 
495  gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), "config.txt");
496 
497  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
498  {
499  char *filename;
500 
501  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
502  RawTextConfigSave config;
503  config.SetFilename (filename);
504  config.Default ();
505  g_free (filename);
506  }
507 
508  gtk_widget_destroy (dialog);
509 }
510 
514 void
515 load_clicked_default (GtkButton *button, gpointer user_data)
516 {
517  GtkWidget *parent_window = GTK_WIDGET (user_data);
518  GtkWidget *dialog;
519 
520  dialog = gtk_file_chooser_dialog_new ("Open File", GTK_WINDOW (parent_window), GTK_FILE_CHOOSER_ACTION_OPEN,
521  GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN,
522  GTK_RESPONSE_ACCEPT, (char *) 0);
523 
524  if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT)
525  {
526  char *filename;
527 
528  filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
529  RawTextConfigLoad config;
530  config.SetFilename (filename);
531  config.Default ();
532  }
533 
534  gtk_widget_destroy (dialog);
535 }
536 
541 GtkWidget *
542 create_view_config_default (GtkTreeStore *model)
543 {
544  GtkTreeViewColumn *col;
545  GtkCellRenderer *renderer;
546  GtkWidget *view;
547 
548  view = gtk_tree_view_new ();
549  g_object_set (view, "has-tooltip", TRUE, (char*) 0);
550  g_signal_connect (view, "query-tooltip", (GCallback) cell_tooltip_callback_config_default, 0);
551 
552  gtk_tree_view_set_grid_lines (GTK_TREE_VIEW (view), GTK_TREE_VIEW_GRID_LINES_BOTH);
553  gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (view), TRUE);
554 
555  col = gtk_tree_view_column_new ();
556  gtk_tree_view_column_set_title (col, "Object Attributes");
557  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
558  renderer = gtk_cell_renderer_text_new ();
559  gtk_tree_view_column_pack_start (col, renderer, TRUE);
560  gtk_tree_view_column_set_cell_data_func (col, renderer, cell_data_function_col_0_config_default, 0, 0);
561  g_object_set (renderer, "editable", FALSE, (char*) 0);
562 
563  col = gtk_tree_view_column_new ();
564  gtk_tree_view_column_set_title (col, "Attribute Value");
565  gtk_tree_view_append_column (GTK_TREE_VIEW (view), col);
566  renderer = gtk_cell_renderer_text_new ();
567  g_signal_connect (renderer, "edited", (GCallback) cell_edited_callback_config_default, model);
568  gtk_tree_view_column_pack_start (col, renderer, TRUE);
569  gtk_tree_view_column_set_cell_data_func (col, renderer, cell_data_function_col_1_config_default, 0, 0);
570 
571  gtk_tree_view_set_model (GTK_TREE_VIEW (view), GTK_TREE_MODEL (model));
572 
573  g_object_unref (model); /* destroy model automatically with view */
574 
575  return view;
576 }
577 
581 gboolean
582 clean_model_callback_config_default (GtkTreeModel *model, GtkTreePath *path,
583  GtkTreeIter *iter, gpointer data)
584 {
585  ModelTypeid *node;
586  gtk_tree_model_get (GTK_TREE_MODEL (model), iter, COL_TYPEID, &node, -1);
587  delete node;
588  gtk_tree_store_set (GTK_TREE_STORE (model), iter, COL_TYPEID, (ModelTypeid*) 0, -1);
589  return FALSE;
590 }
591 
592 
593 } //end ns3 namespace
594 
ns3::TypeId::GetAttributeN
uint32_t GetAttributeN(void) const
Get the number of attributes.
Definition: type-id.cc:968
ns3::RawTextConfigSave
Definition: raw-text-config.h:34
ns3::Ptr
Smart pointer class similar to boost::intrusive_ptr.
Definition: ptr.h:73
ns3::Config::SetDefaultFailSafe
bool SetDefaultFailSafe(std::string fullName, const AttributeValue &value)
Definition: config.cc:782
ns3::StringValue::Get
std::string Get(void) const
Definition: string.cc:31
ns3::RawTextConfigLoad::Attributes
virtual void Attributes(void)
Definition: raw-text-config.cc:172
ns3::StringValue
Hold variables of type string.
Definition: string.h:41
ns3::ModelTypeid::type
enum ns3::ModelTypeid::@3 type
ns3::cell_data_function_col_1
void cell_data_function_col_1(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
This function includes the name of the attribute or the editable value in the second column...
Definition: display-functions.cc:31
ns3::RawTextConfigLoad::SetFilename
virtual void SetFilename(std::string filename)
Definition: raw-text-config.cc:120
ns3::PointerValue::GetObject
Ptr< Object > GetObject(void) const
Get the Object referenced by the PointerValue.
Definition: pointer.cc:55
NS_ASSERT
#define NS_ASSERT(condition)
At runtime, in debugging builds, if this condition is not true, the program prints the source file...
Definition: assert.h:67
ns3::TypeId::GetParent
TypeId GetParent(void) const
Get the parent of this TypeId.
Definition: type-id.cc:847
ns3::get_col_number_from_tree_view_column
int get_col_number_from_tree_view_column(GtkTreeViewColumn *col)
This function gets the column number 0 or 1 from the mouse click.
Definition: display-functions.cc:105
raw-text-config.h
ns3::RawTextConfigSave::SetFilename
virtual void SetFilename(std::string filename)
Definition: raw-text-config.cc:47
ns3::cell_edited_callback
void cell_edited_callback(GtkCellRendererText *cell, gchar *path_string, gchar *new_text, gpointer user_data)
This is the callback called when the value of an attribute is changed.
Definition: display-functions.cc:88
ns3::AttributeChecker::HasUnderlyingTypeInformation
virtual bool HasUnderlyingTypeInformation(void) const =0
ns3::ModelNode::type
enum ns3::ModelNode::@1 type
ns3::AttributeChecker::GetValueTypeName
virtual std::string GetValueTypeName(void) const =0
data
uint8_t data[writeSize]
Definition: socket-bound-tcp-static-routing.cc:53
ns3::cell_data_function_col_1_config_default
void cell_data_function_col_1_config_default(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
This function writes data in the second column, this data is going to be editable if it is a NODE_ATT...
Definition: display-functions.cc:356
ns3::cell_tooltip_callback
gboolean cell_tooltip_callback(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip, GtkTooltip *tooltip, gpointer user_data)
This function displays the tooltip for an object, pointer, vector item or an attribute.
Definition: display-functions.cc:122
ns3::TypeId::HasParent
bool HasParent(void) const
Check if this TypeId has a parent.
Definition: type-id.cc:854
ns3::cell_tooltip_callback_config_default
gboolean cell_tooltip_callback_config_default(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip, GtkTooltip *tooltip, gpointer user_data)
This function is used to display a tooltip whenever the user puts the mouse over a type ID or an attr...
Definition: display-functions.cc:423
ns3::TypeId::AttributeInformation
Attribute implementation.
Definition: type-id.h:69
ns3::load_clicked
void load_clicked(GtkButton *button, gpointer user_data)
If the user presses the button load, it will load the config file into memory.
Definition: display-functions.cc:292
ns3::ModelNode::object
Ptr< Object > object
Definition: model-node-creator.h:47
ns3::TypeId::AttributeInformation::checker
Ptr< const AttributeChecker > checker
Checker object.
Definition: type-id.h:83
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::cell_data_function_col_0_config_default
void cell_data_function_col_0_config_default(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
This function writes the attribute or typeid name in the column 0.
Definition: display-functions.cc:377
ns3::PointerValue
Hold objects of type Ptr.
Definition: pointer.h:36
ns3::TypeId::AttributeInformation::name
std::string name
Attribute name.
Definition: type-id.h:71
ns3::create_view_config_default
GtkWidget * create_view_config_default(GtkTreeStore *model)
This is the main view opening the widget, getting tooltips and drawing the tree of attributes...
Definition: display-functions.cc:542
ns3::Object::GetInstanceTypeId
virtual TypeId GetInstanceTypeId(void) const
Implement the GetInstanceTypeId method defined in ObjectBase.
Definition: object.cc:79
ns3::RawTextConfigSave::Attributes
virtual void Attributes(void)
Definition: raw-text-config.cc:86
ns3::create_view
GtkWidget * create_view(GtkTreeStore *model)
This is the main view opening the widget, getting tooltips and drawing the tree of attributes...
Definition: display-functions.cc:220
ns3::RawTextConfigSave::Default
virtual void Default(void)
Definition: raw-text-config.cc:53
ns3::TypeId::GetName
std::string GetName(void) const
Get the name.
Definition: type-id.cc:880
ns3::ObjectBase::GetAttribute
void GetAttribute(std::string name, AttributeValue &value) const
Get the value of an attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:229
ns3::cell_edited_callback_config_default
void cell_edited_callback_config_default(GtkCellRendererText *cell, gchar *path_string, gchar *new_text, gpointer user_data)
This functions is called whenever there is a change in the value of an attribute If the input value i...
Definition: display-functions.cc:401
ns3::cell_data_function_col_0
void cell_data_function_col_0(GtkTreeViewColumn *col, GtkCellRenderer *renderer, GtkTreeModel *model, GtkTreeIter *iter, gpointer user_data)
This function includes the name of the object, pointer, vector or vector item in the first column...
Definition: display-functions.cc:54
ns3::load_clicked_default
void load_clicked_default(GtkButton *button, gpointer user_data)
If the user presses the button load, it will load the config file into memory.
Definition: display-functions.cc:515
ns3::exit_clicked_callback
void exit_clicked_callback(GtkButton *button, gpointer user_data)
Exit the window when exit button is pressed.
Definition: display-functions.cc:318
ns3::clean_model_callback
gboolean clean_model_callback(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Delete the tree model contents.
Definition: display-functions.cc:339
ns3::clean_model_callback_config_default
gboolean clean_model_callback_config_default(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
Delete the tree model contents.
Definition: display-functions.cc:582
ns3::TypeId::GetAttributeFullName
std::string GetAttributeFullName(uint32_t i) const
Get the Attribute name by index.
Definition: type-id.cc:981
ns3::save_clicked_default
void save_clicked_default(GtkButton *button, gpointer user_data)
This is the action done when the user presses on the save button.
Definition: display-functions.cc:484
ns3::TypeId::GetAttribute
struct TypeId::AttributeInformation GetAttribute(uint32_t i) const
Get Attribute information by index.
Definition: type-id.cc:975
ns3::AttributeChecker::GetUnderlyingTypeInformation
virtual std::string GetUnderlyingTypeInformation(void) const =0
ns3::delete_event_callback
gboolean delete_event_callback(GtkWidget *widget, GdkEvent *event, gpointer user_data)
Exit the application.
Definition: display-functions.cc:328
ns3::ObjectBase::SetAttribute
void SetAttribute(std::string name, const AttributeValue &value)
Set a single attribute, raising fatal errors if unsuccessful.
Definition: object-base.cc:191
ns3::RawTextConfigLoad
Definition: raw-text-config.h:51
ns3::TypeId
a unique identifier for an interface.
Definition: type-id.h:58
ns3::save_clicked
void save_clicked(GtkButton *button, gpointer user_data)
This is the action done when the user presses on the save button.
Definition: display-functions.cc:261
ns3::TypeId::AttributeInformation::help
std::string help
Attribute help string.
Definition: type-id.h:73
ns3::RawTextConfigLoad::Default
virtual void Default(void)
Definition: raw-text-config.cc:136