← Back to branch summary

~ubuntu-branches/ubuntu/trusty/rgtk2/trusty

« back to all changes in this revision

Viewing changes to src/gioUserFuncs.c

  • Committer: Bazaar Package Importer
  • Author(s): Dirk Eddelbuettel
  • Date: 2010-11-03 11:35:46 UTC
  • mfrom: (1.3.7 upstream)
  • Revision ID: james.westby@ubuntu.com-20101103113546-a7fi7jdxdebp0tw1
Tags: 2.20.1-1
* New upstream release

* debian/control: Set (Build-)Depends: to current R version
* debian/control: Set Standards-Version: to current version 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gioUserFuncs.c
 
1
#include "RGtk2/gioUserFuncs.h"
 
2
#if GIO_CHECK_VERSION(2, 16, 0)
 
3
 
 
4
gboolean
 
5
S_GIOSchedulerJobFunc(GIOSchedulerJob* s_job, GCancellable* s_cancellable, gpointer s_user_data)
 
6
{
 
7
  USER_OBJECT_ e;
 
8
  USER_OBJECT_ tmp;
 
9
  USER_OBJECT_ s_ans;
 
10
  gint err;
 
11
 
 
12
  PROTECT(e = allocVector(LANGSXP, 3+((R_CallbackData *)s_user_data)->useData));
 
13
  tmp = e;
 
14
 
 
15
  SETCAR(tmp, ((R_CallbackData *)s_user_data)->function);
 
16
  tmp = CDR(tmp);
 
17
 
 
18
  SETCAR(tmp, toRPointer(s_job, "GIOSchedulerJob"));
 
19
  tmp = CDR(tmp);
 
20
  SETCAR(tmp, toRPointerWithRef(s_cancellable, "GCancellable"));
 
21
  tmp = CDR(tmp);
 
22
  if(((R_CallbackData *)s_user_data)->useData)
 
23
  {
 
24
    SETCAR(tmp, ((R_CallbackData *)s_user_data)->data);
 
25
    tmp = CDR(tmp);
 
26
  }
 
27
 
 
28
  s_ans = R_tryEval(e, R_GlobalEnv, &err);
 
29
 
 
30
  UNPROTECT(1);
 
31
 
 
32
  if(err)
 
33
    return(((gboolean)0));
 
34
  return(((gboolean)asCLogical(s_ans)));
 
35
}
 
36
#endif 
 
37
 
 
38
#if GIO_CHECK_VERSION(2, 16, 0)
 
39
 
 
40
  R_CallbackData * GSimpleAsyncThreadFunc_cbdata;
 
41
gboolean
 
42
S_GSimpleAsyncThreadFunc(GSimpleAsyncResult* s_res, GObject* s_object, GCancellable* s_cancellable)
 
43
{
 
44
  USER_OBJECT_ e;
 
45
  USER_OBJECT_ tmp;
 
46
  USER_OBJECT_ s_ans;
 
47
  gint err;
 
48
 
 
49
  PROTECT(e = allocVector(LANGSXP, 4+GSimpleAsyncThreadFunc_cbdata->useData));
 
50
  tmp = e;
 
51
 
 
52
  SETCAR(tmp, GSimpleAsyncThreadFunc_cbdata->function);
 
53
  tmp = CDR(tmp);
 
54
 
 
55
  SETCAR(tmp, toRPointerWithRef(s_res, "GSimpleAsyncResult"));
 
56
  tmp = CDR(tmp);
 
57
  SETCAR(tmp, toRPointerWithRef(s_object, "GObject"));
 
58
  tmp = CDR(tmp);
 
59
  SETCAR(tmp, toRPointerWithRef(s_cancellable, "GCancellable"));
 
60
  tmp = CDR(tmp);
 
61
  if(GSimpleAsyncThreadFunc_cbdata->useData)
 
62
  {
 
63
    SETCAR(tmp, GSimpleAsyncThreadFunc_cbdata->data);
 
64
    tmp = CDR(tmp);
 
65
  }
 
66
 
 
67
  s_ans = R_tryEval(e, R_GlobalEnv, &err);
 
68
 
 
69
  UNPROTECT(1);
 
70
 
 
71
  if(err)
 
72
    return(((gboolean)0));
 
73
  return(((gboolean)asCLogical(s_ans)));
 
74
}
 
75
#endif 
 
76
 
 
77
#if GIO_CHECK_VERSION(2, 16, 0)
 
78
 
 
79
void
 
80
S_GAsyncReadyCallback(GObject* s_source_object, GSimpleAsyncResult* s_res, gpointer s_user_data)
 
81
{
 
82
  USER_OBJECT_ e;
 
83
  USER_OBJECT_ tmp;
 
84
  USER_OBJECT_ s_ans;
 
85
  gint err;
 
86
 
 
87
  PROTECT(e = allocVector(LANGSXP, 3+((R_CallbackData *)s_user_data)->useData));
 
88
  tmp = e;
 
89
 
 
90
  SETCAR(tmp, ((R_CallbackData *)s_user_data)->function);
 
91
  tmp = CDR(tmp);
 
92
 
 
93
  SETCAR(tmp, toRPointerWithRef(s_source_object, "GObject"));
 
94
  tmp = CDR(tmp);
 
95
  SETCAR(tmp, toRPointerWithRef(s_res, "GSimpleAsyncResult"));
 
96
  tmp = CDR(tmp);
 
97
  if(((R_CallbackData *)s_user_data)->useData)
 
98
  {
 
99
    SETCAR(tmp, ((R_CallbackData *)s_user_data)->data);
 
100
    tmp = CDR(tmp);
 
101
  }
 
102
 
 
103
  s_ans = R_tryEval(e, R_GlobalEnv, &err);
 
104
  R_freeCBData(((R_CallbackData *)s_user_data));
 
105
 
 
106
  UNPROTECT(1);
 
107
 
 
108
  if(err)
 
109
    return;
 
110
}
 
111
#endif 
 
112
 
 
113
#if GIO_CHECK_VERSION(2, 16, 0)
 
114
 
 
115
void
 
116
S_GFileProgressCallback(goffset s_current_num_bytes, goffset s_total_num_bytes, gpointer s_user_data)
 
117
{
 
118
  USER_OBJECT_ e;
 
119
  USER_OBJECT_ tmp;
 
120
  USER_OBJECT_ s_ans;
 
121
  gint err;
 
122
 
 
123
  PROTECT(e = allocVector(LANGSXP, 3+((R_CallbackData *)s_user_data)->useData));
 
124
  tmp = e;
 
125
 
 
126
  SETCAR(tmp, ((R_CallbackData *)s_user_data)->function);
 
127
  tmp = CDR(tmp);
 
128
 
 
129
  SETCAR(tmp, asRNumeric(s_current_num_bytes));
 
130
  tmp = CDR(tmp);
 
131
  SETCAR(tmp, asRNumeric(s_total_num_bytes));
 
132
  tmp = CDR(tmp);
 
133
  if(((R_CallbackData *)s_user_data)->useData)
 
134
  {
 
135
    SETCAR(tmp, ((R_CallbackData *)s_user_data)->data);
 
136
    tmp = CDR(tmp);
 
137
  }
 
138
 
 
139
  s_ans = R_tryEval(e, R_GlobalEnv, &err);
 
140
 
 
141
  UNPROTECT(1);
 
142
 
 
143
  if(err)
 
144
    return;
 
145
}
 
146
#endif 
 
147
 
 
148
#if GIO_CHECK_VERSION(2, 16, 0)
 
149
 
 
150
void
 
151
S_GFileReadMoreCallback(const char* s_file_contents, goffset s_file_size, gpointer s_callback_data)
 
152
{
 
153
  USER_OBJECT_ e;
 
154
  USER_OBJECT_ tmp;
 
155
  USER_OBJECT_ s_ans;
 
156
  gint err;
 
157
 
 
158
  PROTECT(e = allocVector(LANGSXP, 3+((R_CallbackData *)s_callback_data)->useData));
 
159
  tmp = e;
 
160
 
 
161
  SETCAR(tmp, ((R_CallbackData *)s_callback_data)->function);
 
162
  tmp = CDR(tmp);
 
163
 
 
164
  SETCAR(tmp, asRString(s_file_contents));
 
165
  tmp = CDR(tmp);
 
166
  SETCAR(tmp, asRNumeric(s_file_size));
 
167
  tmp = CDR(tmp);
 
168
  if(((R_CallbackData *)s_callback_data)->useData)
 
169
  {
 
170
    SETCAR(tmp, ((R_CallbackData *)s_callback_data)->data);
 
171
    tmp = CDR(tmp);
 
172
  }
 
173
 
 
174
  s_ans = R_tryEval(e, R_GlobalEnv, &err);
 
175
 
 
176
  UNPROTECT(1);
 
177
 
 
178
  if(err)
 
179
    return;
 
180
}
 
181
#endif 
 
182
 
 
183
#if GIO_CHECK_VERSION(2, 16, 0)
 
184
 
 
185
gpointer
 
186
S_GReallocFunc(gpointer s_data, gsize s_size)
 
187
{
 
188
  USER_OBJECT_ e;
 
189
  USER_OBJECT_ tmp;
 
190
  USER_OBJECT_ s_ans;
 
191
  gint err;
 
192
 
 
193
  PROTECT(e = allocVector(LANGSXP, 2+((R_CallbackData *)s_data)->useData));
 
194
  tmp = e;
 
195
 
 
196
  SETCAR(tmp, ((R_CallbackData *)s_data)->function);
 
197
  tmp = CDR(tmp);
 
198
 
 
199
  SETCAR(tmp, asRNumeric(s_size));
 
200
  tmp = CDR(tmp);
 
201
  if(((R_CallbackData *)s_data)->useData)
 
202
  {
 
203
    SETCAR(tmp, ((R_CallbackData *)s_data)->data);
 
204
    tmp = CDR(tmp);
 
205
  }
 
206
 
 
207
  s_ans = R_tryEval(e, R_GlobalEnv, &err);
 
208
 
 
209
  UNPROTECT(1);
 
210
 
 
211
  if(err)
 
212
    return(((gpointer)0));
 
213
  return(((gpointer)asCGenericData(s_ans)));
 
214
}
 
215
#endif 
 
216