Exemple #1
0
int main(int argc, char **argv) {
    WnckScreen *screen;
    WnckWindow *active_window;
    GList *window_l;

    gdk_init(&argc, &argv);

    screen = wnck_screen_get_default();

    sleep(5);

    wnck_screen_force_update(screen);

    active_window = wnck_screen_get_active_window(screen);

    for (window_l = wnck_screen_get_windows(screen); window_l != NULL;
        window_l = window_l->next) {
        WnckWindow *window = WNCK_WINDOW(window_l->data);
        if (strcmp(wnck_window_get_name(window), "Terminal") == 0) {
            wnck_window_activate(window, (guint32)time(NULL));
            break;
        }
//        g_print("Name: '%s', PID: %d(%lu)%s\n", wnck_window_get_name(window),
//            wnck_window_get_pid(window), wnck_window_get_xid(window),
//            window == active_window ? " (active)" : "");
    }

    return 0;
}
Exemple #2
0
int main (int argc, char *argv[])
{
    /* Make sure we exit cleanly (needed for profiling among other things) */
  g_shell_parse_argv(sphinx_command,&argc,&argv,NULL);
     gtk_init(&argc, &argv);
 
     scr = wnck_screen_get_default();
     while(gtk_events_pending()) gtk_main_iteration();
     win = wnck_screen_get_active_window(scr);
      tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
     signal(SIGINT, &sighandler);

    fbs_init (argc, argv);
    
    if ((ad = ad_open_sps (SAMPLE_RATE)) == NULL)
	E_FATAL("ad_open_sps failed\n");

    // E_INFO("%s COMPILED ON: %s, AT: %s\n\n", argv[0], __DATE__, __TIME__);

    if (setjmp(jbuf) == 0) {
      utterance_loop (argc,argv);
    }

    fbs_end ();
    ad_close (ad);

    return 0;
}
Exemple #3
0
/* Triggers when a new active window is selected */
static void active_window_changed (WnckScreen *screen,
                                   WnckWindow *previous,
                                   WTApplet *wtapplet)
{
	// Start tracking the new active window:
	if (wtapplet->activewindow) {
		if (g_signal_handler_is_connected(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_state))
			g_signal_handler_disconnect(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_state);
		if (g_signal_handler_is_connected(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_name))
			g_signal_handler_disconnect(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_name);
		if (g_signal_handler_is_connected(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_icon))
			g_signal_handler_disconnect(G_OBJECT(wtapplet->activewindow), wtapplet->active_handler_icon);
	}
	
	wtapplet->activewindow = wnck_screen_get_active_window(screen);
	wtapplet->umaxedwindow = getUpperMaximized(wtapplet); // returns wbapplet->activewindow if not only_maximized
	wtapplet->rootwindow = getRootWindow(wtapplet->activescreen);
	
	if (wtapplet->activewindow) {
		wtapplet->active_handler_state = g_signal_connect(G_OBJECT (wtapplet->activewindow), "state-changed", G_CALLBACK (active_window_state_changed), wtapplet);
		wtapplet->active_handler_name = g_signal_connect(G_OBJECT (wtapplet->activewindow), "name-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet);
		wtapplet->active_handler_icon = g_signal_connect(G_OBJECT (wtapplet->activewindow), "icon-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet);
										   
		wtapplet->focused = TRUE;

		updateTitle(wtapplet);
	}
}
void init_wnck (WckUtils *win, gboolean only_maximized, gpointer data)
{
    /* save data */
    win->data = data;

    /* get window proprieties */
    win->activescreen = wnck_screen_get_default();
    win->activeworkspace = wnck_screen_get_active_workspace(win->activescreen);
    if (!win->activeworkspace)
        win->activeworkspace = wnck_screen_get_workspace(win->activescreen, 0);
    win->activewindow = wnck_screen_get_active_window(win->activescreen);
    win->umaxwindow = NULL;
    win->controlwindow = NULL;
    win->only_maximized = only_maximized;

    /* Global window tracking */
    g_signal_connect(win->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), win);

    if (win->only_maximized)
    {
        win->sch = g_signal_connect(win->activescreen, "window-closed", G_CALLBACK (on_window_closed), win);
        win->soh = g_signal_connect(win->activescreen, "window-opened", G_CALLBACK (on_window_opened), win);
    }

        win->svh = g_signal_connect(win->activescreen, "viewports-changed", G_CALLBACK (on_viewports_changed), win);
        win->swh = g_signal_connect(win->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), win);

    /* Get controled window */
    track_controled_window (win);
    
    if (!win->controlwindow)
        on_control_window_changed (NULL, NULL, win->data);
}
Exemple #5
0
void Application::init() {
    b2Vec2 gravity(0.0f, 10.0f);
    mWorld = QSharedPointer<b2World>(new b2World(gravity));
    mWorld->SetAllowSleeping(false);

    // Get windowing system
    WnckScreen *screen;
    WnckWindow *active_window;
    WnckWorkspace *active_workspace;
    GList *window_l;

    screen = wnck_screen_get_default ();

    wnck_screen_force_update (screen);

    active_window = wnck_screen_get_active_window (screen);
    active_workspace = wnck_screen_get_active_workspace (screen);

    for(window_l = wnck_screen_get_windows (screen); window_l != NULL; window_l = window_l->next) {
        WnckWindow *window = WNCK_WINDOW (window_l->data);
        if(wnck_window_is_on_workspace(window, active_workspace) &&
                !wnck_window_is_minimized(window) &&
                wnck_window_get_window_type(window) == WNCK_WINDOW_NORMAL) {
            mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(window, mWorld)));
        }
    }

    mPhysicalWindows.append(QSharedPointer<PhysicalWindow>(new PhysicalWindow(100, 100, 100, 100, mWorld)));
}
Exemple #6
0
void curfirst(void)
{
	WnckScreen *screen = wnck_screen_get(0);
	WnckWindow *window = wnck_screen_get_active_window(screen);
	int curid = workspace_get_active();

	if (workspace_change_first_window(curid, window)) {
		tile(curid);
	}
}
Exemple #7
0
/* Triggers when user changes viewports (Compiz) */
static void viewports_changed (WnckScreen *screen,
                               WTApplet *wtapplet)
{
	wtapplet->activeworkspace = wnck_screen_get_active_workspace(screen);
	wtapplet->activewindow = wnck_screen_get_active_window(screen);
	wtapplet->rootwindow = getRootWindow(wtapplet->activescreen); //?
	wtapplet->umaxedwindow = getUpperMaximized(wtapplet);

	// active_window_changed will do it too, but this one will be sooner
	updateTitle(wtapplet);
}
Exemple #8
0
static void
wnck_selector_active_window_changed (WnckScreen   *screen,
                                     WnckWindow   *previous_window,
                                     WnckSelector *selector)
{
  WnckWindow *window;

  window = wnck_screen_get_active_window (screen);

  if (selector->priv->icon_window != window)
    wnck_selector_set_active_window (selector, window);
}
static void
active_window_changed (WnckScreen* screen,
                       WnckWindow* previous,
                       gpointer    user_data)
{
  WorkspaceButton* self = user_data;
  WnckWindow     * current = wnck_screen_get_active_window (screen);

  if (current && wnck_window_is_on_workspace (current, PRIV (self)->workspace) &&
      wnck_screen_get_active_workspace (screen) == PRIV (self)->workspace)
    {
      set_active_window (self, current);
    }
}
static void
on_active_window_changed (WnckScreen *screen,
                          WnckWindow *previously_active_window,
                          gpointer    data)
{
  WnckWindow *active_window;

  active_window = wnck_screen_get_active_window (screen);

  if (active_window)
    g_print ("active: %s\n", wnck_window_get_name (active_window));
  else
    g_print ("no active window\n");
}
Exemple #11
0
/**
 * ww_apply_layout_by_name
 * @layout_name: The name of the layout to apply
 *
 * Apply a given layout to the default screen by looking up the relevant
 * #WwLayout based on its name.
 */
void
ww_apply_layout_by_name (const gchar * layout_name)
{
	WnckScreen *screen;
	WnckWorkspace   *current_ws;
	GList *windows, *struts;
	WnckWindow *active;
	const WwLayout *layout;
	GError *error;
	
	screen = wnck_screen_get_default ();
	wnck_screen_force_update (screen);
	
	current_ws = wnck_screen_get_active_workspace (screen);
	windows = wnck_screen_get_windows (screen);
	struts = ww_filter_strut_windows (windows, current_ws);
	windows = ww_filter_user_windows (windows, current_ws);
	active = wnck_screen_get_active_window (screen);
	
	/* Check that we know the requested layout */
	layout = ww_get_layout (layout_name);
	if (!layout)
	{
		g_printerr ("No such layout: '%s'. Try running with --layouts to "
					"list possible layouts\n", layout_name);
		return;
	}
	
	/* Apply the layout */
	error = NULL;
	layout->handler (screen, windows, struts, active, &error);
	g_list_free (windows);
	g_list_free (struts);
	
	if (error)
	{
		g_printerr ("Failed to apply layout '%s'. Error was:\n%s",
					layout_name, error->message);
		g_error_free (error);
		return;
	}	
}
static void
window_item_activated (GtkWidget * widget,
                       WnckWindow* window)
{
  WnckWorkspace* workspace = wnck_window_get_workspace (window);

  if (workspace && wnck_screen_get_active_workspace (wnck_window_get_screen (window)) != workspace)
    {
      wnck_workspace_activate (workspace, gtk_get_current_event_time ());
    }

  if (wnck_screen_get_active_window (wnck_window_get_screen (window)) == window)
    {
      wnck_window_minimize (window);
    }
  else
    {
      wnck_window_activate_transient (window, gtk_get_current_event_time ());
    }
}
/**
 * Event handler for clicking on the title (not the close button)
 * On double click unmaximized the window
 * On right click it shows the context menu for the current window
 */
static gboolean on_button_press (GtkWidget *title, GdkEventButton *event) {
    g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
    TaskTitlePrivate *priv = TASK_TITLE (title)->priv;
    WnckWindow *window = wnck_screen_get_active_window (priv->screen);
    g_return_val_if_fail (WNCK_IS_WINDOW (window), FALSE);

    if (event->button == 3) { //right click
        if (wnck_window_get_window_type (window) != WNCK_WINDOW_DESKTOP) {
            GtkWidget *menu = wnck_action_menu_new (window);
            gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
                event->button, event->time);
            return TRUE;
        }
    } else if (event->button == 1) { //left button double click
        if (event->type == GDK_2BUTTON_PRESS
            && wnck_window_is_maximized (window)) {
                wnck_window_unmaximize (window);
        }
    }
    return FALSE;
}
Exemple #14
0
static void
wnck_selector_realize (GtkWidget *widget)
{
  WnckSelector *selector;
  WnckScreen   *screen;
  WnckWindow   *window;
  GList        *l;

  GTK_WIDGET_CLASS (wnck_selector_parent_class)->realize (widget);

  selector = WNCK_SELECTOR (widget);
  screen = wnck_selector_get_screen (selector);

  window = wnck_screen_get_active_window (screen);
  wnck_selector_set_active_window (selector, window);

  for (l = wnck_screen_get_windows (screen); l; l = l->next)
    wnck_selector_connect_to_window (selector, l->data);

  wnck_selector_connect_to_screen (selector, screen);
}
Exemple #15
0
static void on_active_window_changed(WnckScreen *screen,
		WnckWindow *previously_active_window,
		gpointer user_data)
{
	GList *window_l;
	WnckWindow *active_window = wnck_screen_get_active_window(screen);
	WnckWorkspace *active_workspace = wnck_screen_get_active_workspace(screen);
	GList *pids_current = NULL;
	GList *pids_other = NULL;

	for (window_l = wnck_screen_get_windows(screen); window_l != NULL; window_l = window_l->next) {
		WnckWindow *window = WNCK_WINDOW(window_l->data);
		WnckApplication *app = wnck_application_get(wnck_window_get_group_leader(window));
		WnckWorkspace *w_workspace = wnck_window_get_workspace(window);
		if (!w_workspace)
			continue;
		GList *app_window_l;

		int w_pid = wnck_application_get_pid(app);
		if (w_workspace == active_workspace) {
			GList *g = g_list_find(pids_current, GINT_TO_POINTER(w_pid));
			if (!g) pids_current = g_list_append(pids_current, GINT_TO_POINTER(w_pid));
		} else {
			GList *g = g_list_find(pids_other, GINT_TO_POINTER(w_pid));
			if (!g) pids_other = g_list_append(pids_other, GINT_TO_POINTER(w_pid));
		}
	}
	for (; pids_other != NULL; pids_other = pids_other->next) {
		GList *g = g_list_find(pids_current, pids_other->data);
		if (g)
			g_print("Another window of this application is active\n");
		else
			g_print("PID: %d\n", stop_pid(GPOINTER_TO_INT(pids_other->data)));
	}
	for (; pids_current != NULL; pids_current = pids_current->next) {
		cont_pid(GPOINTER_TO_INT(pids_current->data));
	}
	g_print("-----\n");
}
Exemple #16
0
static void
on_screen_active_window_changed (WnckScreen    *screen,
                                 WnckWindow    *old_window,
                                 TaskItem      *item)
{
  WnckWindow *window;
  TaskItemPrivate *priv;

  g_return_if_fail (TASK_IS_ITEM (item));

  priv = item->priv;
  window = priv->window;
  
  g_return_if_fail (WNCK_IS_WINDOW (window));
  
  if ((WNCK_IS_WINDOW (old_window) && window == old_window) ||
       window == wnck_screen_get_active_window (screen))
  {
    /* queue a draw to reflect that we are [no longer] the active window */
    gtk_widget_queue_draw (GTK_WIDGET (item));
  }
}
/* Triggers when a new active window is selected */
static void active_window_changed (WnckScreen *screen,
                                   WnckWindow *previous,
                                   WckUtils *win)
{

    win->activewindow = wnck_screen_get_active_window(screen);

    if (win->activewindow != previous)
    {
        wck_signal_handler_disconnect (G_OBJECT(previous), win->ash);

        track_controled_window (win);
    }

    if (win->activewindow
        && (win->activewindow != previous)
        && (wnck_window_get_window_type (win->activewindow) != WNCK_WINDOW_DESKTOP))
    {
        /* Start tracking the new active window */
        win->ash = g_signal_connect(G_OBJECT (win->activewindow), "state-changed", G_CALLBACK (track_changed_max_state), win);
    }
}
/**
 * The event handler for the close icon. This closes the window and terminates
 * the program.
 */
static gboolean on_close_clicked (GtkButton *button,
    GdkEventButton *event,
    TaskTitle *title)
{
    g_return_val_if_fail (TASK_IS_TITLE (title), FALSE);
    TaskTitlePrivate *priv = title->priv;
    if (event->button != 1 || !priv->mouse_in_close_button)
        return FALSE;
    WnckWindow *window = wnck_screen_get_active_window (priv->screen);
    if (!WNCK_IS_WINDOW (window)
        || wnck_window_get_window_type (window) == WNCK_WINDOW_DESKTOP)
    {
        fprintf(stdout, "Error\n");
        fflush(stdout);
    } else {
        if (priv->window == window)
            disconnect_window (title);
        wnck_window_close (window, event->time);
    }
    gtk_widget_queue_draw (GTK_WIDGET (title));
    return TRUE;
}
Exemple #19
0
static void desktop_active_window_changed(WnckScreen* screen, WnckWindow *previous_window, MacMenu* mmb)
{
  WnckWindow* awin = wnck_screen_get_active_window(screen);
  GtkWidget* sck = NULL;
  if (awin != NULL && wnck_window_get_window_type(awin) != WNCK_WINDOW_DESKTOP)
  {
    long inout[2] = {0, 0};
    inout[0] = wnck_window_get_xid(awin);
    if (inout[0])
    {
      g_hash_table_foreach(mmb->mbars_scks, find_mbar_by_mwin, inout);
      if (inout[1])
        sck = g_hash_table_lookup(mmb->mbars_scks, (gpointer) inout[1]);
    }
    if (sck == NULL)
    {
      sck = mmb->dummysck;
      gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10);
    }
    else
    {
      gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS);
    }
    gtk_label_set_text(mmb->label, get_application_name(awin, mmb));
  }
  else
  {
    sck = mmb->mainsck;
    gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10);
    gtk_label_set_text(mmb->label, MAIN_LABEL_TEXT);
  }

  gtk_notebook_set_current_page(
    mmb->notebook,
    gtk_notebook_page_num(mmb->notebook, sck)
  );
}
Exemple #20
0
static void wibuti_watcher_find_window(WibutiWatcher *self) {
	WnckWorkspace *activeworkspace = wnck_screen_get_active_workspace(self->screen);
	WnckWindow *new_active = wnck_screen_get_active_window(self->screen);
	WnckWindow *new_tracked = NULL;

	// stop tracking the old active window
	if (G_IS_OBJECT(self->active)) {
		if (g_signal_handler_is_connected(G_OBJECT(self->active), self->handler_active_state_changed)) {
			g_signal_handler_disconnect(G_OBJECT(self->active), self->handler_active_state_changed);
		}
	}

	if (self->only_maximized) {
		// find upper maximized window
		GList *windows = wnck_screen_get_windows_stacked(self->screen);
		while (windows && windows->data) {
			if (!self->only_maximized || wnck_window_is_maximized(windows->data))
				if (!wnck_window_is_minimized(windows->data) && !wnck_window_is_skip_pager(windows->data))
					if (wnck_window_is_in_viewport(windows->data, activeworkspace))
						new_tracked = windows->data;
			windows = windows->next;
		}

		// start tracking the new active window
		if (new_active) {
			self->handler_active_state_changed = g_signal_connect(G_OBJECT(new_active), "state-changed",
			                                     G_CALLBACK(wibuti_watcher_window_state_changed_cb), self);
		}
	} else {
		new_tracked = new_active;
	}

	// stop tracking the old window
	if (G_IS_OBJECT(self->tracked)) {
#ifdef WIBUTI_WITH_TITLE
		if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_name_changed)) {
			g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_name_changed);
		}
		if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_icon_changed)) {
			g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_icon_changed);
		}
#endif // WIBUTI_WITH_TITLE
		if (g_signal_handler_is_connected(G_OBJECT(self->tracked), self->handler_tracked_state_changed)) {
			g_signal_handler_disconnect(G_OBJECT(self->tracked), self->handler_tracked_state_changed);
		}
	}

	// start tracking the new window
	if (new_tracked) {
#ifdef WIBUTI_WITH_TITLE
		self->handler_name_changed = g_signal_connect(G_OBJECT(new_tracked), "name-changed",
	                                                  G_CALLBACK(wibuti_watcher_name_changed_cb), self);
		self->handler_icon_changed = g_signal_connect(G_OBJECT(new_tracked), "icon-changed",
	                                                  G_CALLBACK(wibuti_watcher_icon_changed_cb), self);
#endif // WIBUTI_WITH_TITLE
		self->handler_tracked_state_changed = g_signal_connect(G_OBJECT(new_tracked), "state-changed",
                                                      G_CALLBACK(wibuti_watcher_window_state_changed_cb), self);
	}
	
	self->tracked = new_tracked;
	self->active = new_active;
}
Exemple #21
0
static void utterance_loop(int argc,char *argv[])
{
  int16 adbuf[4096];
  int32 k, fr, ts, rem;
  char *hyp;
  cont_ad_t *cont;
  int count=0,i=1,flag;
  char word[256];
  /* Initialize continuous listening module */
  if ((cont = cont_ad_init (ad, ad_read)) == NULL)
    E_FATAL("cont_ad_init failed\n");
  if (ad_start_rec (ad) < 0)
    E_FATAL("ad_start_rec failed\n");
  if (cont_ad_calib (cont) < 0)
    E_FATAL("cont_ad_calib failed\n");
  
  for (;;)
    {
           /* Indicate listening for next utterance */
      printf ("READY....\n");
      fflush (stdout); fflush (stderr);
      
      /* Await data for next utterance */
      while ((k = cont_ad_read (cont, adbuf, 4096)) == 0)
	sleep_msec(200);
      
      if (k < 0)
	E_FATAL("cont_ad_read failed\n");
      
      /*
       * Non-zero amount of data received; start recognition of new utterance.
       * NULL argument to uttproc_begin_utt => automatic generation of utterance-id.
       */
      if (uttproc_begin_utt (NULL) < 0)
	E_FATAL("uttproc_begin_utt() failed\n");
      uttproc_rawdata (adbuf, k, 0);
      printf ("Listening...\n"); fflush (stdout);
      
      /* Note timestamp for this first block of data */
      ts = cont->read_ts;
      
      /* Decode utterance until end (marked by a "long" silence, >1sec) */
      for (;;) {
	/* Read non-silence audio data, if any, from continuous listening module */
	if ((k = cont_ad_read (cont, adbuf, 4096)) < 0)
	  E_FATAL("cont_ad_read failed\n");
	if (k == 0) {
	  /*
	   * No speech data available; check current timestamp with most recent
	   * speech to see if more than 1 sec elapsed.  If so, end of utterance.
	   */
	  if ((cont->read_ts - ts) > DEFAULT_SAMPLES_PER_SEC)
	    break;
	} else {
	  /* New speech data received; note current timestamp */
	  ts = cont->read_ts;
	}
	
	/*
	 * Decode whatever data was read above.  NOTE: Non-blocking mode!!
	 * rem = #frames remaining to be decoded upon return from the function.
	 */
	rem = uttproc_rawdata (adbuf, k, 0);
	
	/* If no work to be done, sleep a bit */
	if ((rem == 0) && (k == 0))
	  sleep_msec (20);
      }
      
      /*
       * Utterance ended; flush any accumulated, unprocessed A/D data and stop
       * listening until current utterance completely decoded
       */
      ad_stop_rec (ad);
      while (ad_read (ad, adbuf, 4096) >= 0);
      cont_ad_reset (cont);
      
      printf ("Stopped listening, please wait...\n"); fflush (stdout);
#if 0
      /* Power histogram dump (FYI) */
      cont_ad_powhist_dump (stdout, cont);
#endif
      /* Finish decoding, obtain and print result */
      uttproc_end_utt ();
      if (uttproc_result (&fr, &hyp, 1) < 0)
	E_FATAL("uttproc_result failed\n");
      
      
      /*obtaining the results*/
      sscanf (hyp, "%s", word);
      printf ("%d: %s\n", fr,word); fflush (stdout);
 	  win=wnck_screen_get_active_window(scr);
	  tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
	
      i=g_list_index(tmp,win);/*the place value  of window in the list*/
      printf("<<<<<<<<<<<<<<>>>>>>>>>>>>>>i:%d,%s\n\n\n",i,wnck_window_get_name(win));
      count=0;
      while(tmp!=NULL)
	{
	  printf("%d:%s\n\n",count,wnck_window_get_name(tmp->data));
	  tmp=tmp->next;count++;
	}
            /*comparison and action for DAKKU */
      if(strcmp(word,"PADU")==0)
	g_spawn_command_line_async("totem --play",NULL);
      if(strcmp(word,"EMACS")==0)
	g_spawn_command_line_async("emacs",NULL);
      if(strcmp(word,"SAMAYAM")==0)
	g_spawn_command_line_async(DHVANISCRIPT,NULL);
      if(strcmp(word,"VALAPARATHU")==0)
	g_spawn_command_line_async("epiphany",NULL);
      if(strcmp(word,"EAZHUTHIDAM")==0)
      g_spawn_command_line_async("gedit",NULL);
      /*Minimizing current active window*/
           if (strcmp (word, "CHURUKKU") == 0)
	      wnck_window_minimize(win);
      /*Moving focus(active window)towards the left of the panel.The active window is changed to
 the next normal window on the left.effect of alt+tab key press*/
      if(strcmp(word,"ADUTHATHU")==0)
	{
	  win=wnck_screen_get_active_window(scr);
	  tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
	
	  while(tmp!=NULL)/*while traces the current active window through the list*/
	    {
	      printf("tracing:current:%s\n\ntmp:%s\n\n",wnck_window_get_name(win),wnck_window_get_name(tmp->data));	   
	      if(tmp->data==win)
		{   
			  printf("BREAKED with tmp:%s\n",wnck_window_get_name(tmp->data));
		  break;
		}
	    
	      tmp=tmp->next;
	      
	    }
	  if(tmp==NULL){printf("BULL SHIT GIVE A WINDOW IN THE LIST\n\n");}//exit(1);}
	  if(tmp->next==NULL)/*shifting back to the first window by refreshing the list*/
	    tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
	  else
	    tmp=tmp->next;
	  printf("cuow:%s\n\n",wnck_window_get_name(tmp->data));
	
		
	  
	  while(tmp!=NULL)
	    {
	      printf("tmp in while:%s\n\n",wnck_window_get_name(tmp->data));
	      if(wnck_window_get_window_type(tmp->data)==WNCK_WINDOW_NORMAL)
		{
		  wnck_window_activate(tmp->data,0);
		  flag=1;
		  break;
		}
	      else
		tmp=tmp->next;
	    }
	  
	  if(flag==0)
	    {
	      printf("FLAG==0 DETECTED:\n");
	      tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
	      while(tmp!=NULL)
		{
		  printf("tmp in last while:%s\n",wnck_window_get_name(tmp->data));
		  if(wnck_window_get_window_type(tmp->data)==WNCK_WINDOW_NORMAL)
		    {
		      wnck_window_activate(tmp->data,0);
		      break;
		    }
		  else
		    tmp=tmp->next;
		}
	    }
	
	 
	}
      if(strcmp(word,"VALUTHAKKU")==0)
	{
	  if(wnck_window_get_window_type(win)!= WNCK_WINDOW_NORMAL)
	    {
	      if(wnck_window_get_window_type(wnck_screen_get_previously_active_window(scr))==WNCK_WINDOW_NORMAL)
		win=wnck_screen_get_previously_active_window(scr);
	    }
	      wnck_window_unminimize(win,0);
	    
	}

      while(gtk_events_pending())/*gtk probing and refreshing the win and tmp*/
	{
	  gtk_main_iteration();
	  win=wnck_screen_get_active_window(scr);
	  tmp=wnck_screen_get_windows(wnck_window_get_screen(win));
	  
	}
      
      /* Resume A/D recording for next utterance */
      if (ad_start_rec (ad) < 0)
	E_FATAL("ad_start_rec failed\n");
    }
  
  cont_ad_close (cont);
}
Exemple #22
0
/* Do the actual applet initialization */
static void init_wtapplet (PanelApplet *applet) {
	WTApplet *wtapplet = g_new0 (WTApplet, 1);

	wtapplet->applet = applet;
	wtapplet->prefs = loadPreferences(wtapplet);
	wtapplet->activescreen = wnck_screen_get_default();
	wnck_screen_force_update(wtapplet->activescreen);
	wtapplet->activeworkspace = wnck_screen_get_active_workspace(wtapplet->activescreen);
	wtapplet->activewindow = wnck_screen_get_active_window(wtapplet->activescreen);
	wtapplet->umaxedwindow = getUpperMaximized(wtapplet);
	wtapplet->rootwindow = getRootWindow(wtapplet->activescreen);
	wtapplet->prefbuilder = gtk_builder_new();
	wtapplet->box = GTK_BOX(gtk_hbox_new(FALSE, 0));
	wtapplet->icon = GTK_IMAGE(gtk_image_new());
	wtapplet->title = GTK_LABEL(gtk_label_new(NULL));
	wtapplet->eb_icon = GTK_EVENT_BOX(gtk_event_box_new());
	wtapplet->eb_title = GTK_EVENT_BOX(gtk_event_box_new());
	wtapplet->orient = panel_applet_get_orient(wtapplet->applet);
	wtapplet->size_hints = g_new(gint,2);

	// Widgets to eventboxes, eventboxes to box
	gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->icon), TRUE);
	gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->title), TRUE);
	gtk_container_add (GTK_CONTAINER (wtapplet->eb_icon), GTK_WIDGET(wtapplet->icon));
	gtk_container_add (GTK_CONTAINER (wtapplet->eb_title), GTK_WIDGET(wtapplet->title));
	gtk_event_box_set_visible_window (wtapplet->eb_icon, FALSE);
	gtk_event_box_set_visible_window (wtapplet->eb_title, FALSE);

	// Rotate & place elements
	setAlignment(wtapplet, (gfloat)wtapplet->prefs->alignment);
	placeWidgets(wtapplet);

	// Add box to applet
	gtk_container_add (GTK_CONTAINER(wtapplet->applet), GTK_WIDGET(wtapplet->box));

	// Set event handling (icon & title clicks)
	g_signal_connect(G_OBJECT (wtapplet->eb_icon), "button-press-event", G_CALLBACK (icon_clicked), wtapplet);
	g_signal_connect(G_OBJECT (wtapplet->eb_title), "button-press-event", G_CALLBACK (title_clicked), wtapplet);
	
	// Global window tracking
	g_signal_connect(wtapplet->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), wtapplet); // <-- this thing is crashing with compiz !!!
	g_signal_connect(wtapplet->activescreen, "viewports-changed", G_CALLBACK (viewports_changed), wtapplet);
	g_signal_connect(wtapplet->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), wtapplet);
	g_signal_connect(wtapplet->activescreen, "window-closed", G_CALLBACK (window_closed), wtapplet);
	g_signal_connect(wtapplet->activescreen, "window-opened", G_CALLBACK (window_opened), wtapplet);

	// g_signal_connect(G_OBJECT (wtapplet->title), "size-request", G_CALLBACK (applet_title_size_request), wtapplet);
	g_signal_connect(G_OBJECT (wtapplet->applet), "size-allocate", G_CALLBACK (applet_size_allocate), wtapplet);

	g_signal_connect(G_OBJECT (wtapplet->applet), "change-background", G_CALLBACK (applet_change_background), wtapplet);
	g_signal_connect(G_OBJECT (wtapplet->applet), "change-orient", G_CALLBACK (applet_change_orient), wtapplet);
	g_signal_connect(G_OBJECT (wtapplet->applet), "change-size", G_CALLBACK (applet_change_pixel_size), wtapplet);
	
	// Track active window changes
	wtapplet->active_handler_state = 
		g_signal_connect(G_OBJECT (wtapplet->activewindow), "state-changed", G_CALLBACK (active_window_state_changed), wtapplet);
	wtapplet->active_handler_name = 
		g_signal_connect(G_OBJECT (wtapplet->activewindow), "name-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet);
	wtapplet->active_handler_icon = 
		g_signal_connect(G_OBJECT (wtapplet->activewindow), "icon-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet);

	
	// Setup applet right-click menu
	GtkActionGroup *action_group = gtk_action_group_new ("WindowButtons Applet Actions");
	gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions (action_group, windowtitle_menu_actions, G_N_ELEMENTS (windowtitle_menu_actions), wtapplet);
	panel_applet_setup_menu (applet, windowtitle_menu_items, action_group);
	panel_applet_set_background_widget (wtapplet->applet, GTK_WIDGET (wtapplet->applet)); // Automatic background update
	
	toggleExpand  (wtapplet);
	toggleHidden  (wtapplet);	// Properly hide or show stuff
	updateTitle   (wtapplet);
}
static void
on_active_window_changed (WnckScreen *screen,
                          WnckWindow *old_window,
                          TaskTitle  *title)
{
    g_return_if_fail (TASK_IS_TITLE (title));
    WnckWindow *act_window = wnck_screen_get_active_window (screen);
    WnckWindowType type = WNCK_WINDOW_NORMAL;
    TaskTitlePrivate *priv = title->priv;

    if (act_window)
        type = wnck_window_get_window_type (act_window);

    disconnect_window (title);
    // Depending on the type and state of the window we adjust the title
    if(WNCK_IS_WINDOW(act_window)) {
        if(type == WNCK_WINDOW_DESKTOP) {
            /* The current window is the desktop so we show the home title if
             *  the user has configured this, otherwise we hide the title */
            if (window_picker_applet_get_show_home_title (priv->windowPickerApplet)) {
                show_home_title(title);
            } else {
                hide_title (title);
            }
        } else if(wnck_window_is_skip_tasklist (act_window)
            && type != WNCK_WINDOW_DESKTOP)
        {
            /* The current window is not in the task list, we dont change the
             * current title. */
            return;
        } else if(type == WNCK_WINDOW_DOCK
            || type == WNCK_WINDOW_SPLASHSCREEN
            || type == WNCK_WINDOW_MENU)
        {
            return;
        } else { //for all other types
            if(wnck_window_is_maximized (act_window) && window_picker_applet_get_show_application_title (priv->windowPickerApplet)) {
                //show normal title of window
                gtk_label_set_text (GTK_LABEL (priv->label),
                    wnck_window_get_name (act_window));
                gtk_image_set_from_icon_name (GTK_IMAGE (priv->button_image),
                        "window-close", GTK_ICON_SIZE_MENU);
                gtk_widget_set_tooltip_text (GTK_WIDGET (title),
                     wnck_window_get_name (act_window));
                gtk_widget_set_tooltip_text (priv->button, _("Close window"));
                g_signal_connect (act_window, "name-changed",
                    G_CALLBACK (on_name_changed), title);
                g_signal_connect_after (act_window, "state-changed",
                    G_CALLBACK (on_state_changed), title);
                gtk_widget_show (priv->grid);
                priv->window = act_window;
            } else {
                hide_title (title); //only show the title for maximized windows
            }
        }
    } else { //its not a window
        if (task_list_get_desktop_visible (TASK_LIST (window_picker_applet_get_tasks (priv->windowPickerApplet)))
                && window_picker_applet_get_show_home_title (priv->windowPickerApplet))
        {
            show_home_title(title);
        } else { //reset the task title and hide it
            hide_title (title);
        }
    }

    gtk_widget_queue_draw (GTK_WIDGET (title));
}
Exemple #24
0
WnckWindow *window_get_active(void)
{
	WnckScreen *screen = wnck_screen_get(0);
	return wnck_screen_get_active_window(screen);
}