← Back to branch summary

~ubuntu-branches/ubuntu/precise/gtk+2.0/precise-updates

« back to all changes in this revision

Viewing changes to gdk/win32/gdkinput.c

  • Committer: Package Import Robot
  • Author(s): Ken VanDine
  • Date: 2011-12-01 11:40:06 UTC
  • mfrom: (1.14.11)
  • Revision ID: package-import@ubuntu.com-20111201114006-nrmf6qu3pg512veo
Tags: 2.24.8-0ubuntu1
https://launchpad.net/bugs/189494
https://launchpad.net/bugs/889019
* New upstream release 
  - gtkfilechooser should be more robust to malformed URIs
    in .gtk-bookmarks (LP: #189494)
* debian/patches/010_make_bg_changes_queue_repaint.patch
  - dropped it introduces performance regressions in some gtk2 
    apps (LP: #889019)
* 101_filechooser.patch, 000git_file_chooser.patch: dropped, upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
gdk/win32/gdkinput.c
46
46
 
47
47
/* Global variables  */
48
48
 
49
 
gint              _gdk_input_ignore_core;
50
 
 
51
49
GList            *_gdk_input_devices;
52
50
GList            *_gdk_input_windows;
 
51
gboolean          _gdk_input_in_proximity = 0;
 
52
gboolean          _gdk_input_inside_input_window = 0;
53
53
 
54
54
void
55
55
_gdk_init_input_core (GdkDisplay *display)
291
291
  g_free (events);
292
292
}
293
293
 
294
 
GdkInputWindow *
295
 
_gdk_input_window_find(GdkWindow *window)
296
 
{
297
 
  GList *tmp_list;
298
 
 
299
 
  for (tmp_list=_gdk_input_windows; tmp_list; tmp_list=tmp_list->next)
300
 
    if (((GdkInputWindow *)(tmp_list->data))->window == window)
301
 
      return (GdkInputWindow *)(tmp_list->data);
302
 
 
303
 
  return NULL;      /* Not found */
304
 
}
305
 
 
306
294
/* FIXME: this routine currently needs to be called between creation
307
295
   and the corresponding configure event (because it doesn't get the
308
296
   root_relative_geometry).  This should work with
309
297
   gtk_window_set_extension_events, but will likely fail in other
310
298
   cases */
311
299
 
 
300
static void
 
301
unset_extension_events (GdkWindow *window)
 
302
{
 
303
  GdkWindowObject *window_private;
 
304
  GdkWindowObject *impl_window;
 
305
  GdkInputWindow *iw;
 
306
 
 
307
  window_private = (GdkWindowObject*) window;
 
308
  impl_window = (GdkWindowObject *)_gdk_window_get_impl_window (window);
 
309
  iw = impl_window->input_window;
 
310
 
 
311
  if (window_private->extension_events != 0)
 
312
    {
 
313
      g_assert (iw != NULL);
 
314
      g_assert (g_list_find (iw->windows, window) != NULL);
 
315
 
 
316
      iw->windows = g_list_remove (iw->windows, window);
 
317
      if (iw->windows == NULL)
 
318
        {
 
319
          impl_window->input_window = NULL;
 
320
          _gdk_input_windows = g_list_remove(_gdk_input_windows,iw);
 
321
          g_free (iw);
 
322
        }
 
323
    }
 
324
 
 
325
  window_private->extension_events = 0;
 
326
}
 
327
 
 
328
static void
 
329
gdk_input_get_root_relative_geometry (HWND w,
 
330
                                      int  *x_ret,
 
331
                                      int  *y_ret)
 
332
{
 
333
  POINT pt;
 
334
 
 
335
  pt.x = 0;
 
336
  pt.y = 0;
 
337
  ClientToScreen (w, &pt);
 
338
 
 
339
  if (x_ret)
 
340
    *x_ret = pt.x + _gdk_offset_x;
 
341
  if (y_ret)
 
342
    *y_ret = pt.y + _gdk_offset_y;
 
343
}
 
344
 
312
345
void
313
346
gdk_input_set_extension_events (GdkWindow *window, gint mask,
314
347
                                GdkExtensionMode mode)
315
348
{
316
349
  GdkWindowObject *window_private;
317
 
  GList *tmp_list;
 
350
  GdkWindowObject *impl_window;
318
351
  GdkInputWindow *iw;
319
352
 
320
353
  g_return_if_fail (window != NULL);
324
357
  if (GDK_WINDOW_DESTROYED (window))
325
358
    return;
326
359
 
 
360
  impl_window = (GdkWindowObject *)_gdk_window_get_impl_window (window);
 
361
 
 
362
  if (mode == GDK_EXTENSION_EVENTS_ALL && mask != 0)
 
363
    mask |= GDK_ALL_DEVICES_MASK;
 
364
 
327
365
  if (mode == GDK_EXTENSION_EVENTS_NONE)
328
366
    mask = 0;
329
367
 
 
368
  iw = impl_window->input_window;
 
369
 
330
370
  if (mask != 0)
331
371
    {
332
372
      _gdk_input_wintab_init_check ();
333
373
 
334
 
      iw = g_new(GdkInputWindow,1);
335
 
 
336
 
      iw->window = window;
337
 
      iw->mode = mode;
338
 
 
339
 
      iw->obscuring = NULL;
340
 
      iw->num_obscuring = 0;
341
 
      iw->grabbed = FALSE;
342
 
 
343
 
      _gdk_input_windows = g_list_append(_gdk_input_windows,iw);
 
374
      if (!iw)
 
375
        {
 
376
          iw = g_new0 (GdkInputWindow,1);
 
377
 
 
378
          iw->impl_window = (GdkWindow *)impl_window;
 
379
 
 
380
          iw->windows = NULL;
 
381
 
 
382
          _gdk_input_windows = g_list_append(_gdk_input_windows, iw);
 
383
 
 
384
          gdk_input_get_root_relative_geometry (GDK_WINDOW_HWND (window), &iw->root_x, &iw->root_y);
 
385
 
 
386
          impl_window->input_window = iw;
 
387
        }
 
388
 
 
389
      if (window_private->extension_events == 0)
 
390
        iw->windows = g_list_append (iw->windows, window);
344
391
      window_private->extension_events = mask;
345
 
 
346
 
      /* Add enter window events to the event mask */
347
 
      if (g_list_length (_gdk_input_devices) > 1)
348
 
        gdk_window_set_events (window,
349
 
                               gdk_window_get_events (window) | 
350
 
                               GDK_ENTER_NOTIFY_MASK);
351
392
    }
352
393
  else
353
394
    {
354
 
      iw = _gdk_input_window_find (window);
355
 
      if (iw)
356
 
        {
357
 
          _gdk_input_windows = g_list_remove(_gdk_input_windows,iw);
358
 
          g_free(iw);
359
 
        }
360
 
 
361
 
      window_private->extension_events = 0;
362
 
    }
363
 
 
364
 
  for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
365
 
    {
366
 
      GdkDevicePrivate *gdkdev = tmp_list->data;
367
 
 
368
 
      if (!GDK_IS_CORE (gdkdev))
369
 
        {
370
 
          if (mask != 0 && gdkdev->info.mode != GDK_MODE_DISABLED
371
 
              && (gdkdev->info.has_cursor || mode == GDK_EXTENSION_EVENTS_ALL))
372
 
            _gdk_input_enable_window (window,gdkdev);
373
 
          else
374
 
            _gdk_input_disable_window (window,gdkdev);
375
 
        }
376
 
    }
 
395
      unset_extension_events (window);
 
396
    }
 
397
 
 
398
  _gdk_input_select_events ((GdkWindow *)impl_window);
377
399
}
378
400
 
379
401
void
380
402
_gdk_input_window_destroy (GdkWindow *window)
381
403
{
382
 
  GdkInputWindow *input_window;
383
 
 
384
 
  input_window = _gdk_input_window_find (window);
385
 
  g_return_if_fail (input_window != NULL);
386
 
 
387
 
  _gdk_input_windows = g_list_remove (_gdk_input_windows,input_window);
388
 
  g_free(input_window);
 
404
  unset_extension_events (window);
 
405
}
 
406
 
 
407
void
 
408
_gdk_input_check_proximity (void)
 
409
{
 
410
  GList *l;
 
411
  gboolean new_proximity = FALSE;
 
412
 
 
413
  if (!_gdk_input_inside_input_window)
 
414
    {
 
415
      _gdk_display->ignore_core_events = FALSE;
 
416
      return;
 
417
    }
 
418
 
 
419
  for (l = _gdk_input_devices; l != NULL; l = l->next)
 
420
    {
 
421
      GdkDevicePrivate *gdkdev = l->data;
 
422
 
 
423
      if (gdkdev->info.mode != GDK_MODE_DISABLED &&
 
424
          !GDK_IS_CORE (gdkdev))
 
425
        {
 
426
          if (_gdk_input_in_proximity)
 
427
            {
 
428
              new_proximity = TRUE;
 
429
              break;
 
430
            }
 
431
        }
 
432
    }
 
433
 
 
434
  _gdk_display->ignore_core_events = new_proximity;
389
435
}
390
436
 
391
437
void
394
440
{
395
441
  if (enter)
396
442
    {
397
 
#if 0 /* No idea what to do... */
398
443
      GdkWindowObject *priv = (GdkWindowObject *)window;
399
444
      GdkInputWindow *input_window;
400
445
      gint root_x, root_y;
401
 
#if 0
402
 
      gdk_input_check_proximity(display);
403
 
#endif
 
446
 
 
447
      _gdk_input_inside_input_window = TRUE;
 
448
 
404
449
      input_window = priv->input_window;
405
450
      if (input_window != NULL)
406
451
        {
407
 
          _gdk_input_get_root_relative_geometry (window, &root_x, &root_y);
 
452
          gdk_input_get_root_relative_geometry (GDK_WINDOW_HWND (window), 
 
453
                                                &root_x, &root_y);
408
454
          input_window->root_x = root_x;
409
455
          input_window->root_y = root_y;
410
456
        }
411
 
#endif
412
457
    }
413
458
  else
414
 
    _gdk_input_ignore_core = FALSE;
415
 
}
416
 
 
417
 
void
418
 
_gdk_input_exit (void)
419
 
{
420
 
  GList *tmp_list;
421
 
  GdkDevicePrivate *gdkdev;
422
 
 
423
 
  for (tmp_list = _gdk_input_devices; tmp_list; tmp_list = tmp_list->next)
424
459
    {
425
 
      gdkdev = (GdkDevicePrivate *)(tmp_list->data);
426
 
      if (!GDK_IS_CORE (gdkdev))
427
 
        {
428
 
          gdk_device_set_mode (&gdkdev->info, GDK_MODE_DISABLED);
429
 
 
430
 
          g_free(gdkdev->info.name);
431
 
          g_free(gdkdev->axes);
432
 
          g_free(gdkdev->info.axes);
433
 
          g_free(gdkdev->info.keys);
434
 
          g_free(gdkdev);
435
 
        }
 
460
      _gdk_input_inside_input_window = FALSE;
436
461
    }
437
462
 
438
 
  g_list_free(_gdk_input_devices);
439
 
 
440
 
  for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
441
 
    g_free(tmp_list->data);
442
 
 
443
 
  g_list_free(_gdk_input_windows);
 
463
  _gdk_input_check_proximity ();
444
464
}
445
465
 
446
466
gboolean
473
493
{
474
494
  GList *tmp_list;
475
495
  GdkDevicePrivate *gdkdev;
476
 
  GdkInputMode old_mode;
477
496
  GdkInputWindow *input_window;
478
497
 
479
498
  if (GDK_IS_CORE (device))
484
503
  if (device->mode == mode)
485
504
    return TRUE;
486
505
 
487
 
  old_mode = device->mode;
488
506
  device->mode = mode;
489
507
 
490
508
  if (mode == GDK_MODE_WINDOW)
491
 
    {
492
 
      device->has_cursor = FALSE;
493
 
      for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
494
 
        {
495
 
          input_window = (GdkInputWindow *)tmp_list->data;
496
 
          if (input_window->mode != GDK_EXTENSION_EVENTS_CURSOR)
497
 
            _gdk_input_enable_window (input_window->window, gdkdev);
498
 
          else
499
 
            if (old_mode != GDK_MODE_DISABLED)
500
 
              _gdk_input_disable_window (input_window->window, gdkdev);
501
 
        }
502
 
    }
 
509
    device->has_cursor = FALSE;
503
510
  else if (mode == GDK_MODE_SCREEN)
504
 
    {
505
 
      device->has_cursor = TRUE;
506
 
      for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
507
 
        _gdk_input_enable_window (((GdkInputWindow *)tmp_list->data)->window,
508
 
                                  gdkdev);
509
 
    }
510
 
  else  /* mode == GDK_MODE_DISABLED */
511
 
    {
512
 
      for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
513
 
        {
514
 
          input_window = (GdkInputWindow *)tmp_list->data;
515
 
          if (old_mode != GDK_MODE_WINDOW ||
516
 
              input_window->mode != GDK_EXTENSION_EVENTS_CURSOR)
517
 
            _gdk_input_disable_window (input_window->window, gdkdev);
518
 
        }
519
 
    }
 
511
    device->has_cursor = TRUE;
 
512
 
 
513
  for (tmp_list = _gdk_input_windows; tmp_list; tmp_list = tmp_list->next)
 
514
    {
 
515
      input_window = (GdkInputWindow *)tmp_list->data;
 
516
      _gdk_input_select_events (input_window->impl_window);
 
517
    }
 
518
 
 
519
  if (!GDK_IS_CORE (gdkdev))
 
520
    _gdk_input_update_for_device_mode (gdkdev);
520
521
 
521
522
  return TRUE;
522
523
}