threads.c 8.13 KB
Newer Older
1 2 3 4
#include <stdio.h>
#include <stdlib.h>
#include <clutter/clutter.h>

5
/* our thread-specific data */
6 7 8 9
typedef struct
{
  ClutterActor *stage;
  ClutterActor *label;
10
  ClutterActor *progress;
11
  ClutterActor *rect;
12

13 14
  ClutterTransition *flip;
  ClutterTransition *bounce;
15 16 17 18 19 20 21 22 23 24 25 26 27
} TestThreadData;

static TestThreadData *
test_thread_data_new (void)
{
  TestThreadData *data;

  data = g_new0 (TestThreadData, 1);

  return data;
}

static void
28
test_thread_data_free (gpointer _data)
29
{
30 31 32 33 34
  TestThreadData *data = _data;

  if (data == NULL)
    return;

35 36 37 38 39 40 41 42
  g_print ("Removing thread data [%p]\n", _data);

  g_clear_object (&data->progress);
  g_clear_object (&data->label);
  g_clear_object (&data->stage);
  g_clear_object (&data->rect);
  g_clear_object (&data->flip);
  g_clear_object (&data->bounce);
43 44 45 46 47 48 49 50 51

  g_free (data);
}

static gboolean
test_thread_done_idle (gpointer user_data)
{
  TestThreadData *data = user_data;

52 53
  g_print ("Last update [%p]\n", data);

54
  clutter_text_set_text (CLUTTER_TEXT (data->label), "Completed");
55 56 57

  clutter_actor_remove_transition (data->rect, "bounce");
  clutter_actor_remove_transition (data->rect, "flip");
58

59
  return G_SOURCE_REMOVE;
60 61
}

62 63 64
static void
test_thread_data_done (gpointer _data)
{
65 66
  if (_data == NULL)
    return;
67

68 69
  g_print ("Thread completed\n");

70 71 72 73 74 75 76
  /* since the TestThreadData structure references Clutter data structures
   * we need to free it from within the same thread that called clutter_main()
   * which means using an idle handler in the main loop.
   *
   * clutter_threads_add_idle() is guaranteed to run the callback passed to
   * to it under the Big Clutter Lock.
   */
77 78 79 80
  clutter_threads_add_idle_full (G_PRIORITY_DEFAULT,
                                 test_thread_done_idle,
                                 _data,
                                 test_thread_data_free);
81 82
}

83
/* thread local storage */
84
static GPrivate test_thread_data = G_PRIVATE_INIT (test_thread_data_done);
85

86
typedef struct {
87 88 89 90 91 92 93 94
  gint count;
  TestThreadData *thread_data;
} TestUpdate;

static gboolean
update_label_idle (gpointer data)
{
  TestUpdate *update = data;
95
  guint width;
96 97
  gchar *text;

98 99 100
  if (update->thread_data->label == NULL)
    return G_SOURCE_REMOVE;

101
  text = g_strdup_printf ("Count to %d", update->count);
102
  clutter_text_set_text (CLUTTER_TEXT (update->thread_data->label), text);
103

104
  clutter_actor_set_width (update->thread_data->label, -1);
105

106 107 108 109 110 111 112
  if (update->count == 0)
    width = 0;
  else if (update->count == 100)
    width = 350;
  else
    width = (guint) (update->count / 100.0 * 350.0);

113
  clutter_actor_save_easing_state (update->thread_data->progress);
114
  clutter_actor_set_width (update->thread_data->progress, width);
115
  clutter_actor_restore_easing_state (update->thread_data->progress);
116

117 118
  g_free (text);
  g_free (update);
119

120
  return G_SOURCE_REMOVE;
121 122 123 124 125 126 127 128
}

static void
do_something_very_slow (void)
{
  TestThreadData *data;
  gint i;

129
  data = g_private_get (&test_thread_data);
130

131
  for (i = 0; i <= 100; i++)
132
    {
133 134
      gint msecs;

135
      msecs = 1 + (int) (100.0 * rand () / ((RAND_MAX + 1.0) / 3));
136

137
      /* sleep for a while, to emulate some work being done */
138
      g_usleep (msecs * 1000);
139

140
      if ((i % 10) == 0)
141 142 143
        {
          TestUpdate *update;

144 145
          /* update the UI from within the main loop, making sure that the
           * Big Clutter Lock is held; only one thread at a time can call
146
           * Clutter API, and it's mandatory to do this from the same thread
147 148
           * that called clutter_init()/clutter_main().
           */
149 150 151
          update = g_new (TestUpdate, 1);
          update->count = i;
          update->thread_data = data;
152

153
          clutter_threads_add_idle_full (G_PRIORITY_HIGH,
154 155
                                         update_label_idle,
                                         update, NULL);
156 157 158 159 160 161 162
        }
    }
}

static gpointer
test_thread_func (gpointer user_data)
{
163
  TestThreadData *data = user_data;
164

165
  g_private_set (&test_thread_data, data);
166

167
  /* this function will block */
168 169 170 171 172
  do_something_very_slow ();

  return NULL;
}

173 174 175
static ClutterActor *count_label   = NULL;
static ClutterActor *help_label    = NULL;
static ClutterActor *progress_rect = NULL;
176 177 178
static ClutterActor *rect          = NULL;
static ClutterTransition *flip     = NULL;
static ClutterTransition *bounce   = NULL;
179

180 181 182 183
static gboolean
on_key_press_event (ClutterStage *stage,
                    ClutterEvent *event,
                    gpointer      user_data)
184 185 186
{
  TestThreadData *data;

187
  switch (clutter_event_get_key_symbol (event))
188
    {
189
    case CLUTTER_KEY_s:
190
      clutter_text_set_text (CLUTTER_TEXT (help_label), "Press 'q' to quit");
191

192 193 194 195 196
      /* start the animations */
      clutter_actor_add_transition (rect, "flip", flip);
      clutter_actor_add_transition (rect, "bounce", bounce);

      /* the data structure holding all our objects */
197
      data = test_thread_data_new ();
198
      data->stage = (ClutterActor *) g_object_ref (stage);
199
      data->label = g_object_ref (count_label);
200
      data->progress = g_object_ref (progress_rect);
201 202 203
      data->rect = g_object_ref (rect);
      data->flip = g_object_ref (flip);
      data->bounce = g_object_ref (bounce);
204

205 206
      /* start the thread that updates the counter and the progress bar */
      g_thread_new ("counter", test_thread_func, data);
207

208
      return CLUTTER_EVENT_STOP;
209

210
    case CLUTTER_KEY_q:
211
      clutter_main_quit ();
212

213
      return CLUTTER_EVENT_STOP;
214 215

    default:
216 217
      break;
    }
218

219
  return CLUTTER_EVENT_PROPAGATE;
220 221
}

222 223
int
main (int argc, char *argv[])
224
{
225
  ClutterTransition *transition;
226
  ClutterActor *stage;
227 228
  ClutterPoint start = CLUTTER_POINT_INIT (75.f, 150.f);
  ClutterPoint end = CLUTTER_POINT_INIT (400.f, 150.f);
229

230 231
  if (clutter_init (&argc, &argv) != CLUTTER_INIT_SUCCESS)
    return 1;
232

233 234
  stage = clutter_stage_new ();
  clutter_stage_set_title (CLUTTER_STAGE (stage), "Threading");
235
  clutter_actor_set_background_color (stage, CLUTTER_COLOR_Aluminium3);
236
  clutter_actor_set_size (stage, 600, 300);
237
  g_signal_connect (stage, "destroy", G_CALLBACK (clutter_main_quit), NULL);
238
  
239
  count_label = clutter_text_new_with_text ("Mono 12", "Counter");
240
  clutter_actor_set_position (count_label, 350, 50);
241
  clutter_actor_add_child (stage, count_label);
242

243
  help_label = clutter_text_new_with_text ("Mono 12", "Press 's' to start");
244
  clutter_actor_set_position (help_label, 50, 50);
245
  clutter_actor_add_child (stage, help_label);
246

247 248 249 250 251 252 253 254 255 256
  /* a progress bar */
  progress_rect = clutter_actor_new ();
  clutter_actor_set_background_color (progress_rect, CLUTTER_COLOR_DarkChameleon);
  clutter_actor_set_position (progress_rect, 50, 225);
  clutter_actor_set_size (progress_rect, 350, 50);
  clutter_actor_add_child (stage, progress_rect);

  /* an actor we bounce around */
  rect = clutter_actor_new ();
  clutter_actor_set_background_color (rect, CLUTTER_COLOR_LightScarletRed);
257 258
  clutter_actor_set_position (rect, 75, 150);
  clutter_actor_set_size (rect, 50, 50);
259
  clutter_actor_set_pivot_point (rect, .5f, .5f);
260
  clutter_actor_set_opacity (rect, 224);
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
  clutter_actor_add_child (stage, rect);

  /* two transitions we use to bounce rect around */
  transition = clutter_property_transition_new ("rotation-angle-z");
  clutter_transition_set_from (transition, G_TYPE_DOUBLE, 0.0);
  clutter_transition_set_to (transition, G_TYPE_DOUBLE, 360.0);
  clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), -1);
  clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
  clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 3000);
  flip = transition;

  transition = clutter_property_transition_new ("position");
  clutter_transition_set_from (transition, CLUTTER_TYPE_POINT, &start);
  clutter_transition_set_to (transition, CLUTTER_TYPE_POINT, &end);
  clutter_timeline_set_repeat_count (CLUTTER_TIMELINE (transition), -1);
  clutter_timeline_set_auto_reverse (CLUTTER_TIMELINE (transition), TRUE);
  clutter_timeline_set_duration (CLUTTER_TIMELINE (transition), 3000);
  bounce = transition;
279 280 281 282 283 284 285 286 287 288 289 290 291 292

  g_signal_connect (stage,
                    "button-press-event", G_CALLBACK (clutter_main_quit),
                    NULL);
  g_signal_connect (stage,
                    "key-press-event", G_CALLBACK (on_key_press_event),
                    NULL);

  clutter_actor_show (stage);

  clutter_main ();

  return EXIT_SUCCESS;
}