type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | uint32_t BURTC_CompareGet(unsigned int comp)
{
(void) comp; /* Unused parameter when EFM_ASSERT is undefined. */
EFM_ASSERT(comp == 0);
return BURTC->COMP0;
} |
functions | void BURTC_CounterReset(void)
{
/* Set and clear reset bit */
BUS_RegBitWrite(&BURTC->CTRL, _BURTC_CTRL_RSTEN_SHIFT, 1);
BUS_RegBitWrite(&BURTC->CTRL, _BURTC_CTRL_RSTEN_SHIFT, 0);
} |
functions | void BURTC_Reset(void)
{
bool buResetState;
/* Read reset state, set reset and restore state */
buResetState = BUS_RegBitRead(&RMU->CTRL, _RMU_CTRL_BURSTEN_SHIFT);
BUS_RegBitWrite(&RMU->CTRL, _RMU_CTRL_BURSTEN_SHIFT, 1);
BUS_RegBitWrite(&RMU->CTRL, _RMU_CTRL_BURSTEN_SHIFT, buResetState);
} |
functions | uint32_t BURTC_ClockFreqGet(void)
{
uint32_t clkSel;
uint32_t clkDiv;
uint32_t frequency;
clkSel = BURTC->CTRL & _BURTC_CTRL_CLKSEL_MASK;
clkDiv = (BURTC->CTRL & _BURTC_CTRL_PRESC_MASK) >> _BURTC_CTRL_PRESC_SHIFT;
switch (clkSel)
{
/** Ultra low frequency (1 kHz) clock */
case BURTC_CTRL_CLKSEL_... |
includes |
#include <glib.h> |
defines | #define _W "libquvi: %s: %d" |
functions | QuviBoolean quvi_script_next(quvi_t handle, QuviScriptType type)
{
QuviBoolean r;
GSList *l;
_quvi_t q;
q = (_quvi_t) handle;
/* If G_DISABLE_CHECKS is defined then the check is not performed. */
g_return_val_if_fail(handle != NULL, QUVI_FALSE);
switch (type)
{
case QUVI_SCRIPT_TYPE_SUBTITLE_EX... |
functions | void fmpz_mod_tpoly_fit_length(
fmpz_mod_tpoly_t A,
slong len,
const fmpz_mod_ctx_t ctx)
{
slong i = A->alloc;
if (len <= i)
return;
len = FLINT_MAX(len, 2*i);
A->coeffs = FLINT_ARRAY_REALLOC(A->coeffs, len, fmpz_mod_bpoly_struct);
for ( ; i < len; i++)
fmpz_mod_bpoly... |
functions | void fmpz_mod_tpoly_clear(fmpz_mod_tpoly_t A, const fmpz_mod_ctx_t ctx)
{
slong i;
for (i = 0; i < A->alloc; i++)
fmpz_mod_bpoly_clear(A->coeffs + i, ctx);
flint_free(A->coeffs);
} |
functions | void fmpz_mod_bpoly_reverse_vars(
fmpz_mod_bpoly_t A,
const fmpz_mod_bpoly_t B,
const fmpz_mod_ctx_t ctx)
{
slong i, j;
fmpz_mod_bpoly_zero(A, ctx);
for (i = 0; i < B->length; i++)
{
fmpz_mod_poly_struct * Bi = B->coeffs + i;
for (j = 0; j < Bi->length; j++)
{
... |
functions | void fmpz_mod_bpoly_make_monic_series(
fmpz_mod_bpoly_t A,
const fmpz_mod_bpoly_t B,
slong order,
const fmpz_mod_ctx_t ctx)
{
slong i;
fmpz_mod_poly_t lcinv;
FLINT_ASSERT(B->length > 0);
FLINT_ASSERT(fmpz_mod_bpoly_is_canonical(B, ctx));
fmpz_mod_poly_init(lcinv, ctx);
fmpz_mod... |
functions | void fmpz_mod_bpoly_eval(
fmpz_mod_poly_t E,
const fmpz_mod_bpoly_t A,
const fmpz_t alpha,
const fmpz_mod_ctx_t ctx)
{
slong i;
fmpz_mod_poly_zero(E, ctx);
if (fmpz_is_zero(alpha))
{
for (i = A->length - 1; i >= 0; i--)
if (A->coeffs[i].length > 0)
f... |
functions | void _hensel_lift_fac(
fmpz_mod_bpoly_t G,
fmpz_mod_bpoly_t H,
const fmpz_mod_bpoly_t f,
fmpz_mod_bpoly_t g,
fmpz_mod_bpoly_t h,
const fmpz_mod_bpoly_t a,
const fmpz_mod_bpoly_t b,
slong p0,
slong p1,
const fmpz_mod_ctx_t ctx)
{
slong i, j;
fmpz_mod_bpoly_t c, t1, t2, q, ... |
functions | void _hensel_lift_inv(
fmpz_mod_bpoly_t A,
fmpz_mod_bpoly_t B,
const fmpz_mod_bpoly_t G,
const fmpz_mod_bpoly_t H,
fmpz_mod_bpoly_t a,
fmpz_mod_bpoly_t b,
slong p0,
slong p1,
const fmpz_mod_ctx_t ctx)
{
slong i, j;
fmpz_mod_bpoly_t c, t1, t2, q, r;
fmpz_mod_bpoly_init(c,... |
functions | void _hensel_lift_tree(
int opt,
slong * link,
fmpz_mod_bpoly_struct * v,
fmpz_mod_bpoly_struct * w,
const fmpz_mod_bpoly_t f,
slong j,
slong p0,
slong p1,
const fmpz_mod_ctx_t ctx)
{
FLINT_ASSERT(p1 <= p0);
if (j < 0)
return;
if (opt >= 0)
_hensel_lift_... |
functions | void fmpz_mod_bpoly_lift_init(
fmpz_mod_bpoly_lift_t L,
const fmpz_mod_ctx_t ctx)
{
L->link = NULL;
L->lifted_fac = NULL;
fmpz_mod_tpoly_init(L->tmp, ctx);
fmpz_mod_bpoly_init(L->bmp, ctx);
L->r = 0;
L->fac_lift_order = 0;
L->inv_lift_order = 0;
} |
functions | void fmpz_mod_bpoly_lift_clear(
fmpz_mod_bpoly_lift_t L,
const fmpz_mod_ctx_t ctx)
{
flint_free(L->link);
flint_free(L->lifted_fac);
fmpz_mod_tpoly_clear(L->tmp, ctx);
fmpz_mod_bpoly_clear(L->bmp, ctx);
} |
functions | void _fmpz_mod_bpoly_lift_build_tree(
fmpz_mod_bpoly_lift_t L,
fmpz_mod_bpoly_struct * local_facs,
slong r,
const fmpz_mod_bpoly_t monicA,
const fmpz_mod_ctx_t ctx)
{
slong i, j;
fmpz_mod_bpoly_struct * v, * w;
slong e[FLINT_BITS+1];
slong * link;
fmpz_mod_poly_t d, g, h, a, b;
... |
functions | void _fmpz_mod_bpoly_lift_build_steps(
fmpz_mod_bpoly_lift_t L,
const fmpz_mod_ctx_t ctx)
{
slong i, j, k;
slong r = L->r;
slong order = L->fac_lift_order;
fmpz_mod_bpoly_struct * A, * Bfinal, * U, * B;
fmpz_mod_poly_struct * s, * Binv;
fmpz_mod_poly_struct * c, * t;
FLINT_ASSERT(L-... |
functions | int _use_linear_cutoff(slong r, slong degx)
{
return r < 30 + 5*FLINT_BIT_COUNT(degx);
} |
functions | void fmpz_mod_bpoly_lift_start(
fmpz_mod_bpoly_lift_t L,
fmpz_mod_poly_struct * local_facs,
slong r,
const fmpz_mod_bpoly_t monicA,
const fmpz_mod_ctx_t ctx)
{
slong i, k;
slong degx = fmpz_mod_bpoly_degree0(monicA, ctx);
fmpz_mod_bpoly_struct * A, * Bfinal, * U, * B;
FLINT_ASSERT(r... |
functions | void fmpz_mod_bpoly_lift_combine(
fmpz_mod_bpoly_lift_t L,
fmpz_mod_mat_t N,
const fmpz_mod_bpoly_t monicA,
const fmpz_mod_ctx_t ctx)
{
slong i, j, k, r, degx;
fmpz_mod_bpoly_struct * A, * Bfinal, * U, * B;
slong oldr = L->r;
slong newr = fmpz_mod_mat_nrows(N);
slong order = L->fac_l... |
functions | void fmpz_mod_bpoly_lift_continue(
fmpz_mod_bpoly_lift_t L,
const fmpz_mod_bpoly_t monicA,
slong order,
const fmpz_mod_ctx_t ctx)
{
slong i, j, k;
slong r = L->r;
fmpz_mod_bpoly_struct * A, * Bfinal, * U, * Ue, * B;
fmpz_mod_poly_struct * s, * Binv;
fmpz_mod_poly_struct * c, * t, * c... |
functions | else if (k > 0)
{
fmpz_mod_poly_struct * p;
fmpz_mod_poly_mul(t, B[k].coeffs + 0, ce, ctx);
p = (k == r - 2) ? B[k + 1].coeffs : U[k + 1].coeffs;
fmpz_mod_poly_mul(ce, p, vk, ctx);
fmpz_mod_poly_add(ce, c... |
functions | void _lattice(
fmpz_mod_mat_t N,
fmpz_mod_bpoly_struct * const * g,
slong r,
slong lift_order,
slong * CLD,
slong * lattice_order,
const fmpz_mod_bpoly_t A,
const fmpz_mod_ctx_t ctx)
{
slong i, j, k;
fmpz_mod_bpoly_t Q, R, dg;
fmpz_mod_bpoly_struct * ld;
fmpz_mod_mat_t M,... |
functions | int _zassenhaus(
const zassenhaus_prune_t zas,
slong limit,
fmpz_mod_tpoly_t F,
const fmpz_t malpha,
const fmpz_mod_mat_t N,
fmpz_mod_bpoly_struct * const * g,
slong r,
slong order,
const fmpz_mod_bpoly_t A,
const fmpz_mod_ctx_t ctx)
{
slong total_deg;
int success;
fm... |
functions | else if (is_simple_check)
{
success = 0;
goto cleanup;
} |
functions | int fmpz_mod_bpoly_factor_smprime(
fmpz_mod_poly_t c, /* poly in y */
fmpz_mod_tpoly_t F,
fmpz_mod_bpoly_t A, /* clobbered */
int allow_shift,
const fmpz_mod_ctx_t ctx)
{
int success;
slong i, r;
slong Alenx, Aleny;
slong final_order, lift_order, lattice_order;
slong * CLD... |
main | int main()
{
slong iter;
flint_rand_t state;
flint_printf("chebyshev_u_ui....");
fflush(stdout);
flint_randinit(state);
for (iter = 0; iter < 10000 * arb_test_multiplier(); iter++)
{
arb_t a, b, c, d, e;
ulong n;
slong prec;
n = n_randtest(state);
... |
functions | void isrpipe_init(isrpipe_t *isrpipe, char *buf, size_t bufsize)
{
mutex_init(&isrpipe->mutex);
tsrb_init(&isrpipe->tsrb, buf, bufsize);
} |
functions | int isrpipe_write_one(isrpipe_t *isrpipe, char c)
{
int res = tsrb_add_one(&isrpipe->tsrb, c);
/* `res` is either 0 on success or -1 when the buffer is full. Either way,
* unlocking the mutex is fine.
*/
mutex_unlock(&isrpipe->mutex);
return res;
} |
functions | int isrpipe_read(isrpipe_t *isrpipe, char *buffer, size_t count)
{
int res;
while (!(res = tsrb_get(&isrpipe->tsrb, buffer, count))) {
mutex_lock(&isrpipe->mutex);
} |
includes |
#include <stdio.h> |
includes | #include <stdlib.h> |
main | int
main(void)
{
slong i;
FLINT_TEST_INIT(state);
flint_printf("mul_KS....");
fflush(stdout);
for (i = 0; i < 200 * flint_test_multiplier(); i++)
{
fmpz_poly_mat_t A, B, C, D;
slong m, n, k, bits, deg;
m = n_randint(state, 15);
n = n_randint(state, 15);
... |
includes |
#include <gmp.h> |
functions | void
_fmpz_mod_poly_shift_right(fmpz * res, const fmpz * poly, slong len, slong n)
{
slong i;
/* Copy in forward order to avoid writing over unshifted coefficients */
if (res != poly)
{
for (i = 0; i < len - n; i++)
fmpz_set(res + i, poly + n + i);
} |
functions | void
fmpz_mod_poly_shift_right(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, slong n)
{
if (n == 0)
{
fmpz_mod_poly_set(res, poly);
return;
} |
includes |
#include <config.h> |
functions | SQLRETURN SQLGetConnectOptionA( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLPOINTER value )
{
return SQLGetConnectOption( connection_handle,
option,
value );
} |
functions | SQLRETURN SQLGetConnectOption( SQLHDBC connection_handle,
SQLUSMALLINT option,
SQLPOINTER value )
{
DMHDBC connection = (DMHDBC)connection_handle;
int type = 0;
SQLCHAR s1[ 100 + LOG_MESSAGE_LEN ];
/*
* doesn't require a handle
*/
if ( option == SQL_ATTR_TRACE )
... |
functions | else if ( option == SQL_ATTR_TRACEFILE )
{
SQLRETURN ret = SQL_SUCCESS;
if ( log_info.log_file_name )
{
strcpy( value, log_info.log_file_name );
} |
includes |
#include <math.h> |
includes |
#include <pango/pango-attributes.h> |
functions | void
clutter_color_add (const ClutterColor *a,
const ClutterColor *b,
ClutterColor *result)
{
g_return_if_fail (a != NULL);
g_return_if_fail (b != NULL);
g_return_if_fail (result != NULL);
result->red = CLAMP (a->red + b->red, 0, 255);
result->green = CLAMP (a->green + b->green, 0, 255)... |
functions | void
clutter_color_subtract (const ClutterColor *a,
const ClutterColor *b,
ClutterColor *result)
{
g_return_if_fail (a != NULL);
g_return_if_fail (b != NULL);
g_return_if_fail (result != NULL);
result->red = CLAMP (a->red - b->red, 0, 255);
result->green = CLAMP (a->green - b->green, 0, 255... |
functions | void
clutter_color_lighten (const ClutterColor *color,
ClutterColor *result)
{
clutter_color_shade (color, 1.3, result);
} |
functions | void
clutter_color_darken (const ClutterColor *color,
ClutterColor *result)
{
clutter_color_shade (color, 0.7, result);
} |
functions | void
clutter_color_to_hls (const ClutterColor *color,
float *hue,
float *luminance,
float *saturation)
{
float red, green, blue;
float min, max, delta;
float h, l, s;
g_return_if_fail (color != NULL);
red = color->red / 255.0;
green = colo... |
functions | void
clutter_color_from_hls (ClutterColor *color,
float hue,
float luminance,
float saturation)
{
float tmp1, tmp2;
float tmp3[3];
float clr[3];
int i;
hue /= 360.0;
if (saturation == 0)
{
color->red = color->green = color->blue = (luminance * 255);
retu... |
functions | void
clutter_color_shade (const ClutterColor *color,
gdouble factor,
ClutterColor *result)
{
float h, l, s;
g_return_if_fail (color != NULL);
g_return_if_fail (result != NULL);
clutter_color_to_hls (color, &h, &l, &s);
l = CLAMP (l * factor, 0.0... |
functions | guint32
clutter_color_to_pixel (const ClutterColor *color)
{
g_return_val_if_fail (color != NULL, 0);
return (color->alpha |
color->blue << 8 |
color->green << 16 |
color->red << 24);
} |
functions | void
clutter_color_from_pixel (ClutterColor *color,
guint32 pixel)
{
g_return_if_fail (color != NULL);
color->red = pixel >> 24;
color->green = (pixel >> 16) & 0xff;
color->blue = (pixel >> 8) & 0xff;
color->alpha = pixel & 0xff;
} |
functions | void
skip_whitespace (gchar **str)
{
while (g_ascii_isspace (**str))
*str += 1;
} |
functions | void
parse_rgb_value (gchar *str,
guint8 *color,
gchar **endp)
{
gdouble number;
gchar *p;
skip_whitespace (&str);
number = g_ascii_strtod (str, endp);
p = *endp;
skip_whitespace (&p);
if (*p == '%')
{
*endp = (gchar *) (p + 1);
*color = CLAMP (n... |
functions | gboolean
parse_rgba (ClutterColor *color,
gchar *str,
gboolean has_alpha)
{
skip_whitespace (&str);
if (*str != '(')
return FALSE;
str += 1;
/* red */
parse_rgb_value (str, &color->red, &str);
skip_whitespace (&str);
if (*str != ',')
return FALSE;
str += 1... |
functions | gboolean
parse_hsla (ClutterColor *color,
gchar *str,
gboolean has_alpha)
{
gdouble number;
gdouble h, l, s;
skip_whitespace (&str);
if (*str != '(')
return FALSE;
str += 1;
/* hue */
skip_whitespace (&str);
/* we don't do any angle normalization here because
... |
functions | gboolean
clutter_color_from_string (ClutterColor *color,
const gchar *str)
{
PangoColor pango_color = { 0, } |
functions | gboolean
clutter_color_equal (gconstpointer v1,
gconstpointer v2)
{
const ClutterColor *a, *b;
g_return_val_if_fail (v1 != NULL, FALSE);
g_return_val_if_fail (v2 != NULL, FALSE);
if (v1 == v2)
return TRUE;
a = v1;
b = v2;
return (a->red == b->red &&
a->green == b... |
functions | guint
clutter_color_hash (gconstpointer v)
{
return clutter_color_to_pixel ((const ClutterColor *) v);
} |
functions | void
clutter_color_interpolate (const ClutterColor *initial,
const ClutterColor *final,
gdouble progress,
ClutterColor *result)
{
g_return_if_fail (initial != NULL);
g_return_if_fail (final != NULL);
g_return_if_fai... |
functions | gboolean
clutter_color_progress (const GValue *a,
const GValue *b,
gdouble progress,
GValue *retval)
{
const ClutterColor *a_color = clutter_value_get_color (a);
const ClutterColor *b_color = clutter_value_get_color (b);
ClutterCo... |
functions | void
clutter_color_free (ClutterColor *color)
{
if (G_LIKELY (color != NULL))
g_slice_free (ClutterColor, color);
} |
functions | void
clutter_value_transform_color_string (const GValue *src,
GValue *dest)
{
const ClutterColor *color = g_value_get_boxed (src);
if (color)
{
gchar *string = clutter_color_to_string (color);
g_value_take_string (dest, string);
} |
functions | void
clutter_value_transform_string_color (const GValue *src,
GValue *dest)
{
const char *str = g_value_get_string (src);
if (str)
{
ClutterColor color = { 0, } |
functions | void
clutter_value_set_color (GValue *value,
const ClutterColor *color)
{
g_return_if_fail (CLUTTER_VALUE_HOLDS_COLOR (value));
g_value_set_boxed (value, color);
} |
functions | void
param_color_init (GParamSpec *pspec)
{
ClutterParamSpecColor *cspec = CLUTTER_PARAM_SPEC_COLOR (pspec);
cspec->default_value = NULL;
} |
functions | void
param_color_finalize (GParamSpec *pspec)
{
ClutterParamSpecColor *cspec = CLUTTER_PARAM_SPEC_COLOR (pspec);
clutter_color_free (cspec->default_value);
} |
functions | void
param_color_set_default (GParamSpec *pspec,
GValue *value)
{
const ClutterColor *default_value =
CLUTTER_PARAM_SPEC_COLOR (pspec)->default_value;
clutter_value_set_color (value, default_value);
} |
functions | gint
param_color_values_cmp (GParamSpec *pspec,
const GValue *value1,
const GValue *value2)
{
const ClutterColor *color1 = g_value_get_boxed (value1);
const ClutterColor *color2 = g_value_get_boxed (value2);
int pixel1, pixel2;
if (color1 == NULL)
return co... |
functions | GType
clutter_param_color_get_type (void)
{
static GType pspec_type = 0;
if (G_UNLIKELY (pspec_type == 0))
{
const GParamSpecTypeInfo pspec_info = {
sizeof (ClutterParamSpecColor),
16,
param_color_init,
CLUTTER_TYPE_COLOR,
param_color_finalize,
param_color_... |
structs | struct _ClutterClickActionPrivate
{
ClutterActor *stage;
guint event_id;
guint capture_id;
guint long_press_id;
gint long_press_threshold;
gint long_press_duration;
gint drag_threshold;
guint press_button;
gint press_device_id;
ClutterEventSequence *press_sequence;
ClutterModifierType modifier_... |
functions | void
click_action_set_pressed (ClutterClickAction *action,
gboolean is_pressed)
{
ClutterClickActionPrivate *priv = action->priv;
is_pressed = !!is_pressed;
if (priv->is_pressed == is_pressed)
return;
priv->is_pressed = is_pressed;
g_object_notify_by_pspec (G_OBJECT... |
functions | void
click_action_set_held (ClutterClickAction *action,
gboolean is_held)
{
ClutterClickActionPrivate *priv = action->priv;
is_held = !!is_held;
if (priv->is_held == is_held)
return;
priv->is_held = is_held;
g_object_notify_by_pspec (G_OBJECT (action), obj_props[PROP_H... |
functions | gboolean
click_action_emit_long_press (gpointer data)
{
ClutterClickAction *action = data;
ClutterClickActionPrivate *priv = action->priv;
ClutterActor *actor;
gboolean result;
priv->long_press_id = 0;
actor = clutter_actor_meta_get_actor (data);
g_signal_emit (action, click_signals[LONG_PRESS], 0,
... |
functions | void
click_action_query_long_press (ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
ClutterActor *actor;
gboolean result = FALSE;
gint timeout;
if (priv->long_press_duration < 0)
{
ClutterSettings *settings = clutter_settings_get_default ();
g_object_get (settin... |
functions | void
click_action_cancel_long_press (ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
if (priv->long_press_id != 0)
{
ClutterActor *actor;
gboolean result;
actor = clutter_actor_meta_get_actor (CLUTTER_ACTOR_META (action));
g_source_remove (priv->long_pres... |
functions | gboolean
on_event (ClutterActor *actor,
ClutterEvent *event,
ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
gboolean has_button = TRUE;
if (!clutter_actor_meta_get_enabled (CLUTTER_ACTOR_META (action)))
return CLUTTER_EVENT_PROPAGATE;
switch (... |
functions | gboolean
on_captured_event (ClutterActor *stage,
ClutterEvent *event,
ClutterClickAction *action)
{
ClutterClickActionPrivate *priv = action->priv;
ClutterActor *actor;
ClutterModifierType modifier_state;
gboolean has_button = TRUE;
actor = clutter_actor_meta... |
functions | void
clutter_click_action_set_actor (ClutterActorMeta *meta,
ClutterActor *actor)
{
ClutterClickAction *action = CLUTTER_CLICK_ACTION (meta);
ClutterClickActionPrivate *priv = action->priv;
if (priv->event_id != 0)
{
ClutterActor *old_actor = clutter_actor_meta_get_a... |
functions | void
clutter_click_action_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
switch (... |
functions | void
clutter_click_action_get_property (GObject *gobject,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
ClutterClickActionPrivate *priv = CLUTTER_CLICK_ACTION (gobject)->priv;
switch (prop_id)... |
functions | void
clutter_click_action_class_init (ClutterClickActionClass *klass)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
ClutterActorMetaClass *meta_class = CLUTTER_ACTOR_META_CLASS (klass);
g_type_class_add_private (klass, sizeof (ClutterClickActionPrivate));
meta_class->set_actor = clutter_click_action... |
functions | void
clutter_click_action_init (ClutterClickAction *self)
{
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, CLUTTER_TYPE_CLICK_ACTION,
ClutterClickActionPrivate);
self->priv->long_press_threshold = -1;
self->priv->long_press_duration = -1;
} |
functions | void
clutter_click_action_release (ClutterClickAction *action)
{
ClutterClickActionPrivate *priv;
g_return_if_fail (CLUTTER_IS_CLICK_ACTION (action));
priv = action->priv;
if (!priv->is_held)
return;
/* disconnect the capture */
if (priv->capture_id != 0)
{
g_signal_handler_disconnect (pri... |
functions | guint
clutter_click_action_get_button (ClutterClickAction *action)
{
g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
return action->priv->press_button;
} |
functions | ClutterModifierType
clutter_click_action_get_state (ClutterClickAction *action)
{
g_return_val_if_fail (CLUTTER_IS_CLICK_ACTION (action), 0);
return action->priv->modifier_state;
} |
functions | void
clutter_click_action_get_coords (ClutterClickAction *action,
gfloat *press_x,
gfloat *press_y)
{
g_return_if_fail (CLUTTER_IS_ACTION (action));
if (press_x != NULL)
*press_x = action->priv->press_x;
if (press_y !=... |
includes | #include <teemDio.h> |
includes | #include <sys/types.h> |
includes | #include <unistd.h> |
includes | #include <fcntl.h> |
functions | int
airDioTest(int fd, const void *ptr, size_t size) {
AIR_UNUSED(fd);
AIR_UNUSED(ptr);
AIR_UNUSED(size);
/* Teem makefiles think no direct IO is possible on this architecture */
return airNoDio_arch;
} |
functions | int
airDioTest(int fd, const void *ptr, size_t size) {
struct dioattr dioinfo;
void *tmp;
int flags;
if (airDisableDio) {
/* user turned direct I/O off */
return airNoDio_disable;
} |
functions | void
airDioInfo(int *align, int *min, int *max, int fd) {
AIR_UNUSED(align);
AIR_UNUSED(min);
AIR_UNUSED(max);
AIR_UNUSED(fd);
return;
} |
functions | void
airDioInfo(int *align, int *min, int *max, int fd) {
struct dioattr dioinfo;
if (align && min && max && !fcntl(fd, F_DIOINFO, &dioinfo)) {
*align = dioinfo.d_mem;
*min = dioinfo.d_miniosz;
*max = dioinfo.d_maxiosz;
} |
functions | size_t
airDioRead(int fd, void *_ptr, size_t size) {
AIR_UNUSED(fd);
AIR_UNUSED(_ptr);
AIR_UNUSED(size);
return 0;
} |
functions | size_t
airDioRead(int fd, void *_ptr, size_t size) {
size_t red, totalred;
int align, min, max, flags;
size_t remain, part;
char *ptr;
if (!( _ptr && airNoDio_okay == airDioTest(fd, _ptr, size) )) {
return 0;
} |
functions | size_t
airDioWrite(int fd, const void *_ptr, size_t size) {
AIR_UNUSED(fd);
AIR_UNUSED(_ptr);
AIR_UNUSED(size);
return 0;
} |
functions | size_t
airDioWrite(int fd, const void *_ptr, size_t size) {
size_t rit, totalrit;
int align, min, max, flags;
size_t remain, part;
char *ptr;
if (!( _ptr && (airNoDio_okay == airDioTest(fd, _ptr, size)) )) {
return 0;
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.