static void wnck_action_menu_dispose (GObject *object) { WnckActionMenu *menu; menu = WNCK_ACTION_MENU (object); if (menu->priv->idle_handler) { g_source_remove (menu->priv->idle_handler); menu->priv->idle_handler = 0; } if (WNCK_IS_WINDOW (menu->priv->window)) { g_object_weak_unref (G_OBJECT (menu->priv->window), window_weak_notify, menu); g_signal_handlers_disconnect_by_data (menu->priv->window, menu); WnckScreen *screen = wnck_window_get_screen (menu->priv->window); g_signal_handlers_disconnect_by_data (screen, menu); menu->priv->window = NULL; } G_OBJECT_CLASS (wnck_action_menu_parent_class)->dispose (object); }
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; }
int c_center(lua_State *lua) { int top = lua_gettop(lua); int workspace_width, workspace_height, window_width, window_height; int xoffset, yoffset; WnckScreen *screen; WnckWorkspace *workspace; if (top != 0) { luaL_error(lua, "center: %s", no_indata_expected_error); return 0; } WnckWindow *window = get_current_window(); if (!window) { lua_pushboolean(lua, FALSE); return 1; } wnck_window_get_geometry(window, NULL, NULL, &window_width, &window_height); screen = wnck_window_get_screen(window); workspace = wnck_screen_get_active_workspace(screen); if (workspace == NULL) { workspace = wnck_screen_get_workspace(screen,0); } if (workspace == NULL) { g_printerr(_("Could not get workspace")); lua_pushboolean(lua, FALSE); return 1; } workspace_width = wnck_workspace_get_width(workspace); workspace_height = wnck_workspace_get_height(workspace); xoffset = (workspace_width - window_width) / 2; yoffset = (workspace_height - window_height) / 2; devilspie2_error_trap_push(); XMoveWindow (gdk_x11_get_default_xdisplay(), wnck_window_get_xid(window), xoffset, yoffset); if (devilspie2_error_trap_pop()) { g_printerr("center: %s", failed_string); lua_pushboolean(lua, FALSE); return 1; } lua_pushboolean(lua, TRUE); return 1; }
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 ()); } }
static void refill_submenu_workspace (WnckActionMenu *menu) { GtkWidget *submenu; GList *children; GList *l; int num_workspaces, window_space, i; WnckWorkspace *workspace; submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu->priv->workspace_item)); /* Remove existing items */ children = gtk_container_get_children (GTK_CONTAINER (submenu)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (submenu), l->data); g_list_free (children); workspace = wnck_window_get_workspace (menu->priv->window); num_workspaces = wnck_screen_get_workspace_count (wnck_window_get_screen (menu->priv->window)); if (workspace) window_space = wnck_workspace_get_number (workspace); else window_space = -1; for (i = 0; i < num_workspaces; i++) { char *name; GtkWidget *item; name = get_workspace_name_with_accel (menu->priv->window, i); item = make_menu_item (MOVE_TO_WORKSPACE); g_object_set_data (G_OBJECT (item), "workspace", GINT_TO_POINTER (i)); if (i == window_space) gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); set_item_text (item, name); set_item_stock (item, NULL); g_free (name); } gtk_menu_reposition (GTK_MENU (submenu)); }
/** * Makes a workspace the active one */ int c_change_workspace(lua_State *lua) { int top = lua_gettop(lua); GTimeVal timestamp; if (top != 1) { luaL_error(lua,"change_workspace: %s", one_indata_expected_error); return 0; } int type = lua_type(lua, 1); if (type!=LUA_TNUMBER) { luaL_error(lua,"change_workspace: %s", number_expected_as_indata_error); return 0; } int number = lua_tonumber(lua, 1); WnckWindow *window = get_current_window(); if (window) { WnckScreen *screen; WnckWorkspace *workspace; screen = wnck_window_get_screen(window); workspace = wnck_screen_get_workspace(screen, number-1); if (!workspace) { g_warning(_("Workspace number %d does not exist!"), number); } g_get_current_time(×tamp); if (!devilspie2_emulate) { wnck_workspace_activate(workspace, timestamp.tv_sec); } } lua_pushboolean(lua, TRUE); return 1; }
/** * Return workspace count */ int c_get_workspace_count(lua_State *lua) { int count = 0; int top = lua_gettop(lua); if (top != 0) { luaL_error(lua, "get_workspace_count: %s", no_indata_expected_error); return 0; } WnckWindow *window = get_current_window(); if (window) { WnckScreen *screen; screen = wnck_window_get_screen(window); count = wnck_screen_get_workspace_count(screen); } lua_pushnumber(lua, count); return 1; }
/** * return the geometry of the screen to the LUA script */ int c_get_screen_geometry(lua_State *lua) { int top = lua_gettop(lua); if (top != 0) { luaL_error(lua, "get_screen_geometry: %s", no_indata_expected_error); return 0; } int width = -1, height = -1; WnckWindow *window = get_current_window(); if (window) { WnckScreen *screen; screen = wnck_window_get_screen(window); width = wnck_screen_get_width(screen); height = wnck_screen_get_height(screen); } lua_pushnumber(lua, width); lua_pushnumber(lua, height); return 2; }
static void refill_submenu_viewport (WnckActionMenu *menu) { GtkWidget *submenu; GList *children; GList *l; WnckScreen *screen; WnckWorkspace *workspace; int window_x, window_y; int viewport_x, viewport_y; int viewport_width, viewport_height; int screen_width, screen_height; int x, y; int number; submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (menu->priv->workspace_item)); /* Remove existing items */ children = gtk_container_get_children (GTK_CONTAINER (submenu)); for (l = children; l; l = l->next) gtk_container_remove (GTK_CONTAINER (submenu), l->data); g_list_free (children); screen = wnck_window_get_screen (menu->priv->window); workspace = wnck_screen_get_workspace (screen, 0); wnck_window_get_geometry (menu->priv->window, &window_x, &window_y, NULL, NULL); viewport_x = wnck_workspace_get_viewport_x (workspace); viewport_y = wnck_workspace_get_viewport_y (workspace); window_x += viewport_x; window_y += viewport_y; viewport_width = wnck_workspace_get_width (workspace); viewport_height = wnck_workspace_get_height (workspace); screen_width = wnck_screen_get_width (screen); screen_height = wnck_screen_get_height (screen); number = 1; for (y = 0; y < viewport_height; y += screen_height) { char *label; GtkWidget *item; for (x = 0; x < viewport_width; x += screen_width) { /* Keep this in sync with what is in get_workspace_name_with_accel() */ if (number == 10) label = g_strdup_printf (_("Workspace 1_0")); else label = g_strdup_printf (_("Workspace %s%d"), number < 10 ? "_" : "", number); number++; item = make_menu_item (MOVE_TO_WORKSPACE); g_object_set_data (G_OBJECT (item), "viewport_x", GINT_TO_POINTER (x)); g_object_set_data (G_OBJECT (item), "viewport_y", GINT_TO_POINTER (y)); if (window_x >= x && window_x < x + screen_width && window_y >= y && window_y < y + screen_height) gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item); set_item_text (item, label); set_item_stock (item, NULL); g_free (label); } } gtk_menu_reposition (GTK_MENU (submenu)); }
static char * get_workspace_name_with_accel (WnckWindow *window, int index) { const char *name; int number; name = wnck_workspace_get_name (wnck_screen_get_workspace (wnck_window_get_screen (window), index)); g_assert (name != NULL); /* * If the name is of the form "Workspace x" where x is an unsigned * integer, insert a '_' before the number if it is less than 10 and * return it */ number = 0; if (sscanf (name, _("Workspace %d"), &number) == 1) { /* Keep this in sync with what is in refill_submenu_viewport() */ char *new_name; /* * Above name is a pointer into the Workspace struct. Here we make * a copy copy so we can have our wicked way with it. */ if (number == 10) new_name = g_strdup_printf (_("Workspace 1_0")); else new_name = g_strdup_printf (_("Workspace %s%d"), number < 10 ? "_" : "", number); return new_name; } else { /* * Otherwise this is just a normal name. Escape any _ characters so that * the user's workspace names do not get mangled. If the number is less * than 10 we provide an accelerator. */ char *new_name; const char *source; char *dest; /* * Assume the worst case, that every character is a _. We also * provide memory for " (_#)" */ new_name = g_malloc0 (strlen (name) * 2 + 6 + 1); /* * Now iterate down the strings, adding '_' to escape as we go */ dest = new_name; source = name; while (*source != '\0') { if (*source == '_') *dest++ = '_'; *dest++ = *source++; } /* People don't start at workstation 0, but workstation 1 */ if (index < 9) { g_snprintf (dest, 6, " (_%d)", index + 1); } else if (index == 9) { g_snprintf (dest, 6, " (_0)"); } return new_name; } }
static gboolean update_menu_state (WnckActionMenu *menu) { WnckActionMenuPrivate *priv; WnckWindowActions actions; WnckScreen *screen; WnckWorkspace *workspace; gboolean viewport_mode; gboolean move_workspace_sensitive; priv = menu->priv; priv->idle_handler = 0; actions = wnck_window_get_actions (priv->window); screen = wnck_window_get_screen (priv->window); viewport_mode = wnck_screen_get_workspace_count (screen) == 1 && wnck_workspace_is_virtual (wnck_screen_get_workspace (screen, 0)); move_workspace_sensitive = viewport_mode || (actions & WNCK_WINDOW_ACTION_CHANGE_WORKSPACE) != 0; if (wnck_window_is_minimized (priv->window)) { set_item_text (priv->minimize_item, _("Unmi_nimize")); set_item_stock (priv->minimize_item, NULL); gtk_widget_set_sensitive (priv->minimize_item, (actions & WNCK_WINDOW_ACTION_UNMINIMIZE) != 0); } else { set_item_text (priv->minimize_item, _("Mi_nimize")); set_item_stock (priv->minimize_item, WNCK_STOCK_MINIMIZE); gtk_widget_set_sensitive (priv->minimize_item, (actions & WNCK_WINDOW_ACTION_MINIMIZE) != 0); } if (wnck_window_is_maximized (priv->window)) { set_item_text (priv->maximize_item, _("Unma_ximize")); set_item_stock (priv->maximize_item, NULL); gtk_widget_set_sensitive (priv->maximize_item, (actions & WNCK_WINDOW_ACTION_UNMAXIMIZE) != 0); } else { set_item_text (priv->maximize_item, _("Ma_ximize")); set_item_stock (priv->maximize_item, WNCK_STOCK_MAXIMIZE); gtk_widget_set_sensitive (priv->maximize_item, (actions & WNCK_WINDOW_ACTION_MAXIMIZE) != 0); } g_signal_handlers_block_by_func (G_OBJECT (priv->above_item), item_activated_callback, GINT_TO_POINTER (ABOVE)); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->above_item), wnck_window_is_above (priv->window)); g_signal_handlers_unblock_by_func (G_OBJECT (priv->above_item), item_activated_callback, GINT_TO_POINTER (ABOVE)); gtk_widget_set_sensitive (priv->above_item, (actions & WNCK_WINDOW_ACTION_ABOVE) != 0); g_signal_handlers_block_by_func (G_OBJECT (priv->pin_item), item_activated_callback, GINT_TO_POINTER (PIN)); g_signal_handlers_block_by_func (G_OBJECT (priv->unpin_item), item_activated_callback, GINT_TO_POINTER (UNPIN)); if ((viewport_mode && wnck_window_is_sticky (priv->window)) || (!viewport_mode && wnck_window_is_pinned (priv->window))) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->pin_item), TRUE); else gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (priv->unpin_item), TRUE); g_signal_handlers_unblock_by_func (G_OBJECT (priv->pin_item), item_activated_callback, GINT_TO_POINTER (PIN)); g_signal_handlers_unblock_by_func (G_OBJECT (priv->unpin_item), item_activated_callback, GINT_TO_POINTER (UNPIN)); gtk_widget_set_sensitive (priv->pin_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->unpin_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->close_item, (actions & WNCK_WINDOW_ACTION_CLOSE) != 0); gtk_widget_set_sensitive (priv->move_item, (actions & WNCK_WINDOW_ACTION_MOVE) != 0); gtk_widget_set_sensitive (priv->resize_item, (actions & WNCK_WINDOW_ACTION_RESIZE) != 0); gtk_widget_set_sensitive (priv->workspace_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->left_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->right_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->up_item, move_workspace_sensitive); gtk_widget_set_sensitive (priv->down_item, move_workspace_sensitive); workspace = wnck_window_get_workspace (priv->window); if (viewport_mode && !wnck_window_is_sticky (priv->window)) { int window_x, window_y; int viewport_x, viewport_y; int viewport_width, viewport_height; int screen_width, screen_height; if (!workspace) workspace = wnck_screen_get_workspace (screen, 0); wnck_window_get_geometry (priv->window, &window_x, &window_y, NULL, NULL); viewport_x = wnck_workspace_get_viewport_x (workspace); viewport_y = wnck_workspace_get_viewport_y (workspace); window_x += viewport_x; window_y += viewport_y; viewport_width = wnck_workspace_get_width (workspace); viewport_height = wnck_workspace_get_height (workspace); screen_width = wnck_screen_get_width (screen); screen_height = wnck_screen_get_height (screen); if (window_x >= screen_width) gtk_widget_show (priv->left_item); else gtk_widget_hide (priv->left_item); if (window_x < viewport_width - screen_width) gtk_widget_show (priv->right_item); else gtk_widget_hide (priv->right_item); if (window_y >= screen_height) gtk_widget_show (priv->up_item); else gtk_widget_hide (priv->up_item); if (window_y < viewport_height - screen_height) gtk_widget_show (priv->down_item); else gtk_widget_hide (priv->down_item); } else if (!viewport_mode && workspace && !wnck_window_is_pinned (priv->window)) { if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_LEFT)) gtk_widget_show (priv->left_item); else gtk_widget_hide (priv->left_item); if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_RIGHT)) gtk_widget_show (priv->right_item); else gtk_widget_hide (priv->right_item); if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_UP)) gtk_widget_show (priv->up_item); else gtk_widget_hide (priv->up_item); if (wnck_workspace_get_neighbor (workspace, WNCK_MOTION_DOWN)) gtk_widget_show (priv->down_item); else gtk_widget_hide (priv->down_item); } else { gtk_widget_hide (priv->left_item); gtk_widget_hide (priv->right_item); gtk_widget_hide (priv->up_item); gtk_widget_hide (priv->down_item); } if (viewport_mode) { int viewport_width, viewport_height; int screen_width, screen_height; viewport_width = wnck_workspace_get_width (workspace); viewport_height = wnck_workspace_get_height (workspace); screen_width = wnck_screen_get_width (screen); screen_height = wnck_screen_get_height (screen); gtk_widget_show (priv->workspace_separator); gtk_widget_show (priv->pin_item); gtk_widget_show (priv->unpin_item); if (viewport_width >= 2 * screen_width || viewport_height >= 2 * screen_height) { gtk_widget_show (priv->workspace_item); refill_submenu_viewport (menu); } else { gtk_widget_hide (priv->workspace_item); gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item)))); } } else if (wnck_screen_get_workspace_count (screen) > 1) { gtk_widget_show (priv->workspace_separator); gtk_widget_show (priv->pin_item); gtk_widget_show (priv->unpin_item); gtk_widget_show (priv->workspace_item); refill_submenu_workspace (menu); } else { gtk_widget_hide (priv->workspace_separator); gtk_widget_hide (priv->pin_item); gtk_widget_hide (priv->unpin_item); gtk_widget_hide (priv->workspace_item); gtk_menu_popdown (GTK_MENU (gtk_menu_item_get_submenu (GTK_MENU_ITEM (priv->workspace_item)))); } gtk_menu_reposition (GTK_MENU (menu)); return FALSE; }
static void item_activated_callback (GtkWidget *menu_item, gpointer data) { WnckActionMenu *menu; WnckWindow *window; WindowAction action = GPOINTER_TO_INT (data); WnckScreen *screen; gboolean viewport_mode; menu = get_action_menu (menu_item); if (menu == NULL) return; window = menu->priv->window; screen = wnck_window_get_screen (window); viewport_mode = wnck_screen_get_workspace_count (screen) == 1 && wnck_workspace_is_virtual (wnck_screen_get_workspace (screen, 0)); switch (action) { case CLOSE: /* In an activate callback, so gtk_get_current_event_time() suffices */ wnck_window_close (window, gtk_get_current_event_time ()); break; case MINIMIZE: if (wnck_window_is_minimized (window)) wnck_window_unminimize (window, gtk_get_current_event_time ()); else wnck_window_minimize (window); break; case MAXIMIZE: if (wnck_window_is_maximized (window)) wnck_window_unmaximize (window); else wnck_window_maximize (window); break; case ABOVE: if (wnck_window_is_above (window)) wnck_window_unmake_above (window); else wnck_window_make_above (window); break; case MOVE: wnck_window_keyboard_move (window); break; case RESIZE: wnck_window_keyboard_size (window); break; case PIN: if (!viewport_mode) wnck_window_pin (window); else wnck_window_stick (window); break; case UNPIN: if (!viewport_mode) wnck_window_unpin (window); else wnck_window_unstick (window); break; case LEFT: if (!viewport_mode) { WnckWorkspace *workspace; workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window), WNCK_MOTION_LEFT); wnck_window_move_to_workspace (window, workspace); } else { int width, xw, yw, ww, hw; width = wnck_screen_get_width (screen); wnck_window_get_geometry (window, &xw, &yw, &ww, &hw); wnck_window_unstick (window); wnck_window_set_geometry (window, 0, WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y, xw - width, yw, ww, hw); } break; case RIGHT: if (!viewport_mode) { WnckWorkspace *workspace; workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window), WNCK_MOTION_RIGHT); wnck_window_move_to_workspace (window, workspace); } else { int width, xw, yw, ww, hw; width = wnck_screen_get_width (screen); wnck_window_get_geometry (window, &xw, &yw, &ww, &hw); wnck_window_unstick (window); wnck_window_set_geometry (window, 0, WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y, xw + width, yw, ww, hw); } break; case UP: if (!viewport_mode) { WnckWorkspace *workspace; workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window), WNCK_MOTION_UP); wnck_window_move_to_workspace (window, workspace); } else { int height, xw, yw, ww, hw; height = wnck_screen_get_height (screen); wnck_window_get_geometry (window, &xw, &yw, &ww, &hw); wnck_window_unstick (window); wnck_window_set_geometry (window, 0, WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y, xw, yw - height, ww, hw); } break; case DOWN: if (!viewport_mode) { WnckWorkspace *workspace; workspace = wnck_workspace_get_neighbor (wnck_window_get_workspace (window), WNCK_MOTION_DOWN); wnck_window_move_to_workspace (window, workspace); } else { int height, xw, yw, ww, hw; height = wnck_screen_get_height (screen); wnck_window_get_geometry (window, &xw, &yw, &ww, &hw); wnck_window_unstick (window); wnck_window_set_geometry (window, 0, WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y, xw, yw + height, ww, hw); } break; case MOVE_TO_WORKSPACE: if (!viewport_mode) { int workspace_index; WnckWorkspace *workspace; workspace_index = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (menu_item), "workspace")); workspace = wnck_screen_get_workspace (screen, workspace_index); wnck_window_move_to_workspace (window, workspace); } else { WnckWorkspace *workspace; int new_viewport_x, new_viewport_y; int width, height; int xw, yw, ww, hw; int viewport_x, viewport_y; new_viewport_x = GPOINTER_TO_INT ( g_object_get_data (G_OBJECT (menu_item), "viewport_x")); new_viewport_y = GPOINTER_TO_INT ( g_object_get_data (G_OBJECT (menu_item), "viewport_y")); workspace = wnck_screen_get_workspace (screen, 0); width = wnck_screen_get_width (screen); height = wnck_screen_get_height (screen); wnck_window_get_geometry (window, &xw, &yw, &ww, &hw); viewport_x = wnck_workspace_get_viewport_x (workspace); viewport_y = wnck_workspace_get_viewport_y (workspace); wnck_window_unstick (window); wnck_window_set_geometry (window, 0, WNCK_WINDOW_CHANGE_X | WNCK_WINDOW_CHANGE_Y, xw + new_viewport_x - viewport_x, yw + new_viewport_y - viewport_y, ww, hw); } break; default: g_assert_not_reached (); } }
static GObject * wnck_action_menu_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_properties) { GObject *obj; WnckActionMenu *menu; WnckActionMenuPrivate *priv; GtkWidget *submenu; GtkWidget *separator; GSList *pin_group; WnckScreen *screen; obj = G_OBJECT_CLASS (wnck_action_menu_parent_class)->constructor (type, n_construct_properties, construct_properties); menu = WNCK_ACTION_MENU (obj); priv = menu->priv; if (priv->window == NULL) { g_warning ("No window specified during creation of the action menu"); return obj; } g_object_weak_ref (G_OBJECT (priv->window), window_weak_notify, menu); g_object_weak_ref (G_OBJECT (menu), object_weak_notify, priv->window); priv->minimize_item = make_menu_item (MINIMIZE); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->minimize_item); priv->maximize_item = make_menu_item (MAXIMIZE); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->maximize_item); priv->move_item = make_menu_item (MOVE); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->move_item); set_item_text (priv->move_item, _("_Move")); set_item_stock (priv->move_item, NULL); priv->resize_item = make_menu_item (RESIZE); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->resize_item); set_item_text (priv->resize_item, _("_Resize")); set_item_stock (priv->move_item, NULL); priv->workspace_separator = separator = gtk_separator_menu_item_new (); gtk_widget_show (separator); gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator); priv->above_item = make_check_menu_item (ABOVE, _("Always On _Top")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->above_item); pin_group = NULL; priv->pin_item = make_radio_menu_item (PIN, &pin_group, _("_Always on Visible Workspace")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->pin_item); priv->unpin_item = make_radio_menu_item (UNPIN, &pin_group, _("_Only on This Workspace")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->unpin_item); priv->left_item = make_menu_item (LEFT); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->left_item); set_item_text (priv->left_item, _("Move to Workspace _Left")); set_item_stock (priv->left_item, NULL); priv->right_item = make_menu_item (RIGHT); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->right_item); set_item_text (priv->right_item, _("Move to Workspace R_ight")); set_item_stock (priv->right_item, NULL); priv->up_item = make_menu_item (UP); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->up_item); set_item_text (priv->up_item, _("Move to Workspace _Up")); set_item_stock (priv->up_item, NULL); priv->down_item = make_menu_item (DOWN); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->down_item); set_item_text (priv->down_item, _("Move to Workspace _Down")); set_item_stock (priv->down_item, NULL); priv->workspace_item = gtk_menu_item_new_with_mnemonic (_("Move to Another _Workspace")); gtk_widget_show (priv->workspace_item); submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (priv->workspace_item), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->workspace_item); separator = gtk_separator_menu_item_new (); gtk_widget_show (separator); gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator); priv->close_item = make_menu_item (CLOSE); gtk_menu_shell_append (GTK_MENU_SHELL (menu), priv->close_item); set_item_text (priv->close_item, _("_Close")); set_item_stock (priv->close_item, WNCK_STOCK_DELETE); g_signal_connect_object (G_OBJECT (priv->window), "state_changed", G_CALLBACK (state_changed_callback), G_OBJECT (menu), 0); g_signal_connect_object (G_OBJECT (priv->window), "actions_changed", G_CALLBACK (actions_changed_callback), G_OBJECT (menu), 0); g_signal_connect_object (G_OBJECT (priv->window), "workspace_changed", G_CALLBACK (workspace_changed_callback), G_OBJECT (menu), 0); screen = wnck_window_get_screen (priv->window); g_signal_connect_object (G_OBJECT (screen), "workspace_created", G_CALLBACK (screen_workspace_callback), G_OBJECT (menu), 0); g_signal_connect_object (G_OBJECT (screen), "workspace_destroyed", G_CALLBACK (screen_workspace_callback), G_OBJECT (menu), 0); g_signal_connect_object (G_OBJECT (screen), "viewports_changed", G_CALLBACK (viewports_changed_callback), G_OBJECT (menu), 0); update_menu_state (menu); return obj; }
int c_set_viewport(lua_State *lua) { int top = lua_gettop(lua); WnckScreen *screen; int x,y,width,height, viewport_start; if (top != 1) { luaL_error(lua, "set_viewport: %s", one_indata_expected_error); return 0; } int type = lua_type(lua, 1); if (type != LUA_TNUMBER) { luaL_error(lua, "set_viewport: %s", number_expected_as_indata_error); return 0; } int num = lua_tonumber(lua,1); if (num <= 0) { g_error("set_viewport: %s", integer_greater_than_zero_expected_error); lua_pushboolean(lua, FALSE); return 1; } WnckWindow *window = get_current_window(); if (!window) { lua_pushboolean(lua, FALSE); return 1; } screen = wnck_window_get_screen(window); wnck_window_get_geometry(window, &x, &y, &width, &height); gulong xid = wnck_window_get_xid(window); viewport_start = devilspie2_get_viewport_start(xid); if (viewport_start < 0) { g_printerr("set_viewport: %s", could_not_find_current_viewport_error); lua_pushboolean(lua, FALSE); return 1; } x=((num-1) * wnck_screen_get_width(screen)) - viewport_start + x; devilspie2_error_trap_push(); XMoveResizeWindow(gdk_x11_get_default_xdisplay(), wnck_window_get_xid(window), x, y, width, height); if (devilspie2_error_trap_pop()) { g_printerr("set_viewport: %s", setting_viewport_failed_error); lua_pushboolean(lua, FALSE); return 1; } lua_pushboolean(lua, TRUE); return 1; }
GtkWidget * task_item_new (WnckWindow *window) { GtkWidget *item = NULL; TaskItem *task; TaskItemPrivate *priv; WnckScreen *screen; g_return_val_if_fail (WNCK_IS_WINDOW (window), item); item = g_object_new (TASK_TYPE_ITEM, "has-tooltip", TRUE, "visible-window", FALSE, "above-child", TRUE, NULL); gtk_widget_add_events (item, GDK_ALL_EVENTS_MASK); gtk_container_set_border_width (GTK_CONTAINER (item), 0); task = TASK_ITEM (item); priv = task->priv; priv->window = window; screen = wnck_window_get_screen (window); priv->screen = screen; gtk_drag_dest_set (item, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP, drop_types, n_drop_types, GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets (item); gtk_drag_dest_add_text_targets (item); g_signal_connect (item, "drag-motion", G_CALLBACK (on_drag_motion), NULL); g_signal_connect (item, "drag-leave", G_CALLBACK (on_drag_leave), NULL); g_signal_connect (screen, "viewports-changed", G_CALLBACK (on_screen_active_viewport_changed), item); g_signal_connect (screen, "active-window-changed", G_CALLBACK (on_screen_active_window_changed), item); g_signal_connect (screen, "active-workspace-changed", G_CALLBACK (on_screen_active_workspace_changed), item); g_signal_connect (screen, "window-closed", G_CALLBACK (on_screen_window_closed), item); g_signal_connect (window, "workspace-changed", G_CALLBACK (on_window_workspace_changed), item); g_signal_connect (window, "state-changed", G_CALLBACK (on_window_state_changed), item); g_signal_connect (window, "icon-changed", G_CALLBACK (on_window_icon_changed), item); g_signal_connect (item, "button-release-event", G_CALLBACK (on_task_item_button_released), item); g_signal_connect (item, "button-press-event", G_CALLBACK (on_button_pressed), item); g_signal_connect (item, "size-allocate", G_CALLBACK (on_size_allocate), item); g_signal_connect (item, "query-tooltip", G_CALLBACK (on_query_tooltip), item); g_signal_connect (item, "enter-notify-event", G_CALLBACK (on_enter_notify), item); g_signal_connect (item, "leave-notify-event", G_CALLBACK (on_leave_notify), item); g_signal_connect (item, "drag-motion", G_CALLBACK (on_drag_motion), item); g_signal_connect (item, "drag-leave", G_CALLBACK (on_drag_leave), item); task_item_set_visibility (task); task_item_setup_atk (task); return item; }
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); }