← Back to branch summary

~ubuntu-branches/debian/sid/ibus/sid

« back to all changes in this revision

Viewing changes to ui/gtk3/panel.vala

  • Committer: Package Import Robot
  • Author(s): Osamu Aoki, Aron Xu, Osamu Aoki
  • Date: 2014-08-04 22:42:19 UTC
  • mfrom: (1.5.7)
  • Revision ID: package-import@ubuntu.com-20140804224219-mjprlql1jdwi5sxm
Tags: 1.5.8-1
[ Aron Xu ]
* Allow parallel building

[ Osamu Aoki ]
* Update ibus document with Qt5 support

[ Aron Xu ]
* Imported Upstream version 1.5.8
* Remove patch for chasing HEAD, imported new upstream release
* Remove the patch for updating IBusKeymap jp, applied upstream
* Drop gtk2 version of the password patch because it's never executed
* Drop ibus-541492-xkb.patch
* Drop ibus-530711-preload-sys.patch
* Drop ibus-810211-no-switch-by-no-trigger.patch
* Drop 999-update-po.patch

[ Osamu Aoki ]
* linux-any for ibus-wayland
* Remove some symbols matching ibus-541492-xkb.patch
* Remove old patch for GTK+ 3.6

Show diffs side-by-side

added added

removed removed

Lines of Context:
ui/gtk3/panel.vala
63
63
                                                   GLib.str_equal);
64
64
    private Gdk.RGBA m_xkb_icon_rgba = Gdk.RGBA(){
65
65
            red = 0.0, green = 0.0, blue = 0.0, alpha = 1.0 };
66
 
    private GkbdLayout m_gkbdlayout = null;
67
 
    private XKBLayout m_xkblayout = null;
68
 
    private string[] m_layouts = {};
69
 
    private string[] m_variants = {};
70
 
    private int m_fallback_lock_id = -1;
71
 
    private bool m_changed_xkb_option = false;
72
 
    private GLib.Timer m_changed_layout_timer;
 
66
    private XKBLayout m_xkblayout = new XKBLayout();
 
67
    private bool inited_engines_order = true;
73
68
 
74
69
    private GLib.List<Keybinding> m_keybindings = new GLib.List<Keybinding>();
75
70
 
120
115
 
121
116
    ~Panel() {
122
117
        unbind_switch_shortcut();
123
 
 
124
 
        if (HAVE_IBUS_GKBD && m_gkbdlayout != null) {
125
 
            m_gkbdlayout.changed.disconnect(gkbdlayout_changed_cb);
126
 
            m_gkbdlayout.stop_listen();
127
 
            m_gkbdlayout = null;
128
 
        }
129
 
 
130
 
        m_xkblayout = null;
131
118
    }
132
119
 
133
120
    private void init_settings() {
141
128
                               null);
142
129
        });
143
130
 
144
 
        m_settings_general.changed["preload-engine-mode"].connect((key) => {
145
 
                update_im_engines();
146
 
        });
147
 
 
148
131
        m_settings_general.changed["switcher-delay-time"].connect((key) => {
149
132
                set_switcher_delay_time();
150
133
        });
162
145
                set_use_global_engine();
163
146
        });
164
147
 
 
148
        m_settings_general.changed["use-xmodmap"].connect((key) => {
 
149
                set_use_xmodmap();
 
150
        });
 
151
 
165
152
        m_settings_hotkey.changed["triggers"].connect((key) => {
166
153
                unbind_switch_shortcut();
167
154
                bind_switch_shortcut();
286
273
        m_keybindings = null;
287
274
    }
288
275
 
 
276
    /**
 
277
     * panel_get_engines_from_xkb:
 
278
     * @self: #Panel class
 
279
     * @engines: all engines from ibus_bus_list_engines()
 
280
     * @returns: ibus xkb engines
 
281
     *
 
282
     * Made ibus engines from the current XKB keymaps.
 
283
     * This returns only XKB engines whose name start with "xkb:".
 
284
     */
 
285
    private GLib.List<IBus.EngineDesc>
 
286
            get_engines_from_xkb(GLib.List<IBus.EngineDesc> engines) {
 
287
        string layouts;
 
288
        string variants;
 
289
        string option;
 
290
        XKBLayout.get_layout(out layouts, out variants, out option);
 
291
 
 
292
        GLib.List<IBus.EngineDesc> xkb_engines =
 
293
                new GLib.List<IBus.EngineDesc>();
 
294
        IBus.EngineDesc us_engine =
 
295
                new IBus.EngineDesc("xkb:us::eng",
 
296
                                    "", "", "", "", "", "", "");
 
297
        string[] layout_array = layouts.split(",");
 
298
        string[] variant_array = variants.split(",");
 
299
 
 
300
        for (int i = 0; i < layout_array.length; i++) {
 
301
            string layout = layout_array[i];
 
302
            string variant = null;
 
303
            IBus.EngineDesc current_engine = null;
 
304
 
 
305
            if (i < variant_array.length)
 
306
                variant = variant_array[i];
 
307
 
 
308
            /* If variants == "", variants.split(",") is { null }.
 
309
             * To meet engine.get_layout_variant(), convert null to ""
 
310
             * here.
 
311
             */
 
312
            if (variant == null)
 
313
                variant = "";
 
314
 
 
315
            foreach (unowned IBus.EngineDesc engine in engines) {
 
316
 
 
317
                string name = engine.get_name();
 
318
                if (!name.has_prefix("xkb:"))
 
319
                    continue;
 
320
 
 
321
                if (engine.get_layout() == layout &&
 
322
                    engine.get_layout_variant() == variant) {
 
323
                    current_engine = engine;
 
324
                    break;
 
325
                }
 
326
            }
 
327
 
 
328
            if (current_engine != null) {
 
329
                xkb_engines.append(current_engine);
 
330
            } else if (xkb_engines.find(us_engine) == null) {
 
331
                warning("Fallback %s(%s) to us layout.", layout, variant);
 
332
                xkb_engines.append(us_engine);
 
333
            }
 
334
        }
 
335
 
 
336
        if (xkb_engines.length() == 0)
 
337
            warning("Not found IBus XKB engines from the session.");
 
338
 
 
339
        return xkb_engines;
 
340
    }
 
341
 
 
342
    /**
 
343
     * panel_get_engines_from_locale:
 
344
     * @self: #Panel class
 
345
     * @engines: all engines from ibus_bus_list_engines()
 
346
     * @returns: ibus im engines
 
347
     *
 
348
     * Made ibus engines from the current locale and IBus.EngineDesc.lang .
 
349
     * This returns non-XKB engines whose name does not start "xkb:".
 
350
     */
 
351
    private GLib.List<IBus.EngineDesc>
 
352
            get_engines_from_locale(GLib.List<IBus.EngineDesc> engines) {
 
353
        string locale = Intl.setlocale(LocaleCategory.CTYPE, null);
 
354
 
 
355
        if (locale == null)
 
356
            locale = "C";
 
357
 
 
358
        string lang = locale.split(".")[0];
 
359
        GLib.List<IBus.EngineDesc> im_engines =
 
360
                new GLib.List<IBus.EngineDesc>();
 
361
 
 
362
        foreach (unowned IBus.EngineDesc engine in engines) {
 
363
            string name = engine.get_name();
 
364
 
 
365
            if (name.has_prefix("xkb:"))
 
366
                continue;
 
367
 
 
368
            if (engine.get_language() == lang &&
 
369
                engine.get_rank() > 0)
 
370
                im_engines.append(engine);
 
371
        }
 
372
 
 
373
        if (im_engines.length() == 0) {
 
374
            lang = lang.split("_")[0];
 
375
 
 
376
            foreach (unowned IBus.EngineDesc engine in engines) {
 
377
                string name = engine.get_name();
 
378
 
 
379
                if (name.has_prefix("xkb:"))
 
380
                    continue;
 
381
 
 
382
                if (engine.get_language() == lang &&
 
383
                    engine.get_rank() > 0)
 
384
                    im_engines.append(engine);
 
385
            }
 
386
        }
 
387
 
 
388
        if (im_engines.length() == 0)
 
389
            return im_engines;
 
390
 
 
391
        im_engines.sort((a, b) => {
 
392
            return (int) b.get_rank() - (int) a.get_rank();
 
393
        });
 
394
 
 
395
        return im_engines;
 
396
    }
 
397
 
 
398
    private void init_engines_order() {
 
399
        m_xkblayout.set_latin_layouts(
 
400
                m_settings_general.get_strv("xkb-latin-layouts"));
 
401
 
 
402
        if (inited_engines_order)
 
403
            return;
 
404
 
 
405
        if (m_settings_general.get_strv("preload-engines").length > 0)
 
406
            return;
 
407
 
 
408
        GLib.List<IBus.EngineDesc> engines = m_bus.list_engines();
 
409
        GLib.List<IBus.EngineDesc> xkb_engines = get_engines_from_xkb(engines);
 
410
        GLib.List<IBus.EngineDesc> im_engines =
 
411
                get_engines_from_locale(engines);
 
412
 
 
413
        string[] names = {};
 
414
        foreach (unowned IBus.EngineDesc engine in xkb_engines)
 
415
            names += engine.get_name();
 
416
        foreach (unowned IBus.EngineDesc engine in im_engines)
 
417
            names += engine.get_name();
 
418
 
 
419
        m_settings_general.set_strv("preload-engines", names);
 
420
    }
 
421
 
289
422
    private void set_custom_font() {
290
423
        Gdk.Display display = Gdk.Display.get_default();
291
424
        Gdk.Screen screen = (display != null) ?
362
495
                m_settings_general.get_boolean("use-global-engine");
363
496
    }
364
497
 
 
498
    private void set_use_xmodmap() {
 
499
        m_xkblayout.set_use_xmodmap(
 
500
                m_settings_general.get_boolean("use-xmodmap"));
 
501
    }
 
502
 
365
503
    private void set_show_icon_on_systray() {
366
504
        if (m_status_icon == null)
367
505
            return;
486
624
#endif
487
625
    }
488
626
 
 
627
    private void update_version_1_5_8() {
 
628
        inited_engines_order = false;
 
629
    }
 
630
 
489
631
    private void set_version() {
490
632
        string prev_version = m_settings_general.get_string("version");
491
633
        string current_version = null;
492
634
 
493
 
        if (compare_versions(prev_version, "1.5.3") < 0) {
 
635
        if (compare_versions(prev_version, "1.5.3") < 0)
494
636
            update_version_1_5_3();
495
 
        }
 
637
 
 
638
        if (compare_versions(prev_version, "1.5.8") < 0)
 
639
            update_version_1_5_8();
496
640
 
497
641
        current_version = "%d.%d.%d".printf(IBus.MAJOR_VERSION,
498
642
                                            IBus.MINOR_VERSION,
506
650
    }
507
651
 
508
652
    public void load_settings() {
 
653
        set_version();
 
654
 
509
655
        init_engines_order();
 
656
 
510
657
        // Update m_use_system_keyboard_layout before update_engines()
511
658
        // is called.
512
659
        set_use_system_keyboard_layout();
513
660
        set_use_global_engine();
 
661
        set_use_xmodmap();
514
662
        update_engines(m_settings_general.get_strv("preload-engines"),
515
663
                       m_settings_general.get_strv("engines-order"));
516
664
        unbind_switch_shortcut();
524
672
        set_timeout_property_panel();
525
673
        set_follow_input_cursor_when_always_shown_property_panel();
526
674
        set_xkb_icon_rgba();
527
 
 
528
 
        set_version();
529
 
    }
530
 
 
531
 
    private void gkbdlayout_changed_cb() {
532
 
        /* The callback is called four times after set_layout is called
533
 
         * so check the elapsed and take the first signal only. */
534
 
        double elapsed = m_changed_layout_timer.elapsed();
535
 
        if (elapsed < 1.0 && elapsed > 0.0) {
536
 
            return;
537
 
        }
538
 
 
539
 
        if (m_fallback_lock_id != -1) {
540
 
            /* Call lock_group only when set_layout is called. */
541
 
            m_gkbdlayout.lock_group(m_fallback_lock_id);
542
 
            m_fallback_lock_id = -1;
543
 
        } else {
544
 
            /* Reset default layout when gnome-control-center is called. */
545
 
            m_xkblayout.reset_layout();
546
 
        }
547
 
 
548
 
        update_xkb_engines();
549
 
        m_changed_layout_timer.reset();
550
 
    }
551
 
 
552
 
    private void init_gkbd() {
553
 
        m_gkbdlayout = new GkbdLayout();
554
 
        m_gkbdlayout.changed.connect(gkbdlayout_changed_cb);
555
 
 
556
 
        /* Probably we cannot support both keyboard and ibus indicators
557
 
         * How can I get the engine from keymap of group_id?
558
 
         * e.g. 'en' could be owned by xkb:en and pinyin engines. */
559
 
        //m_gkbdlayout.group_changed.connect((object) => {});
560
 
 
561
 
        m_changed_layout_timer = new GLib.Timer();
562
 
        m_changed_layout_timer.start();
563
 
        m_gkbdlayout.start_listen();
564
 
    }
565
 
 
566
 
    private void init_engines_order() {
567
 
        m_xkblayout = new XKBLayout();
568
 
        string session = Environment.get_variable("DESKTOP_SESSION");
569
 
 
570
 
        if (HAVE_IBUS_GKBD &&
571
 
            session != null && session.length >= 5 &&
572
 
            session[0:5] == "gnome") {
573
 
            init_gkbd();
574
 
        }
575
 
 
576
 
        string[] preload_engines =
577
 
                m_settings_general.get_strv("preload-engines");
578
 
 
579
 
        bool preload_engines_inited =
580
 
                m_settings_general.get_boolean("preload-engines-inited");
581
 
 
582
 
        // Set preload_engines_inited = true for back compatibility
583
 
        if (preload_engines.length != 0 && !preload_engines_inited) {
584
 
                preload_engines_inited = true;
585
 
                m_settings_general.set_boolean("preload-engines-inited", true);
586
 
        }
587
 
 
588
 
        update_xkb_engines();
589
 
 
590
 
        // Before update preload_engine_mode, update_xkb_engines() is called
591
 
        // because "preload-engine-mode" signal calls update_im_engines().
592
 
        if (!preload_engines_inited)
593
 
            m_settings_general.set_int("preload-engine-mode",
594
 
                                       IBus.PreloadEngineMode.LANG_RELATIVE);
595
 
 
596
 
        update_im_engines();
597
 
 
598
 
        if (!preload_engines_inited)
599
 
            m_settings_general.set_boolean("preload-engines-inited", true);
600
 
    }
601
 
 
602
 
    private bool set_lang_relative_preload_engines() {
603
 
        string locale = Intl.setlocale(LocaleCategory.CTYPE, null);
604
 
 
605
 
        if (locale == null)
606
 
            locale = "C";
607
 
 
608
 
        string lang = locale.split(".")[0];
609
 
        GLib.List<IBus.EngineDesc> engines = m_bus.list_engines();
610
 
        string[] im_engines = {};
611
 
 
612
 
        for (unowned GLib.List<IBus.EngineDesc> p = engines;
613
 
             p != null;
614
 
             p = p.next) {
615
 
            unowned IBus.EngineDesc engine = p.data;
616
 
            if (engine.get_language() == lang && engine.get_rank() > 0)
617
 
                im_engines += engine.get_name();
618
 
        }
619
 
 
620
 
        lang = lang.split("_")[0];
621
 
        if (im_engines.length == 0) {
622
 
            for (unowned GLib.List<IBus.EngineDesc> p = engines;
623
 
                 p != null;
624
 
                 p = p.next) {
625
 
                unowned IBus.EngineDesc engine = p.data;
626
 
                if (engine.get_language() == lang && engine.get_rank() > 0)
627
 
                    im_engines += engine.get_name();
628
 
            }
629
 
        }
630
 
 
631
 
        if (im_engines.length == 0)
632
 
            return false;
633
 
 
634
 
        string[] orig_preload_engines =
635
 
                m_settings_general.get_strv("preload-engines");
636
 
        string[] preload_engines = {};
637
 
 
638
 
        // clear input method engines
639
 
        foreach (string name in orig_preload_engines) {
640
 
            if (name.ascii_ncasecmp("xkb:", 4) != 0)
641
 
                continue;
642
 
 
643
 
            preload_engines += name;
644
 
        }
645
 
 
646
 
        foreach (string name in im_engines) {
647
 
            if (!(name in preload_engines))
648
 
                preload_engines += name;
649
 
        }
650
 
 
651
 
        if (string.joinv(",", orig_preload_engines) !=
652
 
            string.joinv(",", preload_engines))
653
 
            m_settings_general.set_strv("preload-engines", preload_engines);
654
 
 
655
 
        return true;
656
 
    }
657
 
 
658
 
    private void update_im_engines() {
659
 
        int preload_engine_mode =
660
 
                m_settings_general.get_int("preload-engine-mode");
661
 
 
662
 
        if (preload_engine_mode == IBus.PreloadEngineMode.USER)
663
 
            return;
664
 
 
665
 
        set_lang_relative_preload_engines();
666
 
    }
667
 
 
668
 
    private void update_xkb_engines() {
669
 
        string var_layout = m_xkblayout.get_layout();
670
 
        string var_variant = m_xkblayout.get_variant();
671
 
        if (var_layout == "") {
672
 
            return;
673
 
        }
674
 
 
675
 
        m_layouts = var_layout.split(",");
676
 
        m_variants = var_variant.split(",");
677
 
 
678
 
        IBus.XKBConfigRegistry registry = new IBus.XKBConfigRegistry();
679
 
        string[] var_xkb_engine_names = {};
680
 
        for (int i = 0; i < m_layouts.length; i++) {
681
 
            string name = m_layouts[i];
682
 
            string lang = null;
683
 
 
684
 
            if (i < m_variants.length && m_variants[i] != "") {
685
 
                name = "%s:%s".printf(name, m_variants[i]);
686
 
                string layout = "%s(%s)".printf(name, m_variants[i]);
687
 
                GLib.List<string> langs =
688
 
                        registry.layout_lang_get_langs(layout);
689
 
                if (langs.length() != 0) {
690
 
                    lang = langs.data;
691
 
                }
692
 
            } else {
693
 
                name = "%s:".printf(name);
694
 
            }
695
 
 
696
 
            if (lang == null) {
697
 
                GLib.List<string> langs =
698
 
                        registry.layout_lang_get_langs(m_layouts[i]);
699
 
                if (langs.length() != 0) {
700
 
                    lang = langs.data;
701
 
                }
702
 
            }
703
 
 
704
 
            var_xkb_engine_names += "%s:%s:%s".printf("xkb", name, lang);
705
 
        }
706
 
 
707
 
        string[] engine_names =
708
 
                m_settings_general.get_strv("preload-engines");
709
 
        bool updated_engine_names = false;
710
 
 
711
 
        foreach (string name in var_xkb_engine_names) {
712
 
            if (name in engine_names)
713
 
                continue;
714
 
            updated_engine_names = true;
715
 
            engine_names += name;
716
 
        }
717
 
 
718
 
        if (updated_engine_names)
719
 
            m_settings_general.set_strv("preload-engines", engine_names);
720
 
 
721
 
        string[] order_names =
722
 
                m_settings_general.get_strv("engines-order");
723
 
        bool updated_order_names = false;
724
 
 
725
 
        foreach (var name in var_xkb_engine_names) {
726
 
            if (name in order_names)
727
 
                continue;
728
 
            order_names += name;
729
 
            updated_order_names = true;
730
 
        }
731
 
 
732
 
        if (updated_order_names)
733
 
            m_settings_general.set_strv("engines-order", order_names);
734
 
    }
735
 
 
736
 
    private void set_xkb_group_layout(IBus.EngineDesc engine) {
737
 
        int[] retval = m_xkblayout.set_layout(engine, true);
738
 
        if (retval[0] >= 0) {
739
 
            /* If an XKB keymap is added into the XKB group,
740
 
             * this._gkbdlayout.lock_group will be called after
741
 
             * 'group-changed' signal is received. */
742
 
            m_fallback_lock_id = retval[0];
743
 
            m_changed_xkb_option = (retval[1] != 0) ? true : false;
744
 
        }
745
 
    }
746
 
 
747
 
    private bool set_gkbd_layout(IBus.EngineDesc engine) {
748
 
        string layout = engine.get_layout();
749
 
        string variant = engine.get_layout_variant();
750
 
 
751
 
        /* If a previous ibus engine changed XKB options, need to set the
752
 
         * default XKB option. */
753
 
        if (m_changed_xkb_option == true) {
754
 
            m_changed_xkb_option = false;
755
 
            return false;
756
 
        }
757
 
 
758
 
        if (variant != "" && variant != "default") {
759
 
            layout = "%s(%s)".printf(layout, variant);
760
 
        }
761
 
 
762
 
        int gkbd_len = m_gkbdlayout.get_group_names().length;
763
 
        for (int i = 0; i < m_layouts.length && i < gkbd_len; i++) {
764
 
            string sys_layout = m_layouts[i];
765
 
            if (i < m_variants.length && m_variants[i] != "") {
766
 
                sys_layout = "%s(%s)".printf(sys_layout, m_variants[i]);
767
 
            }
768
 
            if (sys_layout == layout) {
769
 
                m_gkbdlayout.lock_group(i);
770
 
                return true;
771
 
            }
772
 
        }
773
 
        return false;
774
 
    }
775
 
 
776
 
    private void set_layout(IBus.EngineDesc engine) {
777
 
        string layout = engine.get_layout();
778
 
 
779
 
        if (layout == "" || layout == null) {
780
 
            return;
781
 
        }
782
 
 
783
 
        if (m_xkblayout == null) {
784
 
            init_engines_order();
785
 
        }
786
 
 
787
 
        if (HAVE_IBUS_GKBD && m_gkbdlayout != null) {
788
 
            if (set_gkbd_layout(engine)) {
789
 
                return;
790
 
            }
791
 
            set_xkb_group_layout(engine);
792
 
            return;
793
 
        }
794
 
 
795
 
        m_xkblayout.set_layout(engine);
796
 
    }
797
 
 
798
 
    private void exec_setxkbmap(IBus.EngineDesc engine) {
799
 
        string layout = engine.get_layout();
800
 
        string variant = engine.get_layout_variant();
801
 
        string option = engine.get_layout_option();
802
 
        string standard_error = null;
803
 
        int exit_status = 0;
804
 
        string[] args = { "setxkbmap" };
805
 
 
806
 
        if (layout != null && layout != "" && layout != "default") {
807
 
            args += "-layout";
808
 
            args += layout;
809
 
        }
810
 
        if (variant != null && variant != "" && variant != "default") {
811
 
            args += "-variant";
812
 
            args += variant;
813
 
        }
814
 
        if (option != null && option != "" && option != "default") {
815
 
            /*TODO: Need to get the session XKB options */
816
 
            args += "-option";
817
 
            args += "-option";
818
 
            args += option;
819
 
        }
820
 
 
821
 
        if (args.length == 1) {
822
 
            return;
823
 
        }
824
 
 
825
 
        try {
826
 
            if (!GLib.Process.spawn_sync(null, args, null,
827
 
                                         GLib.SpawnFlags.SEARCH_PATH,
828
 
                                         null, null,
829
 
                                         out standard_error,
830
 
                                         out exit_status)) {
831
 
                warning("Switch xkb layout to %s failed.",
832
 
                        engine.get_layout());
833
 
            }
834
 
        } catch (GLib.SpawnError e) {
835
 
            warning("Execute setxkbmap failed: %s", e.message);
836
 
        }
837
 
 
838
 
        if (exit_status != 0) {
839
 
            warning("Execute setxkbmap failed: %s", standard_error ?? "(null)");
840
 
        }
841
675
    }
842
676
 
843
677
    private void engine_contexts_insert(IBus.EngineDesc engine) {
860
694
 
861
695
        // set xkb layout
862
696
        if (!m_use_system_keyboard_layout)
863
 
            set_layout(engine);
 
697
            m_xkblayout.set_layout(engine);
864
698
 
865
699
        engine_contexts_insert(engine);
866
700
    }
923
757
        }
924
758
    }
925
759
 
926
 
    /* IBus.Bus.get_engines_by_names() returns 'us' engine if the name 
927
 
     * does not exist in simple.xml and 'us' engine could be duplicated.
928
 
     */
929
 
    private IBus.EngineDesc[] uniq_engines(IBus.EngineDesc[] engines) {
930
 
        if (engines.length == 0)
931
 
            return engines;
932
 
 
933
 
        int i = 0;
934
 
        IBus.EngineDesc[] retval = {};
935
 
 
936
 
        for (; i < engines.length; i++) {
937
 
            if (engines[i].get_name() == "xkb:us::eng")
938
 
                break;
939
 
        }
940
 
 
941
 
        if (i == engines.length)
942
 
            return engines;
943
 
 
944
 
        for (int j = 0; j < engines.length; j++) {
945
 
            if (j <= i) {
946
 
                retval += engines[j];
947
 
                continue;
948
 
            }
949
 
 
950
 
            if (engines[i].get_name() == engines[j].get_name())
951
 
                continue;
952
 
 
953
 
            retval += engines[j];
954
 
        }
955
 
 
956
 
        return retval;
957
 
    }
958
 
 
959
760
    private void run_preload_engines(IBus.EngineDesc[] engines, int index) {
960
761
        string[] names = {};
961
762
 
988
789
        }
989
790
 
990
791
        var engines = m_bus.get_engines_by_names(names);
991
 
        engines = uniq_engines(engines);
992
792
 
993
793
        if (m_engines.length == 0) {
994
794
            m_engines = engines;