Conversion of command bindings to text.

Clearing all bindings and binding classes.
Deleting a specific binding based on identifier.
Inverse flag must affect relative device offsets as well.
Fixed a crash-inducing increment typo in a state condition check loop. 

Next up, the default bindings.

doomsday/engine/portable/include/b_class.h

@@ -48,18 +48,21 @@ typedef struct bclass_s {
 } bclass_t;
 
 void            B_UpdateDeviceStateAssociations(void);
-bclass_t       *B_NewClass(const char* name);
+bclass_t*       B_NewClass(const char* name);
 void            B_DestroyAllClasses(void);
 void            B_ActivateClass(bclass_t* bc, boolean doActivate);
-bclass_t       *B_ClassByName(const char* name);
+bclass_t*       B_ClassByPos(int pos);
+bclass_t*       B_ClassByName(const char* name);
 int             B_ClassCount(void);
 int             B_GetClassPos(bclass_t* bc);
 void            B_ReorderClass(bclass_t* bc, int pos);
+void            B_ClearClass(bclass_t* bc);
 void            B_DestroyClass(bclass_t* bc);
 controlbinding_t* B_GetControlBinding(bclass_t* bc, int control);
 void            B_DestroyControlBinding(controlbinding_t* conBin);
 void            B_InitControlBindingList(controlbinding_t* listRoot);
 void            B_DestroyControlBindingList(controlbinding_t* listRoot);
+boolean         B_DeleteBinding(bclass_t* bc, int bid);
 boolean         B_TryEvent(ddevent_t* event);
 void            B_PrintClasses(void);
 void            B_PrintAllBindings(void);

doomsday/engine/portable/include/b_command.h

@@ -35,6 +35,7 @@ typedef struct evbinding_s {
     struct evbinding_s* next;       // Next in list of bindings.
     int         bid;                // Binding identifier.
     char*       command;            // Command to execute.
+
     uint        device;             // Which device? 
     ddeventtype_t type;             // Type of event.
     int         id;                 // Identifier.

doomsday/engine/portable/include/b_main.h

@@ -31,6 +31,7 @@
 void        B_Register(void);
 void        B_Init(void);
 void        B_Shutdown(void);
+boolean     B_Delete(int bid);
 boolean     B_Responder(ddevent_t *ev);
 void        B_WriteToFile(FILE *file);
 

doomsday/engine/portable/include/b_util.h

@@ -71,6 +71,7 @@ boolean     B_CheckAxisPos(ebstate_t test, float testPos, float pos);
 boolean     B_CheckCondition(statecondition_t* cond);
 void        B_AppendDeviceDescToString(uint device, ddeventtype_t type, int id, ddstring_t* str);
 void        B_AppendToggleStateToString(ebstate_t state, ddstring_t* str);
+void        B_AppendAxisPositionToString(ebstate_t state, float pos, ddstring_t* str);
 void        B_AppendAnglePositionToString(float pos, ddstring_t* str);
 void        B_AppendConditionToString(const statecondition_t* cond, ddstring_t* str);
 

doomsday/engine/portable/src/b_class.c

@@ -204,9 +204,14 @@ void B_DestroyClass(bclass_t* bc)
 {
     B_RemoveClass(bc);
     free(bc->name);
+    B_ClearClass(bc);
+    M_Free(bc);
+}
+
+void B_ClearClass(bclass_t* bc)
+{
     B_DestroyCommandBindingList(&bc->commandBinds);
     B_DestroyControlBindingList(&bc->controlBinds);
-    M_Free(bc);
 }
 
 void B_ActivateClass(bclass_t* bc, boolean doActivate)
@@ -227,6 +232,13 @@ bclass_t* B_ClassByName(const char* name)
     return NULL;
 }
 
+bclass_t* B_ClassByPos(int pos)
+{
+    if(pos < 0 || pos >= bindClassCount)
+        return NULL;
+    return bindClasses[pos];
+}
+
 int B_ClassCount(void)
 {
     return bindClassCount;
@@ -319,6 +331,52 @@ void B_DestroyControlBindingList(controlbinding_t* listRoot)
     }
 }
 
+/**
+ * @return  @c true, if the binding was found and deleted.
+ */
+boolean B_DeleteBinding(bclass_t* bc, int bid)
+{
+    evbinding_t* eb = 0;
+    controlbinding_t* conBin = 0;
+    dbinding_t* db = 0;
+    int         i;
+
+    // Check if it one of the command bindings.
+    for(eb = bc->commandBinds.next; eb != &bc->commandBinds; eb = eb->next)
+    {
+        if(eb->bid == bid)
+        {
+            B_DestroyCommandBinding(eb);
+            return true;
+        }
+    }
+
+    // How about one fo the control bindings?
+    for(conBin = bc->controlBinds.next; conBin != &bc->controlBinds; conBin = conBin->next)
+    {
+        if(conBin->bid == bid)
+        {
+            B_DestroyControlBinding(conBin);
+            return true;
+        }
+
+        // It may also be a device binding.
+        for(i = 0; i < DDMAXPLAYERS; ++i)
+        {
+            for(db = conBin->deviceBinds[i].next; db != &conBin->deviceBinds[i]; db = db->next)
+            {
+                if(db->bid == bid)
+                {
+                    B_DestroyDeviceBinding(db);
+                    return true;
+                }
+            }
+        }
+    }
+
+    return false;
+}
+
 boolean B_TryEvent(ddevent_t* event)
 {
     int     i;
@@ -369,6 +427,7 @@ void B_PrintAllBindings(void)
 
     Con_Printf("%i binding classes defined.\n", bindClassCount);
 
+#define BIDFORMAT   "[%4i]"
     for(i = 0; i < bindClassCount; ++i)
     {
         bc = bindClasses[i];
@@ -382,7 +441,7 @@ void B_PrintAllBindings(void)
         for(e = bc->commandBinds.next; e != &bc->commandBinds; e = e->next)
         {
             B_EventBindingToString(e, str);
-            Con_Printf("  [%4i] %s : %s\n", e->bid, Str_Text(str), e->command);
+            Con_Printf("  "BIDFORMAT" %s : %s\n", e->bid, Str_Text(str), e->command);
         }
 
         // Controls.
@@ -392,7 +451,7 @@ void B_PrintAllBindings(void)
         for(c = bc->controlBinds.next; c != &bc->controlBinds; c = c->next)
         {
             const char* controlName = P_PlayerControlById(c->control)->name;
-            Con_Printf("  Control \"%s\":\n", controlName);
+            Con_Printf("  Control \"%s\" "BIDFORMAT":\n", controlName, c->bid);
             for(k = 0; k < DDMAXPLAYERS; ++k)
             {
                 for(count = 0, d = c->deviceBinds[k].next; d != &c->deviceBinds[k]; 
@@ -403,7 +462,7 @@ void B_PrintAllBindings(void)
                 for(d = c->deviceBinds[k].next; d != &c->deviceBinds[k]; d = d->next)
                 {
                     B_DeviceBindingToString(d, str);
-                    Con_Printf("    [%4i] %s\n", d->bid, Str_Text(str));
+                    Con_Printf("    "BIDFORMAT" %s\n", d->bid, Str_Text(str));
                 }                
             }            
         }

doomsday/engine/portable/src/b_command.c

@@ -391,7 +391,29 @@ boolean B_TryCommandBinding(evbinding_t* eb, ddevent_t* event)
  */
 void B_EventBindingToString(const evbinding_t* eb, ddstring_t* str)
 {
-    Str_Clear(str);
+    int         i;
 
+    Str_Clear(str);    
+    B_AppendDeviceDescToString(eb->device, eb->type, eb->id, str);
+
+    if(eb->type == E_TOGGLE)
+    {
+        B_AppendToggleStateToString(eb->state, str);
+    }
+    else if(eb->type == E_AXIS)
+    {
+        B_AppendAxisPositionToString(eb->state, eb->pos, str);
+    }
+    else if(eb->type == E_ANGLE)
+    {
+        B_AppendAnglePositionToString(eb->pos, str);
+    }
+
+    // Append any state conditions.
+    for(i = 0; i < eb->numConds; ++i)
+    {
+        Str_Append(str, " + ");
+        B_AppendConditionToString(&eb->conds[i], str);
+    }    
 }
 

doomsday/engine/portable/src/b_device.c

@@ -267,7 +267,7 @@ void B_EvaluateDeviceBindingList(dbinding_t* listRoot, float* pos, float* relati
     {
         // If this binding has conditions, they may prevent using it.
         skip = false;
-        for(i = 0; i < cb->numConds; ++cb)
+        for(i = 0; i < cb->numConds; ++i)
         {
             if(!B_CheckCondition(&cb->conds[i]))
             {
@@ -325,7 +325,10 @@ void B_EvaluateDeviceBindingList(dbinding_t* listRoot, float* pos, float* relati
 
         // Apply further modifications based on flags.
         if(cb->flags & CBDF_INVERSE)
+        {
             devicePos = -devicePos;
+            deviceOffset = -deviceOffset;            
+        }
         if(cb->flags & CBDF_TIME_STAGED)
         {
             if(nowTime - deviceTime < stageThreshold * 1000)

doomsday/engine/portable/src/b_main.c

@@ -76,8 +76,9 @@ D_CMD(BindEventToCommand);
 D_CMD(BindControlToDevice);
 D_CMD(ListBindings);
 D_CMD(ListBindingClasses);
+D_CMD(ClearBindingClasses);
 D_CMD(ClearBindings);
-D_CMD(DeleteBind);
+D_CMD(DeleteBindingById);
 D_CMD(EnableBindClass);
 
 // PRIVATE FUNCTION PROTOTYPES ---------------------------------------------
@@ -231,6 +232,9 @@ void B_Register(void)
     C_CMD("bindcontrol",    "ss",   BindControlToDevice);
     C_CMD("listbclasses",   NULL,   ListBindingClasses);
     C_CMD("listbindings",   NULL,   ListBindings);
+    C_CMD("clearbindings",  "",     ClearBindings);
+    C_CMD("clearbclasses",  "",     ClearBindingClasses);
+    C_CMD("delbind",        "i",    DeleteBindingById);
 
     //int        i;
 
@@ -246,13 +250,7 @@ void B_Register(void)
     C_CMD("safebind",       NULL,   Bind);
     C_CMD("safebindr",      NULL,   Bind);
     */
-
-    /*
-    for(i = 0; ddBindClasses[i].name; ++i)
-    {
-        DD_AddBindClass(ddBindClasses + i);
-    }
-     */
+
 }
 
 /**
@@ -287,22 +285,6 @@ void B_Init(void)
     B_BindControl("turn", "joy-x + key-shift-up + joy-hat-center + key-code123-down");
 
     B_ActivateClass(B_ClassByName(DEFAULT_BINDING_CLASS_NAME), true);
-
-    /*
-    uint        i;
-
-    for(i = 0; i < NUM_INPUT_DEVICES; ++i)
-    {
-        uint        j;
-        devcontrolbinds_t *dcb = &devCtrlBinds[i];
-
-        for(j = 0; j < NUM_BIND_LISTS; ++j)
-        {
-            dcb->binds[j] = NULL;
-            dcb->numBinds[j] = 0;
-        }
-    }
-     */
 }
 
 /**
@@ -429,6 +411,18 @@ dbinding_t* B_GetControlDeviceBindings(int localNum, int control, bclass_t** bCl
     return &B_GetControlBinding(bc, control)->deviceBinds[localNum];
 }
 
+boolean B_Delete(int bid)
+{
+    int         i;
+
+    for(i = 0; i < B_ClassCount(); ++i)
+    {
+        if(B_DeleteBinding(B_ClassByPos(i), bid))
+            return true;
+    }
+    return false;
+}
+
 D_CMD(BindEventToCommand)
 {
     evbinding_t* b = B_BindCommand(argv[1], argv[2]);
@@ -461,6 +455,41 @@ D_CMD(ListBindings)
     return true;
 }
 
+D_CMD(ClearBindingClasses)
+{
+    B_DestroyAllClasses();
+    return true;
+}
+
+D_CMD(ClearBindings)
+{
+    int         i;
+
+    for(i = 0; i < B_ClassCount(); ++i)
+    {
+        Con_Printf("Clearing binding class \"%s\"...\n", B_ClassByPos(i)->name);
+        B_ClearClass(B_ClassByPos(i));
+    }
+    // We can restart the id counter, all the old bindings were destroyed.
+    bindingIdCounter = 0;
+    return true;
+}
+
+D_CMD(DeleteBindingById)
+{
+    int bid = strtoul(argv[1], NULL, 10);
+
+    if(B_Delete(bid))
+    {
+        Con_Printf("Binding %i deleted successfully.\n", bid);
+    }
+    else
+    {
+        Con_Printf("Cannot delete binding %i, it was not found.\n", bid);
+    }
+    return true;
+}
+
 #if 0
 #if _DEBUG
 const char* EventType_Str(evtype_t type)
@@ -2123,13 +2152,6 @@ D_CMD(Bind)
     return true;
 }
 
-D_CMD(ClearBindings)
-{/*
-    B_ClearBindings(true, false); // Just the active lists.
-    Con_Printf("All bindings cleared.\n");
-*/    return true;
-}
-
 D_CMD(DeleteBind)
 {/*
     Con_Printf("%s is not currently implemented\n", argv[0]);