← Back to branch summary

~ubuntu-branches/ubuntu/natty/fcitx/natty

« back to all changes in this revision

Viewing changes to src/tray.c

  • Committer: Bazaar Package Importer
  • Author(s): Aron Xu
  • Date: 2010-11-25 21:33:23 UTC
  • mfrom: (10.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20101125213323-qlk26krfjil7k2am
Tags: 1:4.0.0-1
http://bugs.debian.org/430420
http://bugs.debian.org/571588
https://launchpad.net/bugs/261382
https://launchpad.net/bugs/238309
http://bugs.debian.org/584307
https://launchpad.net/bugs/482564
* New upstream major release:
  - Get rid of unsafe environment variable usage. (Closes: #430420)
  - Create config file if not exist; Tray icon refresh background. 
    (Closes: #571588)
  - Use utf-8 config file with English options.
  - Fixe input problem in OpenOffice.org. (LP: #261382, LP: #238309)
* debian/control:
  - Update to a new set of Build-Dep packages.
  - Improve descriptions.
  - Remove fonts from Recommends since fcitx can detect system font now.
    (Closes: #584307, LP: #482564)
  - Split package into 12. 
  - Use binutils-gold.
* debian/rules: 
  - Set LDFLAGS="-Wl,--as-needed".
* debian/Makefile, debian/Makefile.am, debian/Makefile.in,
  source.lintian-overrides, README, README.Debian: Remove.
* debian/copyright: Rewrite.
* debian/patches/binutils-gold.patch: 
  - Remove, for upstream has accepted it.
* debian/patches/1ca5ac8c5b.patch:
  - Fix desc.po problem and do not distclean tarball files.
    (Backport from upstream 1ca5ac8c5b commit.)
* debian/docs: Install upstream textual files.
* debian/clean: Clean autoreconf generated files.
* debian/fcitx.doc-base, debian/fcitx-table-wubi.doc-base: 
  - Add doc-base entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tray.c
1
 
#ifdef _ENABLE_TRAY
2
 
 
3
 
#include <string.h>
4
 
#include <stdio.h>
5
 
#include <stdlib.h>
6
 
#include <X11/Xlib.h>
7
 
#include <X11/Xutil.h>
8
 
#include <X11/Xatom.h>
9
 
#include <X11/Xmd.h>
10
 
 
11
 
#include "tray.h"
12
 
 
13
 
#define MAX_SUPPORTED_XEMBED_VERSION 1
14
 
 
15
 
#define XEMBED_MAPPED          (1 << 0)
16
 
 
17
 
/* XEMBED messages */
18
 
#define XEMBED_EMBEDDED_NOTIFY  0
19
 
#define XEMBED_WINDOW_ACTIVATE  1
20
 
#define XEMBED_WINDOW_DEACTIVATE  2
21
 
#define XEMBED_REQUEST_FOCUS 3
22
 
#define XEMBED_FOCUS_IN  4
23
 
#define XEMBED_FOCUS_OUT  5
24
 
#define XEMBED_FOCUS_NEXT 6
25
 
#define XEMBED_FOCUS_PREV 7
26
 
/* 8-9 were used for XEMBED_GRAB_KEY/XEMBED_UNGRAB_KEY */
27
 
#define XEMBED_MODALITY_ON 10
28
 
#define XEMBED_MODALITY_OFF 11
29
 
#define XEMBED_REGISTER_ACCELERATOR     12
30
 
#define XEMBED_UNREGISTER_ACCELERATOR   13
31
 
#define XEMBED_ACTIVATE_ACCELERATOR     14
32
 
 
33
 
Atom Atoms[6];
34
 
static int trapped_error_code = 0;
35
 
static int (*old_error_handler) (Display *d, XErrorEvent *e);
36
 
 
37
 
extern int iScreen;
38
 
 
39
 
/* static void tray_map_window (Display* dpy, Window win); */
40
 
 
41
 
static int
42
 
error_handler(Display     *display,
43
 
        XErrorEvent *error)
44
 
{
45
 
    trapped_error_code = error->error_code;
46
 
    return 0;
47
 
}
48
 
 
49
 
    static void
50
 
trap_errors(void)
51
 
{
52
 
    trapped_error_code = 0;
53
 
    old_error_handler = XSetErrorHandler(error_handler);
54
 
}
55
 
 
56
 
    static int
57
 
untrap_errors(void)
58
 
{
59
 
    XSetErrorHandler(old_error_handler);
60
 
    return trapped_error_code;
61
 
}
62
 
 
63
 
int
64
 
tray_init(Display* dpy, tray_win_t* tray)
65
 
{
66
 
    static char *atom_names[] = {
67
 
        NULL,
68
 
                "MANAGER", 
69
 
                "_NET_SYSTEM_TRAY_OPCODE",
70
 
                "_NET_SYSTEM_TRAY_ORIENTATION",
71
 
                "_NET_SYSTEM_TRAY_VISUAL"
72
 
    };
73
 
 
74
 
        atom_names[0] = strdup("_NET_SYSTEM_TRAY_S0");
75
 
        atom_names[0][17] += iScreen;
76
 
 
77
 
    XInternAtoms (dpy, atom_names, 5, False, Atoms);
78
 
    memset(&tray->visual, 0, sizeof(XVisualInfo));
79
 
 
80
 
    return True;
81
 
}
82
 
 
83
 
int
84
 
tray_find_dock(Display *dpy, Window win)
85
 
{
86
 
    Window Dock;
87
 
    
88
 
    XGrabServer (dpy);
89
 
 
90
 
    Dock = XGetSelectionOwner(dpy, Atoms[ATOM_SELECTION]);
91
 
 
92
 
    if (!Dock)
93
 
        XSelectInput(dpy, RootWindow(dpy, DefaultScreen(dpy)),
94
 
                StructureNotifyMask);
95
 
 
96
 
    XUngrabServer (dpy);
97
 
    XFlush (dpy);
98
 
 
99
 
    if (Dock != None) {
100
 
        tray_send_opcode(dpy, Dock, SYSTEM_TRAY_REQUEST_DOCK, win, 0, 0);
101
 
        return 1;
102
 
    } 
103
 
 
104
 
    return 0;
105
 
}
106
 
 
107
 
XVisualInfo* tray_get_visual(Display* dpy, tray_win_t* tray)
108
 
{
109
 
    Window Dock;
110
 
    Dock = XGetSelectionOwner(dpy, Atoms[ATOM_SELECTION]);
111
 
 
112
 
    if (Dock != None) {
113
 
        Atom actual_type;
114
 
        int actual_format;
115
 
        unsigned long nitems, bytes_remaining;
116
 
        unsigned char *data = 0;
117
 
        int result = XGetWindowProperty(dpy, Dock, Atoms[ATOM_VISUAL], 0, 1,
118
 
                                        False, XA_VISUALID, &actual_type,
119
 
                                        &actual_format, &nitems, &bytes_remaining, &data);
120
 
        VisualID vid = 0;
121
 
        if (result == Success && data && actual_type == XA_VISUALID && actual_format == 32 &&
122
 
                nitems == 1 && bytes_remaining == 0)
123
 
            vid = *(VisualID*)data;
124
 
        if (data)
125
 
            XFree(data);
126
 
        if (vid == 0)
127
 
            return 0;
128
 
        
129
 
        uint mask = VisualIDMask;
130
 
        XVisualInfo *vi, rvi;
131
 
        int count;
132
 
        rvi.visualid = vid;
133
 
        vi = XGetVisualInfo(dpy, mask, &rvi, &count);
134
 
        if (vi) {
135
 
            tray->visual = vi[0];
136
 
            XFree((char*)vi);
137
 
        }
138
 
        if (tray->visual.depth != 32)
139
 
            memset(&tray->visual, 0, sizeof(XVisualInfo));
140
 
    }
141
 
 
142
 
    return tray->visual.visual ? &tray->visual : 0;
143
 
 
144
 
}
145
 
 
146
 
/*    void
147
 
tray_handle_client_message(Display *dpy, Window win, XEvent *an_event)
148
 
{
149
 
    if (an_event->xclient.message_type == Atoms[ATOM_XEMBED]) {
150
 
        switch (an_event->xclient.data.l[1]) {
151
 
            case XEMBED_EMBEDDED_NOTIFY:
152
 
            case XEMBED_WINDOW_ACTIVATE:
153
 
                tray_map_window (dpy, win);
154
 
                break;
155
 
        }
156
 
    }
157
 
 
158
 
    if (an_event->xclient.message_type == Atoms[ATOM_MANAGER] && Dock == None) { 
159
 
        if (an_event->xclient.data.l[1] == Atoms[ATOM_SYSTEM_TRAY])
160
 
            tray_find_dock(dpy, win);
161
 
    }
162
 
}
163
 
*/
164
 
 
165
 
void tray_send_opcode(Display* dpy, Window w,
166
 
        long message, long data1, long data2, long data3)
167
 
{
168
 
    XEvent ev;
169
 
 
170
 
    memset(&ev, 0, sizeof(ev));
171
 
    ev.xclient.type = ClientMessage;
172
 
    ev.xclient.window = w;
173
 
    ev.xclient.message_type = Atoms[ATOM_SYSTEM_TRAY_OPCODE];
174
 
    ev.xclient.format = 32;
175
 
    ev.xclient.data.l[0] = CurrentTime;
176
 
    ev.xclient.data.l[1] = message;
177
 
    ev.xclient.data.l[2] = data1;
178
 
    ev.xclient.data.l[3] = data2;
179
 
    ev.xclient.data.l[4] = data3;
180
 
 
181
 
    trap_errors();
182
 
    XSendEvent(dpy, w, False, NoEventMask, &ev);
183
 
    XSync(dpy, False);
184
 
    if (untrap_errors()) {
185
 
        fprintf(stderr, "Tray.c : X error %i on opcode send\n",
186
 
                trapped_error_code );
187
 
    }
188
 
}
189
 
 
190
 
Window tray_get_dock(Display* dpy)
191
 
{
192
 
    Window dock = XGetSelectionOwner(dpy, Atoms[ATOM_SELECTION]);
193
 
    return dock;
194
 
}
195
 
 
196
 
#endif