//throws IOException public static Data build(Display display) { // display.connection.socket.setSoTimeout (0); // FIXME use Socket.Select instead. int code = display.connection.din.Read (); /* Set the timeout to 10 seconds, a very safe bet to avoid premature * timeout in slow networks. Setting a timeout avoid being locked * when reading a reply or an event of a shorter length than * expected, due to bugs in X server. For instance, the reply of * {@link DBE#visual_info(Drawable[])} has a wrong reply length field * in XFree86 4.0.1 or eariler servers. * * Note that timeout is reset to 0 (no timeout) before reading the * first byte of the message because a blocking read of the next event * or a blocking read of the expected reply from a slow X server should * not be timed out. */ // display.connection.socket.setSoTimeout (10000); // FIXME use Socket.Select instead. if (code == 0) // X Error throw build_error (display); else if (code == 1) // X Reply return build_reply (display); else // X Event return build_event (display, code); }
//throws NotFoundException protected Extension(Display display, String name, String [] minor_opcode_strings, int error_count, int event_count) { this.display = display; this.name = name; Display.ExtensionReply er = display.extension (name); if (!er.present ()) throw new NotFoundException (name); first_event = er.first_event (); first_error = er.first_error (); major_opcode = er.major_opcode (); // register opcode strings display.extension_opcode_strings [major_opcode - 128] = name; display.extension_minor_opcode_strings [major_opcode - 128] = minor_opcode_strings; // register error factory for (int i=0; i<error_count; i++) display.extension_error_factories [first_error - 128 + i] = (ErrorFactory) this; // register event factory for (int i=0; i<event_count; i++) display.extension_event_factories [first_event - 64 + i] = (EventFactory) this; }
public XBM(Display display, int width, int height, int [] xbm) : base(display, width, height) { // take <code>int</code> as parameter to avoid casting in java for (int i=0; i<data.Length; i++) data [i] = (byte) xbm [i]; }
public Error build(Display display, Data data, int code, int seq_no, int bad, int minor_opcode, int major_opcode) { String error_string = ERROR_STRINGS [code - first_error]; return new Error (display, error_string, code, seq_no, bad, minor_opcode, major_opcode); }
/** Writing. */ public Event(Display display, int code, int window_offset) { this.display = display; this.window_offset = window_offset; data = new byte [32]; data [0] = (byte) code; }
//throws NotFoundException { // shape opcode 0 - query version /** * @see <a href="XShapeQueryExtension.html">XShapeQueryExtension</a> */ public Shape(Display display) : base(display, "SHAPE", MINOR_OPCODE_STRINGS, 0, 1) { // check version before any other operations Request request = new Request (display, major_opcode, 0, 1); Data reply = display.read_reply (request); server_major_version = reply.read2 (8); server_minor_version = reply.read2 (10); }
/** Reading. */ public Event(Display display, byte [] data, int window_offset) : base(data) { this.display = display; this.window_offset = window_offset; synthetic = (this.data [0] & 0x80) != 0; this.data [0] &= 0x7f; }
//throws gnu.x11.extension.NotFoundException { // print opcode 0 - query version /** * @see <a href="XpQueryVersion.html">XpQueryVersion</a> */ public Print(Display display) : base(display, "XpExtension", MINOR_OPCODE_STRINGS, 2, 2) { // check version before any other operations Request request = new Request (display, major_opcode, 0, 1); Data reply = display.read_reply (request); server_major_version = reply.read2 (4); server_minor_version = reply.read2 (4); }
public ZPixmap(Display display, int width, int height, Pixmap.Format format) : base(width, height, FORMAT, format) { image_byte_order = display.image_byte_order; pixel_byte_count = pixmap_format.bits_per_pixel () / 8; if (display.default_depth < 24) throw new Error ("Unsupported root depth < 24: " + display.default_depth); }
public Bitmap(Display display, int width, int height) : base(width, height, FORMAT, display.pixmap_formats [0]) { if (display.image_byte_order != LSB_FIRST || display.bitmap_format_bit_order != LEAST_SIGNIFICANT) throw new Error ("Unsupported image format"); scanline_unit = display.bitmap_format_scanline_unit; unit_byte_count = scanline_unit / 8; }
public ZPixmap(Display display) { // for subclass loading format = FORMAT; pixmap_format = display.default_pixmap_format; image_byte_order = display.image_byte_order; pixel_byte_count = pixmap_format.bits_per_pixel () / 8; if (display.default_depth < 24) throw new Error ("Unsupported root depth < 24: " + display.default_depth); }
// opcode 45 - open font /** * @see <a href="XLoadFont.html">XLoadFont</a> */ public Font(Display display, String name) : base(display) { this.name = name; Request request = new Request (display, 45, 3+Data.unit (name)); request.write4 (id); request.write2 (name.Length); request.write2_unused (); request.write1 (name); display.send_request (request); }
//throws NotFoundException { // evi opcode 0 - get version /** * @see <a href="XeviQueryVersion.html">XeviQueryVersion</a> */ public EVI(Display display) : base(display, "Extended-Visual-Information", MINOR_OPCODE_STRINGS) { // check version before any other operations /* Note that the specification says the request includes a major and a * minor version, but most implementation (xfree86 3.3/4.0) does not. * Which one is bugged? */ Request request = new Request (display, major_opcode, 0, 1); Data reply = display.read_reply (request); server_major_version = reply.read2 (8); server_minor_version = reply.read2 (10); }
// TODO public XPM(Display display, String [] xpm) : base(display) { String [] values = xpm [0].Split(new char[] { ' ' }); width = Int32.Parse (values[0]); height = Int32.Parse (values[1]); int num_colors = Int32.Parse (values[2]); int chars_per_pixel = Int32.Parse (values[3]); // TODO how to select best SUITABLE format? format = FORMAT; pixmap_format = display.default_pixmap_format; image_byte_order = display.image_byte_order; pixel_byte_count = pixmap_format.bits_per_pixel () / 8; init (); Hashtable mapping = new Hashtable (2*num_colors); Colormap cmap = display.default_colormap; for (int i=0; i<num_colors; i++) { String [] color = xpm [i+1].Split(new char[] {' '}); String symbol = color[0]; while (color.Length>1 && color[1].Equals ("c")) { // can only parse c for now String color_value = color[2]; if (color_value[0] == '#') { int pixel = Int32.Parse ( color_value.Substring (1, color_value.Length), System.Globalization.NumberStyles.HexNumber); mapping.Add (symbol, new Color (pixel)); } else // not starting with # mapping.Add (symbol, cmap.alloc_named_color (color_value)); } } // TODO more efficient linear for-loop for (int y=0; y<height; y++) { String pixels = xpm [1+num_colors+y]; for (int x=0; x<width; x++) { String symbol = pixels.Substring (x*chars_per_pixel, (x+1)*chars_per_pixel); Color color = (Color) mapping[symbol]; set (x, y, color.pixel); } } }
// xc-misc opcode 0 - get version public XCMisc(gnu.x11.Display display) //throws NotFoundException { : base(display, "XC-MISC", MINOR_OPCODE_STRINGS) { // check version before any other operations Request request = new Request(display, major_opcode, 0, 2); request.write2(CLIENT_MAJOR_VERSION); request.write2(CLIENT_MINOR_VERSION); Data reply = display.read_reply(request); server_major_version = reply.read2(8); server_minor_version = reply.read2(10); }
// dbe opcode 0 - get version public DBE(gnu.x11.Display display) //throws NotFoundException { : base(display, "DOUBLE-BUFFER", MINOR_OPCODE_STRINGS, 1, 0) { // check version before any other operations Request request = new Request(display, major_opcode, 0, 2); request.write1(CLIENT_MAJOR_VERSION); request.write1(CLIENT_MINOR_VERSION); Data reply = display.read_reply(request); server_major_version = reply.read1(8); server_minor_version = reply.read1(9); }
protected Application(String [] args) : base(args, new Option (args)) { // cast `gnu.util.Option option' to `gnu.x11.Option' option = (Option) base.option; String env = Environment.GetEnvironmentVariable ("DISPLAY"); if(env==null || env.Length==0) env="localhost:1"; Display.Name display_name = option.display_name ("display", "X server to connect to", new Display.Name (env)); int send_mode = option.Enum ("send-mode", "request sending mode", Connection.SEND_MODE_STRINGS, Connection.ASYNCHRONOUS); if (help_option) return; display = new Display (display_name); display.connection.send_mode = send_mode; }
public Display.Name display_name(String name, String description, Display.Name default_value) { Display.Name retval = default_value; try { String opt = option (name); if (opt != null) retval = new Display.Name (opt); } catch (Exception e) { invalid_names.Append (name + ", "); // fall through } add_spec (name, "display name", description, default_value.ToString (), retval.ToString ()); return retval; }
//throws IOException public static Error build_connection_error(Display display) { BinaryReader din = display.connection.din; int msg_len = (Int32)din.ReadUInt32 (); int major_version = din.ReadUInt16 (); int minor_version = din.ReadUInt16 (); int total_len = 4 * din.ReadUInt16 (); byte [] buffer = new byte [total_len]; din.Read (buffer,0,total_len); Decoder dec = Encoding.ASCII.GetDecoder(); char [] d = new char[msg_len]; msg_len = dec.GetChars(buffer,0,msg_len,d,0); String reason = new String (d, 0, msg_len); return new Error ("X server connection error" + "\n protocol-major-version: " + major_version + "\n protocol-minor-version " + minor_version + "\n reason: " + reason); }
//throws IOException // WARNING: very naive parsing // TODO public PPM(Display display, StreamReader bin) : base(display) { // format String format = bin.ReadLine (); if (!(format.Equals ("P6"))) throw new Error ("Unsupported format: " + format); // dimension String dimension = bin.ReadLine (); int index = dimension.IndexOf (' '); try { width = Int32.Parse (dimension.Substring (0, index)); height = Int32.Parse (dimension.Substring ( index+1, dimension.Length)); } catch (Exception e) { throw new Error ("Invalid dimension: " + dimension); } String color_count = bin.ReadLine (); // fill up data init (); Colormap cmap = display.default_colormap; for (int y=0; y<height; y++) for (int x=0; x<width; x++) { int r = bin.Read (); int g = bin.Read (); int b = bin.Read (); // FIXME cache and index color set (x, y, cmap.alloc_color8 (r, g, b)); } }
public Request (Display display, int opcode, int unit) { init (display, opcode, 0, unit); }
public Request (Display display, int opcode, bool b, int unit) { init (display, opcode, b ? 1 : 0, unit); }
/** * @see #Atom(Display, String, bool) */ public static Object intern(Display display, String name, bool only_if_exists) { Object value = display.atom_names[name]; if (value != null && value is Atom) return value; return new Atom (display, name, only_if_exists); }
/** * @see #Atom(Display, int, bool) */ public static Object intern(Display display, int id, bool only_if_exists) { Object value = display.atom_ids[id]; if (value != null && value is Atom) return value; return new Atom (display, id, only_if_exists); }
/** * @see #Atom(Display, String, bool) */ public static Object intern(Display display, String name) { return intern (display, name, false); }
/** * @see #Atom(Display, int, bool) */ public static Object intern(Display display, int id) { return intern (display, id, false); }
public gnu.x11.Error build(gnu.x11.Display display, Data data, int code, int seq_no, int bad, int minor_opcode, int major_opcode) { return(new gnu.x11.Error(display, ERROR_STRING, code, seq_no, bad, minor_opcode, major_opcode)); }
// opcode 16 - intern atom /** * @see <a href="XInternAtom.html">XInternAtom</a> */ public Atom(Display display, String name, bool only_if_exists) { this.display = display; this.name = name; Request request = new Request (display, 16, only_if_exists, 2+Data.unit (name)); request.write2 (name.Length); request.write2_unused (); request.write1 (name); Data reply = display.read_reply (request); id = reply.read4 (8); display.atom_ids.Add (id, this); display.atom_names.Add (name, this); }
public FocusOut(Display display, byte [] data) : base(display, data, 8) { }
public Input(Display display, int min_keycode, int max_keycode) { this.display = display; this.min_keycode = min_keycode; this.max_keycode = max_keycode; }
public ValueList (Display display, int opcode, int unit, int id, gnu.x11.ValueList vl) { this.display = display; this.opcode = opcode; this.unit = unit; this.id = id; this.vl = vl; }
// opcode 17 - get atom name /** * @see <a href="XGetAtomName.html">XGetAtomName</a> */ public Atom(Display display, int id, bool only_if_exists) { this.display = display; this.id = id; Request request = new Request (display, 17, 2); request.write4 (id); Data reply = display.read_reply (request); int len = reply.read2 (8); Decoder dec = Encoding.ASCII.GetDecoder(); char [] d = new char[len]; len = dec.GetChars(reply.data,32,len,d,0); name = new String (d, 0, len); display.atom_ids.Add (id, this); display.atom_names.Add (name, this); }
public void init (Display display, int opcode, int second_field, int unit) { // x extensions use extended_maximum_request_length? (glx does not). if // not, we should check opcode here if (display.connected && unit > display.extended_maximum_request_length) throw new Exception ("Request too long (in byte): " + (unit*4) + " > " + (display.extended_maximum_request_length*4)); // big requests in use bool big = display.big_requests_present && unit > display.maximum_request_length; if (big) unit++; // extra storage length = unit * 4; data = new byte [length]; write1 (opcode); write1 (second_field); if (!big) write2 (unit); else { write2 (0); // extended length flag write4 (unit); } }
public BigRequests(gnu.x11.Display display) : base(display, "BIG-REQUESTS", null) { }