X-Git-Url: https://git.dogcows.com/gitweb?a=blobdiff_plain;f=openbox%2Factions.c;h=ac849a9741b794070537ef1094e35787985628cd;hb=677fb4264412007f6d830e5899c9b1fa41b4c95b;hp=00563a700055aa7b2ebeb7064da415895dc4a30f;hpb=780d1b0961e2eed5fea4645b4398fafb4adad73a;p=chaz%2Fopenbox

diff --git a/openbox/actions.c b/openbox/actions.c
index 00563a70..ac849a97 100644
--- a/openbox/actions.c
+++ b/openbox/actions.c
@@ -1,6 +1,6 @@
 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
 
-   actions.h for the Openbox window manager
+   actions.c for the Openbox window manager
    Copyright (c) 2007        Dana Jansens
 
    This program is free software; you can redistribute it and/or modify
@@ -20,11 +20,20 @@
 #include "gettext.h"
 #include "grab.h"
 #include "screen.h"
+#include "event.h"
+#include "config.h"
+#include "client.h"
+#include "focus.h"
+#include "openbox.h"
+#include "debug.h"
+
+#include "actions/all.h"
 
 static void     actions_definition_ref(ObActionsDefinition *def);
 static void     actions_definition_unref(ObActionsDefinition *def);
 static gboolean actions_interactive_begin_act(ObActionsAct *act, guint state);
 static void     actions_interactive_end_act();
+static ObActionsAct* actions_build_act_from_string(const gchar *name);
 
 static ObActionsAct *interactive_act = NULL;
 static guint         interactive_initial_state = 0;
@@ -33,28 +42,36 @@ struct _ObActionsDefinition {
     guint ref;
 
     gchar *name;
-    ObActionsType type;
 
-    ObActionsDataSetupFunc setup;
+    gboolean canbeinteractive;
+    union {
+        ObActionsIDataSetupFunc i;
+        ObActionsDataSetupFunc n;
+    } setup;
     ObActionsDataFreeFunc free;
     ObActionsRunFunc run;
-    ObActionsInteractiveInputFunc i_input;
-    ObActionsInteractiveCancelFunc i_cancel;
+    ObActionsShutdownFunc shutdown;
+    gboolean modifies_focused_window;
 };
 
 struct _ObActionsAct {
     guint ref;
 
     ObActionsDefinition *def;
+    ObActionsIPreFunc i_pre;
+    ObActionsIInputFunc i_input;
+    ObActionsICancelFunc i_cancel;
+    ObActionsIPostFunc i_post;
     gpointer options;
 };
 
 static GSList *registered = NULL;
 
-
 void actions_startup(gboolean reconfig)
 {
     if (reconfig) return;
+
+    action_all_startup();
 }
 
 void actions_shutdown(gboolean reconfig)
@@ -65,40 +82,96 @@ void actions_shutdown(gboolean reconfig)
 
     /* free all the registered actions */
     while (registered) {
-        actions_definition_unref(registered->data);
+        ObActionsDefinition *d = registered->data;
+        if (d->shutdown) d->shutdown();
+        actions_definition_unref(d);
         registered = g_slist_delete_link(registered, registered);
     }
 }
 
-gboolean actions_register(const gchar *name,
-                          ObActionsType type,
-                          ObActionsDataSetupFunc setup,
-                          ObActionsDataFreeFunc free,
-                          ObActionsRunFunc run,
-                          ObActionsInteractiveInputFunc i_input,
-                          ObActionsInteractiveCancelFunc i_cancel)
+ObActionsDefinition* do_register(const gchar *name,
+                                 ObActionsDataFreeFunc free,
+                                 ObActionsRunFunc run)
 {
     GSList *it;
     ObActionsDefinition *def;
 
+    g_assert(run != NULL);
+
     for (it = registered; it; it = g_slist_next(it)) {
         def = it->data;
         if (!g_ascii_strcasecmp(name, def->name)) /* already registered */
-            return FALSE;
+            return NULL;
     }
 
-    g_assert((i_input == NULL) == (i_cancel == NULL));
-
-    def = g_new(ObActionsDefinition, 1);
+    def = g_slice_new0(ObActionsDefinition);
     def->ref = 1;
     def->name = g_strdup(name);
-    def->type = type;
-    def->setup = setup;
     def->free = free;
     def->run = run;
-    def->i_input = i_input;
-    def->i_cancel = i_cancel;
-    return TRUE;
+    def->shutdown = NULL;
+    def->modifies_focused_window = TRUE;
+
+    registered = g_slist_prepend(registered, def);
+    return def;
+}
+
+gboolean actions_register_i(const gchar *name,
+                            ObActionsIDataSetupFunc setup,
+                            ObActionsDataFreeFunc free,
+                            ObActionsRunFunc run)
+{
+    ObActionsDefinition *def = do_register(name, free, run);
+    if (def) {
+        def->canbeinteractive = TRUE;
+        def->setup.i = setup;
+    }
+    return def != NULL;
+}
+
+gboolean actions_register(const gchar *name,
+                          ObActionsDataSetupFunc setup,
+                          ObActionsDataFreeFunc free,
+                          ObActionsRunFunc run)
+{
+    ObActionsDefinition *def = do_register(name, free, run);
+    if (def) {
+        def->canbeinteractive = FALSE;
+        def->setup.n = setup;
+    }
+    return def != NULL;
+}
+
+gboolean actions_set_shutdown(const gchar *name,
+                              ObActionsShutdownFunc shutdown)
+{
+    GSList *it;
+    ObActionsDefinition *def;
+
+    for (it = registered; it; it = g_slist_next(it)) {
+        def = it->data;
+        if (!g_ascii_strcasecmp(name, def->name)) {
+            def->shutdown = shutdown;
+            return TRUE;
+        }
+    }
+    return FALSE;
+}
+
+gboolean actions_set_modifies_focused_window(const gchar *name,
+                                             gboolean modifies)
+{
+    GSList *it;
+    ObActionsDefinition *def;
+
+    for (it = registered; it; it = g_slist_next(it)) {
+        def = it->data;
+        if (!g_ascii_strcasecmp(name, def->name)) {
+            def->modifies_focused_window = modifies;
+            return TRUE;
+        }
+    }
+    return FALSE;
 }
 
 static void actions_definition_ref(ObActionsDefinition *def)
@@ -110,14 +183,14 @@ static void actions_definition_unref(ObActionsDefinition *def)
 {
     if (def && --def->ref == 0) {
         g_free(def->name);
-        g_free(def);
+        g_slice_free(ObActionsDefinition, def);
     }
 }
 
-ObActionsAct* actions_parse_string(const gchar *name)
+static ObActionsAct* actions_build_act_from_string(const gchar *name)
 {
     GSList *it;
-    ObActionsDefinition *def;
+    ObActionsDefinition *def = NULL;
     ObActionsAct *act = NULL;
 
     /* find the requested action */
@@ -130,30 +203,66 @@ ObActionsAct* actions_parse_string(const gchar *name)
 
     /* if we found the action */
     if (def) {
-        act = g_new(ObActionsAct, 1);
+        act = g_slice_new(ObActionsAct);
         act->ref = 1;
         act->def = def;
         actions_definition_ref(act->def);
+        act->i_pre = NULL;
+        act->i_input = NULL;
+        act->i_cancel = NULL;
+        act->i_post = NULL;
         act->options = NULL;
     } else
-        g_message(_("Invalid action '%s' requested. No such action exists."),
+        g_message(_("Invalid action \"%s\" requested. No such action exists."),
                   name);
 
     return act;
 }
 
-ObActionsAct* actions_parse(ObParseInst *i,
-                            xmlDocPtr doc,
-                            xmlNodePtr node)
+ObActionsAct* actions_parse_string(const gchar *name)
+{
+    ObActionsAct *act = NULL;
+
+    if ((act = actions_build_act_from_string(name))) {
+        if (act->def->canbeinteractive) {
+            if (act->def->setup.i)
+                act->options = act->def->setup.i(NULL,
+                                                 &act->i_pre,
+                                                 &act->i_input,
+                                                 &act->i_cancel,
+                                                 &act->i_post);
+        }
+        else {
+            if (act->def->setup.n)
+                act->options = act->def->setup.n(NULL);
+        }
+    }
+                
+
+    return act;
+}
+
+ObActionsAct* actions_parse(xmlNodePtr node)
 {
     gchar *name;
     ObActionsAct *act = NULL;
 
-    if (parse_attr_string("name", node, &name)) {
-        if ((act = actions_parse_string(name)))
+    if (obt_xml_attr_string(node, "name", &name)) {
+        if ((act = actions_build_act_from_string(name))) {
             /* there is more stuff to parse here */
-            act->options = act->def->setup(i, doc, node->children);
-
+            if (act->def->canbeinteractive) {
+                if (act->def->setup.i)
+                    act->options = act->def->setup.i(node->children,
+                                                     &act->i_pre,
+                                                     &act->i_input,
+                                                     &act->i_cancel,
+                                                     &act->i_post);
+            }
+            else {
+                if (act->def->setup.n)
+                    act->options = act->def->setup.n(node->children);
+            }
+        }
         g_free(name);
     }
 
@@ -162,7 +271,7 @@ ObActionsAct* actions_parse(ObParseInst *i,
 
 gboolean actions_act_is_interactive(ObActionsAct *act)
 {
-    return act->def->i_cancel != NULL;
+    return act->i_input != NULL;
 }
 
 void actions_act_ref(ObActionsAct *act)
@@ -174,37 +283,43 @@ void actions_act_unref(ObActionsAct *act)
 {
     if (act && --act->ref == 0) {
         /* free the action specific options */
-        act->def->free(act->options);
+        if (act->def->free)
+            act->def->free(act->options);
         /* unref the definition */
         actions_definition_unref(act->def);
-        g_free(act);
+        g_slice_free(ObActionsAct, act);
     }
 }
 
 static void actions_setup_data(ObActionsData *data,
                                ObUserAction uact,
-                               Time time,
                                guint state,
                                gint x,
-                               gint y)
+                               gint y,
+                               gint button,
+                               ObFrameContext con,
+                               struct _ObClient *client)
 {
-    data->any.uact = uact;
-    data->any.time = time;
-    data->any.state = state;
-    data->any.x = x;
-    data->any.y = y;
+    data->uact = uact;
+    data->state = state;
+    data->x = x;
+    data->y = y;
+    data->button = button;
+    data->context = con;
+    data->client = client;
 }
 
 void actions_run_acts(GSList *acts,
                       ObUserAction uact,
-                      Time time,
                       guint state,
                       gint x,
                       gint y,
+                      gint button,
                       ObFrameContext con,
                       struct _ObClient *client)
 {
     GSList *it;
+    gboolean update_user_time;
 
     /* Don't allow saving the initial state when running things from the
        menu */
@@ -214,77 +329,101 @@ void actions_run_acts(GSList *acts,
     if (x < 0 && y < 0)
         screen_pointer_pos(&x, &y);
 
+    update_user_time = FALSE;
     for (it = acts; it; it = g_slist_next(it)) {
         ObActionsData data;
         ObActionsAct *act = it->data;
         gboolean ok = TRUE;
 
-        data.type = act->def->type;
-        actions_setup_data(&data, uact, time, state, x, y);
-        switch (data.type) {
-        case OB_ACTION_TYPE_GLOBAL:
-            break;
-        case OB_ACTION_TYPE_CLIENT:
-            data.client.context = con;
-            data.client.c = client;
-            break;
-        default:
-            g_assert_not_reached();
-        }
-
-        if (actions_act_is_interactive(act) &&
-            (!interactive_act || interactive_act->def != act->def))
-        {
-            ok = actions_interactive_begin_act(act, state);
+        actions_setup_data(&data, uact, state, x, y, button, con, client);
+
+        /* if they have the same run function, then we'll assume they are
+           cooperating and not cancel eachother out */
+        if (!interactive_act || interactive_act->def->run != act->def->run) {
+            if (actions_act_is_interactive(act)) {
+                /* cancel the old one */
+                if (interactive_act)
+                    actions_interactive_cancel_act();
+                if (act->i_pre)
+                    if (!act->i_pre(state, act->options))
+                        act->i_input = NULL; /* remove the interactivity */
+            }
+            /* check again cuz it might have been cancelled */
+            if (actions_act_is_interactive(act))
+                ok = actions_interactive_begin_act(act, state);
         }
 
         /* fire the action's run function with this data */
         if (ok) {
-            if (!act->def->run(&data, act->options))
-                actions_interactive_end_act();
-            else
-                break; /* no actions are run after the interactive one */
+            if (!act->def->run(&data, act->options)) {
+                if (actions_act_is_interactive(act))
+                    actions_interactive_end_act();
+                if (client && client == focus_client &&
+                    act->def->modifies_focused_window)
+                {
+                    update_user_time = TRUE;
+                }
+            } else {
+                /* make sure its interactive if it returned TRUE */
+                g_assert(act->i_input);
+
+                /* no actions are run after the interactive one */
+                break;
+            }
         }
     }
+    if (update_user_time)
+        event_update_user_time();
 }
 
-gboolean actions_interactive_act_running()
+gboolean actions_interactive_act_running(void)
 {
     return interactive_act != NULL;
 }
 
-void actions_interactive_cancel_act()
+void actions_interactive_cancel_act(void)
 {
     if (interactive_act) {
-        interactive_act->def->i_cancel(interactive_act->options);
+        if (interactive_act->i_cancel)
+            interactive_act->i_cancel(interactive_act->options);
         actions_interactive_end_act();
     }
 }
 
 static gboolean actions_interactive_begin_act(ObActionsAct *act, guint state)
 {
-    /* cancel the old one */
-    if (interactive_act)
-        actions_interactive_cancel_act();
-
     if (grab_keyboard()) {
         interactive_act = act;
         actions_act_ref(interactive_act);
 
         interactive_initial_state = state;
+
+        /* if using focus_delay, stop the timer now so that focus doesn't go
+           moving on us, which would kill the action */
+        event_halt_focus_delay();
+
         return TRUE;
     }
     else
         return FALSE;
 }
 
-static void actions_interactive_end_act()
+static void actions_interactive_end_act(void)
 {
     if (interactive_act) {
-        ungrab_keyboard();
+        ObActionsAct *ia = interactive_act;
 
-        actions_act_unref(interactive_act);
+        /* set this to NULL first so the i_post() function can't cause this to
+           get called again (if it decides it wants to cancel any ongoing
+           interactive action). */
         interactive_act = NULL;
+
+        ungrab_keyboard();
+
+        if (ia->i_post)
+            ia->i_post(ia->options);
+
+        actions_act_unref(ia);
     }
 }
 
@@ -292,8 +431,9 @@ gboolean actions_interactive_input_event(XEvent *e)
 {
     gboolean used = FALSE;
     if (interactive_act) {
-        if (!interactive_act->def->i_input(interactive_initial_state, e,
-                                           interactive_act->options, &used))
+        if (!interactive_act->i_input(interactive_initial_state, e,
+                                      grab_input_context(),
+                                      interactive_act->options, &used))
         {
             used = TRUE; /* if it cancelled the action then it has to of
                             been used */
@@ -302,3 +442,43 @@ gboolean actions_interactive_input_event(XEvent *e)
     }
     return used;
 }
+
+void actions_client_move(ObActionsData *data, gboolean start)
+{
+    static gulong ignore_start = 0;
+    if (start)
+        ignore_start = event_start_ignore_all_enters();
+    else if (config_focus_follow &&
+             data->context != OB_FRAME_CONTEXT_CLIENT)
+    {
+        if (data->uact == OB_USER_ACTION_MOUSE_PRESS) {
+            struct _ObClient *c;
+
+            /* usually this is sorta redundant, but with a press action
+               that moves windows our from under the cursor, the enter
+               event will come as a GrabNotify which is ignored, so this
+               makes a fake enter event
+
+               don't do this if there is a grab on the pointer.  enter events
+               are ignored during a grab, so don't force fake ones when they
+               should be ignored
+            */
+            if (!grab_on_pointer()) {
+                if ((c = client_under_pointer()) && c != data->client) {
+                    ob_debug_type(OB_DEBUG_FOCUS,
+                                  "Generating fake enter because we did a "
+                                  "mouse-event action");
+                    event_enter_client(c);
+                }
+                else if (!c && c != data->client) {
+                    ob_debug_type(OB_DEBUG_FOCUS,
+                                  "Generating fake leave because we did a "
+                                  "mouse-event action");
+                    event_leave_client(data->client);
+                }
+            }
+        }
+        else if (!data->button && !config_focus_under_mouse)
+            event_end_ignore_all_enters(ignore_start);
+    }
+}