void
min_button_event (WnckWindow *win,
decor_event *gtkwd_event,
decor_event_type gtkwd_type)
{
decor_t *d = g_object_get_data (G_OBJECT (win), "decor");
guint state = d->button_states[BUTTON_MIN];
if (action_menu_mapped && gtkwd_type == GButtonPress)
{
gtk_object_destroy (GTK_OBJECT (action_menu));
}
common_button_event (win, gtkwd_event, gtkwd_type,
BUTTON_MIN, 1, _("Minimize Window"));
switch (gtkwd_type) {
case GButtonRelease:
if (gtkwd_event->button == 1)
if (state == BUTTON_EVENT_ACTION_STATE)
wnck_window_minimize (win);
break;
default:
break;
}
}
void
handle_title_button_event (WnckWindow *win,
int action,
decor_event *gtkwd_event)
{
switch (action) {
case CLICK_ACTION_SHADE:
if (wnck_window_is_shaded (win))
wnck_window_unshade (win);
else
wnck_window_shade (win);
break;
case CLICK_ACTION_MAXIMIZE:
if (wnck_window_is_maximized (win))
wnck_window_unmaximize (win);
else
wnck_window_maximize (win);
break;
case CLICK_ACTION_MINIMIZE:
if (!wnck_window_is_minimized (win))
wnck_window_minimize (win);
break;
case CLICK_ACTION_RAISE:
restack_window (win, Above);
break;
case CLICK_ACTION_LOWER:
restack_window (win, Below);
break;
case CLICK_ACTION_MENU:
action_menu_map (win, gtkwd_event->button, gtkwd_event->time);
break;
}
}
/**
* Minimizes the window
*/
int c_minimize_window(lua_State *lua)
{
int top = lua_gettop(lua);
if (top != 0) {
luaL_error(lua,"minimize_window: %s",no_indata_expected_error);
return 0;
}
if (!devilspie2_emulate) {
WnckWindow *window = get_current_window();
if (window) {
wnck_window_minimize(window);
}
}
return 0;
}
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 gboolean
on_task_item_button_released (GtkWidget *widget,
GdkEventButton *event,
TaskItem *item)
{
WnckWindow *window;
WnckScreen *screen;
WnckWorkspace *workspace;
TaskItemPrivate *priv;
g_return_val_if_fail (TASK_IS_ITEM (item), TRUE);
priv = item->priv;
window = priv->window;
g_return_val_if_fail (WNCK_IS_WINDOW (window), TRUE);
screen = priv->screen;
workspace = wnck_window_get_workspace (window);
if (event->button == 1)
{
if (WNCK_IS_WORKSPACE (workspace) && workspace != wnck_screen_get_active_workspace (screen))
{
wnck_workspace_activate (workspace, GDK_CURRENT_TIME);
}
if (wnck_window_is_active (window))
{
wnck_window_minimize (window);
}
else
{
wnck_window_activate (window, GDK_CURRENT_TIME);
}
}
return TRUE;
}
void wibuti_watcher_minimize(WibutiWatcher *self) {
if (WNCK_IS_WINDOW(self->tracked)) {
wnck_window_minimize(self->tracked);
}
}
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 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);
}
