static gboolean add_ip_config_data (NMDnsDnsmasq *self, GVariantBuilder *servers, const NMDnsIPConfigData *data) { if (NM_IS_IP4_CONFIG (data->config)) { return add_ip4_config (self, servers, (NMIP4Config *) data->config, data->iface, data->type == NM_DNS_IP_CONFIG_TYPE_VPN); } else if (NM_IS_IP6_CONFIG (data->config)) { return add_ip6_config (self, servers, (NMIP6Config *) data->config, data->iface, data->type == NM_DNS_IP_CONFIG_TYPE_VPN); } else g_return_val_if_reached (FALSE); }
gboolean msn_session_connect(MsnSession *session, const char *host, int port, gboolean http_method) { g_return_val_if_fail(session != NULL, FALSE); g_return_val_if_fail(!session->connected, TRUE); session->connected = TRUE; session->http_method = http_method; if (session->notification == NULL) { purple_debug_error("msn", "This shouldn't happen\n"); g_return_val_if_reached(FALSE); } return msn_notification_connect(session->notification, host, port); }
const char * nm_connectivity_state_to_string (NMConnectivityState state) { switch (state) { case NM_CONNECTIVITY_UNKNOWN: return "UNKNOWN"; case NM_CONNECTIVITY_NONE: return "NONE"; case NM_CONNECTIVITY_LIMITED: return "LIMITED"; case NM_CONNECTIVITY_PORTAL: return "PORTAL"; case NM_CONNECTIVITY_FULL: return "FULL"; default: g_return_val_if_reached ("???"); } }
static WORD g_resolver_record_type_to_dnstype (GResolverRecordType type) { switch (type) { case G_RESOLVER_RECORD_SRV: return DNS_TYPE_SRV; case G_RESOLVER_RECORD_TXT: return DNS_TYPE_TEXT; case G_RESOLVER_RECORD_SOA: return DNS_TYPE_SOA; case G_RESOLVER_RECORD_NS: return DNS_TYPE_NS; case G_RESOLVER_RECORD_MX: return DNS_TYPE_MX; } g_return_val_if_reached (-1); }
static gint g_resolver_record_type_to_rrtype (GResolverRecordType type) { switch (type) { case G_RESOLVER_RECORD_SRV: return T_SRV; case G_RESOLVER_RECORD_TXT: return T_TXT; case G_RESOLVER_RECORD_SOA: return T_SOA; case G_RESOLVER_RECORD_NS: return T_NS; case G_RESOLVER_RECORD_MX: return T_MX; } g_return_val_if_reached (-1); }
static gint16 on_input_state (guint port, guint device, guint index, guint id) { RetroCore *self; RetroInput input; self = retro_core_get_cb_data (); if (self == NULL) g_return_val_if_reached (0); retro_input_init (&input, device, id, index); return retro_core_get_controller_input_state (self, port, &input); }
/** * Negotiates crypto between the calling programm and the prompt * * Reads data from the transport section of input_data and sends the public key back * in the transport section of the output_data. * * Returns TRUE on success **/ static gboolean negotiate_transport_crypto (void) { gcry_mpi_t base, prime, peer; gcry_mpi_t key, pub, priv; gboolean ret = FALSE; gpointer ikm; gsize n_ikm; g_assert (!the_key); base = prime = peer = NULL; key = pub = priv = NULL; /* The DH stuff coming in from our caller */ if (gku_prompt_util_decode_mpi (input_data, "transport", "prime", &prime) && gku_prompt_util_decode_mpi (input_data, "transport", "base", &base) && gku_prompt_util_decode_mpi (input_data, "transport", "public", &peer)) { /* Generate our own public/priv, and then a key, send it back */ if (egg_dh_gen_pair (prime, base, 0, &pub, &priv)) { gku_prompt_util_encode_mpi (output_data, "transport", "public", pub); /* Build up a key we can use */ ikm = egg_dh_gen_secret (peer, priv, prime, &n_ikm); if (ikm != NULL) { n_the_key = 16; the_key = egg_secure_alloc (n_the_key); if (!egg_hkdf_perform ("sha256", ikm, n_ikm, NULL, 0, NULL, 0, the_key, n_the_key)) g_return_val_if_reached (FALSE); ret = TRUE; } } } gcry_mpi_release (base); gcry_mpi_release (prime); gcry_mpi_release (peer); gcry_mpi_release (key); gcry_mpi_release (pub); gcry_mpi_release (priv); return ret; }
gboolean egg_dh_gen_pair (gcry_mpi_t prime, gcry_mpi_t base, guint bits, gcry_mpi_t *pub, gcry_mpi_t *priv) { guint pbits; g_return_val_if_fail (prime, FALSE); g_return_val_if_fail (base, FALSE); g_return_val_if_fail (pub, FALSE); g_return_val_if_fail (priv, FALSE); pbits = gcry_mpi_get_nbits (prime); g_return_val_if_fail (pbits > 1, FALSE); if (bits == 0) { bits = pbits; } else if (bits > pbits) { g_return_val_if_reached (FALSE); } /* * Generate a strong random number of bits, and not zero. * gcry_mpi_randomize bumps up to the next byte. Since we * need to have a value less than half of prime, we make sure * we bump down. */ *priv = gcry_mpi_snew (bits); g_return_val_if_fail (*priv, FALSE); while (gcry_mpi_cmp_ui (*priv, 0) == 0) gcry_mpi_randomize (*priv, bits, GCRY_STRONG_RANDOM); /* Secret key value must be less than half of p */ if (gcry_mpi_get_nbits (*priv) > bits) gcry_mpi_clear_highbit (*priv, bits); if (gcry_mpi_get_nbits (*priv) > pbits - 1) gcry_mpi_clear_highbit (*priv, pbits - 1); g_assert (gcry_mpi_cmp (prime, *priv) > 0); *pub = gcry_mpi_new (gcry_mpi_get_nbits (*priv)); g_return_val_if_fail (*pub, FALSE); gcry_mpi_powm (*pub, base, *priv, prime); return TRUE; }
static MuMsgPartSigStatusReport* get_status_report (GMimeSignatureList *sigs) { int i; MuMsgPartSigStatus status; MuMsgPartSigStatusReport *status_report; char *report; status = MU_MSG_PART_SIG_STATUS_GOOD; /* let's start positive! */ for (i = 0, report = NULL; i != g_mime_signature_list_length (sigs); ++i) { GMimeSignature *msig; GMimeSignatureStatus sigstat; gchar *rep; msig = g_mime_signature_list_get_signature (sigs, i); sigstat = g_mime_signature_get_status (msig); switch (sigstat) { case GMIME_SIGNATURE_STATUS_GOOD: break; case GMIME_SIGNATURE_STATUS_ERROR: status = MU_MSG_PART_SIG_STATUS_ERROR; break; case GMIME_SIGNATURE_STATUS_BAD: status = MU_MSG_PART_SIG_STATUS_BAD; break; default: g_return_val_if_reached (NULL); } rep = get_verdict_report (msig); report = g_strdup_printf ("%s%s%d: %s", report ? report : "", report ? "; " : "", i + 1, rep); g_free (rep); } status_report = g_slice_new (MuMsgPartSigStatusReport); status_report->verdict = status; status_report->report = report; return status_report; }
static opj_image_t * gst_openjpeg_enc_fill_image (GstOpenJPEGEnc * self, GstVideoFrame * frame) { gint i, ncomps; opj_image_cmptparm_t *comps; OPJ_COLOR_SPACE colorspace; opj_image_t *image; ncomps = GST_VIDEO_FRAME_N_COMPONENTS (frame); comps = g_new0 (opj_image_cmptparm_t, ncomps); for (i = 0; i < ncomps; i++) { comps[i].prec = GST_VIDEO_FRAME_COMP_DEPTH (frame, i); comps[i].bpp = GST_VIDEO_FRAME_COMP_DEPTH (frame, i); comps[i].sgnd = 0; comps[i].w = GST_VIDEO_FRAME_COMP_WIDTH (frame, i); comps[i].h = GST_VIDEO_FRAME_COMP_HEIGHT (frame, i); comps[i].dx = GST_VIDEO_FRAME_WIDTH (frame) / GST_VIDEO_FRAME_COMP_WIDTH (frame, i); comps[i].dy = GST_VIDEO_FRAME_HEIGHT (frame) / GST_VIDEO_FRAME_COMP_HEIGHT (frame, i); } if ((frame->info.finfo->flags & GST_VIDEO_FORMAT_FLAG_YUV)) colorspace = OPJ_CLRSPC_SYCC; else if ((frame->info.finfo->flags & GST_VIDEO_FORMAT_FLAG_RGB)) colorspace = OPJ_CLRSPC_SRGB; else if ((frame->info.finfo->flags & GST_VIDEO_FORMAT_FLAG_GRAY)) colorspace = OPJ_CLRSPC_GRAY; else g_return_val_if_reached (NULL); image = opj_image_create (ncomps, comps, colorspace); g_free (comps); image->x0 = image->y0 = 0; image->x1 = GST_VIDEO_FRAME_WIDTH (frame); image->y1 = GST_VIDEO_FRAME_HEIGHT (frame); self->fill_image (image, frame); return image; }
static const gchar* cmd_help (MuConfigCmd cmd, gboolean long_help) { unsigned u; /* this include gets us MU_HELP_STRINGS */ #include "mu-help-strings.h" for (u = 0; u != G_N_ELEMENTS(MU_HELP_STRINGS); ++u) if (cmd == MU_HELP_STRINGS[u].cmd) { if (long_help) return MU_HELP_STRINGS[u].long_help; else return MU_HELP_STRINGS[u].usage ; } g_return_val_if_reached (""); return ""; }
static GtkActionGroup * mail_browser_get_action_group (EMailReader *reader, EMailReaderActionGroup group) { const gchar *group_name; switch (group) { case E_MAIL_READER_ACTION_GROUP_STANDARD: group_name = ACTION_GROUP_STANDARD; break; case E_MAIL_READER_ACTION_GROUP_SEARCH_FOLDERS: group_name = ACTION_GROUP_SEARCH_FOLDERS; break; default: g_return_val_if_reached (NULL); } return g_object_get_data (G_OBJECT (reader), group_name); }
GimpImageType gimp_babl_format_get_image_type (const Babl *format) { const gchar *name; g_return_val_if_fail (format != NULL, -1); name = babl_get_name (babl_format_get_model (format)); if (! strcmp (name, "Y") || ! strcmp (name, "Y'") || ! strcmp (name, "Y~")) { return GIMP_GRAY_IMAGE; } else if (! strcmp (name, "YA") || ! strcmp (name, "Y'A") || ! strcmp (name, "Y~A")) { return GIMP_GRAYA_IMAGE; } else if (! strcmp (name, "RGB") || ! strcmp (name, "R'G'B'") || ! strcmp (name, "R~G~B~")) { return GIMP_RGB_IMAGE; } else if (! strcmp (name, "RGBA") || ! strcmp (name, "R'G'B'A") || ! strcmp (name, "R~G~B~A")) { return GIMP_RGBA_IMAGE; } else if (babl_format_is_palette (format)) { if (babl_format_has_alpha (format)) return GIMP_INDEXEDA_IMAGE; else return GIMP_INDEXED_IMAGE; } g_return_val_if_reached (-1); }
static gboolean lldp_neighbor_equal (LLDPNeighbor *a, LLDPNeighbor *b) { GHashTableIter iter; gpointer k, v; g_return_val_if_fail (a && a->tlvs, FALSE); g_return_val_if_fail (b && b->tlvs, FALSE); if ( a->chassis_id_type != b->chassis_id_type || a->port_id_type != b->port_id_type || a->dest != b->dest || g_strcmp0 (a->chassis_id, b->chassis_id) || g_strcmp0 (a->port_id, b->port_id)) return FALSE; if (g_hash_table_size (a->tlvs) != g_hash_table_size (b->tlvs)) return FALSE; g_hash_table_iter_init (&iter, a->tlvs); while (g_hash_table_iter_next (&iter, &k, &v)) { GValue *value_a, *value_b; value_a = v; value_b = g_hash_table_lookup (b->tlvs, k); if (!value_b) return FALSE; g_return_val_if_fail (G_VALUE_TYPE (value_a) == G_VALUE_TYPE (value_b), FALSE); if (G_VALUE_HOLDS_STRING (value_a)) { if (g_strcmp0 (g_value_get_string (value_a), g_value_get_string (value_b))) return FALSE; } else if (G_VALUE_HOLDS_UINT (value_a)) { if (g_value_get_uint (value_a) != g_value_get_uint (value_b)) return FALSE; } else g_return_val_if_reached (FALSE); } return TRUE; }
gint gnc_process_get_fd (const Process *proc, const gint std_fd) { const gint *retptr = NULL; g_return_val_if_fail (proc, -1); if (std_fd == 0) retptr = &proc->fd_stdin; else if (std_fd == 1) retptr = &proc->fd_stdout; else if (std_fd == 2) retptr = &proc->fd_stderr; else g_return_val_if_reached (-1); if (*retptr == -1) g_warning ("Pipe to childs file descriptor %d is -1", std_fd); return *retptr; }
G_GNUC_INTERNAL int gvir_config_genum_get_value (GType enum_type, const char *nick, gint default_value) { GEnumClass *enum_class; GEnumValue *enum_value; g_return_val_if_fail(G_TYPE_IS_ENUM(enum_type), default_value); g_return_val_if_fail(nick != NULL, default_value); enum_class = g_type_class_ref(enum_type); enum_value = g_enum_get_value_by_nick(enum_class, nick); g_type_class_unref(enum_class); if (enum_value != NULL) return enum_value->value; g_return_val_if_reached(default_value); }
static DBusMessage* service_method_create_with_master_password (GkdSecretService *self, DBusMessage *message) { DBusError derr = DBUS_ERROR_INIT; DBusMessageIter iter, array; DBusMessage *reply = NULL; GkdSecretSecret *secret = NULL; GckAttributes *attrs = NULL; gchar *path; /* Parse the incoming message */ if (!dbus_message_has_signature (message, "a{sv}(oayays)")) return NULL; if (!dbus_message_iter_init (message, &iter)) g_return_val_if_reached (NULL); attrs = gck_attributes_new (); dbus_message_iter_recurse (&iter, &array); if (!gkd_secret_property_parse_all (&array, SECRET_COLLECTION_INTERFACE, attrs)) { gck_attributes_unref (attrs); return dbus_message_new_error (message, DBUS_ERROR_INVALID_ARGS, "Invalid properties argument"); } dbus_message_iter_next (&iter); secret = gkd_secret_secret_parse (self, message, &iter, &derr); if (secret == NULL) { gck_attributes_unref (attrs); return gkd_secret_error_to_reply (message, &derr); } gck_attributes_add_boolean (attrs, CKA_TOKEN, TRUE); path = gkd_secret_create_with_secret (attrs, secret, &derr); gck_attributes_unref (attrs); gkd_secret_secret_free (secret); if (path == NULL) return gkd_secret_error_to_reply (message, &derr); reply = dbus_message_new_method_return (message); dbus_message_append_args (reply, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID); g_free (path); return reply; }
static const Babl * choose_format (GeglBuffer *buffer, GimpSelectCriterion select_criterion, gint *n_components, gboolean *has_alpha) { const Babl *format = gegl_buffer_get_format (buffer); *has_alpha = babl_format_has_alpha (format); switch (select_criterion) { case GIMP_SELECT_CRITERION_COMPOSITE: if (babl_format_is_palette (format)) format = babl_format ("R'G'B'A float"); else format = gimp_babl_format (gimp_babl_format_get_base_type (format), GIMP_PRECISION_FLOAT_GAMMA, *has_alpha); break; case GIMP_SELECT_CRITERION_R: case GIMP_SELECT_CRITERION_G: case GIMP_SELECT_CRITERION_B: case GIMP_SELECT_CRITERION_A: format = babl_format ("R'G'B'A float"); break; case GIMP_SELECT_CRITERION_H: case GIMP_SELECT_CRITERION_S: case GIMP_SELECT_CRITERION_V: format = babl_format ("HSVA float"); break; default: g_return_val_if_reached (NULL); break; } *n_components = babl_format_get_n_components (format); return format; }
static gboolean mif_read_image_configuration(MIFImageConfiguration *config, const guchar **p, gsize size, guint file_version, GError **error) { if (file_version >= 0x107 && file_version <= 0x109) { if (size < IMAGE_CONFIGURATION_SIZE_1_3) return err_IMAGE_HEADER_TOO_SHORT(error); config->scan_int_to_meter = gwy_get_gdouble_le(p); gwy_debug("scan_int_to_meter: %g", config->scan_int_to_meter); config->xcal = gwy_get_gdouble_le(p); config->ycal = gwy_get_gdouble_le(p); config->zcal = gwy_get_gdouble_le(p); gwy_debug("calibration: %g %g %g", config->xcal, config->ycal, config->zcal); get_CHARARRAY(config->direction, p); gwy_debug_chars(config, direction); get_CHARARRAY(config->signal, p); gwy_debug_chars(config, signal); get_CHARARRAY(config->scan_head, p); gwy_debug_chars(config, scan_head); config->scan_head_code = *((*p)++); get_CHARARRAY(config->scan_mode, p); gwy_debug_chars(config, scan_mode); config->z_linearized = !!*((*p)++); gwy_debug_bool(config, z_linearized); config->z_correction = gwy_get_gfloat_le(p); gwy_debug("z_correction: %g", config->z_correction); config->is_zcorrected = !!*((*p)++); gwy_debug_bool(config, is_zcorrected); config->is_flattened = !!*((*p)++); gwy_debug_bool(config, is_flattened); get_CHARARRAY(config->scan_head_name, p); gwy_debug_chars(config, scan_head_name); } else { g_return_val_if_reached(FALSE); } return TRUE; }
static GstFlowReturn gst_aiff_parse_chain (GstPad * pad, GstBuffer * buf) { GstFlowReturn ret; GstAiffParse *aiff = GST_AIFF_PARSE (GST_PAD_PARENT (pad)); GST_LOG_OBJECT (aiff, "adapter_push %u bytes", GST_BUFFER_SIZE (buf)); gst_adapter_push (aiff->adapter, buf); switch (aiff->state) { case AIFF_PARSE_START: GST_INFO_OBJECT (aiff, "AIFF_PARSE_START"); if ((ret = gst_aiff_parse_parse_stream_init (aiff)) != GST_FLOW_OK) goto done; if (aiff->state != AIFF_PARSE_HEADER) break; /* otherwise fall-through */ case AIFF_PARSE_HEADER: GST_INFO_OBJECT (aiff, "AIFF_PARSE_HEADER"); if ((ret = gst_aiff_parse_stream_headers (aiff)) != GST_FLOW_OK) goto done; if (!aiff->got_comm || aiff->datastart == 0) break; aiff->state = AIFF_PARSE_DATA; GST_INFO_OBJECT (aiff, "AIFF_PARSE_DATA"); /* fall-through */ case AIFF_PARSE_DATA: if ((ret = gst_aiff_parse_stream_data (aiff)) != GST_FLOW_OK) goto done; break; default: g_return_val_if_reached (GST_FLOW_ERROR); } done: return ret; }
static gboolean on_httpstream_recv (CockpitTransport *transport, const gchar *channel, GBytes *payload, CockpitChannelResponse *chesp) { GError *error = NULL; JsonObject *object; gint64 status; const gchar *reason; if (!channel || !g_str_equal (channel, chesp->channel)) return FALSE; g_return_val_if_fail (cockpit_web_response_get_state (chesp->response) == COCKPIT_WEB_RESPONSE_READY, FALSE); /* First response payload message is meta data, then switch to actual data */ g_signal_handler_disconnect (chesp->transport, chesp->transport_recv); chesp->transport_recv = g_signal_connect (chesp->transport, "recv", G_CALLBACK (on_transport_recv), chesp); object = cockpit_json_parse_bytes (payload, &error); if (error) { g_warning ("%s: couldn't parse http-stream1 header payload: %s", chesp->logname, error->message); cockpit_web_response_error (chesp->response, 500, NULL, NULL); g_error_free (error); return TRUE; } if (parse_httpstream_response (chesp, object, &status, &reason)) { if (!ensure_headers (chesp, status, reason)) g_return_val_if_reached (FALSE); } else { cockpit_web_response_error (chesp->response, 500, NULL, NULL); } json_object_unref (object); return TRUE; }
static NMPNetns * _stack_current_netns (int ns_types) { guint j; nm_assert (netns_stack && netns_stack->len > 0); /* we search the stack top-down to find the netns that has * all @ns_types set. */ for (j = netns_stack->len; ns_types && j >= 1; ) { NetnsInfo *info; info = &g_array_index (netns_stack, NetnsInfo, --j); if (NM_FLAGS_ALL (info->ns_types, ns_types)) return info->netns; } g_return_val_if_reached (NULL); }
GObject *gydp_engine_new(GydpEngine engine) { /* extract default engine from configuration */ if( engine == GYDP_ENGINE_DEFAULT ) { /* extract configuration from global app singleton */ GydpConf *config = g_object_get_data(G_OBJECT(gydp_app()), GYDP_APP_CONF); /* get default engine */ gchar *engine_default = gydp_conf_get_string(config, "general", "engine"); engine = gydp_engine_name_to_value(engine_default); g_free(engine_default); } /* create dictionary */ switch( engine ) { case GYDP_ENGINE_YDP: return gydp_dict_ydp_new(); case GYDP_ENGINE_SAP: return gydp_dict_sap_new(); default: g_return_val_if_reached(NULL); } }
IBusSerializable * ibus_serializable_copy (IBusSerializable *object) { g_return_val_if_fail (IBUS_IS_SERIALIZABLE (object), NULL); GType type; IBusSerializable *new_object; type = G_OBJECT_TYPE (object); new_object = g_object_new (type, NULL); g_return_val_if_fail (new_object != NULL, NULL); if (IBUS_SERIALIZABLE_GET_CLASS (new_object)->copy (new_object, object)) { return new_object; } g_object_unref (new_object); g_return_val_if_reached (NULL); }
static CK_RV gkm_mate2_storage_real_read_value (GkmStore *base, GkmObject *object, CK_ATTRIBUTE_PTR attr) { GkmMate2Storage *self = GKM_MATE2_STORAGE (base); const gchar *identifier; GkmDataResult res; gconstpointer value; gsize n_value; CK_RV rv; g_return_val_if_fail (GKM_IS_MATE2_STORAGE (self), CKR_GENERAL_ERROR); g_return_val_if_fail (GKM_IS_OBJECT (object), CKR_GENERAL_ERROR); g_return_val_if_fail (attr, CKR_GENERAL_ERROR); identifier = g_hash_table_lookup (self->object_to_identifier, object); if (!identifier) return CKR_ATTRIBUTE_TYPE_INVALID; if (self->last_mtime == 0) { rv = gkm_mate2_storage_refresh (self); if (rv != CKR_OK) return rv; } res = gkm_mate2_file_read_value (self->file, identifier, attr->type, &value, &n_value); switch (res) { case GKM_DATA_FAILURE: g_return_val_if_reached (CKR_GENERAL_ERROR); case GKM_DATA_UNRECOGNIZED: return CKR_ATTRIBUTE_TYPE_INVALID; case GKM_DATA_LOCKED: return CKR_USER_NOT_LOGGED_IN; case GKM_DATA_SUCCESS: /* Yes, we don't fill a buffer, just return pointer */ attr->pValue = (CK_VOID_PTR)value; attr->ulValueLen = n_value; return CKR_OK; default: g_assert_not_reached (); } }
static int do_shell (ssh_event event, ssh_channel chan) { socket_t fd; struct termios *term = NULL; struct winsize *win = NULL; short events; int fd_status; state.childpid = forkpty (&fd, NULL, term, win); if (state.childpid == 0) { close (state.bind_fd); close (state.session_fd); execl ("/bin/bash", "/bin/bash", NULL); _exit (127); } else if (state.childpid < 0) { g_critical ("forkpty failed: %s", g_strerror (errno)); return -1; } fd_status = fcntl (fd, F_GETFL, 0); if (fcntl (fd, F_SETFL, fd_status | O_NONBLOCK) < 0) { g_critical ("couldn't set non-blocking mode"); return -1; } cb.userdata = (gpointer)(long)fd; ssh_callbacks_init(&cb); ssh_set_channel_callbacks (chan, &cb); events = POLLIN | POLLOUT | POLLPRI | POLLERR | POLLHUP | POLLNVAL; if (ssh_event_add_fd (event, fd, events, fd_data, chan) != SSH_OK) g_return_val_if_reached(-1); return 0; }
static CoglBool _cogl_texture_3d_allocate (CoglTexture *tex, CoglError **error) { CoglTexture3D *tex_3d = COGL_TEXTURE_3D (tex); CoglTextureLoader *loader = tex->loader; _COGL_RETURN_VAL_IF_FAIL (loader, FALSE); switch (loader->src_type) { case COGL_TEXTURE_SOURCE_TYPE_SIZED: return allocate_with_size (tex_3d, loader, error); case COGL_TEXTURE_SOURCE_TYPE_BITMAP: return allocate_from_bitmap (tex_3d, loader, error); default: break; } g_return_val_if_reached (FALSE); }
/* Return nominal icon size for given zoom level. * @zoom_level: zoom level for which to find matching icon size. * * Return value: icon size between NAUTILUS_ICON_SIZE_SMALLEST and * NAUTILUS_ICON_SIZE_LARGEST, inclusive. */ guint nautilus_get_icon_size_for_zoom_level (NautilusZoomLevel zoom_level) { switch (zoom_level) { case NAUTILUS_ZOOM_LEVEL_SMALLEST: return NAUTILUS_ICON_SIZE_SMALLEST; case NAUTILUS_ZOOM_LEVEL_SMALLER: return NAUTILUS_ICON_SIZE_SMALLER; case NAUTILUS_ZOOM_LEVEL_SMALL: return NAUTILUS_ICON_SIZE_SMALL; case NAUTILUS_ZOOM_LEVEL_STANDARD: return NAUTILUS_ICON_SIZE_STANDARD; case NAUTILUS_ZOOM_LEVEL_LARGE: return NAUTILUS_ICON_SIZE_LARGE; case NAUTILUS_ZOOM_LEVEL_LARGER: return NAUTILUS_ICON_SIZE_LARGER; case NAUTILUS_ZOOM_LEVEL_LARGEST: return NAUTILUS_ICON_SIZE_LARGEST; } g_return_val_if_reached (NAUTILUS_ICON_SIZE_STANDARD); }
/** * epc_protocol_get_uri_scheme: * @protocol: a #EpcProtocol * * Queries the URI scheme associated with a #EpcProtocol. * See epc_service_type_build_uri(). * * Returns: Returns the URI scheme associated with @protocol, * or %NULL on unknown protocols. */ const gchar* epc_protocol_get_uri_scheme (EpcProtocol protocol) { switch (protocol) { case EPC_PROTOCOL_HTTPS: return "https"; case EPC_PROTOCOL_HTTP: return "http"; case EPC_PROTOCOL_UNKNOWN: return NULL; default: g_warning ("%s: Unexpected protocol.", G_STRFUNC); break; } g_return_val_if_reached (NULL); }
/** * epc_protocol_get_service_type: * @protocol: a #EpcProtocol * * Queries the DNS-SD service type associated with a #EpcProtocol. * See #EPC_SERVICE_TYPE_HTTP, #EPC_SERVICE_TYPE_HTTPS. * * Returns: Returns the DNS-SD service type associated * with @protocol, or %NULL on unknown protocols. */ const gchar* epc_protocol_get_service_type (EpcProtocol protocol) { switch (protocol) { case EPC_PROTOCOL_HTTPS: return EPC_SERVICE_TYPE_HTTPS; case EPC_PROTOCOL_HTTP: return EPC_SERVICE_TYPE_HTTP; case EPC_PROTOCOL_UNKNOWN: return NULL; default: g_warning ("%s: Unexpected protocol.", G_STRFUNC); break; } g_return_val_if_reached (NULL); }