wm_state.c

基于linux的DVD播放器程序

/* returns 1 if a window manager compliant to the
 * Extended Window Manager Hints (EWMH) spec is running.
 * (version 1.2)
 * Oterhwise returns 0.
 */

static int check_for_EWMH_wm(Display *dpy, char **wm_name_return)
{
  Atom atom;
  Atom type_return;
  Atom type_utf8;
  int format_return;
  unsigned long nitems_return;
  unsigned long bytes_after_return;
  unsigned char *prop_return = NULL;
  Window win_id;
  int status;

  atom = XInternAtom(dpy, "_NET_SUPPORTING_WM_CHECK", True);
  if(atom == None) {
    return 0;
  }

  
  
  
  
  if(XGetWindowProperty(dpy, DefaultRootWindow(dpy), atom, 0,
			1, False, XA_WINDOW,
			&type_return, &format_return, &nitems_return,
			&bytes_after_return, &prop_return) != Success) {
    WARNING("%s", "XGetWindowProperty failed in check_for_EWMH\n");
    return 0;
  }
  
  if(type_return == None) {
    WARNING("%s", "check_for_EWMH: property does not exist\n");
    return 0;
  }

  if(type_return != XA_WINDOW) {
    
    WARNING("%s", "check_for_EWMH: XA_WINDOW property has wrong type\n");
    if(prop_return != NULL) {
      XFree(prop_return);
    }
    return 0;
  } else {
    
    //DNOTE("check_for_EWMH: format: %d\n", format_return);
    //DNOTE("check_for_EWMH: nitmes: %ld\n", nitems_return);
    //DNOTE("check_for_EWMH: bytes_after: %ld\n", bytes_after_return);
    if(format_return == 32 && nitems_return == 1 && bytes_after_return == 0) {

      win_id = *(long *)prop_return;

      //DNOTE("win_id: %ld\n", win_id);

      XFree(prop_return);
      prop_return = NULL;
      
      /* make sure we don't have any unhandled errors */
      XSync(dpy, False);

      /* set error handler so we can check if XGetWindowProperty failed */
      prev_xerrhandler = XSetErrorHandler(xprop_errorhandler);

      /* get the serial of the XGetWindowProperty request */
      req_serial = NextRequest(dpy);

      /* try to get property
       * this can fail if we have a property with the win_id on the
       * root window, but the win_id is no longer valid.
       * This is to check for a stale window manager
       */
      
      status = XGetWindowProperty(dpy, win_id, atom, 0,
				  1, False, XA_WINDOW,
				  &type_return, &format_return, &nitems_return,
				  &bytes_after_return, &prop_return);
      
      /* make sure XGetWindowProperty has been processed and any errors
	 have been returned to us */
      XSync(dpy, False);
      
      /* revert to the previous xerrorhandler */
      XSetErrorHandler(prev_xerrhandler);
      
      if(status != Success) {
	WARNING("%s", "XGetWindowProperty failed in check_for_EWMH\n");
	return 0;
      }
      
      if(type_return == None) {
	WARNING("%s", "check_for_EWMH: property does not exist\n");
	return 0;
      }
      
      if(type_return != XA_WINDOW) {
	WARNING("check_for_EWMH: property has wrong type (%ld)\n",
		type_return);
	if(prop_return != NULL) {
	  XFree(prop_return);
	}
	return 0;
      }
      
      if(type_return == XA_WINDOW) {
	//DNOTE("check_for_EWMH: format: %d\n", format_return);
	//DNOTE("check_for_EWMH: nitmes: %ld\n", nitems_return);
	//DNOTE("check_for_EWMH: bytes_after: %ld\n", bytes_after_return);

	if(format_return == 32 && nitems_return == 1 &&
	   bytes_after_return == 0) {

	  //DNOTE("win_id: %ld\n", *(long *)prop_return);

	  if(win_id == *(long *)prop_return) {
	    // We have successfully detected a EWMH compliant Window Manager
	    XFree(prop_return);


	    /* check the name of the wm */

	    atom = XInternAtom(dpy, "_NET_WM_NAME", True);
	    if(atom != None) {
	      
	      if(XGetWindowProperty(dpy, win_id, atom, 0,
				    4, False, XA_STRING,
				    &type_return, &format_return,
				    &nitems_return,
				    &bytes_after_return,
				    &prop_return) != Success) {
		
		WARNING("%s", "XGetWindowProperty failed in wm_name\n");
		return 0;
	      }
	      
	      if(type_return == None) {
		WARNING("%s", "wm_name: property does not exist\n");
		return 0;
	      }
	      
	      if(type_return != XA_STRING) {
		type_utf8 = XInternAtom(dpy, "UTF8_STRING", True);
		if(type_utf8 == None) {
		  WARNING("%s", "not UTF8_STRING either\n");
		  return 0;
		}
		
		if(type_return == type_utf8) {
		  if(XGetWindowProperty(dpy, win_id, atom, 0,
					4, False, type_utf8,
					&type_return, &format_return,
					&nitems_return,
					&bytes_after_return,
					&prop_return) != Success) {
		    
		    WARNING("%s", "XGetWindowProperty failed in wm_name\n");
		    return 0;
		  }

		  //DNOTE("wm_name: property of type UTF8_STRING\n");
		  
		  //DNOTE("wm_name: format: %d\n", format_return);
		  //DNOTE("wm_name: nitmes: %ld\n", nitems_return);
		  //DNOTE("wm_name: bytes_after: %ld\n", bytes_after_return);
		  if(format_return == 8) {
		    DNOTE("wm_name: %s\n", (char *)prop_return);
		    *wm_name_return = strdup((char *)prop_return);
		  }
		  
		}
		if(prop_return != NULL) {
		  XFree(prop_return);
		}
	      } else {
		
		//DNOTE("wm_name: format: %d\n", format_return);
		//DNOTE("wm_name: nitmes: %ld\n", nitems_return);
		//DNOTE("wm_name: bytes_after: %ld\n", bytes_after_return);
		if(format_return == 8) {
		  DNOTE("wm_name: %s\n", (char *)prop_return);
		  *wm_name_return = strdup((char *)prop_return);
		}
	        XFree(prop_return);
		/* end name check */
	      }
	    }
	    return 1;
	  }
	}
	XFree(prop_return);
	return 0;
      }
    }
    XFree(prop_return);
    return 0;
  }
  return 0;
}


/* returns 1 if a window manager compliant to the
 * Extended Window Manager Hints (EWMH) spec.
 * supports the _NET_WM_STATE_FULLSCREEN window state
 * Oterhwise returns 0.
 */

static int check_for_state_fullscreen(Display *dpy)
{
  Atom net_supported, net_wm_state, net_wm_state_fullscreen;
  Atom type_return;
  int format_return;
  unsigned long nitems_return;
  unsigned long bytes_after_return;
  unsigned char *prop_return = NULL;
  int nr_items = 40;
  int item_offset = 0;
  int supports_net_wm_state = 0;
  int supports_net_wm_state_fullscreen = 0;

  net_supported = XInternAtom(dpy, "_NET_SUPPORTED", False);
  if(net_supported == None) {
    return 0;
  }
  
  net_wm_state = XInternAtom(dpy, "_NET_WM_STATE", False);
  if(net_wm_state == None) {
    return 0;
  }

  net_wm_state_fullscreen = XInternAtom(dpy, "_NET_WM_STATE_FULLSCREEN",
					False);
  if(net_wm_state_fullscreen == None) {
    return 0;
  }

  
  
  
  do {
    if(XGetWindowProperty(dpy, DefaultRootWindow(dpy), net_supported,
			  item_offset, nr_items, False, XA_ATOM,
			  &type_return, &format_return, &nitems_return,
			  &bytes_after_return, &prop_return) != Success) {
      WARNING("%s", "XGetWindowProperty failed in check_for_state_fullscreen\n");
      return 0;
    }
    
    if(type_return == None) {
      WARNING("%s", "check_for_state_fullscreen: property does not exist\n");
      return 0;
    }
    
    if(type_return != XA_ATOM) {
      
      WARNING("%s", "check_for_state_fullscreen: XA_ATOM property has wrong type\n");
      if(prop_return != NULL) {
	XFree(prop_return);
      }
      return 0;
    } else {
      // _NET_SUPPORTED is set, lets see what is in it
      
      //DNOTE("check_for_state_fullscreen: format: %d\n", format_return);
      //DNOTE("check_for_state_fullscreen: nitmes: %ld\n", nitems_return);
      //DNOTE("check_for_state_fullscreen: bytes_after: %ld\n", bytes_after_return);
      
      if(format_return == 32) {
	int n;
	
	for(n = 0; n < nitems_return; n++) {
	  if(((long *)prop_return)[n] == net_wm_state) {
	    supports_net_wm_state = 1;
	  } else if(((long *)prop_return)[n] == net_wm_state_fullscreen) {
	    supports_net_wm_state_fullscreen = 1;
	  }
	  
	  if(supports_net_wm_state && supports_net_wm_state_fullscreen) {
	    XFree(prop_return);
	    prop_return = NULL;
	    
	    return 1;
	  }
	}
	
	
	XFree(prop_return);
	prop_return = NULL;
      
	
	
      } else {
	XFree(prop_return);
	return 0;
      }
    }
    
    item_offset+= nr_items;
    
  } while(bytes_after_return > 0);
  return 0;

}


static int check_for_gnome_wm_layers(Display *dpy)
{
  Atom layer_atom;
  Atom atom;
  Atom type_return;
  int format_return;
  unsigned long nitems_return;
  unsigned long bytes_after_return;
  unsigned char *prop_return = NULL;
  int index = 0;
  
  atom = XInternAtom(dpy, "_WIN_PROTOCOLS", True);
  if(atom == None) {
    WARNING("%s", "no atom: _WIN_PROTOCOLS");
    return 0;
  }
  
  layer_atom = XInternAtom(dpy, "_WIN_LAYER", True);
  if(layer_atom == None) {
    WARNING("%s", "no atom: _WIN_LAYER");
    return 0;
  }
  
  do {
  
    if(XGetWindowProperty(dpy, DefaultRootWindow(dpy), atom, index,
			  1, False, XA_ATOM,
			  &type_return, &format_return, &nitems_return,
			  &bytes_after_return, &prop_return) != Success) {
      WARNING("%s", "XGetWindowProperty failed in check_for_gnome\n");
      return 0;
    }
    index++;
    
    if(type_return == None) {
      WARNING("%s", "check_for_layer: property does not exist\n");
      return 0;
    }
    
    if(type_return != XA_ATOM) {
      WARNING("%s", "check_for_layer: property has wrong type\n");
      if(prop_return != NULL) {
	XFree(prop_return);
      }
      return 0;
    }
    
    if(type_return == XA_ATOM) {
      //DNOTE("check_for_layer: format: %d\n", format_return);
      //DNOTE("check_for_layer: nitmes: %ld\n", nitems_return);
      //DNOTE("check_for_layer: bytes_after: %ld\n", bytes_after_return);
      if(format_return == 32 &&
	 nitems_return == 1) {

	if(layer_atom == *(long *)prop_return) {
	  // we found _WIN_LAYER
	  
	  //DNOTE("_WIN_LAYER found\n");
	  XFree(prop_return);
	  return 1;
	}
      }
      XFree(prop_return);
    }
  } while(bytes_after_return != 0);
  return 0;
}

void init_wm_state(Display *dpy, Window win)
{
  static int initialized = 0;
  
  if(initialized) {
    return;
  }
  
  wm_state_atom = XInternAtom(dpy, "WM_STATE", False);
  initialized = 1;
  
}

int ChangeWindowState(Display *dpy, Window win, WindowState_t state)
{
  init_wm_state(dpy, win);

  if(state != current_state) {

    EWMH_wm = check_for_EWMH_wm(dpy, &wm_name);
    if(EWMH_wm) {
      if(DpyInfoGetEWMHFullscreen()) {
	has_ewmh_state_fullscreen = check_for_state_fullscreen(dpy);
      } else {
	has_ewmh_state_fullscreen = 0;
      }
    }
    
    gnome_wm = check_for_gnome_wm(dpy);
    
    //DNOTE("EWMH_wm: %s\n", EWMH_wm ? "True" : "False");
    //DNOTE("gnome_wm: %s\n", gnome_wm ? "True" : "False");
    
    if(gnome_wm) {
      gnome_wm_layers = check_for_gnome_wm_layers(dpy);
    }
    
    switch(state) {
    case WINDOW_STATE_FULLSCREEN:
      switch_to_fullscreen_state(dpy, win);
      break;
    case WINDOW_STATE_NORMAL:
      switch_to_normal_state(dpy, win);
      break;
    default:
      ERROR("%s", "unknown window state\n");
      break;
    }
    if(wm_name != NULL) {
      free(wm_name);
      wm_name = NULL;
    }
  }
  
  return 1;
  
}