int process_info_list(struct section *osconfig, InfoListItem *ci) { int i=0,type,errCount=0; InfoItem *pItem; while(1) { type = ci[i].attr_type; if(type == END_LIST) break; // exit list... if(type == GET_VALUE) { // process list entry for GET_VALUE type pItem = ci[i].item; if(pItem != 0) { char str_len[81]; pItem->off = get_property_value(osconfig, ci[i].attr_path, ci[i].attr_name, ci[i].attr_default); // printf("get_property_value( %s, %s)\n",ci[i].attr_path,ci[i].attr_name); snprintf(str_len, sizeof(str_len), "%s_len", ci[i].attr_name); pItem->len = get_property_value(osconfig, ci[i].attr_path, str_len, ci[i].attr_default_len); // printf("get_property_value( %s, %s)\n",ci[i].attr_path, str_len); if(pItem->off == 0) { errCount++; // printf("Warning: Failed to get value for %s %s\n",ci[i].attr_path, ci[i].attr_name); } } else { printf("Error: Invalid storage for property, check property list definition, item %d\n",i); } } else { printf("Unsupported property accessor type, check propertylist, item %d\n", i); } i++; } // printf("Processed %d elements with %d issues\n",i,errCount); return errCount; }
/* Calculate storage filename using notification keys. */ string NotifConfig::get_storage_filename() const throw (NotifConfig::GeneralConfigError) { string filename; try { /* Get data path key. */ filename = get_property_value(DATA_PATH_KEY).to_string() + "/"; /* Get data root key. */ filename.append(get_property_value(DATA_ROOT_KEY).to_string() + "/"); /* Get admin port key. */ filename.append(get_property_value(ADMIN_PORT_KEY).to_string() + "/"); /* Get properties filename key. */ filename.append(get_property_value(PROPS_FILENAME_KEY).to_string()); } catch (PropertyNotFound & e) { string msg = "cannot resolve storage filename: property '"; msg.append(e.property_name + "' was not found"); throw GeneralConfigError(msg); } return filename; }
TEST_FIXTURE(e2e_raw_client, update_entity_with_patch) { auto model = client.get_model().get(); //check the old value auto query_result = client.get_data_from_server(U("Accounts(101)")).get(); auto old_entity = std::dynamic_pointer_cast<odata_entity_value>(query_result[0]); std::shared_ptr<odata_value> old_value; old_entity->get_property_value(U("Country"), old_value); auto old_country = std::dynamic_pointer_cast<odata_primitive_value>(old_value); VERIFY_ARE_EQUAL(U("US"), old_country->as<::utility::string_t>()); //update the entity with patch old_entity->set_value(U("Country"), U("GB")); auto response_code = client.patch_entity(U("Accounts"), old_entity).get(); VERIFY_ARE_EQUAL(204, response_code); //query the updated entity auto check_query = client.get_data_from_server(U("Accounts(101)")).get(); auto new_entity = std::dynamic_pointer_cast<odata_entity_value>(check_query[0]); std::shared_ptr<odata_value> property_value; VERIFY_IS_TRUE(new_entity->get_property_value(U("Country"), property_value)); auto primitive_value = std::dynamic_pointer_cast<odata_primitive_value>(property_value); ::utility::string_t new_country = primitive_value->as<::utility::string_t>(); VERIFY_ARE_EQUAL(U("GB"), new_country); }
void interp_err(dbref player, dbref program, struct inst *pc, struct inst *arg, int atop, dbref origprog, const char *msg1, const char *msg2) { char buf[BUFFER_LEN]; char buf2[BUFFER_LEN]; char tbuf[40]; int errcount; time_t lt; err++; if (OWNER(origprog) == OWNER(player)) { strcpyn(buf, sizeof(buf), "\033[1;31;40mProgram Error. Your program just got the following error.\033[0m"); } else { snprintf(buf, sizeof(buf), "\033[1;31;40mProgrammer Error. Please tell %s what you typed, and the following message.\033[0m", NAME(OWNER(origprog))); } notify_nolisten(player, buf, 1); snprintf(buf, sizeof(buf), "\033[1m%s(#%d), line %d; %s: %s\033[0m", NAME(program), program, pc ? pc->line : -1, msg1, msg2); notify_nolisten(player, buf, 1); lt = time(NULL); #ifndef WIN32 format_time(tbuf, 32, "%c", localtime(<)); #else format_time(tbuf, 32, "%c", uw32localtime(<)); #endif strip_ansi(buf2, buf); errcount = get_property_value(origprog, ".debug/errcount"); errcount++; add_property(origprog, ".debug/errcount", NULL, errcount); add_property(origprog, ".debug/lasterr", buf2, 0); add_property(origprog, ".debug/lastcrash", NULL, (int)lt); add_property(origprog, ".debug/lastcrashtime", tbuf, 0); if (origprog != program) { errcount = get_property_value(program, ".debug/errcount"); errcount++; add_property(program, ".debug/errcount", NULL, errcount); add_property(program, ".debug/lasterr", buf2, 0); add_property(program, ".debug/lastcrash", NULL, (int)lt); add_property(program, ".debug/lastcrashtime", tbuf, 0); } }
int set_property_value(void) { #ifdef CONFIGFILE //use it #else char CONFIGFILE[BUFSIZ]; strcpy(CONFIGFILE,getenv("HOME")); strcat(CONFIGFILE,"/.jasm_config"); #endif FILE * fconfig; char get_buffer_from_file[BUFSIZ]; int index=0; if((fconfig=fopen(CONFIGFILE,"r"))==NULL){ property_values[0]=3; property_values[1]=3; return 1; } while(fgets(get_buffer_from_file,BUFSIZ,fconfig) != NULL){ index++; char * get_val; get_val = get_property_value(get_buffer_from_file); property_values[index] = atoi(get_buffer_from_file); } fclose(fconfig); return 0; }
static void flags_changed (GObject *object, GParamSpec *pspec, gpointer data) { GList *children, *c; GValue val = G_VALUE_INIT; GFlagsClass *fclass; guint flags; gint i; GtkWidget *viewport; GtkWidget *box; fclass = G_FLAGS_CLASS (g_type_class_peek (pspec->value_type)); g_value_init (&val, pspec->value_type); get_property_value (object, pspec, &val); flags = g_value_get_flags (&val); g_value_unset (&val); viewport = gtk_bin_get_child (GTK_BIN (data)); box = gtk_bin_get_child (GTK_BIN (viewport)); children = gtk_container_get_children (GTK_CONTAINER (box)); for (c = children; c; c = c->next) block_controller (G_OBJECT (c->data)); for (c = children, i = 0; c; c = c->next, i++) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->data), (fclass->values[i].value & flags) != 0); for (c = children; c; c = c->next) unblock_controller (G_OBJECT (c->data)); g_list_free (children); }
/* * Inputs: * lpg is the property group to look up * lprop is the property within that group to look up * Outputs: * answer is a pointer to the property value * Returns: * 0 on success * -1 on failure * If successful, the property value is retured in *answer. * Otherwise, *answer is undefined, and it is up to the caller to decide * how to handle that case. */ int lookup_boolean_property(const char *lpg, const char *lprop, boolean_t *answer) { int result = -1; scf_resources_t res; uint8_t prop_val; if (get_property_value(lpg, lprop, &res) != 0) { /* * an error was already logged by get_property_value, * and it released any resources assigned to res before * returning. */ return (result); } if (scf_value_get_boolean(res.sr_val, &prop_val) != 0) { syslog(LOG_ERR, "scf_value_get_boolean() failed: %s", scf_strerror(scf_error())); goto cleanup; } *answer = (boolean_t)prop_val; dprintf("lookup_boolean_property(%s, %s) returns %s", lpg, lprop, *answer ? "TRUE" : "FALSE"); result = 0; cleanup: release_scf_resources(&res); return (result); }
/* * Inputs: * lpg is the property group to look up * lprop is the property within that group to look up * Outputs: * answer is a pointer to the property value * Returns: * 0 on success * -1 on failure * If successful, the property value is retured in *answer. * Otherwise, *answer is undefined, and it is up to the caller to decide * how to handle that case. */ int lookup_count_property(const char *lpg, const char *lprop, uint64_t *answer) { int result = -1; scf_resources_t res; if (get_property_value(lpg, lprop, &res) != 0) { /* * an error was already logged by get_property_value, * and it released any resources assigned to res before * returning. */ return (result); } if (scf_value_get_count(res.sr_val, answer) != 0) { syslog(LOG_ERR, "scf_value_get_count() failed: %s", scf_strerror(scf_error())); goto cleanup; } dprintf("lookup_count_property(%s, %s) returns %lld", lpg, lprop, *answer); result = 0; cleanup: release_scf_resources(&res); return (result); }
G_GNUC_BEGIN_IGNORE_DEPRECATIONS static void color_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkColorChooser *cb = GTK_COLOR_CHOOSER (data); GValue val = G_VALUE_INIT; GdkColor *color; GdkRGBA rgba; g_value_init (&val, GDK_TYPE_COLOR); get_property_value (object, pspec, &val); color = g_value_get_boxed (&val); rgba.red = color->red / 65535.0; rgba.green = color->green / 65535.0; rgba.blue = color->blue / 65535.0; rgba.alpha = 1.0; if (g_value_get_boxed (&val)) { block_controller (G_OBJECT (cb)); gtk_color_chooser_set_rgba (cb, &rgba); unblock_controller (G_OBJECT (cb)); } g_value_unset (&val); }
int ewmh_get_window_state(RDPCLIENT * This, Window w) { unsigned long nitems_return; unsigned char *prop_return; uint32 *return_words; unsigned long item; BOOL maximized_vert, maximized_horz, hidden; maximized_vert = maximized_horz = hidden = False; if (get_property_value(This, w, "_NET_WM_STATE", 64, &nitems_return, &prop_return, 0) < 0) return SEAMLESSRDP_NORMAL; return_words = (uint32 *) prop_return; for (item = 0; item < nitems_return; item++) { if (return_words[item] == This->ewmhints.state_maximized_vert_atom) maximized_vert = True; if (return_words[item] == This->ewmhints.state_maximized_horz_atom) maximized_horz = True; if (return_words[item] == This->ewmhints.state_hidden_atom) hidden = True; } XFree(prop_return); if (maximized_vert && maximized_horz) return SEAMLESSRDP_MAXIMIZED; else if (hidden) return SEAMLESSRDP_MINIMIZED; else return SEAMLESSRDP_NORMAL; }
static void font_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkFontChooser *fb = GTK_FONT_CHOOSER (data); GValue val = G_VALUE_INIT; const PangoFontDescription *font_desc; PangoFontDescription *fb_font_desc; g_value_init (&val, PANGO_TYPE_FONT_DESCRIPTION); get_property_value (object, pspec, &val); font_desc = g_value_get_boxed (&val); fb_font_desc = gtk_font_chooser_get_font_desc (fb); if (font_desc == NULL || (fb_font_desc != NULL && !pango_font_description_equal (fb_font_desc, font_desc))) { block_controller (G_OBJECT (fb)); gtk_font_chooser_set_font_desc (fb, font_desc); unblock_controller (G_OBJECT (fb)); } g_value_unset (&val); pango_font_description_free (fb_font_desc); }
RD_BOOL ewmh_is_window_above(Window w) { unsigned long nitems_return; unsigned char *prop_return; unsigned long *return_words; unsigned long item; RD_BOOL above; above = False; if (get_property_value(w, "_NET_WM_STATE", 64, &nitems_return, &prop_return, 0) < 0) return False; return_words = (unsigned long *) prop_return; for (item = 0; item < nitems_return; item++) { if (return_words[item] == g_net_wm_state_above_atom) above = True; } XFree(prop_return); return above; }
static void unichar_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkEntry *entry = GTK_ENTRY (data); gunichar new_val; gunichar old_val = unichar_get_value (entry); GValue val = G_VALUE_INIT; gchar buf[7]; gint len; g_value_init (&val, pspec->value_type); get_property_value (object, pspec, &val); new_val = (gunichar)g_value_get_uint (&val); if (new_val != old_val) { if (!new_val) len = 0; else len = g_unichar_to_utf8 (new_val, buf); buf[len] = '\0'; block_controller (G_OBJECT (entry)); gtk_entry_set_text (entry, buf); unblock_controller (G_OBJECT (entry)); } }
int process_properties_list(struct section *osconfig, PropertyListItem *ci) { int i=0,type,errCount=0; uint32_t *pAdr; while(1) { type = ci[i].attr_type; if(type == END_LIST) break; // exit list... if(type == GET_VALUE) { // process list entry for GET_VALUE type pAdr = ci[i].attr_adr; if(pAdr != 0) { *pAdr = get_property_value(osconfig, ci[i].attr_path, ci[i].attr_name, ci[i].attr_default); // printf("get_property_value( %s, %s)\n",ci[i].attr_path,ci[i].attr_name); if(*pAdr == 0) { errCount++; // printf("Warning: Failed to get value for %s %s\n",ci[i].attr_path, ci[i].attr_name); } } else { printf("Error: Invalid storage for property, check property list definition, item %d\n",i); } } else { printf("Unsupported property accessor type, check propertylist, item %d\n", i); } i++; } // printf("Processed %d elements with %d issues\n",i,errCount); return errCount; }
const char * safegetprop_strict(dbref player, dbref what, dbref perms, const char *inbuf) { const char *ptr; char bbuf[BUFFER_LEN]; static char vl[32]; if (!inbuf) { notify_nolisten(player, "PropFetch: Propname required.", 1); return NULL; } while (*inbuf == PROPDIR_DELIMITER) inbuf++; if (!*inbuf) { notify_nolisten(player, "PropFetch: Propname required.", 1); return NULL; } strcpy(bbuf, inbuf); ptr = get_property_class(what, bbuf); if (!ptr) { int i; i = get_property_value(what, bbuf); if (!i) { dbref dd; dd = get_property_dbref(what, bbuf); if (dd == NOTHING) { *vl = '\0'; ptr = vl; return ptr; } else { sprintf(vl, "#%d", dd); ptr = vl; } } else { sprintf(vl, "%d", i); ptr = vl; } } #ifdef COMPRESS ptr = uncompress(ptr); #endif if (!Wizperms(perms)) { if (Prop_Hidden(bbuf)) { notify_nolisten(player, "PropFetch: Permission denied.", 1); return NULL; } // if (Prop_Private(bbuf) && OWNER(perms) != OWNER(what)) { if (Prop_Private(bbuf) && !controls_nowizperm(OWNER(perms), what)) { notify_nolisten(player, "PropFetch: Permission denied.", 1); return NULL; } } return ptr; }
void ewmh_del_icon(Window wnd, uint32 width, uint32 height) { unsigned long nitems, i, icon_size; unsigned char *props; unsigned long *cur_set, *new_set; cur_set = NULL; new_set = NULL; if (get_property_value(wnd, "_NET_WM_ICON", 10000, &nitems, &props, 1) < 0) return; cur_set = (unsigned long *) props; for (i = 0; i < nitems;) { if (cur_set[i] == width && cur_set[i + 1] == height) break; i += 2 + cur_set[i] * cur_set[i + 1]; } if (i == nitems) goto out; icon_size = width * height + 2; new_set = xmalloc((nitems - icon_size) * sizeof(unsigned long)); if (i != 0) memcpy(new_set, cur_set, i * sizeof(unsigned long)); if (i != nitems - icon_size) memcpy(new_set + i, cur_set + i + icon_size, (nitems - (i + icon_size)) * sizeof(unsigned long)); nitems -= icon_size; XChangeProperty(g_display, wnd, g_net_wm_icon_atom, XA_CARDINAL, 32, PropModeReplace, (unsigned char *) new_set, nitems); xfree(new_set); out: XFree(cur_set); }
//TaggedSection function bodies================================================= TaggedSection::TaggedSection(data_tag pProps, bool mMain) : IsMainSection(mMain) { //set the data separator for output filtering Separator = "\t"; //extract section properties extract_properties(pProps, Properties); if (IsMainSection) //set tag type for subsections__________________________________________ { TAG_TYPE = get_property_value(Properties, SECTION_TYPE); OPEN_TAG = construct_open(TAG_TYPE); CLOSE_TAG = construct_close(TAG_TYPE); } //______________________________________________________________________ }
static void double_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkAdjustment *adj = GTK_ADJUSTMENT (data); GValue val = G_VALUE_INIT; g_value_init (&val, G_TYPE_DOUBLE); get_property_value (object, pspec, &val); if (g_value_get_double (&val) != gtk_adjustment_get_value (adj)) { block_controller (G_OBJECT (adj)); gtk_adjustment_set_value (adj, g_value_get_double (&val)); unblock_controller (G_OBJECT (adj)); } g_value_unset (&val); }
int ewmh_get_window_desktop(Window wnd) { unsigned long nitems_return; unsigned char *prop_return; int desktop; if (get_property_value(wnd, "_NET_WM_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0) return (-1); if (nitems_return != 1) { logger(GUI, Error, "ewmh_get_window_desktop(), _NET_WM_DESKTOP has bad length"); return (-1); } desktop = *prop_return; XFree(prop_return); return desktop; }
int ewmh_get_window_desktop(RDPCLIENT * This, Window wnd) { unsigned long nitems_return; unsigned char *prop_return; int desktop; if (get_property_value(This, wnd, "_NET_WM_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0) return (-1); if (nitems_return != 1) { fprintf(stderr, "_NET_WM_DESKTOP has bad length\n"); return (-1); } desktop = *prop_return; XFree(prop_return); return desktop; }
int get_current_workarea(RDPCLIENT * This, uint32 * x, uint32 * y, uint32 * width, uint32 * height) { int current_desktop; unsigned long nitems_return; unsigned char *prop_return; uint32 *return_words; const uint32 net_workarea_x_offset = 0; const uint32 net_workarea_y_offset = 1; const uint32 net_workarea_width_offset = 2; const uint32 net_workarea_height_offset = 3; const uint32 max_prop_length = 32 * 4; /* Max 32 desktops */ if (get_property_value (This, DefaultRootWindow(This->display), "_NET_WORKAREA", max_prop_length, &nitems_return, &prop_return, 0) < 0) return (-1); if (nitems_return % 4) { fprintf(stderr, "_NET_WORKAREA has odd length\n"); return (-1); } current_desktop = get_current_desktop(This); if (current_desktop < 0) return -1; return_words = (uint32 *) prop_return; *x = return_words[current_desktop * 4 + net_workarea_x_offset]; *y = return_words[current_desktop * 4 + net_workarea_y_offset]; *width = return_words[current_desktop * 4 + net_workarea_width_offset]; *height = return_words[current_desktop * 4 + net_workarea_height_offset]; XFree(prop_return); return (0); }
int get_current_workarea(uint32 * x, uint32 * y, uint32 * width, uint32 * height) { int current_desktop; unsigned long nitems_return; unsigned char *prop_return; long *return_words; const uint32 net_workarea_x_offset = 0; const uint32 net_workarea_y_offset = 1; const uint32 net_workarea_width_offset = 2; const uint32 net_workarea_height_offset = 3; const uint32 max_prop_length = 32 * 4; /* Max 32 desktops */ if (get_property_value (DefaultRootWindow(g_display), "_NET_WORKAREA", max_prop_length, &nitems_return, &prop_return, 0) < 0) return (-1); if (nitems_return % 4) { logger(GUI, Error, "get_current_workarea(),_NET_WORKAREA has bad length"); return (-1); } current_desktop = get_current_desktop(); if (current_desktop < 0) return -1; return_words = (long *) prop_return; *x = return_words[current_desktop * 4 + net_workarea_x_offset]; *y = return_words[current_desktop * 4 + net_workarea_y_offset]; *width = return_words[current_desktop * 4 + net_workarea_width_offset]; *height = return_words[current_desktop * 4 + net_workarea_height_offset]; XFree(prop_return); return (0); }
/* Get current desktop number Returns -1 on error */ static int get_current_desktop(void) { unsigned long nitems_return; uint32 *prop_return; int current_desktop; if (get_property_value("_NET_CURRENT_DESKTOP", 1, &nitems_return, (unsigned char **) &prop_return) < 0) return (-1); if (nitems_return != 1) { fprintf(stderr, "_NET_CURRENT_DESKTOP has bad length\n"); return (-1); } current_desktop = *prop_return; XFree(prop_return); return current_desktop; }
static void enum_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkWidget *viewport; GtkWidget *box; GList *children, *c; GValue val = G_VALUE_INIT; GEnumClass *eclass; gint i, j; eclass = G_ENUM_CLASS (g_type_class_peek (pspec->value_type)); g_value_init (&val, pspec->value_type); get_property_value (object, pspec, &val); i = 0; while (i < eclass->n_values) { if (eclass->values[i].value == g_value_get_enum (&val)) break; ++i; } g_value_unset (&val); viewport = gtk_bin_get_child (GTK_BIN (data)); box = gtk_bin_get_child (GTK_BIN (viewport)); children = gtk_container_get_children (GTK_CONTAINER (box)); for (c = children; c; c = c->next) block_controller (G_OBJECT (c->data)); for (c = children, j = 0; c; c = c->next, j++) { if (j == i) gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (c->data), TRUE); } for (c = children; c; c = c->next) unblock_controller (G_OBJECT (c->data)); }
/* Get current desktop number Returns -1 on error */ static int get_current_desktop(void) { unsigned long nitems_return; unsigned char *prop_return; int current_desktop; if (get_property_value (DefaultRootWindow(g_display), "_NET_CURRENT_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0) return (-1); if (nitems_return != 1) { logger(GUI, Error, "get_current_desktop(), _NET_CURRENT_DESKTOP has bad length"); return (-1); } current_desktop = *prop_return; XFree(prop_return); return current_desktop; }
/* Get current desktop number Returns -1 on error */ static int get_current_desktop(RDPCLIENT * This) { unsigned long nitems_return; unsigned char *prop_return; int current_desktop; if (get_property_value (This, DefaultRootWindow(This->display), "_NET_CURRENT_DESKTOP", 1, &nitems_return, &prop_return, 0) < 0) return (-1); if (nitems_return != 1) { fprintf(stderr, "_NET_CURRENT_DESKTOP has bad length\n"); return (-1); } current_desktop = *prop_return; XFree(prop_return); return current_desktop; }
void prim_getpropval(PRIM_PROTOTYPE) { CHECKOP(2); oper1 = POP(); oper2 = POP(); if (oper1->type != PROG_STRING) abort_interp("Non-string argument (2)"); if (!oper1->data.string) abort_interp("Empty string argument (2)"); if (!valid_object(oper2)) abort_interp("Non-object argument (1)"); CHECKREMOTE(oper2->data.objref); if (!prop_read_perms(ProgUID, oper2->data.objref, oper1->data.string->data, mlev)) abort_interp("Permission denied."); { char type[BUFFER_LEN]; int len = oper1->data.string->length; strcpyn(type, sizeof(type), oper1->data.string->data); while (len-- > 0 && type[len] == PROPDIR_DELIMITER) { type[len] = '\0'; } result = get_property_value(oper2->data.objref, type); #ifdef LOG_PROPS log2file("props.log", "#%d (%d) GETPROPVAL: o=%d n=\"%s\" v=%d", program, pc->line, oper2->data.objref, type, result); #endif /* if (Typeof(oper2->data.objref) != TYPE_PLAYER) ts_lastuseobject(oper2->data.objref); */ } CLEAR(oper1); CLEAR(oper2); PushInt(result); }
static void rgba_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkColorChooser *cb = GTK_COLOR_CHOOSER (data); GValue val = G_VALUE_INIT; GdkRGBA *color; GdkRGBA cb_color; g_value_init (&val, GDK_TYPE_RGBA); get_property_value (object, pspec, &val); color = g_value_get_boxed (&val); gtk_color_chooser_get_rgba (GTK_COLOR_CHOOSER (cb), &cb_color); if (color != NULL && !gdk_rgba_equal (color, &cb_color)) { block_controller (G_OBJECT (cb)); gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (cb), color); unblock_controller (G_OBJECT (cb)); } g_value_unset (&val); }
void check_properties(const char *dir, dbref obj) { int val; char *buf, *prop; PropPtr pptr; PropPtr pref; char name[BUFFER_LEN]; pref = first_prop(obj, dir, &pptr, name); while (pref > 0) { buf = (char *) malloc(strlen(dir) + strlen(name) + 2); (void) strcat(strcpy(buf, dir), name); if (prop = (char *) get_property_class(obj, buf)) printf("%s%c%s\n", buf + 1, PROP_DELIMITER, uncompress(prop)); else if (val = get_property_value(obj, buf)) printf("%s%c^%d\n", buf + 1, PROP_DELIMITER, val); if (is_propdir(obj, buf)) check_properties((char *) strcat(buf, "/"), obj); free(buf); pref = next_prop(pptr, pref, name); } }
static void bool_changed (GObject *object, GParamSpec *pspec, gpointer data) { GtkToggleButton *tb = GTK_TOGGLE_BUTTON (data); GtkWidget *child; GValue val = G_VALUE_INIT; g_value_init (&val, G_TYPE_BOOLEAN); get_property_value (object, pspec, &val); if (g_value_get_boolean (&val) != gtk_toggle_button_get_active (tb)) { block_controller (G_OBJECT (tb)); gtk_toggle_button_set_active (tb, g_value_get_boolean (&val)); unblock_controller (G_OBJECT (tb)); } child = gtk_bin_get_child (GTK_BIN (tb)); gtk_label_set_text (GTK_LABEL (child), g_value_get_boolean (&val) ? "TRUE" : "FALSE"); g_value_unset (&val); }