#include "vapiGtkInterface.h"#include "vapiOptions.h"Diagrama de dependências de inclusão para vapiGtkOptions.h:
Este grafo mostra quais são os ficheiros que incluem directamente ou indirectamente este ficheiro:
Ir para o código fonte deste ficheiro.
Definições de tipos | |
| typedef int(*) | vGtkOptionsCustomCreate (vOptions *Options, vOptionsSettings *OptionsSettings, GList **OptionsList[3], GList **tempList[3], int i, int widgetsWidth, GCallback EventFunc, vpointer EventData) |
| typedef int(*) | vGtkOptionsCustomGet (vOptions *options, vOptionsSettings *OptionsSettings, GList **OptionsData) |
| typedef int(*) | vGtkOptionsCustomPopulate (vOptions *Options, vOptionsSettings *OptionsSettings, GList **OptionsList[3], int i) |
Funções | |
| void | vapiGtkOptionsBlockEvents (GList **OptionsEvents) |
| void | vapiGtkOptionsCreate (GtkWidget *ParentContainer, GtkWidget **Container, GList **OptionsList[3], vOptions *Options, vOptionsSettings *OptionsSettings, vGtkOptionsCustomCreate CustomFunc, GCallback EventFunc, vpointer EventData) |
| GtkWidget * | vapiGtkOptionsCreateByInterfaceType (vInterfaceType interfaceType, double min, double max, double scale, double defaultValue) |
| int | vapiGtkOptionsCreateDefault (vOptions *Options, vOptionsSettings *OptionsSettings, GList **OptionsList[3], GList **tempList[3], int i, int widgetsWidth, GCallback EventFunc, vpointer EventData) |
| void | vapiGtkOptionsFree (GtkWidget **Container, GList **OptionsList[3]) |
| GtkWidget * | vapiGtkOptionsGetAssociatedWidget (const char *requiredOption, vOptionsSettings *OptionsSettings, GList **OptionsData) |
| vTempFloat * | vapiGtkOptionsGetOptionByInterfaceType (GtkWidget *Range, vInterfaceType interfaceType, vBoolean ISint) |
| void | vapiGtkOptionsGetOptions (vOptions *options, vOptionsSettings *OptionsSettings, vGtkOptionsCustomGet CustomGet, GList **OptionsData) |
| void | vapiGtkOptionsPopulate (vOptions *Options, vOptionsSettings *OptionsSettings, GList **OptionsList[3], vGtkOptionsCustomPopulate CustomFunc) |
| void | vapiGtkOptionsSetOptionByInterfaceType (GtkWidget *Range, double Value, vInterfaceType interfaceType, vBoolean ISint) |
| void | vapiGtkOptionsUnBlockEvents (GList **OptionsEvents) |
| typedef int(*) vGtkOptionsCustomCreate(vOptions *Options, vOptionsSettings *OptionsSettings, GList **OptionsList[3], GList **tempList[3], int i, int widgetsWidth, GCallback EventFunc, vpointer EventData) |
Definido na linha 6 do ficheiro vapiGtkOptions.h.
| typedef int(*) vGtkOptionsCustomGet(vOptions *options, vOptionsSettings *OptionsSettings, GList **OptionsData) |
Definido na linha 14 do ficheiro vapiGtkOptions.h.
| typedef int(*) vGtkOptionsCustomPopulate(vOptions *Options, vOptionsSettings *OptionsSettings, GList **OptionsList[3], int i) |
Definido na linha 18 do ficheiro vapiGtkOptions.h.
| void vapiGtkOptionsBlockEvents | ( | GList ** | OptionsEvents | ) |
Definido na linha 461 do ficheiro vapiGtkOptions.c.
Referências _vapiEventList::eventHandler e _vapiEventList::widget.
Referenciado por vapiGtkOptionsPopulate() e vapiGtkSaveSelectedRegion().
00462 { 00463 int listSize, i; 00464 vapiEventList *eventList; 00465 if (*OptionsEvents == NULL) 00466 { 00467 return; 00468 } 00469 listSize = g_list_length (*OptionsEvents); 00470 if (listSize > 0) 00471 { 00472 for (i = 0; i < listSize; i++) 00473 { 00474 eventList = (vapiEventList *) g_list_nth_data 00475 (*OptionsEvents, i); 00476 g_signal_handler_block (GTK_OBJECT 00477 (eventList->widget), 00478 eventList->eventHandler); 00479 } 00480 } 00481 00482 00483 }
Here is the caller graph for this function:
| void vapiGtkOptionsCreate | ( | GtkWidget * | ParentContainer, | |
| GtkWidget ** | Container, | |||
| GList ** | OptionsList[3], | |||
| vOptions * | Options, | |||
| vOptionsSettings * | OptionsSettings, | |||
| vGtkOptionsCustomCreate | CustomFunc, | |||
| GCallback | EventFunc, | |||
| vpointer | EventData | |||
| ) |
Definido na linha 18 do ficheiro vapiGtkOptions.c.
Referências OptionWidgetsWidth, vapiGtkOptionsCreateDefault() e vapiGtkOptionsFree().
Referenciado por vapiGtkOperationShowOptions(), vapiGtkWindowIOAddSelectIO() e vapiGtkWindowIOConfiguredSelect().
00024 { 00025 int i = 0, j; 00026 GList *tempList[3], **tempLists[3]; 00027 int widgetsWidth = OptionWidgetsWidth; 00028 00029 tempList[0] = NULL; 00030 tempList[1] = NULL; 00031 tempList[2] = NULL; 00032 00033 tempLists[0] = &tempList[0]; 00034 tempLists[1] = &tempList[1]; 00035 tempLists[2] = &tempList[2]; 00036 00037 00038 /* 00039 * Criar Listas 00040 */ 00041 vapiGtkOptionsFree (Container, OptionsList); 00042 *Container = gtk_scrolled_window_new (NULL, NULL); 00043 00044 gtk_scrolled_window_set_policy ((GtkScrolledWindow *) * Container, 00045 GTK_POLICY_AUTOMATIC, 00046 GTK_POLICY_AUTOMATIC); 00047 00048 gtk_box_pack_start ((GtkBox *) 00049 ParentContainer, *Container, TRUE, TRUE, 1); 00050 gtk_box_reorder_child ((GtkBox *) ParentContainer, *Container, 4); 00051 00052 *OptionsList[0] = 00053 g_list_append (*OptionsList[0], gtk_vbox_new (TRUE, 1)); 00054 00055 gtk_scrolled_window_add_with_viewport ((GtkScrolledWindow *) 00056 * Container, 00057 g_list_nth_data (*OptionsList 00058 [0], 0)); 00059 gtk_box_set_homogeneous ((GtkBox *) 00060 g_list_nth_data (*OptionsList[0], 0), FALSE); 00061 00062 00063 /* 00064 * Criar as widgets para as opções. 00065 * Primeiro, as custom, caso existam. 00066 */ 00067 if (CustomFunc != NULL) 00068 { 00069 i = CustomFunc (Options, OptionsSettings, 00070 OptionsList, tempLists, 00071 i, widgetsWidth, EventFunc, EventData); 00072 } 00073 00074 /* 00075 * Depois as default. 00076 */ 00077 i = vapiGtkOptionsCreateDefault (Options, OptionsSettings, 00078 OptionsList, tempLists, 00079 i, widgetsWidth, EventFunc, 00080 EventData); 00081 00082 /* inserir todos na vbox */ 00083 for (j = 0; j < i; j++) 00084 { 00085 gtk_box_pack_start ((GtkBox *) 00086 g_list_nth_data (*OptionsList[0], 00087 0), 00088 (GtkWidget *) 00089 g_list_nth_data 00090 (tempList[1], j), FALSE, FALSE, 6); 00091 gtk_box_pack_start ((GtkBox *) 00092 g_list_nth_data (*OptionsList[0], 00093 0), 00094 (GtkWidget *) 00095 g_list_nth_data (*OptionsList[1], 00096 j), FALSE, FALSE, 0); 00097 if (tempList[0] != NULL && j > 0) 00098 { 00099 gtk_box_pack_start ((GtkBox *) 00100 g_list_nth_data (*OptionsList[0], 00101 0), 00102 (GtkWidget *) 00103 g_list_nth_data (tempList[0], 00104 j - 1), FALSE, 00105 FALSE, 0); 00106 } 00107 00108 tempList[2] = 00109 g_list_append (tempList[2], gtk_hseparator_new ()); 00110 gtk_widget_set_size_request (g_list_nth_data 00111 (tempList[2], j), widgetsWidth, 00112 5); 00113 00114 gtk_box_pack_start ((GtkBox *) 00115 g_list_nth_data (*OptionsList[0], 00116 0), 00117 (GtkWidget *) 00118 g_list_nth_data (tempList[2], 00119 j), FALSE, FALSE, 0); 00120 00121 } 00122 g_list_free (tempList[0]); 00123 g_list_free (tempList[1]); 00124 g_list_free (tempList[2]); 00125 gtk_widget_show_all (*Container); 00126 }
Grafo de chamadas desta função:
Here is the caller graph for this function:
| GtkWidget* vapiGtkOptionsCreateByInterfaceType | ( | vInterfaceType | interfaceType, | |
| double | min, | |||
| double | max, | |||
| double | scale, | |||
| double | defaultValue | |||
| ) |
Definido na linha 355 do ficheiro vapiGtkOptions.c.
Referenciado por vapiGtkOptionsCreateDefault().
00358 { 00359 GtkWidget *newRange=NULL; 00360 00361 if (interfaceType == vBar || !interfaceType) 00362 { 00363 newRange = gtk_hscale_new_with_range (min, max, scale); 00364 gtk_range_set_value ((GtkRange *) newRange, defaultValue); 00365 gtk_range_set_update_policy ((GtkRange *) 00366 newRange, 00367 GTK_UPDATE_DISCONTINUOUS); 00368 } 00369 if (interfaceType == vSpin) 00370 { 00371 newRange = gtk_spin_button_new_with_range (min, max, scale); 00372 gtk_spin_button_set_value ((GtkSpinButton *) newRange, 00373 defaultValue); 00374 gtk_spin_button_set_update_policy ((GtkSpinButton *) newRange, 00375 GTK_UPDATE_IF_VALID); 00376 } 00377 return newRange; 00378 }
Here is the caller graph for this function:
| int vapiGtkOptionsCreateDefault | ( | vOptions * | Options, | |
| vOptionsSettings * | OptionsSettings, | |||
| GList ** | OptionsList[3], | |||
| GList ** | tempList[3], | |||
| int | i, | |||
| int | widgetsWidth, | |||
| GCallback | EventFunc, | |||
| vpointer | EventData | |||
| ) |
Definido na linha 164 do ficheiro vapiGtkOptions.c.
Referências _vapiEventList::eventHandler, _vOptionsSettings::floats, _vOptions::floats, _vOptionsSettings::floatsNumber, _vOptint::interfaceType, _vOptfloat::interfaceType, _vOptionsSettings::ints, _vOptions::ints, _vOptionsSettings::intsNumber, vapiGtkOptionsCreateByInterfaceType(), vBar e _vapiEventList::widget.
Referenciado por vapiGtkOptionsCreate().
00169 { 00170 int j, k; 00171 vapiEventList *eventList; 00172 if (OptionsSettings->floatsNumber) 00173 { 00174 00175 for (j = 0; j < OptionsSettings->floatsNumber; j++) 00176 { 00177 *OptionsList[1] = 00178 g_list_append (*OptionsList[1], 00179 vapiGtkOptionsCreateByInterfaceType 00180 (OptionsSettings-> 00181 floats[j].interfaceType, 00182 OptionsSettings-> 00183 floats[j].min, 00184 OptionsSettings-> 00185 floats[j].max, 00186 OptionsSettings-> 00187 floats[j].scale, 00188 Options->floats[j])); 00189 gtk_widget_set_size_request (g_list_nth_data 00190 (*OptionsList[1], i), 00191 widgetsWidth, 35); 00192 00193 *tempList[1] = 00194 g_list_append (*tempList[1], 00195 gtk_label_new 00196 (OptionsSettings->floats[j]. 00197 name)); 00198 00199 00200 *tempList[2] = 00201 g_list_append (*tempList[2], 00202 gtk_hseparator_new ()); 00203 if (OptionsSettings->floats[j].interfaceType == vBar) 00204 { 00205 eventList = malloc (sizeof (vapiEventList)); 00206 eventList->widget 00207 = 00208 g_list_nth_data (*OptionsList[1], i); 00209 eventList->eventHandler = 00210 g_signal_connect_after 00211 (G_OBJECT 00212 (g_list_nth_data 00213 (*OptionsList[1], 00214 i)), 00215 "value-changed", 00216 EventFunc, EventData); 00217 *OptionsList[2] = 00218 g_list_append (*OptionsList[2], 00219 eventList); 00220 } 00221 00222 ++i; 00223 } 00224 } 00225 if (OptionsSettings->intsNumber) 00226 { 00227 00228 for (j = 0; j < OptionsSettings->intsNumber; j++) 00229 { 00230 00231 *OptionsList[1] = 00232 g_list_append (*OptionsList[1], 00233 vapiGtkOptionsCreateByInterfaceType 00234 (OptionsSettings-> 00235 ints[j].interfaceType, 00236 OptionsSettings-> 00237 ints[j].min, 00238 OptionsSettings-> 00239 ints[j].max, 00240 OptionsSettings-> 00241 ints[j].scale, 00242 Options->ints[j])); 00243 *tempList[1] = 00244 g_list_append (*tempList[1], 00245 gtk_label_new 00246 (OptionsSettings->ints[j]. 00247 name)); 00248 if (OptionsSettings->ints[j].interfaceType == vBar) 00249 { 00250 eventList = malloc (sizeof (vapiEventList)); 00251 eventList->widget 00252 = 00253 g_list_nth_data (*OptionsList[1], i); 00254 eventList->eventHandler = 00255 g_signal_connect_after 00256 (G_OBJECT 00257 (g_list_nth_data 00258 (*OptionsList[1], 00259 i)), 00260 "value-changed", 00261 EventFunc, EventData); 00262 *OptionsList[2] = 00263 g_list_append (*OptionsList[2], 00264 eventList); 00265 } 00266 00267 00268 ++i; 00269 } 00270 } 00271 if (OptionsSettings->charsNumber) 00272 { 00273 for (j = 0; j < OptionsSettings->charsNumber; j++) 00274 { 00275 *OptionsList[1] = 00276 g_list_append (*OptionsList[1], 00277 gtk_entry_new ()); 00278 *tempList[1] = 00279 g_list_append (*tempList[1], 00280 gtk_label_new 00281 (OptionsSettings->chars[j]. 00282 name)); 00283 00284 00285 gtk_entry_set_text ((GtkEntry *) 00286 g_list_nth_data (*OptionsList[1], 00287 i), 00288 Options->chars[j].ch); 00289 ++i; 00290 } 00291 } 00292 if (OptionsSettings->chooseNumber) 00293 { 00294 for (j = 0; j < OptionsSettings->chooseNumber; j++) 00295 { 00296 *OptionsList[1] = 00297 g_list_append (*OptionsList[1], 00298 gtk_combo_box_new_text ()); 00299 *tempList[1] = 00300 g_list_append (*tempList[1], 00301 gtk_label_new 00302 (OptionsSettings->choose[j]. 00303 name)); 00304 00305 00306 for (k = 0; 00307 k < 00308 OptionsSettings->choose[j].numberOfChoices; k++) 00309 { 00310 gtk_combo_box_append_text ((GtkComboBox *) 00311 g_list_nth_data 00312 (*OptionsList[1], 00313 i), 00314 OptionsSettings-> 00315 choose[j]. 00316 listOfChoices[k]. 00317 ch); 00318 } 00319 00320 gtk_combo_box_set_active ((GtkComboBox *) 00321 g_list_nth_data 00322 (*OptionsList[1], i), 00323 OptionsSettings-> 00324 choose[j].defaultOption); 00325 ++i; 00326 } 00327 } 00328 if (OptionsSettings->booleansNumber) 00329 { 00330 for (j = 0; j < OptionsSettings->booleansNumber; j++) 00331 { 00332 *OptionsList[1] = 00333 g_list_append (*OptionsList[1], 00334 gtk_check_button_new ()); 00335 *tempList[1] = 00336 g_list_append (*tempList[1], 00337 gtk_label_new 00338 (OptionsSettings->booleans[j]. 00339 name)); 00340 00341 00342 gtk_toggle_button_set_active ((GtkToggleButton *) 00343 g_list_nth_data 00344 (*OptionsList[1], i), 00345 OptionsSettings-> 00346 booleans[j]. 00347 defaultValue); 00348 ++i; 00349 } 00350 } 00351 return i; 00352 }
Grafo de chamadas desta função:
Here is the caller graph for this function:
| void vapiGtkOptionsFree | ( | GtkWidget ** | Container, | |
| GList ** | OptionsList[3] | |||
| ) |
Definido na linha 129 do ficheiro vapiGtkOptions.c.
Referenciado por vapiGtkOptionsCreate() e vapiGtkWindowIOAddSelectIO().
00130 { 00131 int listSize, i; 00132 if (*Container != 0) 00133 { 00134 g_list_free (*OptionsList[0]); 00135 g_list_free (*OptionsList[1]); 00136 /* 00137 * A lista de eventos tem uma estrutura cujo espaço é alocado. 00138 * Esse espaço tem que ser libertado. 00139 */ 00140 if (*OptionsList[2] != NULL) 00141 { 00142 listSize = g_list_length (*OptionsList[2]); 00143 if (listSize > 0) 00144 { 00145 for (i = 0; i < listSize; i++) 00146 { 00147 free (g_list_nth_data 00148 (*OptionsList[2], i)); 00149 } 00150 g_list_free (*OptionsList[2]); 00151 } 00152 } 00153 gtk_widget_destroy (*Container); 00154 *Container = 0; 00155 *OptionsList[0] = NULL; 00156 *OptionsList[1] = NULL; 00157 *OptionsList[2] = NULL; 00158 } 00159 00160 00161 }
Here is the caller graph for this function:
| GtkWidget* vapiGtkOptionsGetAssociatedWidget | ( | const char * | requiredOption, | |
| vOptionsSettings * | OptionsSettings, | |||
| GList ** | OptionsData | |||
| ) |
Definido na linha 511 do ficheiro vapiGtkOptions.c.
Referências _vOptionsSettings::charsNumber, _vOptionsSettings::floatsNumber, _vOptionsSettings::intsNumber e vapiGtkOptionsCountCustomOperationsMembers().
Referenciado por vapiGtkSaveSelectedRegion() e vapiGtkSaveTemplate().
00514 { 00515 int i = 0, varNumber = 0, times; 00516 00517 /* 00518 * FIXME: isto tem que ser opção e ter opção para retornar 00519 * as widgets das customOptions. 00520 */ 00521 times = vapiGtkOptionsCountCustomOperationsMembers (OptionsSettings); 00522 00523 switch (requiredOption[i]) 00524 { 00525 case 'f': 00526 { 00527 00528 if (OptionsSettings->floatsNumber == 0) 00529 { 00530 return NULL; 00531 } 00532 varNumber = atoi (&requiredOption[i]); 00533 /* 00534 * Para floats, antes existe o times, e em seguida basta o 00535 * numero do float. 00536 */ 00537 return g_list_nth_data (*OptionsData, varNumber + times); 00538 break; 00539 } 00540 case 'd': 00541 { 00542 00543 if (OptionsSettings->intsNumber == 0) 00544 { 00545 return NULL; 00546 } 00547 varNumber = atoi (&requiredOption[++i]); 00548 /* 00549 * Para ints, antes existe o times e os floats, e em seguida basta o 00550 * numero do int. 00551 */ 00552 return g_list_nth_data (*OptionsData, 00553 times + varNumber + 00554 OptionsSettings->floatsNumber); 00555 break; 00556 } 00557 case 'c': 00558 { 00559 00560 if (OptionsSettings->charsNumber == 0) 00561 { 00562 return NULL; 00563 } 00564 varNumber = atoi (&requiredOption[++i]); 00565 /* 00566 * Para ints, antes existe o times e os floats, e em seguida basta o 00567 * numero do int. 00568 */ 00569 return g_list_nth_data (*OptionsData, 00570 varNumber + times + 00571 OptionsSettings-> 00572 floatsNumber + 00573 OptionsSettings->intsNumber); 00574 break; 00575 } 00576 00577 } 00578 return NULL; 00579 00580 }
Grafo de chamadas desta função:
Here is the caller graph for this function:
| vTempFloat* vapiGtkOptionsGetOptionByInterfaceType | ( | GtkWidget * | Range, | |
| vInterfaceType | interfaceType, | |||
| vBoolean | ISint | |||
| ) |
Definido na linha 616 do ficheiro vapiGtkOptions.c.
Referências _vTempFloat::intValue, _vTempFloat::value, vBar e vSpin.
Referenciado por vapiGtkOptionsGetOptions().
00619 { 00620 vTempFloat *Value = malloc (sizeof (vTempFloat)); 00621 00622 if (interfaceType == vBar || !interfaceType) 00623 { 00624 if (ISint) 00625 { 00626 Value->intValue = 00627 (int) gtk_range_get_value ((GtkRange *) 00628 Range); 00629 } 00630 else 00631 { 00632 Value->value = 00633 gtk_range_get_value ((GtkRange *) Range); 00634 } 00635 00636 } 00637 if (interfaceType == vSpin) 00638 { 00639 if (ISint) 00640 { 00641 Value->intValue = 00642 gtk_spin_button_get_value_as_int ((GtkSpinButton *) Range); 00643 } 00644 else 00645 { 00646 Value->value = 00647 gtk_spin_button_get_value ((GtkSpinButton *) 00648 Range); 00649 } 00650 00651 } 00652 00653 return Value; 00654 00655 }
Here is the caller graph for this function:
| void vapiGtkOptionsGetOptions | ( | vOptions * | options, | |
| vOptionsSettings * | OptionsSettings, | |||
| vGtkOptionsCustomGet | CustomGet, | |||
| GList ** | OptionsData | |||
| ) |
Definido na linha 658 do ficheiro vapiGtkOptions.c.
Referências _vOptions::floats, _vOptionsSettings::floats, _vOptionsSettings::floatsNumber, _vOptions::ints, _vOptionsSettings::ints, _vOptionsSettings::intsNumber, _vTempFloat::intValue, v_debug, _vTempFloat::value, vapiGtkOptionsGetOptionByInterfaceType(), vFALSE e vTRUE.
Referenciado por vapiGtkMacroAppendItem(), vapiGtkMacroInsertItem(), vapiGtkMacroUpdateItemOptions(), vapiGtkOperationApply(), vapiGtkWindowIOAdd_Add() e vapiGtkWindowIOConfiguredSaveChanges().
00662 { 00663 vTempFloat *tempFloat; 00664 int i=0, j; 00665 00666 if (CustomGet!=NULL) 00667 { 00668 i= CustomGet(options, 00669 OptionsSettings, OptionsData); 00670 } 00671 00672 if (OptionsSettings->floatsNumber) 00673 { 00674 for (j = 0; j < OptionsSettings->floatsNumber; j++) 00675 { 00676 tempFloat = (vTempFloat *) 00677 vapiGtkOptionsGetOptionByInterfaceType 00678 (g_list_nth_data 00679 (*OptionsData, i), 00680 OptionsSettings->floats[j]. 00681 interfaceType, vFALSE); 00682 options->floats[j] = tempFloat->value; 00683 v_debug ("OPTIONS FLOAT VALOR: %f", options->floats[j]); 00684 free (tempFloat); 00685 ++i; 00686 } 00687 } 00688 if (OptionsSettings->intsNumber) 00689 { 00690 for (j = 0; j < OptionsSettings->intsNumber; j++) 00691 { 00692 00693 tempFloat = (vTempFloat *) 00694 vapiGtkOptionsGetOptionByInterfaceType 00695 (g_list_nth_data 00696 (*OptionsData, i), 00697 OptionsSettings->ints[j]. 00698 interfaceType, vTRUE); 00699 options->ints[j] = tempFloat->intValue; 00700 v_debug ("OPTIONS VALOR: %d", options->ints[j]); 00701 free (tempFloat); 00702 ++i; 00703 } 00704 } 00705 if (OptionsSettings->charsNumber) 00706 { 00707 for (j = 0; j < OptionsSettings->charsNumber; j++) 00708 { 00709 options->chars[j].ch = 00710 vapiReturnStringPointer (gtk_entry_get_text 00711 ((GtkEntry *) 00712 g_list_nth_data 00713 (*OptionsData, i))); 00714 v_debug ("GET O CHAR: %s.", options->chars[j].ch); 00715 ++i; 00716 } 00717 } 00718 if (OptionsSettings->chooseNumber) 00719 { 00720 for (j = 0; j < OptionsSettings->chooseNumber; j++) 00721 { 00722 00723 options->choices[j] = 00724 gtk_combo_box_get_active ((GtkComboBox *) 00725 g_list_nth_data 00726 (*OptionsData, i)); 00727 ++i; 00728 } 00729 } 00730 if (OptionsSettings->booleansNumber) 00731 { 00732 for (j = 0; j < OptionsSettings->booleansNumber; j++) 00733 { 00734 00735 options->booleans[j] = 00736 gtk_toggle_button_get_active ((GtkToggleButton 00737 *) 00738 g_list_nth_data 00739 (*OptionsData, 00740 i)); 00741 ++i; 00742 } 00743 } 00744 }
Grafo de chamadas desta função:
Here is the caller graph for this function:
| void vapiGtkOptionsPopulate | ( | vOptions * | Options, | |
| vOptionsSettings * | OptionsSettings, | |||
| GList ** | OptionsList[3], | |||
| vGtkOptionsCustomPopulate | CustomFunc | |||
| ) |
Definido na linha 382 do ficheiro vapiGtkOptions.c.
Referências _vOptionsSettings::floats, _vOptions::floats, _vOptionsSettings::floatsNumber, _vOptionsSettings::ints, _vOptions::ints, _vOptionsSettings::intsNumber, vapiGtkOptionsBlockEvents(), vapiGtkOptionsSetOptionByInterfaceType(), vFALSE e vTRUE.
Referenciado por vapiGtkMacroSelectItem() e vapiGtkOperationShowOptions().
00386 { 00387 int i = 0, j; 00388 00389 vapiGtkOptionsBlockEvents (OptionsList[2]); 00390 00391 i = CustomFunc (Options, OptionsSettings, OptionsList, i); 00392 00393 if (OptionsSettings->floatsNumber) 00394 { 00395 for (j = 0; j < OptionsSettings->floatsNumber; j++) 00396 { 00397 00398 vapiGtkOptionsSetOptionByInterfaceType 00399 (g_list_nth_data 00400 (*OptionsList[1], i), 00401 Options->floats[j], 00402 OptionsSettings->floats[j]. 00403 interfaceType, vFALSE); 00404 ++i; 00405 } 00406 } 00407 if (OptionsSettings->intsNumber) 00408 { 00409 00410 for (j = 0; j < OptionsSettings->intsNumber; j++) 00411 { 00412 00413 vapiGtkOptionsSetOptionByInterfaceType 00414 (g_list_nth_data 00415 (*OptionsList[1], i), 00416 Options->ints[j], 00417 OptionsSettings->ints[j]. 00418 interfaceType, vTRUE); 00419 ++i; 00420 } 00421 } 00422 if (OptionsSettings->charsNumber) 00423 { 00424 for (j = 0; j < OptionsSettings->charsNumber; j++) 00425 { 00426 00427 gtk_entry_set_text ((GtkEntry *) 00428 g_list_nth_data 00429 (*OptionsList[1], i), 00430 Options->chars[j].ch); 00431 ++i; 00432 } 00433 } 00434 if (OptionsSettings->chooseNumber) 00435 { 00436 for (j = 0; j < OptionsSettings->chooseNumber; j++) 00437 { 00438 gtk_combo_box_set_active ((GtkComboBox *) 00439 g_list_nth_data 00440 (*OptionsList[1], i), 00441 Options->choices[j]); 00442 ++j; 00443 } 00444 } 00445 if (OptionsSettings->booleansNumber) 00446 { 00447 for (j = 0; j < OptionsSettings->booleansNumber; j++) 00448 { 00449 00450 gtk_toggle_button_set_active ((GtkToggleButton *) 00451 g_list_nth_data 00452 (*OptionsList[1], i), 00453 Options->booleans[j]); 00454 ++j; 00455 } 00456 } 00457 vapiGtkOptionsUnBlockEvents (OptionsList[2]); 00458 }
Grafo de chamadas desta função:
Here is the caller graph for this function:
| void vapiGtkOptionsSetOptionByInterfaceType | ( | GtkWidget * | Range, | |
| double | Value, | |||
| vInterfaceType | interfaceType, | |||
| vBoolean | ISint | |||
| ) |
Definido na linha 583 do ficheiro vapiGtkOptions.c.
Referenciado por vapiGtkOptionsPopulate().
00586 { 00587 00588 if (interfaceType == vBar || !interfaceType) 00589 { 00590 if (ISint) 00591 { 00592 gtk_range_set_value ((GtkRange *) Range, (int) Value); 00593 } 00594 else 00595 { 00596 gtk_range_set_value ((GtkRange *) Range, Value); 00597 } 00598 } 00599 if (interfaceType == vSpin) 00600 { 00601 if (ISint) 00602 { 00603 gtk_spin_button_set_value ((GtkSpinButton *) Range, 00604 (int) Value); 00605 } 00606 else 00607 { 00608 gtk_spin_button_set_value ((GtkSpinButton *) Range, 00609 Value); 00610 } 00611 } 00612 00613 }
Here is the caller graph for this function:
| void vapiGtkOptionsUnBlockEvents | ( | GList ** | OptionsEvents | ) |
Definido na linha 486 do ficheiro vapiGtkOptions.c.
Referências _vapiEventList::eventHandler e _vapiEventList::widget.
Referenciado por vapiGtkSaveSelectedRegion().
00487 { 00488 int listSize, i; 00489 vapiEventList *eventList; 00490 if (*OptionsEvents == NULL) 00491 { 00492 return; 00493 } 00494 listSize = g_list_length (*OptionsEvents); 00495 if (listSize > 0) 00496 { 00497 for (i = 0; i < listSize; i++) 00498 { 00499 eventList = (vapiEventList *) g_list_nth_data 00500 (*OptionsEvents, i); 00501 g_signal_handler_unblock (GTK_OBJECT 00502 (eventList->widget), 00503 eventList->eventHandler); 00504 } 00505 } 00506 00507 00508 }
Here is the caller graph for this function:
1.5.1